gshock-api 2.0.24__tar.gz → 2.0.26__tar.gz

{gshock_api-2.0.24/src/gshock_api.egg-info → gshock_api-2.0.26}/PKG-INFO

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

{gshock_api-2.0.24 → gshock_api-2.0.26}/pyproject.toml

@@ -5,7 +5,7 @@ requires = ["setuptools>=61.0"]
 
 [project]
 name = "gshock_api"  # Change to your project name
-version = "2.0.24"
+version = "2.0.26"
 description = "Pythgon API for GShock Watches using BLE"
 readme = "README.rst"
 authors = [{ name = "Ivo Zivkov", email = "izivkov@gmail.com" }]

{gshock_api-2.0.24 → gshock_api-2.0.26}/setup.py

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

gshock_api-2.0.26/src/gshock_api/always_connected_watch_filter.py

@@ -0,0 +1,40 @@
+import time
+from gshock_api.watch_info import watch_info
+
+class AlwaysConnectedWatchFilter:
+    """
+    For always-connected watches, limit the connection frequency to once every 6 hours. 
+    Otherwise, they may block other watches from connecting.
+    """
+
+    def __init__(self):
+        self.last_connected_times = {}
+
+    def connection_filter(self, watch_name):
+        watch = watch_info.lookup_watch_info(watch_name)
+
+        if not watch["alwaysConnected"]:
+            # not always connected - allow...
+            return True
+
+        last_time = self.last_connected_times.get(watch_name)
+        now = time.time()
+
+        if last_time is None:
+            # connected for the first time - allow...
+            self.update_connection_time(watch_name=watch_name)
+            return True
+
+        elapsed = now - last_time
+        if elapsed > 6 * 3600:
+            # last connected more than 6 hours ago - allow...
+            self.update_connection_time(watch_name=watch_name)
+            return True
+
+        # last connected less than 6 hours ago - deny...
+        return False
+
+    def update_connection_time(self, watch_name):
+        self.last_connected_times[watch_name.strip()] = time.time()
+
+always_connected_watch_filter = AlwaysConnectedWatchFilter()

{gshock_api-2.0.24 → gshock_api-2.0.26}/src/gshock_api/connection.py

@@ -33,15 +33,13 @@ class Connection:
             for char in service.characteristics:
                 self.characteristics_map[char.uuid] = char.uuid  # Store in map
 
-        logger.info(f"Characteristics map initialized: {self.characteristics_map}")
-
-    async def connect(self, excluded_watches: list[str] | None = None) -> bool:
+    async def connect(self, watch_filter=None) -> bool:
         try:
             # Scan for device if address not provided
             if self.address == None:
                 device = await scanner.scan(
                     device_address=self.address if self.address else None,
-                    excluded_watches=excluded_watches
+                    watch_filter=watch_filter
                 )
                 if device is None:
                     logger.info("No G-Shock device found or name matches excluded watches.")
@@ -90,8 +88,10 @@ class Connection:
                     )
                 return
 
+            responseType = True if handle == 0x0E else False
+
             await self.client.write_gatt_char(
-                uuid, to_casio_cmd(data)
+                uuid, to_casio_cmd(data), response=responseType
             )
 
         except Exception as e:

{gshock_api-2.0.24 → gshock_api-2.0.26}/src/gshock_api/gshock_api.py

@@ -455,3 +455,6 @@ class GshockAPI:
         encrypted_buffer = AppNotificationIO.xor_encode_buffer(encoded_buffer)
         await self.connection.write(0xD, encrypted_buffer)
 
+# Note: replace all logging calls with 'print' or minimal logger.
+# Ensure your async calls and message_dispatcher methods are ported or stubbed for MicroPython.
+

{gshock_api-2.0.24 → gshock_api-2.0.26}/src/gshock_api/iolib/dst_watch_state_io.py

