remove fire-and-forget methods | remove _async in methods name

Author: ndonkoHenri

CHANGELOG.md

@@ -10,9 +10,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Added
 
 - Deployed online documentation: https://flet-dev.github.io/flet-geolocator/
-- `Geolocator` control new methods: `distance_between_async`
+- `Geolocator` control new methods: `distance_between`
 - `Geolocator` control new properties: `position`, `configuration`
-- New dataclasses: 
+- New dataclasses:
     - `GeolocatorConfiguration`
     - `GeolocatorWebConfiguration`
     - `GeolocatorIosConfiguration`
@@ -26,19 +26,19 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 #### Breaking Changes
 
 - `Geolocator` must now be added to `Page.services` instead of `Page.overlay`.
-- `Geolocator` method `get_current_position_async` parameters changed: 
+- `Geolocator` method `get_current_position_async` parameters changed:
     - removed `accuracy`
     - `location_settings` renamed to `configuration` (type changed)
     - `wait_timeout` renamed to `timeout`
 - In all `Geolocator` methods, parameter `wait_timeout` renamed to `timeout`.
-- Removed sync methods from `Geolocator`: 
-    - `get_current_position` → use `get_current_position_async` instead
-    - `get_last_known_position` → use `get_last_known_position_async` instead
-    - `get_permission_status` → use `get_permission_status_async` instead
-    - `request_permission` → use `request_permission_async` instead
-    - `is_location_service_enabled` → use `is_location_service_enabled_async` instead
-    - `open_app_settings` → use `open_app_settings_async` instead
-    - `open_location_settings` → use `open_location_settings_async` instead
+- The following `Geolocator` sync methods were made [`async`](https://docs.python.org/3/library/asyncio.html):
+    - `get_current_position`
+    - `get_last_known_position`
+    - `get_permission_status`
+    - `request_permission`
+    - `is_location_service_enabled`
+    - `open_app_settings`
+    - `open_location_settings`
 - Enum `GeolocatorActivityType` renamed to `GeolocatorIosActivityType`
 
 ## [0.1.0] - 2025-01-15
@@ -47,4 +47,4 @@ Initial release.
 
 
 [0.2.0]: https://github.com/flet-dev/flet-lottie/compare/0.1.0...0.2.0
-[0.1.0]: https://github.com/flet-dev/flet-lottie/releases/tag/0.1.0
+[0.1.0]: https://github.com/flet-dev/flet-lottie/releases/tag/0.1.0

examples/geolocator_example/src/main.py

@@ -34,36 +34,36 @@ def show_snackbar(message):
         page.show_dialog(ft.SnackBar(ft.Text(message)))
 
     async def handle_permission_request(e):
-        p = await gl.request_permission_async(timeout=60)
+        p = await gl.request_permission(timeout=60)
         page.add(ft.Text(f"request_permission: {p}"))
         show_snackbar(f"Permission request sent: {p}")
 
     async def handle_get_permission_status(e):
-        p = await gl.get_permission_status_async()
+        p = await gl.get_permission_status()
         show_snackbar(f"Permission status: {p}")
 
     async def handle_get_current_position(e):
-        p = await gl.get_current_position_async()
+        p = await gl.get_current_position()
         show_snackbar(f"Current position: ({p.latitude}, {p.longitude})")
 
     async def handle_get_last_known_position(e):
-        p = await gl.get_last_known_position_async()
+        p = await gl.get_last_known_position()
         show_snackbar(f"Last known position: ({p.latitude}, {p.longitude})")
 
     async def handle_location_service_enabled(e):
-        p = await gl.is_location_service_enabled_async()
+        p = await gl.is_location_service_enabled()
         show_snackbar(f"Location service enabled: {p}")
 
     async def handle_open_location_settings(e):
-        p = await gl.open_location_settings_async()
+        p = await gl.open_location_settings()
         page.close(location_settings_dlg)
         if p is True:
             show_snackbar("Location settings opened successfully.")
         else:
             show_snackbar("Location settings could not be opened.")
 
     async def handle_open_app_settings(e):
-        p = await gl.open_app_settings_async()
+        p = await gl.open_app_settings()
         page.close(app_settings_dlg)
         if p:
             show_snackbar("App settings opened successfully.")
@@ -91,7 +91,7 @@ async def handle_open_app_settings(e):
                 ),
                 ft.OutlinedButton(
                     "Get Last Known Position",
-                    visible=False if page.web else True,
+                    visible=not page.web,
                     on_click=handle_get_last_known_position,
                 ),
                 ft.OutlinedButton(
@@ -100,12 +100,12 @@ async def handle_open_app_settings(e):
                 ),
                 ft.OutlinedButton(
                     "Open Location Settings",
-                    visible=False if page.web else True,  # (1)!
+                    visible=not page.web,  # (1)!
                     on_click=lambda e: page.open(location_settings_dlg),
                 ),
                 ft.OutlinedButton(
                     "Open App Settings",
-                    visible=False if page.web else True,  # (1)!
+                    visible=not page.web,  # (1)!
                     on_click=lambda e: page.open(app_settings_dlg),
                 ),
             ],

