mudra-sdk 0.2.2__tar.gz → 0.2.4__tar.gz

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mudra_sdk
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python SDK for Mudra with native library support
 Author: Foad Khoury
 Project-URL: Documentation, https://wearable-devices.github.io/#welcome

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk/__init__.py

@@ -2,7 +2,7 @@
 Mudra SDK - Python client for Mudra API
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 __author__ = "Foad Khoury"
 
 # Import main classes/functions to make them available at package level
@@ -13,6 +13,7 @@ from .service import *
 # Define what's available when someone does: from mudra_sdk import *
 __all__ = [
     "Mudra",
-    "MudraDevice",  
+    "MudraDevice",
     "FirmwareCallbacks",
+    "FirmwareDetails",
 ]

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk/cloud/api_config.py

@@ -122,7 +122,7 @@ class Endpoint(Enum):
     ABORT_VIDEO_RECORDING = ("data/upload/abortVideoRecording", HttpMethod.POST)
     DOWNLOAD_RECORDING = ("data/download/recordingDb", HttpMethod.POST)
     DOWNLOAD_VIDEO_RECORDING_DIRECT = ("data/download/directVideoRecording", HttpMethod.POST)
-    LICENSE_SECURE_TOKEN = ("license/secure-token", HttpMethod.POST)
+    LICENSE_SECURE_TOKEN = ("license/getLicense", HttpMethod.POST)
 
     def __init__(self, path: str, method: HttpMethod):
         self.path = path

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk/cloud/data.py

@@ -458,12 +458,12 @@ class SetSerialNumberRequest:
 @dataclass
 class LicenseSecureTokenRequest:
     """Request for license/secure-token API"""
-    random_number: bytes
+    securityNumber: int
 
     def to_json(self) -> Dict[str, Any]:
         return {
-            'encryptionMethod': 'BITWISE',
-            'random_number': list(self.random_number),
+            'encryptionMethod': 'ADVANCED',
+            'securityNumber': self.securityNumber,
         }
 
 

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk/cloud/mudra_server_client.py

@@ -622,12 +622,10 @@ class MudraServerClient(RequestInterceptorDelegate):
             }
         )
 
-    def send_security_number_api_call(self, random_number: bytes) -> Optional[bytes]:
-        """Call license secure token API with random number. Returns token as bytes or None.
-            uses first 4 bytes of random_number."""
+    def send_security_number_api_call(self, securityNumber: int) -> Optional[bytes]:
+        """Call license secure token API with value. Returns token as bytes or None."""
         try:
