gshock-api 2.0.2__tar.gz → 2.0.4__tar.gz

gshock_api-2.0.4/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: gshock_api
+Version: 2.0.4
+Summary: Pythgon API for GShock Watches using BLE
+Home-page: https://github.com/pyscaffold/pyscaffold/
+Author: Ivo Zivkov
+Author-email: Ivo Zivkov <izivkov@gmail.com>
+Platform: any
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: requests
+Dynamic: license-file
+
+gshock_api
+================
+
+Announcement
+============
+
+The library now supports sending application-level notifications to watches that support it, namely:
+
+* DW-H5600
+* GBD-H2000
+* GBD-200
+* GBD-100
+* GBD-800
+* GBD-100BAR
+* GBX-100
+
+The new API is **send_app_notification** function. 
+See the `examples/api_test.py <https://github.com/izivkov/gshock_api/blob/main/src/examples/api_tests.py#L453-L456>`_ file for usage examples.
+
+Only the **DW-H5600** watch has been tested. If you have any of the watches supporting notifications, please let me know your findings.
+
+
+Overview
+========
+This is a **Python API library** for G-Shock watches that support Bluetooth Low Energy (BLE) communication.
+
+G(M)W-5600, G(M)W-5000, GA-B2100, GA-B001-1AER, GST-B500, GST-B200, MSG-B100, 
+G-B001, GBD-H1000 (Partial support), MRG-B5000, GCW-B5000, GG-B100, ABL-100WE, 
+Edifice ECB-30, ECB-10, ECB-20, most Edifice watches, most Protrek models.
+
+It can perform the following tasks:
+
+- Set watch's time
+- Set Home Time (Home City)
+- Set Alarms
+- Set Reminders
+- Set watch's settings.
+- Get watch's name
+- Get watch's battery level
+- Get Watch's temperature
+- Get/Set watch's Timer
+- Send notifications to watch (supported models)
+
+Dependencies
+============
+
+This project requires the following Python packages:
+.. code-block:: sh
+
+   pytz
+   bleak
+
+
+So you can install them using the following command:
+.. code-block:: sh
+    
+   pip3 install -r requirements.txt
+
+
+To understand how to use the library, please refer to the **`src/examples`** folder.
+
+Virtual Environment Setup
+=========================
+
+It is recommended that you create a virtual environment to run the tests:
+
+1. Create a virtual environment:
+
+   .. code-block:: sh
+
+      # Create a virtual environment
+      python3 -m venv venv
+
+      # Activate it (Mac/Linux)
+      source venv/bin/activate
+
+      # Install dependencies
+      pip3 install -e .
+
+2. Run the tests:
+
+   .. code-block:: sh
+
+      python3 src/examples/api_tests.py [--multi-watch]
+
+The optional **`--multi-watch`** parameter forces the library to scan for watches every time it tries to connect to a watch. If not provided, 
+the library will try to connect to the last connected watch only. If you have multiple watches, you should use this parameter.
+      
+The optional **`--multi-watch`** parameter forces the library to scan for watches every time it tries to connect to a watch. If not provided, 
+the library will try to connect to the last connected watch only. If you have multiple watches, you should use this parameter.
+
+
+Installing the library for your project:
+========================================
+
+.. code-block:: sh
+
+   pip3 install gshock-api
+
+See `this project <https://github.com/izivkov/GShockTimeServer>`_ using this library to run a time server for G-Shock watches.
+
+See also `this blog <https://digitalsober.wordpress.com/2025/05/05/g-shock-watch-integration-with-sxmo/>`_ for using the library in the `SXMO <https://sxmo.org/>`_ mobile environment.
+
+Troubleshooting:
+================
+If your watch cannot connect, and the 
+**`--multi-watch`** parameter is not used, remove the **`config.ini`** file and try again.

gshock_api-2.0.4/README.rst

