sensor-sdk 1.3.3__py3-none-win_amd64.whl

sensor/__init__.py

@@ -0,0 +1,34 @@
+from sensor.sensor_controller import SensorController
+from sensor.sensor_profile import SensorProfile
+from sensor.sensor_device import BLEDevice, DeviceInfo, DeviceStateEx
+from sensor.sensor_data import DataType, Sample, SensorData
+from sensor import _dll
+from sensor._dll import dll_path
+from sensor._sync import submit
+
+__version__ = "1.3.3"
+
+def capi_version() -> int:
+    return _dll.load_dll().sen_capi_version()
+
+def __getattr__(name):
+    if name == "SensorControllerInstance":
+        from sensor.sensor_controller import SensorControllerInstance
+        return SensorControllerInstance
+    raise AttributeError("module %r has no attribute %r" % (__name__, name))
+
+__all__ = [
+    "SensorController",
+    "SensorControllerInstance",
+    "SensorProfile",
+    "BLEDevice",
+    "DeviceInfo",
+    "DeviceStateEx",
+    "DataType",
+    "Sample",
+    "SensorData",
+    "dll_path",
+    "capi_version",
+    "submit",
+    "__version__",
+]

sensor/_dll.py

@@ -0,0 +1,381 @@
+import ctypes
+import os
+import platform
+import sys
+import warnings
+from pathlib import Path
+
+SEN_CAPI_VERSION = 20
+
+def _library_name():
+    if sys.platform == "win32":
+        return "sensor.dll"
+    if sys.platform == "darwin":
+        return "libsensor.dylib"
+    return "libsensor.so"
+
+def _candidate_paths():
+    env = os.environ.get("SENSOR_SDK_CAPI_DLL")
+    if env:
+        yield env
+    name = _library_name()
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    yield os.path.join(pkg_dir, "bin", name)
+    repo_root = Path(pkg_dir).resolve().parents[2]
+    if sys.platform == "win32":
+        base = repo_root / "lib" / "windows"
+        yield str(base / "x64" / "Debug" / name)
+        yield str(base / "x64" / "Release" / name)
+        yield str(base / "Win32" / "Debug" / "sensor32.dll")
+        yield str(base / "Win32" / "Release" / "sensor32.dll")
+    elif sys.platform == "darwin":
+        yield str(repo_root / "lib" / "mac" / "Debug" / name)
+        yield str(repo_root / "lib" / "mac" / "Release" / name)
+    else:
+        machine = platform.machine().lower()
+        arch_dir = {"amd64": "x86_64", "aarch64": "arm64"}.get(machine, machine)
+        base = repo_root / "lib" / "linux" / arch_dir
+        for config in ("Debug", "Release"):
+            for suffix in ("_x86", "_x64", "_arm64"):
+                yield str(base / config / ("libsensor%s.so" % suffix))
+
+_dll = None
+_dll_path = None
+
+def _expose_bumble_glue(loaded_path):
+    repo_root = Path(os.path.dirname(os.path.abspath(__file__))).resolve().parents[2]
+    helper = repo_root / "helper"
+    if not helper.is_dir():
+        return
+    try:
+        Path(loaded_path).resolve().relative_to(repo_root / "lib")
+    except ValueError:
+        return
+    p = str(helper)
+    if p not in sys.path:
+        sys.path.append(p)
+
+def load_dll():
+    global _dll, _dll_path
+    if _dll is not None:
+        return _dll
+    errors = []
+    for path in _candidate_paths():
+        try:
+            _dll = ctypes.CDLL(path)
+            _dll_path = path
+            _declare(_dll)
+            lib_version = _dll.sen_capi_version()
+            if lib_version != SEN_CAPI_VERSION:
+                warnings.warn(
+                    "the sensor binding was built for SEN_CAPI_VERSION %d but %s "
+                    "reports %d; rebuild the library or update the binding"
+                    % (SEN_CAPI_VERSION, path, lib_version))
+            _expose_bumble_glue(path)
+            return _dll
+        except OSError as e:
+            errors.append("%s: %s" % (path, e))
+    raise OSError(
+        "cannot load the sensor SDK library; tried:\n  " + "\n  ".join(errors)
+        + "\nSet SENSOR_SDK_CAPI_DLL to the library path."
+    )
+
+def dll_path():
+    load_dll()
+    return _dll_path
+
+class sen_sample_t(ctypes.Structure):
+    _fields_ = [
+        ("absTimeStampInSec", ctypes.c_double),
+        ("channelIndex", ctypes.c_int32),
+        ("sampleIndex", ctypes.c_int32),
+        ("rawData", ctypes.c_int32),
+        ("data", ctypes.c_float),
+        ("impedance", ctypes.c_float),
+        ("saturation", ctypes.c_float),
+        ("isLost", ctypes.c_uint8),
+        ("_reserved", ctypes.c_uint8 * 7),
+    ]
+
+class sen_data_info_t(ctypes.Structure):
+    _fields_ = [
+        ("deviceMac", ctypes.c_char * 18),
+        ("dataType", ctypes.c_int32),
+        ("lostPackageCount", ctypes.c_int32),
+        ("sampleRate", ctypes.c_float),
+        ("channelCount", ctypes.c_int32),
+        ("channelMask", ctypes.c_uint64),
+        ("sampleCount", ctypes.c_int32),
+        ("startTimeStamp", ctypes.c_uint32),
+        ("delay", ctypes.c_uint32),
+        ("startTimeSec", ctypes.c_double),
+        ("deviceName", ctypes.c_char * 32),
+    ]
+
+class sen_data_view_t(ctypes.Structure):
+    _fields_ = [
+        ("startSampleIndex", ctypes.c_int32),
+        ("startTimeStamp", ctypes.c_uint32),
+        ("info", ctypes.POINTER(sen_data_info_t)),
+        ("samples", ctypes.POINTER(sen_sample_t)),
+        ("samplesBytes", ctypes.c_size_t),
+    ]
+
+class sen_ble_device_t(ctypes.Structure):
+    _fields_ = [
+        ("name", ctypes.c_char * 32),
+        ("mac", ctypes.c_char * 18),
+        ("rssi", ctypes.c_int16),
+    ]
+
+class sen_device_info_t(ctypes.Structure):
+    _fields_ = [
+        ("structSize", ctypes.c_uint32),
+        ("deviceName", ctypes.c_char * 32),
+        ("modelName", ctypes.c_char * 32),
+        ("hardwareVersion", ctypes.c_char * 32),
+        ("firmwareVersion", ctypes.c_char * 32),
+        ("MTUSize", ctypes.c_uint16),
+        ("isMTUFine", ctypes.c_uint8),
+        ("EMGGain", ctypes.c_uint8),
+        ("EEGGain", ctypes.c_uint8),
+        ("ECGGain", ctypes.c_uint8),
+        ("EMGChannelCount", ctypes.c_uint8),
+        ("EEGChannelCount", ctypes.c_uint8),
+        ("ECGChannelCount", ctypes.c_uint8),
+        ("BRTHChannelCount", ctypes.c_uint8),
+        ("AccChannelCount", ctypes.c_uint8),
+        ("GyroChannelCount", ctypes.c_uint8),
+        ("MagAngleChannelCount", ctypes.c_uint8),
+        ("EMGSampleRate", ctypes.c_uint16),
+        ("EEGSampleRate", ctypes.c_uint16),
+        ("ECGSampleRate", ctypes.c_uint16),
+        ("BRTHSampleRate", ctypes.c_uint16),
+        ("AccSampleRate", ctypes.c_uint16),
+        ("GyroSampleRate", ctypes.c_uint16),
+        ("MagAngleSampleRate", ctypes.c_uint16),
+        ("ImuChannelCount", ctypes.c_uint8),
+        ("ImuSampleRate", ctypes.c_uint16),
+        ("EulerChannelCount", ctypes.c_uint8),
+        ("EulerSampleRate", ctypes.c_uint16),
+        ("QuatChannelCount", ctypes.c_uint8),
+        ("QuatSampleRate", ctypes.c_uint16),
+        ("PpgChannelCount", ctypes.c_uint8),
+        ("PpgSampleRate", ctypes.c_uint16),
+        ("Spo2ChannelCount", ctypes.c_uint8),
+        ("Spo2SampleRate", ctypes.c_uint16),
+        ("ImpeChannelCount", ctypes.c_uint8),
+        ("ImpeSampleRate", ctypes.c_uint16),
+        ("EmgMaxSampleRate", ctypes.c_uint16),
+        ("EegMaxSampleRate", ctypes.c_uint16),
+        ("EcgMaxSampleRate", ctypes.c_uint16),
+        ("ConnectionIntervalMs", ctypes.c_double),
+        ("PeripheralLatency", ctypes.c_int32),
+        ("SupervisionTimeoutMs", ctypes.c_int32),
+        ("backend", ctypes.c_char * 16),
+        ("GestChannelCount", ctypes.c_uint8),
+        ("GestSampleRate", ctypes.c_uint16),
+    ]
+
+SEN_BIN_MAX_SENSOR_DATAS = 14
+
+class sen_bin_sensor_data_config_t(ctypes.Structure):
+    _fields_ = [
+        ("sampleRate", ctypes.c_double),
+        ("k", ctypes.c_double),
+        ("channelMask", ctypes.c_uint64),
+        ("dataType", ctypes.c_int32),
+        ("typeIndex", ctypes.c_uint8),
+        ("channelCount", ctypes.c_uint8),
+        ("packageIndexLength", ctypes.c_uint8),
+        ("resolutionBits", ctypes.c_uint8),
+        ("resolutionSigned", ctypes.c_uint8),
+        ("rawDataBias", ctypes.c_int8),
+        ("packageSampleCount", ctypes.c_uint16),
+        ("minPackageSampleCount", ctypes.c_uint16),
+    ]
+
+class sen_bin_file_info_t(ctypes.Structure):
+    _fields_ = [
+        ("structSize", ctypes.c_uint32),
+        ("mac", ctypes.c_char * 18),
+        ("deviceName", ctypes.c_char * 32),
+        ("durationSec", ctypes.c_double),
+        ("valid", ctypes.c_uint8),
+        ("_reserved", ctypes.c_uint8 * 7),
+        ("deviceInfo", sen_device_info_t),
+        ("configVersion", ctypes.c_uint32),
+        ("chipType", ctypes.c_int32),
+        ("isUniversalStream", ctypes.c_uint8),
+        ("isNewEmg", ctypes.c_uint8),
+        ("isContainQat6", ctypes.c_uint8),
+        ("ppgModel", ctypes.c_uint8),
+        ("featureMap", ctypes.c_int64),
+        ("notifyDataFlag", ctypes.c_int64),
+        ("sensorDataCount", ctypes.c_uint32),
+        ("sensorDatas", sen_bin_sensor_data_config_t * SEN_BIN_MAX_SENSOR_DATAS),
+        ("firstDataTsMs", ctypes.c_uint64),
+        ("lastDataTsMs", ctypes.c_uint64),
+    ]
+
+_sen_scan_result_cb = ctypes.CFUNCTYPE(
+    None, ctypes.c_void_p, ctypes.POINTER(sen_ble_device_t), ctypes.c_size_t)
+_sen_enable_changed_cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int)
+_sen_data_cb = ctypes.CFUNCTYPE(
+    None, ctypes.c_void_p, ctypes.c_void_p,
+    ctypes.POINTER(sen_data_view_t), ctypes.c_size_t)
+_sen_state_cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int)
+_sen_error_cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p)
+_sen_power_cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int)
+_sen_auto_reconnect_answer_cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int)
+_sen_auto_reconnect_cb = ctypes.CFUNCTYPE(
+    None, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int,
+    _sen_auto_reconnect_answer_cb, ctypes.c_void_p)
+_sen_device_info_update_cb = ctypes.CFUNCTYPE(
+    None, ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(sen_device_info_t))
+_sen_data_transfer_state_cb = ctypes.CFUNCTYPE(
+    None, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int)
+
+_sen_completion_cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int, ctypes.c_char_p)
+_sen_param_cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p)
+_sen_battery_cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int, ctypes.c_char_p)
+_sen_info_cb = ctypes.CFUNCTYPE(
+    None, ctypes.c_void_p, ctypes.POINTER(sen_device_info_t), ctypes.c_char_p)
+_sen_multi_result_cb = ctypes.CFUNCTYPE(
+    None, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p),
+    ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_char_p), ctypes.c_size_t)
+
+class sen_profile_cbs_t(ctypes.Structure):
+    _fields_ = [
+        ("structSize", ctypes.c_uint32),
+        ("onData", _sen_data_cb),
+        ("onStateChange", _sen_state_cb),
+        ("onError", _sen_error_cb),
+        ("onPowerChange", _sen_power_cb),
+        ("onAutoReconnect", _sen_auto_reconnect_cb),
+        ("onDeviceInfoUpdate", _sen_device_info_update_cb),
+        ("onDataTransferStateChange", _sen_data_transfer_state_cb),
+    ]
+
+class sen_controller_cbs_t(ctypes.Structure):
+    _fields_ = [
+        ("structSize", ctypes.c_uint32),
+        ("onScanResult", _sen_scan_result_cb),
+        ("onEnableChanged", _sen_enable_changed_cb),
+    ]
+
+def _declare(dll):
+    P_CTRL = ctypes.c_void_p
+    P_PROF = ctypes.c_void_p
+    c_str = ctypes.c_char_p
+    c_size = ctypes.c_size_t
+
+    dll.sen_terminate.restype = None
+    dll.sen_terminate.argtypes = []
+    dll.sen_capi_version.restype = ctypes.c_uint32
+    dll.sen_capi_version.argtypes = []
+    dll.sen_controller_create.restype = P_CTRL
+    dll.sen_controller_create.argtypes = []
+    dll.sen_controller_destroy.restype = None
+    dll.sen_controller_destroy.argtypes = [P_CTRL]
+    dll.sen_controller_set_callbacks.restype = None
+    dll.sen_controller_set_callbacks.argtypes = [P_CTRL, ctypes.POINTER(sen_controller_cbs_t), ctypes.c_void_p]
+
+    dll.sen_controller_is_enable.restype = ctypes.c_int
+    dll.sen_controller_is_enable.argtypes = [P_CTRL]
+    dll.sen_controller_is_scanning.restype = ctypes.c_int
+    dll.sen_controller_is_scanning.argtypes = [P_CTRL]
+    dll.sen_controller_start_scan.restype = ctypes.c_int
+    dll.sen_controller_start_scan.argtypes = [P_CTRL, ctypes.c_int]
+    dll.sen_controller_stop_scan.restype = ctypes.c_int
+    dll.sen_controller_stop_scan.argtypes = [P_CTRL]
+    dll.sen_controller_scan_once.restype = None
+    dll.sen_controller_scan_once.argtypes = [P_CTRL, ctypes.c_int, _sen_scan_result_cb, ctypes.c_void_p]
+
+    dll.sen_controller_require_sensor.restype = P_PROF
+    dll.sen_controller_require_sensor.argtypes = [P_CTRL, c_str]
+    dll.sen_controller_get_sensor.restype = P_PROF
+    dll.sen_controller_get_sensor.argtypes = [P_CTRL, c_str]
+    dll.sen_controller_get_sensors.restype = c_size
+    dll.sen_controller_get_sensors.argtypes = [P_CTRL, ctypes.POINTER(P_PROF), c_size]
+    dll.sen_controller_get_connected_sensors.restype = c_size
+    dll.sen_controller_get_connected_sensors.argtypes = [P_CTRL, ctypes.POINTER(P_PROF), c_size]
+
+    dll.sen_controller_get_bin_file_info.restype = ctypes.c_int
+    dll.sen_controller_get_bin_file_info.argtypes = [P_CTRL, c_str, ctypes.POINTER(sen_bin_file_info_t)]
+    dll.sen_controller_replay_bin_file.restype = P_PROF
+    dll.sen_controller_replay_bin_file.argtypes = [P_CTRL, c_str, c_str, ctypes.c_int, ctypes.c_uint32]
+    dll.sen_controller_multi_replay_bin_file.restype = c_size
+    dll.sen_controller_multi_replay_bin_file.argtypes = [
+        P_CTRL, ctypes.POINTER(c_str), ctypes.POINTER(c_str), c_size,
+        ctypes.c_int, ctypes.c_uint32, ctypes.POINTER(P_PROF)]
+    dll.sen_controller_pause_bin_replay.restype = None
+    dll.sen_controller_pause_bin_replay.argtypes = [P_CTRL, c_str, c_str, c_size]
+    dll.sen_controller_resume_bin_replay.restype = None
+    dll.sen_controller_resume_bin_replay.argtypes = [P_CTRL, c_str, c_str, c_size]
+    dll.sen_controller_stop_bin_replay.restype = None
+    dll.sen_controller_stop_bin_replay.argtypes = [P_CTRL, c_str, c_str, c_size]
+    dll.sen_controller_parse_bin_to_csv.restype = None
+    dll.sen_controller_parse_bin_to_csv.argtypes = [P_CTRL, c_str, c_str, _sen_param_cb, ctypes.c_void_p]
+
+    dll.sen_controller_get_version.restype = None
+    dll.sen_controller_get_version.argtypes = [P_CTRL, c_str, c_size]
+
+    dll.sen_controller_get_param.restype = None
+    dll.sen_controller_get_param.argtypes = [P_CTRL, c_str, _sen_param_cb, ctypes.c_void_p]
+    dll.sen_controller_set_param.restype = None
+    dll.sen_controller_set_param.argtypes = [P_CTRL, c_str, c_str, _sen_param_cb, ctypes.c_void_p]
+
+    dll.sen_controller_log.restype = None
+    dll.sen_controller_log.argtypes = [P_CTRL, c_str, c_str]
+
+    dll.sen_controller_on_suspend.restype = None
+    dll.sen_controller_on_suspend.argtypes = [P_CTRL]
+
+    dll.sen_controller_check_setup_dongle.restype = None
+    dll.sen_controller_check_setup_dongle.argtypes = [P_CTRL, _sen_param_cb, ctypes.c_void_p]
+
+    dll.sen_controller_multi_start_data.restype = None
+    dll.sen_controller_multi_start_data.argtypes = [P_CTRL, ctypes.POINTER(P_PROF), c_size, ctypes.c_int, ctypes.c_int, ctypes.c_int, _sen_multi_result_cb, ctypes.c_void_p]
+    dll.sen_controller_multi_stop_data.restype = None
+    dll.sen_controller_multi_stop_data.argtypes = [P_CTRL, ctypes.POINTER(P_PROF), c_size, ctypes.c_int, _sen_multi_result_cb, ctypes.c_void_p]
+
+    dll.sen_profile_set_callbacks.restype = None
+    dll.sen_profile_set_callbacks.argtypes = [P_PROF, ctypes.POINTER(sen_profile_cbs_t), ctypes.c_void_p]
+    dll.sen_profile_get_device.restype = None
+    dll.sen_profile_get_device.argtypes = [P_PROF, ctypes.POINTER(sen_ble_device_t)]
+    dll.sen_profile_get_state.restype = ctypes.c_int
+    dll.sen_profile_get_state.argtypes = [P_PROF]
+    dll.sen_profile_connect.restype = None
+    dll.sen_profile_connect.argtypes = [P_PROF, _sen_completion_cb, ctypes.c_void_p]
+    dll.sen_profile_disconnect.restype = None
+    dll.sen_profile_disconnect.argtypes = [P_PROF, _sen_completion_cb, ctypes.c_void_p]
+    dll.sen_profile_has_init.restype = ctypes.c_int
+    dll.sen_profile_has_init.argtypes = [P_PROF]
+    dll.sen_profile_has_start_data_notification.restype = ctypes.c_int
+    dll.sen_profile_has_start_data_notification.argtypes = [P_PROF]
+
+    dll.sen_profile_init.restype = None
+    dll.sen_profile_init.argtypes = [P_PROF, ctypes.c_int, ctypes.c_int, ctypes.c_int, _sen_completion_cb, ctypes.c_void_p]
+    dll.sen_profile_start_data.restype = None
+    dll.sen_profile_start_data.argtypes = [P_PROF, ctypes.c_int, _sen_completion_cb, ctypes.c_void_p]
+    dll.sen_profile_stop_data.restype = None
+    dll.sen_profile_stop_data.argtypes = [P_PROF, ctypes.c_int, _sen_completion_cb, ctypes.c_void_p]
+
+    dll.sen_profile_get_battery_level.restype = None
+    dll.sen_profile_get_battery_level.argtypes = [P_PROF, ctypes.c_int, _sen_battery_cb, ctypes.c_void_p]
+    dll.sen_profile_fetch_device_info.restype = None
+    dll.sen_profile_fetch_device_info.argtypes = [P_PROF, ctypes.c_int, _sen_info_cb, ctypes.c_void_p]
+    dll.sen_profile_get_device_info.restype = None
+    dll.sen_profile_get_device_info.argtypes = [P_PROF, ctypes.POINTER(sen_device_info_t)]
+
+    dll.sen_profile_set_param.restype = None
+    dll.sen_profile_set_param.argtypes = [P_PROF, ctypes.c_int, c_str, c_str, _sen_param_cb, ctypes.c_void_p]
+    dll.sen_profile_get_param.restype = None
+    dll.sen_profile_get_param.argtypes = [P_PROF, ctypes.c_int, c_str, _sen_param_cb, ctypes.c_void_p]
+
+    dll.sen_profile_set_auto_reconnect.restype = None
+    dll.sen_profile_set_auto_reconnect.argtypes = [P_PROF, ctypes.c_int]
+
+    dll.sen_profile_log.restype = None
+    dll.sen_profile_log.argtypes = [P_PROF, c_str, c_str]

