sensor-sdk 1.3.3__py3-none-win_amd64.whl

sensor/sensor_profile.py

@@ -0,0 +1,674 @@
+import asyncio
+import ctypes
+import inspect
+import threading
+import traceback
+from typing import Callable, Optional
+
+from . import _dll
+from . import _sync
+from .sensor_data import SensorData
+from .sensor_device import BLEDevice, DeviceInfo, DeviceStateEx
+
+_sdk_thread_ids = set()
+_sdk_thread_ids_lock = threading.Lock()
+
+def _mark_sdk_thread():
+    with _sdk_thread_ids_lock:
+        _sdk_thread_ids.add(threading.get_ident())
+
+def _is_sdk_thread() -> bool:
+    with _sdk_thread_ids_lock:
+        return threading.get_ident() in _sdk_thread_ids
+
+def _raise_on_sdk_thread():
+    if _is_sdk_thread():
+        raise RuntimeError("blocking sync call from an SDK callback thread")
+
+def _decode_str(raw) -> str:
+    if not raw:
+        return ""
+    return raw.decode("utf-8", errors="replace") if isinstance(raw, bytes) else str(raw)
+
+def _resolve_future(loop, fut, value):
+    def _set():
+        if not fut.done():
+            fut.set_result(value)
+    try:
+        loop.call_soon_threadsafe(_set)
+    except Exception:
+        pass
+
+def _ctx_self(ctx) -> "SensorProfile":
+    return ctypes.cast(ctx, ctypes.POINTER(ctypes.py_object)).contents.value
+
+def _wrap_auto_reconnect_callback(callback):
+    if callback is None:
+        return None
+    try:
+        argc = len(inspect.signature(callback).parameters)
+    except (TypeError, ValueError):
+        argc = 3
+    if argc == 2:
+        def _wrapped(sensor, has_last_session, answer):
+            answer(bool(callback(sensor, has_last_session)))
+        return _wrapped
+    return callback
+
+class SensorProfile:
+    def __init__(self, controller, handle):
+        self._controller = controller
+        self._handle = handle
+
+        self._on_error_callback: Optional[Callable[["SensorProfile", str], None]] = None
+        self._on_state_change: Optional[Callable[["SensorProfile", DeviceStateEx], None]] = None
+        self._on_sensor_notify_data: Optional[Callable[["SensorProfile", list], None]] = None
+        self._on_auto_reconnect: Optional[Callable[["SensorProfile", bool, Callable[[bool], None]], None]] = None
+        self._on_auto_reconnect_orig: Optional[Callable] = None
+        self._on_power_changed: Optional[Callable[["SensorProfile", int], None]] = None
+        self._on_device_info_update: Optional[Callable[["SensorProfile", DeviceInfo], None]] = None
+        self._on_data_transfer_state_change: Optional[Callable[["SensorProfile", bool], None]] = None
+
+        self._power = -1
+        self._auto_reconnect = False
+        self._device_info: Optional[DeviceInfo] = None
+        self._ble_device: Optional[BLEDevice] = None
+        self._pending_cbs = []
+
+        self._ctx = ctypes.py_object(self)
+        self._ctx_ptr = ctypes.cast(ctypes.pointer(self._ctx), ctypes.c_void_p)
+        self._c_on_data = _dll._sen_data_cb(SensorProfile._c_data)
+        self._c_on_state = _dll._sen_state_cb(SensorProfile._c_state)
+        self._c_on_error = _dll._sen_error_cb(SensorProfile._c_error)
+        self._c_on_power = _dll._sen_power_cb(SensorProfile._c_power)
+        self._c_on_auto_reconnect = _dll._sen_auto_reconnect_cb(SensorProfile._c_auto_reconnect)
+        self._c_on_device_info_update = _dll._sen_device_info_update_cb(SensorProfile._c_device_info_update)
+        self._c_on_data_transfer_state_change = _dll._sen_data_transfer_state_cb(SensorProfile._c_data_transfer_state_change)
+        self._cbs = _dll.sen_profile_cbs_t()
+        self._cbs.structSize = ctypes.sizeof(self._cbs)
+        self._cbs.onData = self._c_on_data
+        self._cbs.onStateChange = self._c_on_state
+        self._cbs.onError = self._c_on_error
+        self._cbs.onPowerChange = self._c_on_power
+        self._cbs.onAutoReconnect = self._c_on_auto_reconnect
+        self._cbs.onDeviceInfoUpdate = self._c_on_device_info_update
+        self._cbs.onDataTransferStateChange = self._c_on_data_transfer_state_change
+        _dll.load_dll().sen_profile_set_callbacks(
+            self._handle, ctypes.byref(self._cbs), self._ctx_ptr)
+
+    @staticmethod
+    def _c_data(ctx, profile, views, view_count):
+        _mark_sdk_thread()
+        try:
+            self = _ctx_self(ctx)
+            cb = self._on_sensor_notify_data
+            if cb is None or view_count == 0:
+                return
+            data_list = [SensorProfile._copy_view(views[i]) for i in range(view_count)]
+            cb(self, data_list)
+        except Exception:
+            traceback.print_exc()
+
+    @staticmethod
+    def _c_state(ctx, profile, new_state):
+        _mark_sdk_thread()
+        try:
+            self = _ctx_self(ctx)
+            if new_state == DeviceStateEx.Disconnected.value:
+                self._device_info = None
+                self._ble_device = None
+                self._power = -1
+            cb = self._on_state_change
+            if cb is not None:
+                cb(self, DeviceStateEx(new_state))
+        except Exception:
+            traceback.print_exc()
+
+    @staticmethod
+    def _c_error(ctx, profile, error_msg):
+        _mark_sdk_thread()
+        try:
+            self = _ctx_self(ctx)
+            cb = self._on_error_callback
+            if cb is not None:
+                cb(self, _decode_str(error_msg))
+        except Exception:
+            traceback.print_exc()
+
+    @staticmethod
+    def _c_power(ctx, profile, power):
+        _mark_sdk_thread()
+        try:
+            self = _ctx_self(ctx)
+            if power >= 0:
+                self._power = power
+            cb = self._on_power_changed
+            if cb is not None:
+                cb(self, power)
+        except Exception:
+            traceback.print_exc()
+
+    @staticmethod
+    def _c_auto_reconnect(ctx, profile, has_last_session, answer, answer_ctx):
+        _mark_sdk_thread()
+        answered = False
+
+        def _answer(handled: bool):
+            nonlocal answered
+            if answered:
+                return
+            answered = True
+            answer(answer_ctx, 1 if handled else 0)
+
+        try:
+            self = _ctx_self(ctx)
+            cb = self._on_auto_reconnect
+            if cb is None:
+                _answer(False)
+                return
+            cb(self, has_last_session != 0, _answer)
+        except Exception:
+            traceback.print_exc()
+            try:
+                _answer(False)
+            except Exception:
+                traceback.print_exc()
+
+    @staticmethod
+    def _c_device_info_update(ctx, profile, info):
+        _mark_sdk_thread()
+        try:
+            self = _ctx_self(ctx)
+            if info:
+                self._device_info = DeviceInfo._from_c(info.contents)
+            cb = self._on_device_info_update
+            if cb is not None and self._device_info is not None:
+                cb(self, self._device_info)
+        except Exception:
+            traceback.print_exc()
+
+    @staticmethod
+    def _c_data_transfer_state_change(ctx, profile, is_transferring):
+        _mark_sdk_thread()
+        try:
+            self = _ctx_self(ctx)
+            cb = self._on_data_transfer_state_change
+            if cb is not None:
+                cb(self, is_transferring != 0)
+        except Exception:
+            traceback.print_exc()
+
+    @staticmethod
+    def _copy_view(view) -> SensorData:
+        sd = SensorData()
+        info_addr = ctypes.cast(view.info, ctypes.c_void_p).value
+        sd._info = ctypes.cast(info_addr, ctypes.POINTER(_dll.sen_data_info_t)) if info_addr else None
+        sd._startSampleIndex = view.startSampleIndex
+        sd._view_start_time_stamp = view.startTimeStamp
+        samples_addr = ctypes.cast(view.samples, ctypes.c_void_p).value
+        if samples_addr and view.samplesBytes > 0:
+            sd._buf = (ctypes.c_char * view.samplesBytes).from_address(samples_addr)
+        return sd
+
+    @property
+    def on_error_callback(self):
+        return self._on_error_callback
+
+    @on_error_callback.setter
+    def on_error_callback(self, callback):
+        self._on_error_callback = callback
+
+    @property
+    def on_state_change(self):
+        return self._on_state_change
+
+    @on_state_change.setter
+    def on_state_change(self, callback):
+        self._on_state_change = callback
+
+    @property
+    def on_sensor_notify_data(self):
+        return self._on_sensor_notify_data
+
+    @on_sensor_notify_data.setter
+    def on_sensor_notify_data(self, callback):
+        self._on_sensor_notify_data = callback
+
+    @property
+    def on_auto_reconnect(self):
+        return self._on_auto_reconnect_orig
+
+    @on_auto_reconnect.setter
+    def on_auto_reconnect(self, callback):
+        self._on_auto_reconnect_orig = callback
+        self._on_auto_reconnect = _wrap_auto_reconnect_callback(callback)
+
+    @property
+    def onAutoReconnect(self):
+        return self._on_auto_reconnect_orig
+
+    @onAutoReconnect.setter
+    def onAutoReconnect(self, callback):
+        self._on_auto_reconnect_orig = callback
+        self._on_auto_reconnect = _wrap_auto_reconnect_callback(callback)
+
+    @property
+    def on_power_changed(self):
+        return self._on_power_changed
+
+    @on_power_changed.setter
+    def on_power_changed(self, callback):
+        self._on_power_changed = callback
+
+    @property
+    def on_device_info_update(self):
+        return self._on_device_info_update
+
+    @on_device_info_update.setter
+    def on_device_info_update(self, callback):
+        self._on_device_info_update = callback
+
+    @property
+    def on_data_transfer_state_change(self):
+        return self._on_data_transfer_state_change
+
+    @on_data_transfer_state_change.setter
+    def on_data_transfer_state_change(self, callback):
+        self._on_data_transfer_state_change = callback
+
+    @property
+    def onStateChanged(self):
+        return self._on_state_change
+
+    @onStateChanged.setter
+    def onStateChanged(self, callback):
+        self._on_state_change = callback
+
+    @property
+    def onErrorCallback(self):
+        return self._on_error_callback
+
+    @onErrorCallback.setter
+    def onErrorCallback(self, callback):
+        self._on_error_callback = callback
+
+    @property
+    def onDataCallback(self):
+        return self._on_sensor_notify_data
+
+    @onDataCallback.setter
+    def onDataCallback(self, callback):
+        self._on_sensor_notify_data = callback
+
+    @property
+    def onPowerChanged(self):
+        return self._on_power_changed
+
+    @onPowerChanged.setter
+    def onPowerChanged(self, callback):
+        self._on_power_changed = callback
+
+    @property
+    def onDeviceInfoUpdate(self):
+        return self._on_device_info_update
+
+    @onDeviceInfoUpdate.setter
+    def onDeviceInfoUpdate(self, callback):
+        self._on_device_info_update = callback
+
+    @property
+    def onDataTransferStateChange(self):
+        return self._on_data_transfer_state_change
+
+    @onDataTransferStateChange.setter
+    def onDataTransferStateChange(self, callback):
+        self._on_data_transfer_state_change = callback
+
+    @property
+    def autoReconnect(self) -> bool:
+        return self._auto_reconnect
+
+    @autoReconnect.setter
+    def autoReconnect(self, enabled: bool):
+        self.setAutoReconnect(enabled)
+        self._auto_reconnect = bool(enabled)
+
+    @property
+    def BLEDevice(self) -> BLEDevice:
+        if self._ble_device is None:
+            dev = _dll.sen_ble_device_t()
+            _dll.load_dll().sen_profile_get_device(self._handle, ctypes.byref(dev))
+            self._ble_device = BLEDevice._from_c(dev)
+        return self._ble_device
+
+    @property
+    def deviceState(self) -> DeviceStateEx:
+        return DeviceStateEx(_dll.load_dll().sen_profile_get_state(self._handle))
+
+    @property
+    def isReady(self) -> bool:
+        return self.deviceState == DeviceStateEx.Ready
+
+    @property
+    def hasInited(self) -> bool:
+        return _dll.load_dll().sen_profile_has_init(self._handle) != 0
+
+    @property
+    def isDataTransfering(self) -> bool:
+        return _dll.load_dll().sen_profile_has_start_data_notification(self._handle) != 0
+
+    def _track(self, cb_obj):
+        self._pending_cbs.append(cb_obj)
+        return cb_obj
+
+    def _discard(self, cb_obj):
+        try:
+            self._pending_cbs.remove(cb_obj)
+        except ValueError:
+            pass
+
+    def _connect(self, cb: Optional[Callable[[bool, str], None]] = None):
+        @_dll._sen_completion_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(result != 0, _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_profile_connect(self._handle, _cb, None)
+
+    def _disconnect(self, cb: Optional[Callable[[bool, str], None]] = None):
+        @_dll._sen_completion_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(result != 0, _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_profile_disconnect(self._handle, _cb, None)
+
+    def setAutoReconnect(self, enabled: bool):
+        _dll.load_dll().sen_profile_set_auto_reconnect(self._handle, 1 if enabled else 0)
+
+    def _init(self, packageSampleCount: int, powerRefreshInterval: int,
+              timeoutInMS: int, cb: Callable[[bool, str], None]):
+        @_dll._sen_completion_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(result != 0, _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_profile_init(
+            self._handle, packageSampleCount, timeoutInMS, powerRefreshInterval, _cb, None)
+
+    def _startDataNotification(self, timeoutInMS: int, cb: Callable[[bool, str], None]):
+        @_dll._sen_completion_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(result != 0, _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_profile_start_data(self._handle, timeoutInMS, _cb, None)
+
+    def _stopDataNotification(self, timeoutInMS: int, cb: Callable[[bool, str], None]):
+        @_dll._sen_completion_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(result != 0, _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_profile_stop_data(self._handle, timeoutInMS, _cb, None)
+
+    def _setParam(self, timeoutInMS: int, key: str, value: str,
+                  cb: Callable[[str, str], None]):
+        @_dll._sen_param_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(_decode_str(result), _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_profile_set_param(
+            self._handle, timeoutInMS, key.encode(), value.encode(), _cb, None)
+
+    def _getParam(self, timeoutInMS: int, key: str, cb: Callable[[str, str], None]):
+        @_dll._sen_param_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(_decode_str(result), _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_profile_get_param(
+            self._handle, timeoutInMS, key.encode(), _cb, None)
+
+    def _getBatteryLevel(self, timeoutInMS: int, cb: Callable[[int, str], None]):
+        @_dll._sen_battery_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if result >= 0:
+                    self._power = result
+                if cb is not None:
+                    cb(result, _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_profile_get_battery_level(self._handle, timeoutInMS, _cb, None)
+
+    def _fetchDeviceInfo(self, timeoutInMS: int,
+                         cb: Callable[[Optional[DeviceInfo], str], None]):
+        @_dll._sen_info_cb
+        def _cb(ctx, info, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    out = DeviceInfo._from_c(info.contents) if info else None
+                    if out is not None:
+                        self._device_info = out
+                    cb(out, _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_profile_fetch_device_info(self._handle, timeoutInMS, _cb, None)
+
+    def connect(self):
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncConnect(), 40.0)
+        except _sync.FuturesTimeoutError:
+            return False
+
+    def disconnect(self):
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncDisconnect(), 25.0)
+        except _sync.FuturesTimeoutError:
+            return None
+
+    def init(self, packageSampleCount: int, powerRefreshInterval: int,
+             timeoutInMS: int = 0):
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(
+                self.asyncInit(packageSampleCount, powerRefreshInterval, timeoutInMS),
+                _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 15.0)
+        except _sync.FuturesTimeoutError:
+            return None
+
+    def startDataNotification(self, timeoutInMS: int = 0):
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncStartDataNotification(timeoutInMS),
+                                  _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 15.0)
+        except _sync.FuturesTimeoutError:
+            return None
+
+    def stopDataNotification(self, timeoutInMS: int = 0):
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncStopDataNotification(timeoutInMS),
+                                  _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 15.0)
+        except _sync.FuturesTimeoutError:
+            return None
+
+    def setParam(self, key: str, value, timeoutInMS: int = 0) -> str:
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncSetParam(key, value, timeoutInMS),
+                                  _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 15.0)
+        except _sync.FuturesTimeoutError:
+            return "Error: Timeout"
+
+    def getParam(self, key: str, timeoutInMS: int = 0) -> str:
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncGetParam(key, timeoutInMS),
+                                  _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 15.0)
+        except _sync.FuturesTimeoutError:
+            return "Error: Timeout"
+
+    def getBatteryLevel(self) -> int:
+        if self._power >= 0:
+            return self._power
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncGetBatteryLevel(),
+                                  _sync.effective_timeout_ms(0) / 1000.0 + 17.0)
+        except _sync.FuturesTimeoutError:
+            return -1
+
+    def fetchDeviceInfo(self, timeoutInMS: int = 0) -> Optional[DeviceInfo]:
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncFetchDeviceInfo(timeoutInMS),
+                                  _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 15.0)
+        except _sync.FuturesTimeoutError:
+            return None
+
+    def getDeviceInfo(self) -> Optional[DeviceInfo]:
+        if self._device_info is not None:
+            return self._device_info
+        info = _dll.sen_device_info_t()
+        info.structSize = ctypes.sizeof(info)
+        _dll.load_dll().sen_profile_get_device_info(self._handle, ctypes.byref(info))
+        out = DeviceInfo._from_c(info)
+        if not (out.DeviceName or out.ModelName):
+            return None
+        self._device_info = out
+        return out
+
+    def log(self, message: str, level: str = "I"):
+        try:
+            _dll.load_dll().sen_profile_log(
+                self._handle, str(message).encode(), str(level).encode())
+        except Exception:
+            traceback.print_exc()
+
+    async def asyncConnect(self) -> bool:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._connect(cb=lambda ok, err: _resolve_future(loop, fut, ok))
+        try:
+            return await asyncio.wait_for(fut, 30.0)
+        except asyncio.TimeoutError:
+            return False
+
+    async def asyncDisconnect(self) -> bool:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._disconnect(cb=lambda ok, err: _resolve_future(loop, fut, ok))
+        try:
+            return await asyncio.wait_for(fut, 15.0)
+        except asyncio.TimeoutError:
+            return False
+
+    async def asyncInit(self, packageSampleCount: int, powerRefreshInterval: int,
+                        timeoutInMS: int = 0) -> bool:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._init(packageSampleCount, powerRefreshInterval, timeoutInMS,
+                   cb=lambda ok, err: _resolve_future(loop, fut, ok))
+        try:
+            return await asyncio.wait_for(
+                fut, _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 5.0)
+        except asyncio.TimeoutError:
+            return False
+
+    async def asyncStartDataNotification(self, timeoutInMS: int = 0) -> bool:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._startDataNotification(timeoutInMS, cb=lambda ok, err: _resolve_future(loop, fut, ok))
+        try:
+            return await asyncio.wait_for(
+                fut, _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 5.0)
+        except asyncio.TimeoutError:
+            return False
+
+    async def asyncStopDataNotification(self, timeoutInMS: int = 0) -> bool:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._stopDataNotification(timeoutInMS, cb=lambda ok, err: _resolve_future(loop, fut, ok))
+        try:
+            return await asyncio.wait_for(
+                fut, _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 5.0)
+        except asyncio.TimeoutError:
+            return False
+
+    async def asyncGetBatteryLevel(self) -> int:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._getBatteryLevel(0, cb=lambda level, err: _resolve_future(loop, fut, level))
+        try:
+            return await asyncio.wait_for(
+                fut, _sync.effective_timeout_ms(0) / 1000.0 + 2.0)
+        except asyncio.TimeoutError:
+            return -1
+
+    async def asyncSetParam(self, key: str, value, timeoutInMS: int = 0) -> str:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._setParam(timeoutInMS, key, str(value),
+                       cb=lambda res, err: _resolve_future(loop, fut, err if err and res in ('', 'Error') else res))
+        try:
+            return await asyncio.wait_for(
+                fut, _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 2.0)
+        except asyncio.TimeoutError:
+            return "Error: Timeout"
+
+    async def asyncGetParam(self, key: str, timeoutInMS: int = 0) -> str:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._getParam(timeoutInMS, key, cb=lambda res, err: _resolve_future(loop, fut, err if err and res in ('', 'Error') else res))
+        try:
+            return await asyncio.wait_for(
+                fut, _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 2.0)
+        except asyncio.TimeoutError:
+            return "Error: Timeout"
+
+    async def asyncFetchDeviceInfo(self, timeoutInMS: int = 0) -> Optional[DeviceInfo]:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._fetchDeviceInfo(timeoutInMS, cb=lambda info, err: _resolve_future(loop, fut, info))
+        try:
+            return await asyncio.wait_for(
+                fut, _sync.effective_timeout_ms(timeoutInMS) / 1000.0 + 5.0)
+        except asyncio.TimeoutError:
+            return None

sensor_sdk-1.3.3.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: sensor-sdk
+Version: 1.3.3
+Summary: Python sdk for Synchroni
+Home-page: https://github.com/oymotion/SynchroniSDKPython
+Author: Martin Ye
+Author-email: yecq_82@hotmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Pure-ctypes Python bindings over the SensorSDKCXX flat C API (drop-in replacement for the SensorSDKPython package), bundling the native sensor library and the frozen BLE helper (USB dongle backend).