@@ -8,7 +8,6 @@ from gshock_api.casio_constants import CasioConstants
 
 CHARACTERISTICS = CasioConstants.CHARACTERISTICS
 
-
 class DtsState(IntEnum):
     ZERO = 0
     TWO = 2

{gshock_api-2.0.24 → gshock_api-2.0.26}/src/gshock_api/scanner.py

@@ -17,11 +17,10 @@ class Scanner:
     async def scan(
         self,
         device_address: str | None = None,
-        excluded_watches: list[str] | None = None,
+        watch_filter = None,
         max_retries: int = 60,  # Optional: to prevent infinite loops
     ) -> BLEDevice | None:
         scanner = BleakScanner()
-        excluded_watches = excluded_watches or []
 
         retries = 0
         device = None
@@ -39,9 +38,8 @@ class Scanner:
                             return False
 
                         is_casio = parts[0].lower() == "casio"
-                        is_excluded = len(parts) > 1 and parts[1] in excluded_watches
-
-                        return is_casio and not is_excluded
+                        passed = is_casio and (watch_filter is None or watch_filter(device.name))
+                        return passed
                     
                     device = await scanner.find_device_by_filter(
                         casio_filter,

{gshock_api-2.0.24 → gshock_api-2.0.26}/src/gshock_api/watch_info.py

@@ -1,7 +1,6 @@
-from enum import Enum
 from gshock_api.logger import logger
 
-class WATCH_MODEL(Enum):
+class WATCH_MODEL:
     GA = 1
     GW = 2
     DW = 3
@@ -17,6 +16,7 @@ class WATCH_MODEL(Enum):
     GB = 13
     GM = 14
     ABL = 15
+    DW_H = 16
     UNKNOWN = 20
 
 class WatchInfo:
@@ -167,6 +167,7 @@ class WatchInfo:
                 "longLightDuration": "3s",
                 "worldCities": False,
                 "temperature": False,
+                "alwaysConnected": True,
             },
             {
                 "model": WATCH_MODEL.ECB,
@@ -185,6 +186,23 @@ class WatchInfo:
                 "hasPowerSavingMode": False,
                 "hasDnD": True
             },