@@ -0,0 +1,107 @@
+gshock_api
+================
+
+Announcement
+============
+
+The library now supports sending application-level notifications to watches that support it, namely:
+
+* DW-H5600
+* GBD-H2000
+* GBD-200
+* GBD-100
+* GBD-800
+* GBD-100BAR
+* GBX-100
+
+The new API is **send_app_notification** function. 
+See the `examples/api_test.py <https://github.com/izivkov/gshock_api/blob/main/src/examples/api_tests.py#L453-L456>`_ file for usage examples.
+
+Only the **DW-H5600** watch has been tested. If you have any of the watches supporting notifications, please let me know your findings.
+
+
+Overview
+========
+This is a **Python API library** for G-Shock watches that support Bluetooth Low Energy (BLE) communication.
+
+G(M)W-5600, G(M)W-5000, GA-B2100, GA-B001-1AER, GST-B500, GST-B200, MSG-B100, 
+G-B001, GBD-H1000 (Partial support), MRG-B5000, GCW-B5000, GG-B100, ABL-100WE, 
+Edifice ECB-30, ECB-10, ECB-20, most Edifice watches, most Protrek models.
+
+It can perform the following tasks:
+
+- Set watch's time
+- Set Home Time (Home City)
+- Set Alarms
+- Set Reminders
+- Set watch's settings.
+- Get watch's name
+- Get watch's battery level
+- Get Watch's temperature
+- Get/Set watch's Timer
+- Send notifications to watch (supported models)
+
+Dependencies
+============
+
+This project requires the following Python packages:
+.. code-block:: sh
+
+   pytz
+   bleak
+
+
+So you can install them using the following command:
+.. code-block:: sh
+    
+   pip3 install -r requirements.txt
+
+
+To understand how to use the library, please refer to the **`src/examples`** folder.
+
+Virtual Environment Setup
+=========================
+
+It is recommended that you create a virtual environment to run the tests:
+
+1. Create a virtual environment:
+
+   .. code-block:: sh
+
+      # Create a virtual environment
+      python3 -m venv venv
+
+      # Activate it (Mac/Linux)
+      source venv/bin/activate
+
+      # Install dependencies
+      pip3 install -e .
+
+2. Run the tests:
+
+   .. code-block:: sh
+
+      python3 src/examples/api_tests.py [--multi-watch]
+
+The optional **`--multi-watch`** parameter forces the library to scan for watches every time it tries to connect to a watch. If not provided, 
+the library will try to connect to the last connected watch only. If you have multiple watches, you should use this parameter.
+      
+The optional **`--multi-watch`** parameter forces the library to scan for watches every time it tries to connect to a watch. If not provided, 
+the library will try to connect to the last connected watch only. If you have multiple watches, you should use this parameter.
+
+
+Installing the library for your project:
+========================================
+
+.. code-block:: sh
+
+   pip3 install gshock-api
+
+See `this project <https://github.com/izivkov/GShockTimeServer>`_ using this library to run a time server for G-Shock watches.
+
+See also `this blog <https://digitalsober.wordpress.com/2025/05/05/g-shock-watch-integration-with-sxmo/>`_ for using the library in the `SXMO <https://sxmo.org/>`_ mobile environment.
+
+Troubleshooting:
+================
+If your watch cannot connect, and the 
+**`--multi-watch`** parameter is not used, remove the **`config.ini`** file and try again.

{gshock_api-2.0.2 → gshock_api-2.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gshock_api"  # Change to your project name
-version = "2.0.2"
+version = "2.0.4"
 description = "Pythgon API for GShock Watches using BLE"
 readme = "README.rst"
 authors = [{ name = "Ivo Zivkov", email = "izivkov@gmail.com" }]

{gshock_api-2.0.2 → gshock_api-2.0.4}/setup.py

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

gshock_api-2.0.4/src/gshock_api/app_notification.py

@@ -0,0 +1,55 @@
+from enum import Enum
+from dataclasses import dataclass
+
+class NotificationType(Enum):
+    GENERIC = 0
+    PHONE_CALL_URGENT = 1
+    PHONE_CALL = 2
+    EMAIL = 3
+    MESSAGE = 4
+    CALENDAR = 5
+    EMAIL_SMS = 6
+
+@dataclass
+class AppNotification:
+    
+    type: NotificationType
+    timestamp: str
+    app: str
+    title: str
+    text: str
+    short_text: str = ""
+
+    def __post_init__(self):
+        max_length_text = 193
+        max_length_short_text = 40
+        max_combined = 206  # Example combined max in bytes
+
+        # Truncate individual fields by UTF-8 byte length
+        text_bytes = self.text.encode("utf-8")
+        if len(text_bytes) > max_length_text:
+            self.text = text_bytes[:max_length_text].decode("utf-8", errors="ignore")
+
+        short_text_bytes = self.short_text.encode("utf-8")
+        if len(short_text_bytes) > max_length_short_text:
+            self.short_text = short_text_bytes[:max_length_short_text].decode("utf-8", errors="ignore")
+
+        # Now check combined UTF-8 byte length
+        text_bytes = self.text.encode("utf-8")
+        short_text_bytes = self.short_text.encode("utf-8")
+        total_len = len(text_bytes) + len(short_text_bytes)
+        if total_len > max_combined:
+            # Only shorten text, not short_text
+            allowed_text_bytes = max(0, max_combined - len(short_text_bytes))
+            self.text = text_bytes[:allowed_text_bytes].decode("utf-8", errors="ignore")
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type,
+            "timestamp": self.timestamp,
+            "app": self.app,
+            "title": self.title,
+            "text": self.text,
+            "short_text": self.short_text,
+        }
+    