-            first_four = random_number[:4] if len(random_number) >= 4 else random_number
-            request = LicenseSecureTokenRequest(random_number=bytes(first_four))
+            request = LicenseSecureTokenRequest(securityNumber=securityNumber)
             response = self._make_api_call(
                 endpoint=Endpoint.LICENSE_SECURE_TOKEN,
                 data=request.to_json(),

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk/models/__init__.py

@@ -1,3 +1,4 @@
 from .mudra import Mudra
 from .mudra_device import MudraDevice
 from .enums import FirmwareCallbacks
+from .firmware_details import FirmwareDetails

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk/models/callbacks.py

@@ -130,7 +130,7 @@ class BleServiceDelegate(ABC):
         pass
 
     @abstractmethod
-    def on_security_number_received(self, device_address: str, data: bytes):
+    def on_security_number_received(self, device_address: str, value: int):
         pass
 
     @abstractmethod

mudra_sdk-0.2.4/mudra_sdk/models/firmware_details.py

@@ -0,0 +1,12 @@
+class FirmwareDetails:
+
+    __slots__ = ()
+
+    def __new__(cls):
+        raise TypeError("%s cannot be instantiated" % cls.__name__)
+
+    #: Stable firmware version for Mudra Band (DFU, device info, cloud details).
+    STABLE_VERSION_MUDRA = "6.0.8.5"
+
+    #: Release / MDK target firmware version for update checks.
+    RELEASE_VERSION_MUDRA = "6.0.8.5"

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk/models/mudra.py

@@ -91,7 +91,7 @@ class Mudra(BleServiceDelegate):
 
     async def set_band_mode(self, device: mudraDeviceModule.MudraDevice, band_mode: BandMode):
         await self._ble_service.set_band_mode(device, band_mode)
-
+        
     async def get_security_number(self, device: mudraDeviceModule.MudraDevice):
         await self._ble_service.get_security_number(device)
 
@@ -157,9 +157,9 @@ class Mudra(BleServiceDelegate):
         if device_address in self._mudra_devices:
             self._mudra_devices[device_address].on_firmware_version_received(version)
 
-    def on_security_number_received(self, device_address: str, data: bytes):
+    def on_security_number_received(self, device_address: str, value: int):
         if device_address in self._mudra_devices:
-            self._mudra_devices[device_address].on_security_number_received(data)
+            self._mudra_devices[device_address].on_security_number_received(value)
 
     def on_battery_level_changed(self, device_address: str, level: int):
         if device_address in self._mudra_devices:
@@ -185,6 +185,7 @@ class Mudra(BleServiceDelegate):
         mudra_device = self._mudra_devices[device.address]
         if mudra_device and self._delegate:
             self._delegate.on_mudra_device_disconnected(device)
+            mudra_device.handle_disconnection()
 
     def on_mudra_device_disconnecting(self, device: BLEDevice):
         mudra_device = self._mudra_devices[device.address]

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk/models/mudra_device.py

@@ -10,6 +10,40 @@ import mudra_sdk.models.mudra as mudraModule
 import mudra_sdk.models.computation_wrapper as computationWrapperModule
 from mudra_sdk.service.ble_service import MudraBLEServicesUUID, MudraCharacteristicUUID
 
+
+class SecurityNumberPoller:
+    __slots__ = ("_device", "_task")
+
+    def __init__(self, device: "MudraDevice"):
+        self._device = device
+        self._task: Optional[asyncio.Task] = None
+
+    def start(self) -> None:
+        if self._task is not None and not self._task.done():
+            return
+        loop = asyncio.get_running_loop()
+        self._task = loop.create_task(self._poll_until_received())
+
+    def stop(self) -> None:
+        if self._task is None:
+            return
+        task = self._task
+        self._task = None
+        if not task.done():
+            task.cancel()
+
+    async def _poll_until_received(self) -> None:
+        try:
+            while True:
+                await self._device.get_security_number()
+                await asyncio.sleep(0.1)
+        except asyncio.CancelledError:
+            raise
+        finally:
+            if self._task is asyncio.current_task():
+                self._task = None
+
+
 class MudraDevice(BLEDevice):
     def __init__(self, ble_device: BLEDevice):
         super().__init__(ble_device.address, ble_device.name, ble_device.details)
@@ -49,8 +83,8 @@ class MudraDevice(BLEDevice):
             FirmwareDataType.embeddedAirTouch: False,
         }
         ### ----------------------- Parameters ----------------------- ###
-        self._security_number: Optional[bytes] = None
         self._license_sent: bool = False
+        self._security_number_poller = SecurityNumberPoller(self)
 
         ### ----------------------- Data Recorder ----------------------- ###
         self._data_recorder = DataRecorder()
@@ -61,7 +95,6 @@ class MudraDevice(BLEDevice):
         self._on_navigation_axis_ready: Optional[computationWrapperModule.OnNavigationAxisReceivedCallback] = None
         self._on_navigation_direction_ready: Optional[computationWrapperModule.OnNavigationDirectionReceivedCallback] = None
         self._on_button_changed_ready: Optional[computationWrapperModule.OnAirMouseButtonChangedReceivedCallback] = None
-        self._on_security_number_received: Optional[computationWrapperModule.OnSecurityNumberReceivedCallback] = None
 
         ### ----------------------- Parameters Callbacks ----------------------- ###
         self._on_charging_state_changed: Optional[computationWrapperModule.OnChargingStateChangedCallback] = None
