aidlabsdk 2.5.0__py3-none-win_amd64.whl

aidlab/__init__.py

@@ -0,0 +1,43 @@
+"""
+Aidlab Python SDK
+"""
+
+from .activity_type import ActivityType
+from .aidlab_error import AidlabError, AidlabErrorCode
+from .aidlab_manager import AidlabManager
+from .body_position import BodyPosition
+from .data_type import DataType
+from .device import Device
+from .device_delegate import DeviceDelegate
+from .disconnect_reason import DisconnectReason
+from .sync_state import SyncState
+from .transport import AidlabScanner, AidlabTransport, AidlabTransportFactory, DeviceInfo
+from .wear_state import WearState
+
+try:
+    from . import bleak_adapter as _bleak_adapter
+except ImportError:
+    _bleak_exports = []
+else:
+    BleakAidlabScanner = _bleak_adapter.BleakAidlabScanner
+    BleakTransport = _bleak_adapter.BleakTransport
+    BleakTransportFactory = _bleak_adapter.BleakTransportFactory
+    _bleak_exports = ["BleakAidlabScanner", "BleakTransport", "BleakTransportFactory"]
+
+__all__ = [
+    "ActivityType",
+    "AidlabError",
+    "AidlabErrorCode",
+    "AidlabManager",
+    "AidlabScanner",
+    "AidlabTransport",
+    "AidlabTransportFactory",
+    "BodyPosition",
+    "DataType",
+    "Device",
+    "DeviceDelegate",
+    "DeviceInfo",
+    "DisconnectReason",
+    "SyncState",
+    "WearState",
+] + _bleak_exports

aidlab/_native.py

@@ -0,0 +1,62 @@
+"""Native Aidlab SDK library selection shared by runtime and packaging."""
+
+from __future__ import annotations
+
+import platform
+import sys
+from typing import TypedDict
+
+
+class NativeTarget(TypedDict):
+    library: str
+    wheel_platform: str
+
+
+NATIVE_TARGETS: dict[str, NativeTarget] = {
+    "linux-x86_64": {
+        "library": "aidlabsdk-linux-gnu.so",
+        "wheel_platform": "linux_x86_64",
+    },
+    "linux-aarch64": {
+        "library": "aidlabsdk-linux-gnu-aarch64.so",
+        "wheel_platform": "linux_aarch64",
+    },
+    "linux-armv7l": {
+        "library": "aidlabsdk-linux-gnueabihf.so",
+        "wheel_platform": "linux_armv7l",
+    },
+    "macos-universal2": {
+        "library": "aidlabsdk.dylib",
+        "wheel_platform": "macosx_11_0_universal2",
+    },
+    "windows-x86_64": {
+        "library": "aidlabsdk.dll",
+        "wheel_platform": "win_amd64",
+    },
+}
+
+
+def native_target_key(system_platform: str | None = None, machine: str | None = None) -> str:
+    """Return the distribution target for the current host."""
+    current_platform = (system_platform or sys.platform).lower()
+    current_machine = (machine or platform.machine()).lower()
+
+    if current_platform.startswith("linux"):
+        if current_machine in {"x86_64", "amd64"}:
+            return "linux-x86_64"
+        if current_machine in {"aarch64", "arm64"}:
+            return "linux-aarch64"
+        if current_machine in {"armv6l", "armv7l"}:
+            return "linux-armv7l"
+        raise RuntimeError(f"Unsupported Linux architecture: {current_machine}")
+
+    if current_platform == "darwin":
+        return "macos-universal2"
+    if current_platform == "win32":
+        return "windows-x86_64"
+    raise RuntimeError(f"Unsupported operating system: {current_platform}")
+
+
+def native_library_name(system_platform: str | None = None, machine: str | None = None) -> str:
+    """Return the packaged library filename for the requested host."""
+    return NATIVE_TARGETS[native_target_key(system_platform, machine)]["library"]

aidlab/activity_type.py

@@ -0,0 +1,27 @@
+"""
+Created by Jakub Domaszewicz on 16.03.2024.
+"""
+
+from enum import IntEnum
+
+
+class ActivityType(IntEnum):
+    """
+    Enumerates the possible types of activities that can be recognized by the device.
+
+    Attributes:
+        UNKNOWN (0): The activity is unknown or not recognized.
+        AUTOMOTIVE (1): The user is in a vehicle, such as a car, bus, or train.
+        WALKING (2): The user is walking.
+        RUNNING (4): The user is running.
+        CYCLING (8): The user is cycling.
+        STILL (16): The user is still, i.e. not moving.
+
+    """
+
+    UNKNOWN = 0
+    AUTOMOTIVE = 1
+    WALKING = 2
+    RUNNING = 4
+    CYCLING = 8
+    STILL = 16

aidlab/aidlab_error.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from enum import IntEnum
+
+
+class AidlabErrorCode(IntEnum):
+    NONE = 0
+    TRANSPORT = 1000
+    PROTOCOL = 2000
+    SDK = 9000
+
+    @classmethod
+    def from_value(cls, value: int) -> "AidlabErrorCode":
+        try:
+            return cls(value)
+        except ValueError:
+            return cls.SDK
+
+
+@dataclass(frozen=True)
+class AidlabError:
+    code: AidlabErrorCode
+    message: str
+
+    def __str__(self) -> str:
+        return f"AidlabError(code={self.code.name}, message={self.message})"

