gshock-api 2.0.5__tar.gz → 2.0.7__tar.gz

{gshock_api-2.0.5/src/gshock_api.egg-info → gshock_api-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gshock_api
-Version: 2.0.5
+Version: 2.0.7
 Summary: Pythgon API for GShock Watches using BLE
 Home-page: https://github.com/pyscaffold/pyscaffold/
 Author: Ivo Zivkov

{gshock_api-2.0.5 → gshock_api-2.0.7}/pyproject.toml

@@ -1,10 +1,11 @@
 [build-system]
-requires = ["setuptools", "wheel"]
+# requires = ["setuptools", "wheel"]
 build-backend = "setuptools.build_meta"
+requires = ["setuptools>=61.0"]
 
 [project]
 name = "gshock_api"  # Change to your project name
-version = "2.0.5"
+version = "2.0.7"
 description = "Pythgon API for GShock Watches using BLE"
 readme = "README.rst"
 authors = [{ name = "Ivo Zivkov", email = "izivkov@gmail.com" }]

{gshock_api-2.0.5 → gshock_api-2.0.7}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='gshock_api',
-    version='2.0.5',
+    version='2.0.7',
     package_dir={'': 'src'},
     packages=find_packages(where='src'),
     install_requires=[

gshock_api-2.0.7/src/gshock_api/cancelable_result.py

@@ -0,0 +1,23 @@
+import asyncio
+from typing import Any
+from gshock_api.exceptions import GShockConnectionError
+
+class CancelableResult:
+    def __init__(self, timeout: float = 10.0):
+        self._timeout = timeout
+        self._future: asyncio.Future[Any] = asyncio.Future()
+
+    async def get_result(self) -> Any:
+        try:
+            result = await asyncio.wait_for(self._future, timeout=self._timeout)
+            return result
+        except asyncio.TimeoutError as e:
+            if not self._future.done():
+                self._future.set_result('')  # or raise an exception instead
+            raise GShockConnectionError(f"Timeout occured waiting for response from the watch: {e}") from e
+
+    def set_result(self, result: Any) -> None:
+        if not self._future.done():
+            self._future.set_result(result)
+
+cancelable_result = CancelableResult()

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/connection.py

@@ -1,4 +1,5 @@
-import asyncio
+import asyncio, time
+from tracemalloc import start
 from bleak import BleakClient
 from bleak.backends.characteristic import BleakGATTCharacteristic
 from gshock_api.casio_constants import CasioConstants
@@ -8,6 +9,7 @@ from gshock_api.logger import logger
 from gshock_api.watch_info import watch_info
 from bleak.backends.device import BLEDevice
 from gshock_api.scanner import scanner
+from gshock_api.exceptions import GShockConnectionError
 
 class Connection:
     def __init__(self, address = None):
@@ -25,7 +27,7 @@ class Connection:
         """
         Prints all services and characteristics of the connected BLE device.
         """
-        services = await self.client.get_services()
+        services = self.client.services
         for service in services:
             for char in service.characteristics:
                 self.characteristics_map[char.uuid] = char.uuid  # Store in map
@@ -35,7 +37,6 @@ class Connection:
             # Scan for device if address not provided
             device = await scanner.scan(device_address=self.address if self.address else None)
             self.address = device.address  # Always update with actual device found
-            logger.info(f"Found device: {device.name} ({self.address})")
 
             self.client = BleakClient(self.address)
             await self.client.connect()
@@ -50,7 +51,7 @@ class Connection:
             return True
 
         except Exception as e:
-            logger.warning(f"[GShock Connect] Connection failed: {e}")
+            logger.info(f"[GShock Connect] Connection failed: {e}")
             return False
 
     async def disconnect(self):
@@ -59,30 +60,31 @@ class Connection:
     def is_service_supported(self, handle):
         uuid = self.handles_map.get(handle)
         supported = (uuid not in self.characteristics_map)
-        print(f"write, service with handle {handle} is supported: {supported}")
         return supported
 
     async def write(self, handle, data):
         try:
             uuid = self.handles_map.get(handle)
+
             if (uuid not in self.characteristics_map):
-                logger.error(
+                logger.info(
                     "write failed: handle {} not in characteristics map".format(handle)
                 )
                 if (handle == 13):
-                    logger.error(
-                        "Your watch does not suppot notifications..."
+                    logger.info(
+                        "Your watch does not support notifications..."
                     )
                 return
-            
+
             await self.client.write_gatt_char(
                 uuid, to_casio_cmd(data)
             )
+
         except Exception as e:
-            logger.debug("write failed with exception: {}".format(e))
+            print("Exception type:", type(e))
+            raise GShockConnectionError(f"Unable to write to G-Shock device: {e}") from e
 
     async def request(self, request):
-        logger.info("write: {}".format(request))
         await self.write(0xC, request)
 
     def init_handles_map(self):

gshock_api-2.0.7/src/gshock_api/exceptions.py

@@ -0,0 +1,9 @@
+# gshock_api/exceptions.py
+
+class GShockError(Exception):
+    """Base exception for all G-Shock errors."""
+    pass
+
+class GShockConnectionError(GShockError):
+    """Raised when BLE connection to G-Shock device fails."""
+    pass

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/gshock_api.py

@@ -205,8 +205,6 @@ class GshockAPI:
         if current_time == None:
             current_time = time.time()
 
-        self.logger.info(f"=======> passed: ${current_time}, ${time.time()}")
-
         await self.initialize_for_setting_time()
         await self._set_time(current_time)
         current_time = None
@@ -231,7 +229,7 @@ class GshockAPI:
 
     async def _get_alarms(self):
         result = await message_dispatcher.AlarmsIO.request(self.connection)
-        return await result
+        return result
 
     async def set_alarms(self, alarms):
         """Sets alarms to the watch. Up to 5 alarms are supported on the watch.

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/alarms_io.py

@@ -9,14 +9,12 @@ from gshock_api.casio_constants import CasioConstants
 
 CHARACTERISTICS = CasioConstants.CHARACTERISTICS
 
-
 class AlarmsIO:
     result: CancelableResult = None
     connection = None
 
     @staticmethod
     async def request(connection):
-        await connection.request("GET_ALARMS")
         AlarmsIO.connection = connection
 
         alarms_inst.clear()
@@ -27,9 +25,8 @@ class AlarmsIO:
     async def _get_alarms(connection):
         await connection.sendMessage("""{ "action": "GET_ALARMS"}""")
 
-        loop = asyncio.get_running_loop()
-        AlarmsIO.result = loop.create_future()
-        return AlarmsIO.result
+        AlarmsIO.result = CancelableResult()
+        return await AlarmsIO.result.get_result()
 
     @staticmethod
     async def send_to_watch(message=""):

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/app_info_io.py

@@ -15,13 +15,11 @@ class AppInfoIO:
 
     @staticmethod
     async def request(connection):
-        logger.info(f"AppInfoIO request")
         AppInfoIO.connection = connection
         await connection.request("22")
 
-        loop = asyncio.get_running_loop()
-        AppInfoIO.result = loop.create_future()
-        return AppInfoIO.result
+        AppInfoIO.result = CancelableResult()
+        return AppInfoIO.result.get_result()
 
     @staticmethod
     async def send_to_watch(connection):
@@ -29,8 +27,6 @@ class AppInfoIO:
 
     @staticmethod
     def on_received(data):
-        logger.info(f"AppInfoIO onReceived")
-
         def set_app_info(data: str):
             # App info:
             # This is needed to re-enable button D (Lower-right) after the watch has been reset or BLE has been cleared.

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/button_pressed_io.py

@@ -26,9 +26,8 @@ class ButtonPressedIO:
         ButtonPressedIO.connection = connection
         await connection.request("10")
 
-        loop = asyncio.get_running_loop()
-        ButtonPressedIO.result = loop.create_future()
-        return ButtonPressedIO.result
+        ButtonPressedIO.result = CancelableResult()
+        return ButtonPressedIO.result.get_result()
 
     @staticmethod
     async def send_to_watch(connection):
@@ -36,14 +35,10 @@ class ButtonPressedIO:
 
     @staticmethod
     async def send_to_watch_set(data):
-        logger.info(f"TimerIO sendToWatchSet: {data}")
-
         await ButtonPressedIO.connection.write(0x000E, data)
 
     @staticmethod
     def on_received(data):
-        logger.info(f"ButtonPressedIO onReceived")
-
         def button_pressed_callback(data):
             """
             RIGHT BUTTON: 0x10 17 62 07 38 85 CD 7F ->04<- 03 0F FF FF FF FF 24 00 00 00
@@ -57,7 +52,6 @@ class ButtonPressedIO:
             if len(data) >= 19:
                 ble_int_arr = to_int_array(to_hex_string(data))
                 button_indicator = ble_int_arr[8]
-                logger.info(f"Buttom code pressed: ${button_indicator}")
                 ret = (
                     WatchButton.LOWER_LEFT
                     if (button_indicator == 0 or button_indicator == 1)

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/dst_for_world_cities_io.py

@@ -14,14 +14,12 @@ class DstForWorldCitiesIO:
 
     @staticmethod
     async def request(connection, city_number: int):
-        logger.info(f"DstForWorldCitiesIO request")
         DstForWorldCitiesIO.connection = connection
         key = "1e0{}".format(city_number)
         await connection.request(key)
 
-        loop = asyncio.get_running_loop()
-        DstForWorldCitiesIO.result = loop.create_future()
-        return DstForWorldCitiesIO.result
+        DstForWorldCitiesIO.result = CancelableResult()
+        return DstForWorldCitiesIO.result.get_result()
 
     @staticmethod
     async def send_to_watch(connection):
@@ -29,5 +27,4 @@ class DstForWorldCitiesIO:
 
     @staticmethod
     def on_received(data):
-        logger.info(f"DstForWorldCitiesIO onReceived")
         DstForWorldCitiesIO.result.set_result(data)

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/dst_watch_state_io.py

@@ -20,14 +20,13 @@ class DstWatchStateIO:
 
     @staticmethod
     async def request(connection, state: DtsState):
-        logger.info(f"DstWatchStateIO request")
         DstWatchStateIO.connection = connection
         key = f"1d0{state.value}"
         await connection.request(key)
 
-        loop = asyncio.get_running_loop()
-        DstWatchStateIO.result = loop.create_future()
-        return DstWatchStateIO.result
+        DstWatchStateIO.result = CancelableResult()
+        return DstWatchStateIO.result.get_result()
+
 
     @staticmethod
     async def send_to_watch(connection):
@@ -35,5 +34,4 @@ class DstWatchStateIO:
 
     @staticmethod
     def on_received(data):
-        logger.info(f"DstWatchStateIO onReceived")
         DstWatchStateIO.result.set_result(data)

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/events_io.py

@@ -41,20 +41,16 @@ class EventsIO:
 
     @staticmethod
     async def request(connection, event_number):
-        logger.info(f"EventsIO request")
         EventsIO.connection = connection
 
         await connection.request("30{}".format(event_number))  # reminder title
         await connection.request("31{}".format(event_number))  # reminder time
 
-        loop = asyncio.get_running_loop()
-        EventsIO.result = loop.create_future()
-        return EventsIO.result
+        EventsIO.result = CancelableResult()
+        return EventsIO.result.get_result()
 
     @staticmethod
     async def send_to_watch_set(message):
-        logger.info(f"EventsIO sendToWatchSet: {message}")
-
         def reminder_title_from_json(reminder_json):
             title_str = reminder_json.get("title")
             return to_byte_array(title_str, 18)
@@ -342,7 +338,6 @@ class EventsIO:
 
         reminder_json = json.loads(reminder_time_to_json(data[2:]))
         reminder_json.update(EventsIO.title)
-        logger.info(reminder_json)
         EventsIO.result.set_result(reminder_json)
 
     @staticmethod

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/settings_io.py

@@ -16,25 +16,20 @@ class SettingsIO:
 
     @staticmethod
     async def request(connection):
-        logger.info(f"TimerIO request")
         SettingsIO.connection = connection
         await connection.request("13")
 
-        loop = asyncio.get_running_loop()
-        SettingsIO.result = loop.create_future()
-        return SettingsIO.result
+        SettingsIO.result = CancelableResult()
+        return SettingsIO.result.get_result()
 
     @staticmethod
     def send_to_watch(message):
-        logger.info(f"SettingsIO sendToWatch: {message}")
         SettingsIO.connection.write(
             0x000C, bytearray([CHARACTERISTICS["CASIO_SETTING_FOR_BASIC"]])
         )
 
     @staticmethod
     async def send_to_watch_set(message):
-        logger.info(f"SettingsIO sendToWatchSet: {message}")
-
         def encode(settings):
             mask_24_hours = 0b00000001
             MASK_BUTTON_TONE_OFF = 0b00000010

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/time_adjustement_io.py

@@ -20,27 +20,23 @@ class TimeAdjustmentIO:
 
     @staticmethod
     async def request(connection):
-        logger.info(f"TimerIO request")
         TimeAdjustmentIO.connection = connection
         await connection.request("11")
 
-        loop = asyncio.get_running_loop()
-        TimeAdjustmentIO.result = loop.create_future()
-        return TimeAdjustmentIO.result
+        TimeAdjustmentIO.result = CancelableResult()
+        return TimeAdjustmentIO.result.get_result()
+
 
     @staticmethod
     def send_to_watch(message):
-        logger.info(f"TimeAdjustmentIO sendToWatch: {message}")
         TimeAdjustmentIO.connection.write(
             0x000C, bytearray([CHARACTERISTICS["TIME_ADJUSTMENT"]])
         )
 
     @staticmethod
     async def send_to_watch_set(message):
-        logger.info(f"TimeAdjustmentIO sendToWatchSet: {message}")
 
         if TimeAdjustmentIO.original_value == None:
-            logging.error("Error: Must call get before set")
             return ErrorIO.request("Error: Must call get before set")
 
         time_adjustment = json.loads(message).get("timeAdjustment") == "True"
@@ -61,7 +57,6 @@ class TimeAdjustmentIO:
 
     @staticmethod
     def on_received(message):
-        logger.info(f"TimeAdjustmentIO onReceived: {message}")
         TimeAdjustmentIO.original_value = to_hex_string(
             message
         )  # save original message

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/time_io.py

@@ -3,17 +3,16 @@ import datetime
 import json
 import time
 from typing import Any
-from gshock_api.cancelable_result import CancelableResult
 from gshock_api.logger import logger
 
 from gshock_api.utils import to_compact_string, to_hex_string
 from gshock_api.casio_constants import CasioConstants
+import bleak
 
 CHARACTERISTICS = CasioConstants.CHARACTERISTICS
 
 
 class TimeIO:
-    result: CancelableResult = None
     connection = None
 
     @staticmethod
@@ -32,14 +31,19 @@ class TimeIO:
     @staticmethod
     async def send_to_watch_set(message):
         date_time_ms = int(json.loads(message).get("value"))
-        logger.info("date_time_ms: {}".format(date_time_ms))
         date_time = datetime.datetime.fromtimestamp(date_time_ms / 1000.0)
         time_data = TimeEncoder.prepare_current_time(date_time)
         time_command = to_hex_string(
             bytearray([CHARACTERISTICS["CASIO_CURRENT_TIME"]]) + time_data
         )
-        await TimeIO.connection.write(0xE, to_compact_string(time_command))
-
+        try:
+            await TimeIO.connection.write(0xE, to_compact_string(time_command))
+        except (Exception) as e:
+            # Ignore this exception if the LOWER-RIGHT button is pressed.
+            # In this case, the connection will be closed before the call completes with a response, and we get an EOFError.
+            # The call actually works, though.
+            
+            logger.info(f"Error {e} ignored due to timeout limitation")
 
 class TimeEncoder:
     def prepare_current_time(date: datetime.datetime):

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/timer_io.py

@@ -16,13 +16,12 @@ class TimerIO:
 
     @staticmethod
     async def request(connection):
-        logger.info(f"TimerIO request")
         TimerIO.connection = connection
         await connection.request("18")
 
-        loop = asyncio.get_running_loop()
-        TimerIO.result = loop.create_future()
-        return TimerIO.result
+        TimerIO.result = CancelableResult()
+        return TimerIO.result.get_result()
+
 
     @staticmethod
     async def send_to_watch(connection):
@@ -30,8 +29,6 @@ class TimerIO:
 
     @staticmethod
     async def send_to_watch_set(data):
-        logger.info(f"TimerIO sendToWatchSet: {data}")
-
         def encode(seconds_str):
             in_seconds = int(seconds_str)
             hours = in_seconds // 3600
@@ -53,8 +50,6 @@ class TimerIO:
 
     @staticmethod
     def on_received(data):
-        logger.info(f"TimerIO onReceived")
-
         def decode_value(data: str) -> str:
             timer_int_array = data
 

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/watch_condition_io.py

@@ -19,13 +19,11 @@ class WatchConditionIO:
 
     @staticmethod
     async def request(connection):
-        logger.info(f"WatchConditionIO request")
         WatchConditionIO.connection = connection
         await connection.request("28")
 
-        loop = asyncio.get_running_loop()
-        WatchConditionIO.result = loop.create_future()
-        return WatchConditionIO.result
+        WatchConditionIO.result = CancelableResult()
+        return WatchConditionIO.result.get_result()
 
     @staticmethod
     async def send_to_watch(connection):
@@ -33,16 +31,11 @@ class WatchConditionIO:
 
     @staticmethod
     def on_received(data):
-        logger.info(f"WatchConditionIO onReceived")
-
         def decode_value(data: str) -> WatchConditionIO.WatchConditionValue:
             int_arr = list(map(int, data))
             bytes_data = bytes(int_arr[1:])
 
             if len(bytes_data) >= 2:
-                # Battery level between 15 and 20 for B2100 and between 12 and 19 for B5600. Scale accordingly to %
-                logger.info(f"battery level row value: {int(bytes_data[0])}")
-
                 battery_level_lower_limit = watch_info.batteryLevelLowerLimit
                 battery_level_upper_limit = watch_info.batteryLevelUpperLimit
 

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/watch_name_io.py

@@ -15,9 +15,8 @@ class WatchNameIO:
         WatchNameIO.connection = connection
         await connection.request("23")
 
-        loop = asyncio.get_running_loop()
-        WatchNameIO.result = loop.create_future()
-        return WatchNameIO.result
+        WatchNameIO.result = CancelableResult()
+        return WatchNameIO.result.get_result()
 
     @staticmethod
     def on_received(data):

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/iolib/world_cities_io.py

@@ -13,15 +13,13 @@ class WorldCitiesIO:
 
     @staticmethod
     async def request(connection, cityNumber: int):
-        logger.info(f"DstWatchStateIO request")
         WorldCitiesIO.connection = connection
         key = "1f0{}".format(cityNumber)
 
         await connection.request(key)
 
-        loop = asyncio.get_running_loop()
-        WorldCitiesIO.result = loop.create_future()
-        return WorldCitiesIO.result
+        WorldCitiesIO.result = CancelableResult()
+        return WorldCitiesIO.result.get_result()
 
     @staticmethod
     async def send_to_watch(connection):
@@ -29,5 +27,4 @@ class WorldCitiesIO:
 
     @staticmethod
     def on_received(data):
-        logger.info(f"WorldCitiesIO onReceived")
         WorldCitiesIO.result.set_result(data)

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/message_dispatcher.py

@@ -72,7 +72,6 @@ class MessageDispatcher:
         if key not in MessageDispatcher.data_received_messages:
             logger.info(f"Unknown key: {key}")
         else:
-            logger.info(f"Found key: {MessageDispatcher.data_received_messages[key]}")
             MessageDispatcher.data_received_messages[key](data)
 
 # Usage example

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/scanner.py

@@ -11,7 +11,6 @@ class Scanner:
 
     async def scan(self, device_address=None) -> BLEDevice:
         scanner = BleakScanner()
-        logger.info("Scanning for devices...")
 
         if device_address is None:
             while True:
@@ -19,7 +18,6 @@ class Scanner:
                     lambda d, ad: d.name and d.name.lower().startswith("casio"),
                     timeout=5 * 60.0,
                 )
-                logger.info(f"device: {device}")
                 if device is None:
                     continue
                 

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api/watch_info.py

@@ -202,8 +202,6 @@ class WatchInfo:
         if len(parts) > 1:
             self.shortName = parts[1]
 
-        logger.info(f"============> self.shortName: ${self.shortName}")
-
         # *** Order matters. Start with the longest shortName first. ***
         if self.shortName.startswith("MSG"):
             self.model = WATCH_MODEL.MSG

{gshock_api-2.0.5 → gshock_api-2.0.7/src/gshock_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gshock_api
-Version: 2.0.5
+Version: 2.0.7
 Summary: Pythgon API for GShock Watches using BLE
 Home-page: https://github.com/pyscaffold/pyscaffold/
 Author: Ivo Zivkov

{gshock_api-2.0.5 → gshock_api-2.0.7}/src/gshock_api.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/gshock_api/casio_constants.py
 src/gshock_api/configurator.py
 src/gshock_api/connection.py
 src/gshock_api/event.py
+src/gshock_api/exceptions.py
 src/gshock_api/gshock_api.py
 src/gshock_api/logger.py
 src/gshock_api/mailsener.py

gshock_api-2.0.5/src/gshock_api/cancelable_result.py

@@ -1,38 +0,0 @@
-import asyncio
-from typing import Any
-
-class CancelableResult:
-    def __init__(self, timeout: float = 5.0):
-        self._timeout = timeout
-        self._future: asyncio.Future[Any] = asyncio.Future()
-
-    async def get_result(self) -> Any:
-        try:
-            return await asyncio.wait_for(self._future, timeout=self._timeout)
-        except asyncio.TimeoutError:
-            if not self._future.done():
-                self._future.set_result('')
-            return await self._future
-
-    def set_result(self, result: Any) -> None:
-        if not self._future.done():
-            self._future.set_result(result)
-
-# Example usage
-async def main():
-    cancelable_result = CancelableResult(timeout=5)
-
-    # Simulate some async work that might or might not set a result
-    async def some_async_work():
-        await asyncio.sleep(3)  # Change this to 6 to test the timeout
-        cancelable_result.set_result('Result after async work')
-
-    await asyncio.gather(some_async_work(), asyncio.sleep(6))
-
-    final_result = await cancelable_result.get_result()
-    print(f'Final result: "{final_result}"')
-
-# Run the main coroutine
-# asyncio.run(main())
-
-cancelable_result = CancelableResult()