{gshock_api-2.0.2 → gshock_api-2.0.4}/src/gshock_api/casio_constants.py

@@ -6,6 +6,7 @@ class CasioConstants:
         "26eb002c-b012-49a8-b1f8-394fb2032b0f"
     )
     CASIO_ALL_FEATURES_CHARACTERISTIC_UUID = "26eb002d-b012-49a8-b1f8-394fb2032b0f"
+    CASIO_NOTIFICATION_CHARACTERISTIC_UUID = "26eb0030-b012-49a8-b1f8-394fb2032b0f"
     CASIO_DATA_REQUEST_SP_CHARACTERISTIC_UUID = "26eb0023-b012-49a8-b1f8-394fb2032b0f"
     CASIO_CONVOY_CHARACTERISTIC_UUID = "26eb0024-b012-49a8-b1f8-394fb2032b0f"
     SERIAL_NUMBER_STRING = "00002a25-0000-1000-8000-00805f9b34fb"

{gshock_api-2.0.2 → gshock_api-2.0.4}/src/gshock_api/connection.py

@@ -5,26 +5,43 @@ from gshock_api.casio_constants import CasioConstants
 from gshock_api import message_dispatcher
 from gshock_api.utils import to_casio_cmd
 from gshock_api.logger import logger
+from gshock_api.watch_info import watch_info
+from gshock_api.device import Device
 
 class Connection:
-    def __init__(self, device):
+    def __init__(self, device: Device):
         self.handles_map = self.init_handles_map()
         self.device = device
-        self.client = BleakClient(device)
+        self.client = BleakClient(device.address)
+        self.characteristics_map = {}
+
 
     def notification_handler(
         self, characteristic: BleakGATTCharacteristic, data: bytearray
     ):
         message_dispatcher.MessageDispatcher.on_received(data)
 
+    async def init_characteristics_map(self):
+        """
+        Prints all services and characteristics of the connected BLE device.
+        """
+        services = await self.client.get_services()
+        for service in services:
+            for char in service.characteristics:
+                self.characteristics_map[char.uuid] = char.uuid  # Store in map
+
     async def connect(self):
         try:
             await self.client.connect()
+            await self.init_characteristics_map()
             await self.client.start_notify(
                 CasioConstants.CASIO_ALL_FEATURES_CHARACTERISTIC_UUID,
                 self.notification_handler,
             )
+            
+            watch_info.set_name_and_model(self.device.name)
             return True
+        
         except Exception as e:
             logger.debug(f"Cannot connect: {e}")
             return False
@@ -32,10 +49,27 @@ class Connection:
     async def disconnect(self):
         await self.client.disconnect()
 
+    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(
+                    "write failed: handle {} not in characteristics map".format(handle)
+                )
+                if (handle == 13):
+                    logger.error(
+                        "Your watch does not suppot notifications..."
+                    )
+                return
+            
             await self.client.write_gatt_char(
-                self.handles_map[handle], to_casio_cmd(data)
+                uuid, to_casio_cmd(data)
             )
         except Exception as e:
             logger.debug("write failed with exception: {}".format(e))
@@ -54,6 +88,7 @@ class Connection:
             0x0C
         ] = CasioConstants.CASIO_READ_REQUEST_FOR_ALL_FEATURES_CHARACTERISTIC_UUID
         handles_map[0x0E] = CasioConstants.CASIO_ALL_FEATURES_CHARACTERISTIC_UUID
+        handles_map[0x0D] = CasioConstants.CASIO_NOTIFICATION_CHARACTERISTIC_UUID
         handles_map[0x11] = CasioConstants.CASIO_DATA_REQUEST_SP_CHARACTERISTIC_UUID
         handles_map[0x14] = CasioConstants.CASIO_CONVOY_CHARACTERISTIC_UUID
         handles_map[0xFF] = CasioConstants.SERIAL_NUMBER_STRING
@@ -61,5 +96,4 @@ class Connection:
         return handles_map
 
     async def sendMessage(self, message):
-        # await callWriter(self, message)
         await message_dispatcher.MessageDispatcher.send_to_watch(message)

gshock_api-2.0.4/src/gshock_api/device.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+@dataclass
+class Device:
+    name: str
+    address: str

{gshock_api-2.0.2 → gshock_api-2.0.4}/src/gshock_api/gshock_api.py

@@ -1,24 +1,20 @@
-import asyncio
 import logging
 import json
 import time
 
-# from data_watcher import data_watcher
 from gshock_api.iolib.dst_watch_state_io import DtsState
 from gshock_api.iolib.button_pressed_io import WatchButton
+from gshock_api.iolib.app_notification_io import AppNotificationIO
+
 from gshock_api import message_dispatcher
 from gshock_api.utils import (
-    to_ascii_string,
     to_hex_string,
-    to_int_array,
     to_compact_string,
-    clean_str,
 )
 from gshock_api.alarms import alarms_inst
 from gshock_api.event import Event
 from gshock_api.watch_info import watch_info
 