aidlab/aidlab_manager.py

@@ -0,0 +1,64 @@
+"""
+Part of the Aidlab Python SDK, providing the core functionality for scanning compatible devices.
+
+To customise logging, configure the standard Python logging system in your
+application, for example:
+
+    logging.getLogger("aidlab.aidlab_manager").setLevel(logging.INFO)
+
+Created by Szymon Gesicki on 09.05.2020.
+"""
+
+import logging
+
+from .device import Device
+from .transport import AidlabScanner, AidlabTransportFactory
+
+logger = logging.getLogger(__name__)
+
+
+class AidlabManager:
+    """
+    The central class of the Aidlab SDK for scanning compatible devices.
+    """
+
+    def __init__(
+        self,
+        scanner: AidlabScanner | None = None,
+        transport_factory: AidlabTransportFactory | None = None,
+    ):
+        if scanner is None or transport_factory is None:
+            try:
+                from .bleak_adapter import BleakAidlabScanner, BleakTransportFactory
+            except ImportError as exc:
+                raise RuntimeError(
+                    "Default BLE adapter requires the 'bleak' dependency. "
+                    "Install it or provide custom scanner and transport_factory."
+                ) from exc
+
+        self._scanner = scanner if scanner is not None else BleakAidlabScanner()
+        self._transport_factory = transport_factory if transport_factory is not None else BleakTransportFactory()
+
+    async def scan(self, timeout: int = 10) -> list[Device]:
+        """
+        Scans for compatible devices.
+
+        :param timeout: The time in seconds to scan for devices.
+        """
+
+        logger.info("Scanning for devices (timeout: %d seconds)...", timeout)
+
+        devices = await self._scanner.scan(timeout)
+
+        compatible_devices = [
+            Device(
+                address=device.address,
+                name=device.name,
+                transport=self._transport_factory.create(device),
+            )
+            for device in devices
+        ]
+
+        logger.info("Finished scanning. Found %d devices.", len(compatible_devices))
+
+        return compatible_devices