@@ -85,10 +118,11 @@ class MudraDevice(BLEDevice):
             if not status:
                 return False
         print(f"Device {self.name} is finished initializing")
-        await self.get_security_number()
-        await self.get_security_number()
         return await mudraModule.Mudra().is_connected(self)
 
+    def handle_disconnection(self):
+        self._security_number_poller.stop()
+        
     ### ----------------------- Ready Methods ----------------------- ###
 
     def on_pressure_data_received(self, pressure_data: float):
@@ -113,26 +147,31 @@ class MudraDevice(BLEDevice):
             self._on_navigation_direction_ready(direction)
 
     def on_charging_state_changed(self, is_charging: bool):
+        print(f"Charging state changed: {is_charging}")
         self._is_charging = is_charging
         if self._on_charging_state_changed:
             self._on_charging_state_changed(is_charging)
 
     def on_serial_number_right_part_received(self, serial_number: int):
+        print(f"Serial number right part received: {serial_number}")
         self._serial_number_right_part = serial_number
 
     def on_serial_number_left_part_received(self, serial_number: int):
+        print(f"Serial number left part received: {serial_number}")
         self._serial_number_left_part = serial_number
 
     def on_firmware_version_received(self, version: str):
+        print(f"Firmware version received: {version}")
         self._firmware_version = version
 
-    def on_security_number_received(self, data: bytes):
-        self._security_number = data
-        if self._on_security_number_received:
-            self._on_security_number_received(data)
+    def on_security_number_received(self, value: int):
+        print(f"Security number received: {value}")
 
+        self._security_number_poller.stop()
         if not self._license_sent:
-            self._send_security_number(data)
+            self._license_sent = True
+            loop = asyncio.get_running_loop()
+            loop.create_task(self._send_security_number(value))
 
     def on_battery_level_changed(self, level: int):
         self._battery_level = level
@@ -145,7 +184,6 @@ class MudraDevice(BLEDevice):
         return self._is_charging
 
     def get_serial_number(self) -> Optional[int]:
-        self._license_sent = False
         if self._serial_number_right_part is not None and self._serial_number_left_part is not None:
             return self._serial_number_right_part + self._serial_number_left_part
         return None
@@ -167,20 +205,19 @@ class MudraDevice(BLEDevice):
         if self._characteristic_status[MudraCharacteristicUUID.COMMAND_CHARACTERISTIC]:
             await mudraModule.Mudra().set_band_mode(self, band_mode)
 
-    async def get_security_number(self,):
+    async def get_security_number(self):
         if self._characteristic_status[MudraCharacteristicUUID.COMMAND_CHARACTERISTIC]:
             await mudraModule.Mudra().get_security_number(self)
 
-    def _send_security_number(self, random_number: bytes):
-        """Call send_security_number API and set license on device"""
-        self._license_sent = True
+    async def _send_security_number(self, value: int):
+        """Sync fallback when no asyncio loop is running."""
         try:
-            token = MudraServerClient().send_security_number_api_call(random_number)
+            token = MudraServerClient().send_security_number_api_call(value)
             if token is not None:
-                # Schedule async set_license - BLE callback may be sync but typically runs in async context
                 try:
                     loop = asyncio.get_running_loop()
                     loop.create_task(self.set_license(token))
+                    self._license_sent = False
                 except RuntimeError:
                     print("Cannot set license: no running event loop (ensure app uses asyncio)")
             else:
@@ -203,6 +240,8 @@ class MudraDevice(BLEDevice):
     def on_characteristic_discovered(self, characteristic_uuid: MudraCharacteristicUUID):
         print(f"Characteristic discovered: {characteristic_uuid}")
         self._characteristic_status[characteristic_uuid] = True
+        if(characteristic_uuid == MudraCharacteristicUUID.COMMAND_CHARACTERISTIC):
+            self._security_number_poller.start()
 
     def on_firmware_status_updated(self, data: bytes):
         self.firmware_status.update(data)