+            {
+                "model": WATCH_MODEL.DW_H,
+                "worldCitiesCount": 2,
+                "dstCount": 1,
+                "alarmCount": 5,
+                "hasAutoLight": True,
+                "hasReminders": False,
+                "shortLightDuration": "1.5s",
+                "longLightDuration": "3s",
+                "worldCities": True,
+                "temperature": False,
+                "hasBatteryLevel": False,
+                "alwaysConnected": True,
+                "findButtonUserDefined": True,
+                "hasPowerSavingMode": False,
+                "hasDnD": True
+            },
             {
                 "model": WATCH_MODEL.UNKNOWN,
                 "worldCitiesCount": 2,
@@ -201,32 +219,63 @@ class WatchInfo:
         self.model_map = {entry["model"]: entry for entry in self.models}
 
     def set_name_and_model(self, name):
-        self.name = name
-        self.shortName = None
-        self.model = WATCH_MODEL.UNKNOWN
+        details = self._resolve_watch_details(name)
+        if not details:
+            return
+        
+        # Persist fields
+        self.name                  = details["name"]
+        self.shortName             = details["shortName"]
+        self.model                 = details["model"]
+        self.hasReminders          = details["hasReminders"]
+        self.hasAutoLight          = details["hasAutoLight"]
+        self.alarmCount            = details["alarmCount"]
+        self.worldCitiesCount      = details["worldCitiesCount"]
+        self.dstCount              = details["dstCount"]
+        self.shortLightDuration    = details["shortLightDuration"]
+        self.longLightDuration     = details["longLightDuration"]
+        self.weekLanguageSupported = details["weekLanguageSupported"]
+        self.worldCities           = details["worldCities"]
+        self.temperature           = details["temperature"]
+        self.batteryLevelLowerLimit= details["batteryLevelLowerLimit"]
+        self.batteryLevelUpperLimit= details["batteryLevelUpperLimit"]
+        self.alwaysConnected       = details["alwaysConnected"]
+        self.findButtonUserDefined = details["findButtonUserDefined"]
+        self.hasPowerSavingMode    = details["hasPowerSavingMode"]
+        self.hasDnD                = details["hasDnD"]
+        self.hasBatteryLevel       = details["hasBatteryLevel"]
+        self.hasWorldCities        = details["hasWorldCities"]
 
-        parts = self.name.split(" ")
-        if len(parts) > 1:
-            self.shortName = parts[1]
+    def lookup_watch_info(self, name):
+        # Public non-destructive lookup
+        return self._resolve_watch_details(name)
 
-        if not self.shortName:
-            return
+    def _resolve_watch_details(self, name):
+        # Internal method for lookup logic
+        shortName = None
+        model = WATCH_MODEL.UNKNOWN
+
+        parts = name.split(" ")
+        if len(parts) > 1:
+            shortName = parts[1]  # instead of `parts`
+        if not shortName:
+            return None  # Could return a dict of defaults or None
 
-        # Special case: exact match for ECB models
-        if self.shortName in {"ECB-10", "ECB-20", "ECB-30"}:
-            self.model = WATCH_MODEL.ECB
-        elif self.shortName.startswith("ABL"): # ABL-100WE
-            self.model = WATCH_MODEL.ABL
-        elif self.shortName.startswith("GST"): # GST-B100
-            self.model = WATCH_MODEL.GST
+        if shortName in {"ECB-10", "ECB-20", "ECB-30"}:
+            model = WATCH_MODEL.ECB
+        elif shortName.startswith("ABL"):
+            model = WATCH_MODEL.ABL
+        elif shortName.startswith("GST"):
+            model = WATCH_MODEL.GST
         else:
-            # Ordered prefix-to-model mapping (longer prefixes first)
             prefix_map = [
                 ("MSG", WATCH_MODEL.MSG),
                 ("GPR", WATCH_MODEL.GPR),
+                ("GM-B2100", WATCH_MODEL.GA),
                 ("GBM", WATCH_MODEL.GA),
                 ("GBD", WATCH_MODEL.GBD),
                 ("GMW", WATCH_MODEL.GMW),
+                ("DW-H",  WATCH_MODEL.DW_H),
                 ("DW",  WATCH_MODEL.DW),
                 ("GA",  WATCH_MODEL.GA),
                 ("GB",  WATCH_MODEL.GB),
@@ -235,35 +284,37 @@ class WatchInfo:
                 ("MRG", WATCH_MODEL.MRG),
                 ("ABL", WATCH_MODEL.ABL),
             ]
-
-            for prefix, model in prefix_map:
-                if self.shortName.startswith(prefix):
-                    self.model = model
+            for prefix, m in prefix_map:
+                if shortName.startswith(prefix):
+                    model = m
                     break
 
-        model_info = self.model_map.get(self.model)
-        if not model_info:
-            return
-
-        # Set attributes with defaults
-        self.hasReminders          = model_info.get("hasReminders", False)
-        self.hasAutoLight          = model_info.get("hasAutoLight", False)
-        self.alarmCount            = model_info.get("alarmCount", 0)
-        self.worldCitiesCount      = model_info.get("worldCitiesCount", 0)
-        self.dstCount              = model_info.get("dstCount", 0)
-        self.shortLightDuration    = model_info.get("shortLightDuration", 0)
-        self.longLightDuration     = model_info.get("longLightDuration", 0)
-        self.weekLanguageSupported = model_info.get("weekLanguageSupported", True)
-        self.worldCities           = model_info.get("worldCities", True)
-        self.temperature           = model_info.get("temperature", True)
-        self.batteryLevelLowerLimit= model_info.get("batteryLevelLowerLimit", 15)
-        self.batteryLevelUpperLimit= model_info.get("batteryLevelUpperLimit", 20)
-        self.alwaysConnected       = model_info.get("alwaysConnected", False)
-        self.findButtonUserDefined = model_info.get("findButtonUserDefined", False)
-        self.hasPowerSavingMode    = model_info.get("hasPowerSavingMode", False)
-        self.hasDnD                = model_info.get("hasDnD", False)
-        self.hasBatteryLevel       = model_info.get("hasBatteryLevel", False)
-        self.hasWorldCities        = model_info.get("hasWorldCities", True)
+        model_info = self.model_map.get(model, {})
+        computed = {
+            "name": name,
+            "shortName": shortName,
+            "model": model,
+            # Use model_info for each property
+            "hasReminders": model_info.get("hasReminders", False),
+            "hasAutoLight": model_info.get("hasAutoLight", False),
+            "alarmCount": model_info.get("alarmCount", 0),
+            "worldCitiesCount": model_info.get("worldCitiesCount", 0),
+            "dstCount": model_info.get("dstCount", 0),
+            "shortLightDuration": model_info.get("shortLightDuration", ""),
+            "longLightDuration": model_info.get("longLightDuration", ""),
+            "weekLanguageSupported": model_info.get("weekLanguageSupported", True),
+            "worldCities": model_info.get("worldCities", True),
+            "temperature": model_info.get("temperature", True),
+            "batteryLevelLowerLimit": model_info.get("batteryLevelLowerLimit", 15),
+            "batteryLevelUpperLimit": model_info.get("batteryLevelUpperLimit", 20),
+            "alwaysConnected": model_info.get("alwaysConnected", False),
+            "findButtonUserDefined": model_info.get("findButtonUserDefined", False),
+            "hasPowerSavingMode": model_info.get("hasPowerSavingMode", False),
+            "hasDnD": model_info.get("hasDnD", False),
+            "hasBatteryLevel": model_info.get("hasBatteryLevel", False),
+            "hasWorldCities": model_info.get("hasWorldCities", True),
+        }
+        return computed
 
     def set_address(self, address):
         self.address = address

{gshock_api-2.0.24 → gshock_api-2.0.26/src/gshock_api.egg-info}/PKG-INFO

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

{gshock_api-2.0.24 → gshock_api-2.0.26}/src/gshock_api.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ setup.cfg
 setup.py
 src/gshock_api/__init__.py
 src/gshock_api/alarms.py
+src/gshock_api/always_connected_watch_filter.py
 src/gshock_api/app_notification.py
 src/gshock_api/cancelable_result.py
 src/gshock_api/casio_constants.py

{gshock_api-2.0.24 → gshock_api-2.0.26}/src/gshock_api/iolib/events_io.py

@@ -17,7 +17,6 @@ from gshock_api.utils import (
 
 CHARACTERISTICS = CasioConstants.CHARACTERISTICS
 
-
 class ReminderMasks:
     YEARLY_MASK = 0b00001000
     MONTHLY_MASK = 0b00010000
@@ -33,7 +32,6 @@ class ReminderMasks:
 
     ENABLED_MASK = 0b00000001
 
-
 class EventsIO:
     result: CancelableResult = None
     connection = None
@@ -184,6 +182,7 @@ class EventsIO:
             title_byte_arr += bytearray([index + 1])
             title_byte_arr += title
             title_byte_arr_to_send = to_compact_string(to_hex_string(title_byte_arr))
+
             await EventsIO.connection.write(0x000E, title_byte_arr_to_send)
 
             reminder_time_byte_arr = bytearray([])
@@ -195,6 +194,7 @@ class EventsIO:
             reminder_time_byte_arr_to_send = to_compact_string(
                 to_hex_string(bytearray(reminder_time_byte_arr))
             )
+
             await EventsIO.connection.write(0x000E, reminder_time_byte_arr_to_send)
 
     @staticmethod