aidlab/bleak_adapter.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import suppress
+
+from bleak import BleakClient, BleakScanner
+from bleak.backends.characteristic import BleakGATTCharacteristic
+from bleak.backends.device import BLEDevice
+
+from .transport import (
+    AidlabScanner,
+    AidlabTransport,
+    AidlabTransportFactory,
+    DeviceInfo,
+)
+
+
+class BleakTransport(AidlabTransport):
+    def __init__(self, device: str | BLEDevice):
+        self._device = device
+        self._client: BleakClient | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._disconnect_queue: asyncio.Queue[None] = asyncio.Queue()
+        self._notify_slots: dict[str, _NotifySlot] = {}
+
+    @property
+    def mtu_size(self) -> int:
+        client = self._client
+        if client is None:
+            return 23
+        return getattr(client, "mtu_size", 23)
+
+    async def connect(self) -> None:
+        await self._reset_notifications()
+        self._loop = asyncio.get_running_loop()
+
+        def _on_disconnect(_client: BleakClient) -> None:
+            loop = self._loop
+            if loop is not None and not loop.is_closed():
+                loop.call_soon_threadsafe(self._disconnect_queue.put_nowait, None)
+
+        client = BleakClient(self._device, disconnected_callback=_on_disconnect)
+        self._client = client
+        await client.connect(timeout=10)
+
+    async def disconnect(self) -> None:
+        try:
+            await self._require_client().disconnect()
+        finally:
+            await self._reset_notifications()
+
+    async def read_char(self, uuid: str) -> bytes:
+        return bytes(await self._require_client().read_gatt_char(uuid))
+
+    async def write_char(self, uuid: str, data: bytes, response: bool = True) -> None:
+        client = self._require_client()
+        characteristic = client.services.get_characteristic(uuid)
+        if characteristic is None:
+            raise RuntimeError(f"BLE characteristic {uuid} is unavailable")
+
+        properties = set(characteristic.properties)
+        if response:
+            if "write" not in properties:
+                raise RuntimeError(f"BLE characteristic {uuid} does not support writes with response")
+        elif "write-without-response" not in properties:
+            raise RuntimeError(f"BLE characteristic {uuid} does not support writes without response")
+
+        await client.write_gatt_char(characteristic, data, response)
+
+    async def notifications(self, uuid: str):
+        slot = self._notify_slots.get(uuid)
+        if slot is None:
+            slot = _NotifySlot(uuid=uuid, transport=self)
+            self._notify_slots[uuid] = slot
+        return await slot.subscribe()
+
+    async def disconnections(self):
+        return _queue_iter(self._disconnect_queue)
+
+    def _require_client(self) -> BleakClient:
+        client = self._client
+        if client is None:
+            raise RuntimeError("BLE client is not connected")
+        return client
+
+    async def _reset_notifications(self) -> None:
+        slots = list(self._notify_slots.values())
+        self._notify_slots.clear()
+        for slot in slots:
+            await slot.close()
+
+
+async def _queue_iter(queue: asyncio.Queue[None] | asyncio.Queue[bytes]):
+    while True:
+        item = await queue.get()
+        yield item
+
+
+class _NotifySlot:
+    def __init__(self, uuid: str, transport: BleakTransport):
+        self._uuid = uuid
+        self._transport = transport
+        self._queues: list[asyncio.Queue[bytes]] = []
+        self._active = False
+        self._lock = asyncio.Lock()
+
+    async def subscribe(self):
+        queue: asyncio.Queue[bytes] = asyncio.Queue()
+        self._queues.append(queue)
+        await self._ensure_started()
+
+        async def _gen():
+            try:
+                while True:
+                    data = await queue.get()
+                    yield data
+            finally:
+                await self._remove_queue(queue)
+
+        return _gen()
+
+    async def _ensure_started(self) -> None:
+        async with self._lock:
+            if self._active:
+                return
+            self._active = True
+            client = self._transport._require_client()
+            loop = asyncio.get_running_loop()
+
+            def _on_data(_sender: BleakGATTCharacteristic, data: bytearray) -> None:
+                payload = bytes(data)
+                loop.call_soon_threadsafe(self._deliver_payload, payload)
+
+            await client.start_notify(self._uuid, _on_data)
+
+    def _deliver_payload(self, payload: bytes) -> None:
+        if not self._active:
+            return
+        for q in list(self._queues):
+            q.put_nowait(payload)
+
+    async def _remove_queue(self, queue: asyncio.Queue[bytes]) -> None:
+        async with self._lock:
+            with suppress(ValueError):
+                self._queues.remove(queue)
+            if self._queues:
+                return
+            if not self._active:
+                return
+            self._active = False
+            client = self._transport._client
+            if client is None:
+                return
+            with suppress(Exception):
+                await client.stop_notify(self._uuid)
+
+    async def close(self) -> None:
+        async with self._lock:
+            self._queues.clear()
+            if not self._active:
+                return
+            self._active = False
+            client = self._transport._client
+            if client is None:
+                return
+            with suppress(Exception):
+                await client.stop_notify(self._uuid)
+
+
+class BleakAidlabScanner(AidlabScanner):
+    async def scan(self, timeout: float = 10.0) -> list[DeviceInfo]:
+        devices = await BleakScanner.discover(timeout=timeout)
+        compatible_devices: list[DeviceInfo] = []
+
+        for device in devices:
+            if (device.name == "Aidlab 2" or device.name == "Aidlab") and device.address:
+                compatible_devices.append(DeviceInfo(address=device.address, name=device.name, metadata=device))
+
+        return compatible_devices
+
+
+class BleakTransportFactory(AidlabTransportFactory):
+    def create(self, device: DeviceInfo) -> AidlabTransport:
+        native_device = device.metadata if isinstance(device.metadata, BLEDevice) else device.address
+        return BleakTransport(native_device)

aidlab/body_position.py

@@ -0,0 +1,25 @@
+"""
+Created by Jakub Domaszewicz on 17.12.2023.
+"""
+
+from enum import IntEnum
+
+
+class BodyPosition(IntEnum):
+    """
+    Enumerates the possible positions of a body when lying on a bed with a device.
+    Each value represents a specific orientation of the body relative to the bed.
+
+    Attributes:
+        UNKNOWN (0): The body's position is unknown or not recognized.
+        PRONE (1): The body is lying face down on its stomach.
+        SUPINE (2): The body is lying face up on its back.
+        LEFT_SIDE (3): The body is lying on its left side.
+        RIGHT_SIDE (4): The body is lying on its right side.
+    """
+
+    UNKNOWN = 0
+    PRONE = 1
+    SUPINE = 2
+    LEFT_SIDE = 3
+    RIGHT_SIDE = 4

aidlab/data_type.py

@@ -0,0 +1,31 @@
+"""
+Created by Szymon Gesicki on 07.11.2021.
+"""
+
+from enum import IntEnum
+
+
+class DataType(IntEnum):
+    """
+    Data types that can be received from Aidlab and Aidmed One.
+    See the documentation to learn more about each data type.
+    """
+
+    ECG = 0
+    RESPIRATION = 1
+    SKIN_TEMPERATURE = 2
+    MOTION = 3
+    RESERVED_0 = 4  # Was BATTERY. Enabled by default since SDK 1.6.0
+    ACTIVITY = 5
+    ORIENTATION = 6
+    STEPS = 7
+    HEART_RATE = 8
+    RESERVED_1 = 9  # Was HEALTH_THERMOMETHER. No longer in use. Use SKIN_TEMPERATURE instead.
+    SOUND_VOLUME = 10
+    RR = 11
+    PRESSURE = 12  # Supported since Firmware 3.0.0. No longer available as characteristic.
+    RESERVED_2 = 13  # Was SOUND_FEATURES. No longer in use.
+    RESPIRATION_RATE = 14
+    BODY_POSITION = 15
+    EDA = 16
+    GPS = 17