@@ -264,9 +303,6 @@ class MudraDevice(BLEDevice):
         self._computation_wrapper.set_air_touch_active(active)
         await self._update_state_enabled()
 
-    async def set_on_security_number_received(self, callback: computationWrapperModule.OnSecurityNumberReceivedCallback) -> None:
-        self._on_security_number_received = callback
-
     ### ----------------------- Is Callbacks set Methods ----------------------- ###
 
     def is_on_imu_gyro_callback_set(self) -> bool:

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk/service/ble_service.py

@@ -2,7 +2,7 @@ import asyncio
 from calendar import c
 import cmd
 from enum import Enum
-from typing import Any, Callable, Optional, Dict
+from typing import Any, Callable, Optional, Dict, List, Tuple
 from bleak import BleakScanner, BleakClient
 from bleak.backends.device import BLEDevice
 from bleak.backends.service import BleakGATTServiceCollection
@@ -10,8 +10,6 @@ from mudra_sdk.models.enums import AirMouseButton, FirmwareCallbacks, FirmwareCo
 
 from ..models.callbacks import BleServiceDelegate
 
-from typing import Optional
-
 class BleService:
     _instance = None
     _delegate: Optional[BleServiceDelegate] = None
@@ -56,8 +54,6 @@ class BleService:
             # Attempt connection
             print(f"Calling BleakClient.connect() for {address}")
             await client.connect()
-            import asyncio
-            await asyncio.sleep(10)
             
             # Store the connected client
             self._connected_clients[address] = client
@@ -266,13 +262,13 @@ class BleService:
             case FirmwareCallbacks.BAND_CONNECTION_STATUS:
                 pass
             case FirmwareCallbacks.SecurityNumber:
-                if self._delegate:
-                    self._delegate.on_security_number_received(device.address, data[1:])
+                if self._delegate and len(data) >= 5:
+                    value = data[4] << 24 | data[3] << 16 | data[2] << 8 | data[1]
+                    self._delegate.on_security_number_received(device.address, value)
             case FirmwareCallbacks.NONE:
                 print("NONE")
             case _:
                 print("Unknown firmware callback")
-
     def _logging_notification_handler(self, device: BLEDevice, sender: int, data: bytearray):
         """Handle LOGGING characteristic notifications."""
         print(f"LOGGING notification from {sender} (device {device.address}): {data.hex()}")
@@ -449,15 +445,10 @@ class BleService:
         await self.send_general_command(device, bytes(cmd))
 
     async def set_license(self, device: BLEDevice, data: bytes):
-        cmd = bytearray(FirmwareCommand.setLicense.id)
-        cmd[2] = data[0]
-        cmd[3] = data[1]
-        cmd[4] = data[2]
-        cmd[5] = data[3]
+        cmd = bytearray(list(FirmwareCommand.setLicense.id) + list(data))
         await self.send_general_command(device, bytes(cmd))
 
     ### ----------------------- Scan Methods ----------------------- ###
-    
     @property
     def _is_scanning(self) -> bool:
         """Check if currently scanning for devices."""

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mudra_sdk
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python SDK for Mudra with native library support
 Author: Foad Khoury
 Project-URL: Documentation, https://wearable-devices.github.io/#welcome

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/mudra_sdk.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ mudra_sdk/models/callbacks.py
 mudra_sdk/models/computation_wrapper.py
 mudra_sdk/models/data_recorder.py
 mudra_sdk/models/enums.py
+mudra_sdk/models/firmware_details.py
 mudra_sdk/models/firmware_status.py
 mudra_sdk/models/mudra.py
 mudra_sdk/models/mudra_device.py

{mudra_sdk-0.2.2 → mudra_sdk-0.2.4}/setup.py

@@ -29,7 +29,7 @@ if libs_dir.exists():
 
 setup(
     name="mudra_sdk",
-    version="0.2.2",  
+    version="0.2.4",  
     packages=find_packages(exclude=["test*", "tests*"]),
     install_requires=[
         "bleak>=0.21.0",