src/flet_geolocator/geolocator.py

@@ -1,4 +1,3 @@
-import asyncio
 from dataclasses import field
 from typing import Optional
 
@@ -50,7 +49,7 @@ class Geolocator(ft.Service):
     Starts as `None` and will be updated when the position changes.
     """
 
-    async def get_current_position_async(
+    async def get_current_position(
         self,
         configuration: Optional[GeolocatorConfiguration] = None,
         timeout: float = 30,
@@ -77,16 +76,14 @@ async def get_current_position_async(
         Raises:
             TimeoutError: If the request times out.
         """
-        r = await self._invoke_method_async(
+        r = await self._invoke_method(
             method_name="get_current_position",
             arguments={"configuration": configuration or self.configuration},
             timeout=timeout,
         )
         return GeolocatorPosition(**r)
 
-    async def get_last_known_position_async(
-        self, timeout: float = 10
-    ) -> GeolocatorPosition:
+    async def get_last_known_position(self, timeout: float = 10) -> GeolocatorPosition:
         """
         Gets the last known position stored on the user's device.
         The accuracy can be defined using the
@@ -106,13 +103,13 @@ async def get_last_known_position_async(
             TimeoutError: If the request times out.
         """
         assert not self.page.web, "get_last_known_position is not supported on web"
-        r = await self._invoke_method_async(
+        r = await self._invoke_method(
             "get_last_known_position",
             timeout=timeout,
         )
         return GeolocatorPosition(**r)
 
-    async def get_permission_status_async(
+    async def get_permission_status(
         self, timeout: float = 10
     ) -> GeolocatorPermissionStatus:
         """
@@ -127,15 +124,13 @@ async def get_permission_status_async(
         Raises:
             TimeoutError: If the request times out.
         """
-        r = await self._invoke_method_async(
+        r = await self._invoke_method(
             "get_permission_status",
             timeout=timeout,
         )
         return GeolocatorPermissionStatus(r)
 
-    async def request_permission_async(
-        self, timeout: int = 60
-    ) -> GeolocatorPermissionStatus:
+    async def request_permission(self, timeout: int = 60) -> GeolocatorPermissionStatus:
         """
         Requests the device for access to the device's location.
 
@@ -148,13 +143,13 @@ async def request_permission_async(
         Raises:
             TimeoutError: If the request times out.
         """
-        r = await self._invoke_method_async(
+        r = await self._invoke_method(
             "request_permission",
             timeout=timeout,
         )
         return GeolocatorPermissionStatus(r)
 
-    async def is_location_service_enabled_async(self, timeout: float = 10) -> bool:
+    async def is_location_service_enabled(self, timeout: float = 10) -> bool:
         """
         Checks if location service is enabled.
 
@@ -167,11 +162,9 @@ async def is_location_service_enabled_async(self, timeout: float = 10) -> bool:
         Raises:
             TimeoutError: If the request times out.
         """
-        return await self._invoke_method_async(
-            "is_location_service_enabled", timeout=timeout
-        )
+        return await self._invoke_method("is_location_service_enabled", timeout=timeout)
 
-    async def open_app_settings_async(self, timeout: float = 10) -> bool:
+    async def open_app_settings(self, timeout: float = 10) -> bool:
         """
         Attempts to open the app's settings.
 
@@ -189,31 +182,12 @@ async def open_app_settings_async(self, timeout: float = 10) -> bool:
             TimeoutError: If the request times out.
         """
         assert not self.page.web, "open_app_settings is not supported on web"
-        return await self._invoke_method_async(
+        return await self._invoke_method(
             "open_app_settings",
             timeout=timeout,
         )
 
-    def open_location_settings(self, timeout: float = 10):
-        """
-        Attempts to open the device's location settings.
-
-        Note:
-            This method is not supported on web plaform.
-
-        Args:
-            timeout: The maximum amount of time (in seconds) to wait for a response.
-
-        Returns:
-            `True` if the device's settings were opened successfully, `False` otherwise.
-
-        Raises:
-            AssertionError: If invoked on a web platform.
-            TimeoutError: If the request times out.
-        """
-        asyncio.create_task(self.open_location_settings_async(timeout=timeout))
-
-    async def open_location_settings_async(self, timeout: float = 10):
+    async def open_location_settings(self, timeout: float = 10):
         """
         Attempts to open the device's location settings.
 
@@ -231,12 +205,12 @@ async def open_location_settings_async(self, timeout: float = 10):
             TimeoutError: If the request times out.
         """
         assert not self.page.web, "open_location_settings is not supported on web"
-        await self._invoke_method_async(
+        await self._invoke_method(
             "open_location_settings",
             timeout=timeout,
         )
 
-    async def distance_between_async(
+    async def distance_between(
         self,
         start_latitude: ft.Number,
         start_longitude: ft.Number,
@@ -263,7 +237,7 @@ async def distance_between_async(
         Raises:
             TimeoutError: If the request times out.
         """
-        await self._invoke_method_async(
+        await self._invoke_method(
             method_name="distance_between",
             arguments={
                 "start_latitude": start_latitude,

src/flet_geolocator/types.py

@@ -94,15 +94,16 @@ class GeolocatorPermissionStatus(Enum):
     """
     Permission to access the device's location is denied.
 
-    The app should try to request permission using the [`Geolocator.request_permission`][(p).] method.
+    The app should try to request permission using the
+    [`Geolocator.request_permission`][(p).] method.
     """
 
     DENIED_FOREVER = "deniedForever"
     """
     Permission to access the device's location is permanently denied.
 
-    When requesting permissions, the permission dialog will not be shown until the user updates
-    the permission in the app settings.
+    When requesting permissions, the permission dialog will not be shown until the
+    user updates the permission in the app settings.
     """
 
     WHILE_IN_USE = "whileInUse"
@@ -112,15 +113,16 @@ class GeolocatorPermissionStatus(Enum):
 
     ALWAYS = "always"
     """
-    Permission to access the device's location is allowed even when the app is running in the background.
+    Permission to access the device's location is allowed even when the app is
+    running in the background.
     """
 
     UNABLE_TO_DETERMINE = "unableToDetermine"
     """
     Permission status cannot be determined.
 
-    This status is only returned by the [`Geolocator.request_permission`][(p).] method on the web platform
-    for browsers that did not implement the Permissions API.
+    This status is only returned by the [`Geolocator.request_permission`][(p).] method
+    on the web platform for browsers that did not implement the Permissions API.
     See: https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API
     """
 
@@ -240,7 +242,8 @@ class GeolocatorPosition:
     The floor specifies the floor of the building on which the device is
     located.
 
-    The floor property is only available on iOS and only when the information is available.
+    The floor property is only available on iOS
+    and only when the information is available.
     In all other cases this value will be `None`.
     """
 
@@ -363,7 +366,8 @@ class ForegroundNotificationConfiguration:
     """
     When enabled, a WifiLock is acquired when background execution is started.
     This allows the application to keep the Wi-Fi radio awake, even when the
-    user has not used the device in a while (e.g. for background network communications).
+    user has not used the device in a while
+    (e.g. for background network communications).
 
     Wifi lock permissions should be obtained first by using a permissions library.
     """
@@ -392,16 +396,17 @@ class GeolocatorAndroidConfiguration(GeolocatorConfiguration):
     """
     Whether altitude should be calculated as MSL (EGM2008) from NMEA messages
     and reported as the altitude instead of using the geoidal height (WSG84). Setting
-    this property true will help to align Android altitude to that of iOS which uses MSL.
+    this property true will help to align Android altitude to that of iOS which
+    uses MSL.
 
-    If the NMEA message is empty then the altitude reported will still be the standard WSG84
-    altitude from the GPS receiver.
+    If the NMEA message is empty then the altitude reported will still be
+    the standard WSG84 altitude from the GPS receiver.
 
     MSL Altitude is only available starting from Android N and not all devices support
     NMEA message returning $GPGGA sequences.
 
-    This property only works with position stream updates and has no effect when getting the
-    current position or last known position.
+    This property only works with position stream updates and has no effect when
+    getting the current position or last known position.
     """
 
     foreground_notification_config: Optional[ForegroundNotificationConfiguration] = None