sensor/_sync.py

@@ -0,0 +1,85 @@
+import asyncio
+import queue
+import threading
+import traceback
+from concurrent.futures import Future
+from concurrent.futures import TimeoutError as FuturesTimeoutError
+
+_loop = None
+_thread = None
+_lock = threading.Lock()
+
+def _run(loop):
+    asyncio.set_event_loop(loop)
+    loop.run_forever()
+
+def get_loop():
+    global _loop, _thread
+    with _lock:
+        if _loop is None:
+            loop = asyncio.new_event_loop()
+            t = threading.Thread(target=_run, args=(loop,),
+                                 name="sensor-sync-loop", daemon=True)
+            t.start()
+            _loop = loop
+            _thread = t
+        return _loop
+
+def is_loop_thread():
+    t = _thread
+    return t is not None and threading.get_ident() == t.ident
+
+_assumed_cmd_timeout_ms = 10000
+
+def effective_timeout_ms(timeout_ms):
+    return timeout_ms if timeout_ms > 0 else _assumed_cmd_timeout_ms
+
+def note_cmd_timeout_ms(v):
+    global _assumed_cmd_timeout_ms
+    try:
+        v = int(v)
+    except (TypeError, ValueError):
+        return
+    if v > 0:
+        _assumed_cmd_timeout_ms = v
+
+def run_sync(coro, timeout):
+    if is_loop_thread():
+        coro.close()
+        raise RuntimeError("blocking sync call from the sensor sync thread")
+    return asyncio.run_coroutine_threadsafe(coro, get_loop()).result(timeout)
+
+class _Runner:
+    def __init__(self):
+        self._q = queue.Queue()
+        self._thread = threading.Thread(target=self._run, name="sensor-runner",
+                                        daemon=True)
+        self._thread.start()
+
+    def _run(self):
+        while True:
+            fn, fut = self._q.get()
+            if fn is None:
+                return
+            if not fut.set_running_or_notify_cancel():
+                continue
+            try:
+                fut.set_result(fn())
+            except BaseException as e:
+                fut.set_exception(e)
+                traceback.print_exc()
+
+    def submit(self, fn, *args, **kwargs):
+        fut = Future()
+        self._q.put((lambda: fn(*args, **kwargs), fut))
+        return fut
+
+_runner = None
+_runner_lock = threading.Lock()
+
+def submit(fn, *args, **kwargs):
+    global _runner
+    with _runner_lock:
+        if _runner is None:
+            _runner = _Runner()
+    return _runner.submit(fn, *args, **kwargs)

sensor/pyinstaller_hooks/__init__.py

@@ -0,0 +1,4 @@
+import os
+
+def get_hook_dirs():
+    return [os.path.dirname(os.path.abspath(__file__))]

sensor/pyinstaller_hooks/hook-sensor.py

@@ -0,0 +1,3 @@
+from PyInstaller.utils.hooks import collect_data_files
+
+datas = collect_data_files("sensor", includes=["bin/*"])