-
 class GshockAPI:
     """
     This class contains all the API functions. This should the the main interface to the
@@ -163,6 +159,9 @@ class GshockAPI:
         for item in array_of_dst_watch_state[: watch_info.dstCount]:
             await self.read_and_write(item["function"], item["state"])
 
+    async def send_app_notification (self, hex_str):
+        await self.connection.write(0xD, hex_str)
+
     async def read_write_dst_for_world_cities(self):
         array_of_get_dst_for_world_cities = [
             {"function": self.get_dst_for_world_cities, "city_number": 0},
@@ -451,6 +450,8 @@ class GshockAPI:
         result = await message_dispatcher.AppInfoIO.request(self.connection)
         return await result
 
-    # def subscribe(self, subject_name, on_next) -> None:
-    #     data_watcher.add_subject(subject_name)
-    #     data_watcher.subscribe("GshockAPI", subject_name, on_next)
+    async def send_app_notification (self, notification):
+        encoded_buffer = AppNotificationIO.encode_notification_packet(notification)
+        encrypted_buffer = AppNotificationIO.xor_encode_buffer(encoded_buffer)
+        await self.connection.write(0xD, encrypted_buffer)
+

gshock_api-2.0.4/src/gshock_api/iolib/app_notification_io.py

@@ -0,0 +1,170 @@
+from gshock_api.app_notification import AppNotification, NotificationType
+
+class AppNotificationIO:
+    def xor_decode_buffer(buffer: str, key: int = 255) -> bytes:
+        """
+        Decodes a hex-encoded buffer using XOR with the given key.
+
+        Args:
+            buffer (str): The hex-encoded buffer as a string.
+            key (int): The XOR key to decode the buffer.
+
+        Returns:
+            bytes: The XOR-decoded bytes.
+        """
+        buffer_bytes = bytes.fromhex(buffer)
+        decoded_bytes = bytes(b ^ key for b in buffer_bytes)
+        return decoded_bytes
+
+    def xor_encode_buffer(decoded_bytes: bytes, key: int = 255) -> str:
+        """
+        Encodes a buffer using XOR with the given key.
+
+        Args:
+            decoded_bytes (bytes): The original decoded bytes to encode.
+            key (int): The XOR key to encode the buffer.
+
+        Returns:
+            str: The XOR-encoded buffer as a hex string.
+        """
+        encoded_bytes = bytes(b ^ key for b in decoded_bytes)
+        return encoded_bytes.hex()
+
+    def read_length_prefixed_string(buf: bytes, offset: int) -> tuple[str, int]:
+        if offset + 2 > len(buf):
+            raise ValueError("Not enough data to read length prefix")
+
+        length = buf[offset]
+        if buf[offset + 1] != 0x00:
+            raise ValueError("Expected null second byte in length prefix")
+
+        start = offset + 2
+        end = start + length
+        if end > len(buf):
+            raise ValueError("String length exceeds buffer")
+
+        string = buf[start:end].decode("utf-8")
+        return string, end
+
+    def decode_notification_packet(buf: bytes) -> AppNotification:
+        """
+        Decodes a G-Shock calendar notification buffer into an AppNotification object.
+        """
+        offset = 0
+
+        if len(buf) < 6:
+            raise ValueError("Buffer too short")
+
+        # Read 6-byte header (skip or store if needed)
+        offset = 6
+
+        # Read 1-byte type
+        notif_type = buf[offset]
+        notif_type_enum = NotificationType(notif_type)
+        offset += 1
+
+        # Read 15-byte ASCII timestamp
+        timestamp_raw = buf[offset:offset + 15].decode("ascii")
+        offset += 15
+
+        # Read app name (length-prefixed UTF-8 string)
+        app, offset = AppNotificationIO.read_length_prefixed_string(buf, offset)
+
+        # Read title (length-prefixed UTF-8 string)
+        title, offset = AppNotificationIO.read_length_prefixed_string(buf, offset)
+
+        # Read empty string (length-prefixed UTF-8 string, skip)
+        _, offset = AppNotificationIO.read_length_prefixed_string(buf, offset)
+
+        # Read text (length-prefixed UTF-8 string)
+        text, offset = AppNotificationIO.read_length_prefixed_string(buf, offset)
+
+        # Construct and return AppNotification object
+        notification = AppNotification(
+            type = notif_type_enum,
+            timestamp=timestamp_raw,
+            app=app,
+            title=title,
+            text=text
+        )
+        return notification
+        
+    
+    def write_length_prefixed_string(text: str) -> bytes:
+        """
+        Encodes a string as a length-prefixed UTF-8 byte sequence for G-Shock BLE notifications.
+
+        Structure:
+        ----------
+        [Length: 1 byte][0x00][UTF-8 bytes of string]
+
+        - Length: Number of bytes in the UTF-8 encoded string (max 255).
+        - 0x00: Separator byte (always 0x00).
+        - UTF-8 bytes: The actual string data.
+
+        Args:
+            text (str): The string to encode.
+
+        Returns:
+            bytes: The encoded length-prefixed UTF-8 byte sequence.
+
+        Raises:
+            ValueError: If the encoded string is longer than 255 bytes.
+        """
+        
+        encoded = text.encode("utf-8")
+        if len(encoded) > 255:
+            raise ValueError("Encoded string too long")
+        return bytes([len(encoded), 0x00]) + encoded
+
+    def encode_notification_packet(data: AppNotification) -> bytes:
+        """
+        Encodes an AppNotification object into a binary buffer for G-Shock BLE notifications.
+
+        Message Structure:
+        ------------------
+        The encoded message has the following structure (all fields are concatenated in order):
+
+        [Header: 6 bytes] +
+        [Type: 1 byte] +
+        [Timestamp: 15 bytes, ASCII] +
+        [App Name: length-prefixed UTF-8 string] +
+        [Title: length-prefixed UTF-8 string] +
+        [Short Text: length-prefixed UTF-8 string] +
+        [Text: length-prefixed UTF-8 string]
+
+        - Header: Fixed 6-byte value (hex "000000000001").
+        - Type: 1 byte, value from NotificationType enum.
+        - Timestamp: 15 ASCII characters.
+        - App Name, Title, Short Text, Text: Each is encoded as [length (1 byte)][0x00][UTF-8 bytes].
+          - The length is the number of bytes in the UTF-8 encoded string (max 255).
+          - The second byte is always 0x00 as a separator.
+
+        Args:
+            data (AppNotification): The notification to encode.
+
+        Returns:
+            bytes: The encoded binary buffer.
+
+        Raises:
+            TypeError: If data is not an AppNotification instance.
+            ValueError: If any string field is too long to encode.
+
+        Example:
+            >>> notif = AppNotification(type=NotificationType.CALENDAR, timestamp="20250516T233000", app="Calendar", title="Meeting", text="Discuss project")
+            >>> buf = AppNotificationIO.encode_notification_packet(notif)
+        """
+
+        if not isinstance(data, AppNotification):
+            raise TypeError("data must be an AppNotification instance")
+    
+        header = "000000000001"
+        result = bytearray()
+        result += bytes.fromhex(header)
+        result.append(data.type.value)
+        result += data.timestamp.encode("ascii")
+        result += AppNotificationIO.write_length_prefixed_string(data.app)
+        result += AppNotificationIO.write_length_prefixed_string(data.title)
+        result += AppNotificationIO.write_length_prefixed_string(data.short_text)  # Empty string for the separator
+        result += AppNotificationIO.write_length_prefixed_string(data.text)
+        return bytes(result)

{gshock_api-2.0.2 → gshock_api-2.0.4}/src/gshock_api/iolib/button_pressed_io.py

@@ -8,7 +8,6 @@ from gshock_api.casio_constants import CasioConstants
 
 CHARACTERISTICS = CasioConstants.CHARACTERISTICS
 
-
 class WatchButton(IntEnum):
     UPPER_LEFT = 1
     LOWER_LEFT = 2

{gshock_api-2.0.2 → gshock_api-2.0.4}/src/gshock_api/iolib/dst_watch_state_io.py

@@ -14,7 +14,6 @@ class DtsState(IntEnum):
     TWO = 2
     FOUR = 4
 
-
 class DstWatchStateIO:
     result: CancelableResult = None
     connection = None

{gshock_api-2.0.2 → gshock_api-2.0.4}/src/gshock_api/iolib/error_io.py

@@ -3,5 +3,5 @@ from gshock_api.logger import logger
 
 class ErrorIO:
     @staticmethod
-    async def on_received(message):
+    def on_received(message):
         logger.info(f"ErrorIO onReceived: {message}")

{gshock_api-2.0.2 → gshock_api-2.0.4}/src/gshock_api/message_dispatcher.py

@@ -75,7 +75,6 @@ class MessageDispatcher:
             logger.info(f"Found key: {MessageDispatcher.data_received_messages[key]}")
             MessageDispatcher.data_received_messages[key](data)
 
-
 # Usage example
 if __name__ == "__main__":
     # Simulated messages

{gshock_api-2.0.2 → gshock_api-2.0.4}/src/gshock_api/scanner.py

@@ -4,12 +4,12 @@ from bleak import BleakScanner
 from gshock_api.configurator import conf
 from gshock_api.watch_info import watch_info
 from gshock_api.logger import logger
-
+from gshock_api.device import Device 
 
 class Scanner:
     CASIO_SERVICE_UUID = "00001804-0000-1000-8000-00805f9b34fb"
 
-    async def scan(self, device_address=None):
+    async def scan(self, device_address=None) -> Device:
         scanner = BleakScanner()
         logger.info("Scanning for devices...")
 
@@ -22,10 +22,9 @@ class Scanner:
                 logger.info(f"device: {device}")
                 if device is None:
                     continue
-
-                # watch_info.set_name(device.name)
-                # watch_info.set_address(device.address)
-                watch_info.set_name_and_model(device.name)
+                
+                # This is now set after connection in Connection class
+                # watch_info.set_name_and_model(device.name)
 
                 conf.put("device.address", device.address)
                 conf.put("device.name", device.name)
@@ -35,8 +34,8 @@ class Scanner:
             device = await scanner.find_device_by_address(
                 device_address, sys.float_info.max
             )
+            watch_info.set_name_and_model(device.name)
 
-        return device
-
+        return Device(device.name, device.address)
 
 scanner = Scanner()

gshock_api-2.0.4/src/gshock_api.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: gshock_api
+Version: 2.0.4
+Summary: Pythgon API for GShock Watches using BLE
+Home-page: https://github.com/pyscaffold/pyscaffold/
+Author: Ivo Zivkov
+Author-email: Ivo Zivkov <izivkov@gmail.com>
+Platform: any
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: requests
+Dynamic: license-file
+
+gshock_api
+================
+
+Announcement
+============
+
+The library now supports sending application-level notifications to watches that support it, namely:
+
+* DW-H5600
+* GBD-H2000
+* GBD-200
+* GBD-100
+* GBD-800
+* GBD-100BAR
+* GBX-100
+
+The new API is **send_app_notification** function. 
+See the `examples/api_test.py <https://github.com/izivkov/gshock_api/blob/main/src/examples/api_tests.py#L453-L456>`_ file for usage examples.
+
+Only the **DW-H5600** watch has been tested. If you have any of the watches supporting notifications, please let me know your findings.
+
+
+Overview
+========
+This is a **Python API library** for G-Shock watches that support Bluetooth Low Energy (BLE) communication.
+
+G(M)W-5600, G(M)W-5000, GA-B2100, GA-B001-1AER, GST-B500, GST-B200, MSG-B100, 
+G-B001, GBD-H1000 (Partial support), MRG-B5000, GCW-B5000, GG-B100, ABL-100WE, 
+Edifice ECB-30, ECB-10, ECB-20, most Edifice watches, most Protrek models.
+
+It can perform the following tasks:
+
+- Set watch's time
+- Set Home Time (Home City)
+- Set Alarms
+- Set Reminders
+- Set watch's settings.
+- Get watch's name
+- Get watch's battery level
+- Get Watch's temperature
+- Get/Set watch's Timer
+- Send notifications to watch (supported models)
+
+Dependencies
+============
+
+This project requires the following Python packages:
+.. code-block:: sh
+
+   pytz
+   bleak
+
+
+So you can install them using the following command:
+.. code-block:: sh
+    
+   pip3 install -r requirements.txt
+
+
+To understand how to use the library, please refer to the **`src/examples`** folder.
+
+Virtual Environment Setup
+=========================
+
+It is recommended that you create a virtual environment to run the tests:
+
+1. Create a virtual environment:
+
+   .. code-block:: sh
+
+      # Create a virtual environment
+      python3 -m venv venv
+
+      # Activate it (Mac/Linux)
+      source venv/bin/activate
+
+      # Install dependencies
+      pip3 install -e .
+
+2. Run the tests:
+
+   .. code-block:: sh
+
+      python3 src/examples/api_tests.py [--multi-watch]
+
+The optional **`--multi-watch`** parameter forces the library to scan for watches every time it tries to connect to a watch. If not provided, 
+the library will try to connect to the last connected watch only. If you have multiple watches, you should use this parameter.
+      
+The optional **`--multi-watch`** parameter forces the library to scan for watches every time it tries to connect to a watch. If not provided, 
+the library will try to connect to the last connected watch only. If you have multiple watches, you should use this parameter.
+
+
+Installing the library for your project:
+========================================
+
+.. code-block:: sh
+
+   pip3 install gshock-api
+
+See `this project <https://github.com/izivkov/GShockTimeServer>`_ using this library to run a time server for G-Shock watches.
+
+See also `this blog <https://digitalsober.wordpress.com/2025/05/05/g-shock-watch-integration-with-sxmo/>`_ for using the library in the `SXMO <https://sxmo.org/>`_ mobile environment.
+
+Troubleshooting:
+================
+If your watch cannot connect, and the 
+**`--multi-watch`** parameter is not used, remove the **`config.ini`** file and try again.

{gshock_api-2.0.2 → gshock_api-2.0.4}/src/gshock_api.egg-info/SOURCES.txt

@@ -5,11 +5,12 @@ setup.cfg
 setup.py
 src/gshock_api/__init__.py
 src/gshock_api/alarms.py
+src/gshock_api/app_notification.py
 src/gshock_api/cancelable_result.py
 src/gshock_api/casio_constants.py
 src/gshock_api/configurator.py
 src/gshock_api/connection.py
-src/gshock_api/core.py
+src/gshock_api/device.py
 src/gshock_api/event.py
 src/gshock_api/gshock_api.py
 src/gshock_api/logger.py
@@ -28,6 +29,7 @@ src/gshock_api.egg-info/top_level.txt
 src/gshock_api/iolib/__init__.py
 src/gshock_api/iolib/alarms_io.py
 src/gshock_api/iolib/app_info_io.py
+src/gshock_api/iolib/app_notification_io.py
 src/gshock_api/iolib/button_pressed_io.py
 src/gshock_api/iolib/dst_for_world_cities_io.py
 src/gshock_api/iolib/dst_watch_state_io.py

gshock_api-2.0.2/PKG-INFO

@@ -1,100 +0,0 @@
-Metadata-Version: 2.4
-Name: gshock_api
-Version: 2.0.2
-Summary: Pythgon API for GShock Watches using BLE
-Home-page: https://github.com/pyscaffold/pyscaffold/
-Author: Ivo Zivkov
-Author-email: Ivo Zivkov <izivkov@gmail.com>
-Platform: any
-Description-Content-Type: text/x-rst
-License-File: LICENSE.txt
-Requires-Dist: requests
-Dynamic: license-file
-
-GShockTimeServer
-================
-
-Overview
-========
-GShockTimeServer allows you to set the correct time on your Casio G-Shock watches, including:
-
-- `B5600 <https://amzn.to/3Mt68Qb>`__
-- `B5000 <https://amzn.to/4194M13>`__
-- `B2100 <https://amzn.to/3MUDCGY>`__
-
-Additionally, this repository provides an API for developing applications for these watches.  
-While still a work in progress, you can refer to the ``api_tests.py`` file for usage examples.
-
-Usage
-=====
-This app can run on any device with Python and Bluetooth capabilities—from a desktop to a Raspberry Pi Zero.  
-It has been tested on Linux but should also work on Windows.
-
-.. image:: images/pizero.jpg
-   :alt: Pi Zero Running the Server
-   :align: center
-
-Setting the Time
-----------------
-1. Ensure the app is running on your device.
-2. Short-press the **lower-right** button on your G-Shock watch to connect.
-3. Once connected, the app will automatically set the correct time on your watch.
-4. If **AUTO TIME ADJUSTMENT** is enabled, the watch will sync up to **four times daily**.
-
-Dependencies
-============
-
-This project requires the following Python packages:
-```
-pytz
-bleak
-```
-
-So you can install them using the following command:
-```
-pip3 install -r requirements.txt
-```
-
-Virtual Environment Setup
-=========================
-To run the server in a virtual environment:
-
-1. Create a virtual environment:
-
-.. code-block:: sh
-
-   # Create a virtual environment
-   python3 -m venv myenv
-
-   # Activate it (Mac/Linux)
-   source myenv/bin/activate
-
-   # Install dependencies
-   pip3 install -e .
-
-2. Run the tests:
-
-.. code-block:: sh
-
-   python3 src/examples/api_tests.py [--multi-watch]
-
-3. Run the server:
-
-.. code-block:: sh
-
-   python3 src/examples/gshock_server.py [--multi-watch]
-
-The optional **`--multi-watch`** parameter allows you to connect if you have multiple watches.
-
-
-Installing the library for your project:
-========================================
-
-```
-pip3 install gshock-api
-```
-
-Troubleshooting:
-================
-If your watch cannot connect, and the 
-**`--multi-watch`** parameter is not used, remove the **`config.ini`** file and try again.

gshock_api-2.0.2/README.rst

@@ -1,87 +0,0 @@
-GShockTimeServer
-================
-
-Overview
-========
-GShockTimeServer allows you to set the correct time on your Casio G-Shock watches, including:
-
-- `B5600 <https://amzn.to/3Mt68Qb>`__
-- `B5000 <https://amzn.to/4194M13>`__
-- `B2100 <https://amzn.to/3MUDCGY>`__
-
-Additionally, this repository provides an API for developing applications for these watches.  
-While still a work in progress, you can refer to the ``api_tests.py`` file for usage examples.
-
-Usage
-=====
-This app can run on any device with Python and Bluetooth capabilities—from a desktop to a Raspberry Pi Zero.  
-It has been tested on Linux but should also work on Windows.
-
-.. image:: images/pizero.jpg
-   :alt: Pi Zero Running the Server
-   :align: center
-
-Setting the Time
-----------------
-1. Ensure the app is running on your device.
-2. Short-press the **lower-right** button on your G-Shock watch to connect.
-3. Once connected, the app will automatically set the correct time on your watch.
-4. If **AUTO TIME ADJUSTMENT** is enabled, the watch will sync up to **four times daily**.
-
-Dependencies
-============
-
-This project requires the following Python packages:
-```
-pytz
-bleak
-```
-
-So you can install them using the following command:
-```
-pip3 install -r requirements.txt
-```
-
-Virtual Environment Setup
-=========================
-To run the server in a virtual environment:
-
-1. Create a virtual environment:
-
-.. code-block:: sh
-
-   # Create a virtual environment
-   python3 -m venv myenv
-
-   # Activate it (Mac/Linux)
-   source myenv/bin/activate
-
-   # Install dependencies
-   pip3 install -e .
-
-2. Run the tests:
-
-.. code-block:: sh
-
-   python3 src/examples/api_tests.py [--multi-watch]
-
-3. Run the server:
-
-.. code-block:: sh
-
-   python3 src/examples/gshock_server.py [--multi-watch]
-
-The optional **`--multi-watch`** parameter allows you to connect if you have multiple watches.
-
-
-Installing the library for your project:
-========================================
-
-```
-pip3 install gshock-api
-```
-
-Troubleshooting:
-================
-If your watch cannot connect, and the 
-**`--multi-watch`** parameter is not used, remove the **`config.ini`** file and try again.

gshock_api-2.0.2/src/gshock_api/core.py

@@ -1,4 +0,0 @@
-# filepath: gshock_api/src/gshock_api/core.py
-def example_function():
-    return "Hello from gshock_api core!"
-    

gshock_api-2.0.2/src/gshock_api.egg-info/PKG-INFO

@@ -1,100 +0,0 @@
-Metadata-Version: 2.4
-Name: gshock_api
-Version: 2.0.2
-Summary: Pythgon API for GShock Watches using BLE
-Home-page: https://github.com/pyscaffold/pyscaffold/
-Author: Ivo Zivkov
-Author-email: Ivo Zivkov <izivkov@gmail.com>
-Platform: any
-Description-Content-Type: text/x-rst
-License-File: LICENSE.txt
-Requires-Dist: requests
-Dynamic: license-file
-
-GShockTimeServer
-================
-
-Overview
-========
-GShockTimeServer allows you to set the correct time on your Casio G-Shock watches, including:
-
-- `B5600 <https://amzn.to/3Mt68Qb>`__
-- `B5000 <https://amzn.to/4194M13>`__
-- `B2100 <https://amzn.to/3MUDCGY>`__
-
-Additionally, this repository provides an API for developing applications for these watches.  
-While still a work in progress, you can refer to the ``api_tests.py`` file for usage examples.
-
-Usage
-=====
-This app can run on any device with Python and Bluetooth capabilities—from a desktop to a Raspberry Pi Zero.  
-It has been tested on Linux but should also work on Windows.
-
-.. image:: images/pizero.jpg
-   :alt: Pi Zero Running the Server
-   :align: center
-
-Setting the Time
-----------------
-1. Ensure the app is running on your device.
-2. Short-press the **lower-right** button on your G-Shock watch to connect.
-3. Once connected, the app will automatically set the correct time on your watch.
-4. If **AUTO TIME ADJUSTMENT** is enabled, the watch will sync up to **four times daily**.
-
-Dependencies
-============
-
-This project requires the following Python packages:
-```
-pytz
-bleak
-```
-
-So you can install them using the following command:
-```
-pip3 install -r requirements.txt
-```
-
-Virtual Environment Setup
-=========================
-To run the server in a virtual environment:
-
-1. Create a virtual environment:
-
-.. code-block:: sh
-
-   # Create a virtual environment
-   python3 -m venv myenv
-
-   # Activate it (Mac/Linux)
-   source myenv/bin/activate
-
-   # Install dependencies
-   pip3 install -e .
-
-2. Run the tests:
-
-.. code-block:: sh
-
-   python3 src/examples/api_tests.py [--multi-watch]
-
-3. Run the server:
-
-.. code-block:: sh
-
-   python3 src/examples/gshock_server.py [--multi-watch]
-
-The optional **`--multi-watch`** parameter allows you to connect if you have multiple watches.
-
-
-Installing the library for your project:
-========================================
-
-```
-pip3 install gshock-api
-```
-
-Troubleshooting:
-================
-If your watch cannot connect, and the 
-**`--multi-watch`** parameter is not used, remove the **`config.ini`** file and try again.