sensor-sdk 0.1.9__tar.gz → 0.2.1__tar.gz

{sensor_sdk-0.1.9/sensor_sdk.egg-info → sensor_sdk-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sensor-sdk
-Version: 0.1.9
+Version: 0.2.1
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye

{sensor_sdk-0.1.9 → sensor_sdk-0.2.1}/sensor/bleak_no_ack_patch.py

@@ -3,7 +3,7 @@
 某些 Windows 主机上 write-with-response 会因为系统 ACK 等待导致命令超时，
 把命令特征强制改成无响应写入可以显著提升命令通道的实时性。
 
-默认只作用于 SDK 已知的两个 CMD 特征 UUID；传入空列表或 `None` 则全局生效。
+默认只作用于 SDK 已知的两个 CMD 特征 UUID；传 `None` 则全局生效，空列表表示不匹配任何特征。
 """
 
 import logging
@@ -53,6 +53,7 @@ def apply(cmd_char_uuids=DEFAULT_CMD_CHAR_UUIDS):
         return await orig_write(self, char_specifier, data, response=response)
 
     BleakClient.write_gatt_char = patched_write
+    BleakClient._orig_write_gatt_char = orig_write  # type: ignore[attr-defined]
     BleakClient._no_ack_patched = True  # type: ignore[attr-defined]
     logger.debug(
         "Applied bleak write-without-response patch (targets: %s)",
@@ -70,6 +71,8 @@ def reset():
     if not getattr(BleakClient, "_no_ack_patched", False):
         return
 
-    # 找到原始的未绑定方法比较麻烦，这里简单把标记清掉，
-    # 实际撤销需要保存原始方法；apply 没有保存，故 reset 仅作占位。
+    orig_write = getattr(BleakClient, "_orig_write_gatt_char", None)
+    if orig_write is not None:
+        BleakClient.write_gatt_char = orig_write
+        del BleakClient._orig_write_gatt_char  # type: ignore[attr-defined]
     BleakClient._no_ack_patched = False  # type: ignore[attr-defined]

{sensor_sdk-0.1.9 → sensor_sdk-0.2.1}/sensor/bleak_process.py

@@ -25,6 +25,10 @@ OYM_DATA_NOTIFY_CHAR_UUID = "f000ffe2-0451-4000-b000-000000000000"
 RFSTAR_CMD_UUID = "00000002-0000-1000-8000-00805f9b34fb"
 RFSTAR_DATA_UUID = "00000003-0000-1000-8000-00805f9b34fb"
 
+# 异常断开后自动重连参数
+_MAX_RECONNECT_ATTEMPTS = 5
+_RECONNECT_DELAY_SECONDS = 1.0
+
 
 def _extract_mac(_device: bleak.BLEDevice, adv: AdvertisementData) -> str:
 
@@ -93,6 +97,8 @@ class BleakProcess(multiprocessing.Process):
         self._power_intervals: dict = {}  # mac -> int (ms)
         self._data_tasks: dict = {}       # mac -> asyncio.Task
         self._battery_tasks: dict = {}    # mac -> asyncio.Task
+        self._reconnect_info: dict = {}   # mac -> {cmd, attempts, task, normal_disconnect}
+        self._main_event_loop = None      # BleakProcess 主事件循环
 
         # Per-device event loops and threads
         self._event_loops: dict = {}      # mac -> asyncio.AbstractEventLoop
@@ -344,6 +350,7 @@ class BleakProcess(multiprocessing.Process):
         self._msg_queue = queue.Queue()
 
         async def _run_main():
+            self._main_event_loop = asyncio.get_running_loop()
             publisher_task = asyncio.create_task(self._publisher_task())
             try:
                 await self._main_loop()
@@ -581,6 +588,14 @@ class BleakProcess(multiprocessing.Process):
         name = cmd.get("name", "")
         service_data = cmd.get("service_data", {})
 
+        # 保存连接信息，用于异常断开后自动重连
+        self._reconnect_info[device_mac] = {
+            "cmd": cmd,
+            "attempts": 0,
+            "task": None,
+            "normal_disconnect": False,
+        }
+
         event_loop = self._event_loops.get(device_mac)
         gforce_event_loop = self._gforce_event_loop
         data_event_loop = self._data_event_loops.get(device_mac)
@@ -676,8 +691,18 @@ class BleakProcess(multiprocessing.Process):
         self._raw_bufs[device_mac] = raw_buf
         self._device_states[device_mac] = "Connected"
 
+        # 重连成功，重置重连计数
+        reconnect_info = self._reconnect_info.get(device_mac)
+        if reconnect_info is not None:
+            reconnect_info["attempts"] = 0
+
         # Create data context
-        data_ctx = SensorProfileDataCtx(gforce, device_mac, raw_buf)
+        data_ctx = SensorProfileDataCtx(
+            gforce,
+            device_mac,
+            raw_buf,
+            on_reconnect_request=lambda: self._schedule_reconnect(device_mac),
+        )
         self._data_ctxs[device_mac] = data_ctx
 
         # Start data processing loop in data_event_loop
@@ -705,6 +730,19 @@ class BleakProcess(multiprocessing.Process):
             if device_mac not in self._gforces and not disconnect_client:
                 return  # Already cleaned
 
+            # 用户主动断开时标记为正常断开，并取消正在进行的自动重连
+            if disconnect_client:
+                info = self._reconnect_info.get(device_mac)
+                if info is not None:
+                    info["normal_disconnect"] = True
+                    task = info.get("task")
+                    if task is not None:
+                        try:
+                            task.cancel()
+                        except Exception:
+                            pass
+                        info["task"] = None
+
             # Cancel data task (running in data_event_loop)
             if device_mac in self._data_tasks:
                 task = self._data_tasks.pop(device_mac, None)
@@ -750,8 +788,63 @@ class BleakProcess(multiprocessing.Process):
             self._raw_bufs.pop(device_mac, None)
             self._device_states[device_mac] = "Disconnected"
 
+            # 正常断开后清理重连信息；异常断开保留以继续自动重连
+            if disconnect_client:
+                self._reconnect_info.pop(device_mac, None)
+
         self._publish("state_changed", device_mac=device_mac, state="Disconnected")
 
+    def _schedule_reconnect(self, device_mac: str):
+        """从 watchdog 线程调用，调度一次自动重连。"""
+        info = self._reconnect_info.get(device_mac)
+        if info is None or info.get("normal_disconnect"):
+            return
+        if info.get("task") is not None:
+            return  # 已有重连任务在进行
+        if info["attempts"] >= _MAX_RECONNECT_ATTEMPTS:
+            SdkLog.e(_TAG, f"Max reconnect attempts reached for {device_mac}")
+            return
+
+        info["attempts"] += 1
+        SdkLog.i(_TAG, f"Scheduling reconnect attempt {info['attempts']} for {device_mac}")
+
+        loop = self._main_event_loop
+        if loop is None or loop.is_closed():
+            SdkLog.e(_TAG, f"Main event loop not available, cannot reconnect {device_mac}")
+            return
+
+        async def _delayed_reconnect():
+            await asyncio.sleep(_RECONNECT_DELAY_SECONDS)
+            await self._do_reconnect(device_mac)
+
+        try:
+            info["task"] = asyncio.run_coroutine_threadsafe(_delayed_reconnect(), loop)
+        except Exception as e:
+            SdkLog.exception(_TAG, f"Failed to schedule reconnect for {device_mac}: {e}")
+            info["task"] = None
+
+    async def _do_reconnect(self, device_mac: str):
+        """执行一次自动重连。"""
+        info = self._reconnect_info.get(device_mac)
+        if info is None or info.get("normal_disconnect"):
+            return
+
+        # 已经连接则无需重连
+        if device_mac in self._gforces:
+            info["task"] = None
+            return
+
+        SdkLog.i(_TAG, f"Reconnecting {device_mac}, attempt {info['attempts']}")
+        try:
+            await self._do_connect(info["cmd"])
+        except Exception as e:
+            SdkLog.exception(_TAG, f"Reconnect attempt failed for {device_mac}: {e}")
+            # 失败后会再次由 _schedule_reconnect 决定是否继续
+            self._schedule_reconnect(device_mac)
+        finally:
+            if info is not None:
+                info["task"] = None
+
     async def _do_disconnect(self, cmd: dict):
 
         device_mac = cmd["device_mac"]
@@ -1111,6 +1204,12 @@ class BleakProcess(multiprocessing.Process):
             sorted_keys = sorted(ctx.notify_map.keys())
             result = "|".join(f"{k}|{ctx.notify_map[k]}" for k in sorted_keys)
 
+        if key == "NTF_IMU":
+            imu_sub_keys = ["NTF_GFORCE_ACC", "NTF_GFORCE_GYRO", "NTF_GFORCE_QUAT", "NTF_GFORCE_EULER"]
+            result = "ON" if all(ctx.notify_map.get(k) == "ON" for k in imu_sub_keys) else "OFF"
+        elif key in ctx.notify_map:
+            result = ctx.notify_map[key]
+
         if key == "DEBUG_LOG_PATH":
             result = SdkLog.get_log_path() or ""
 
@@ -1154,6 +1253,8 @@ class BleakProcess(multiprocessing.Process):
 
         result = "Error: Not supported"
         needs_restart = False
+        oym_needs_subscribe = False
+        was_streaming = ctx.isDataTransfering
 
         ntf_keys = [
             "NTF_GEST", "NTF_EMG", "NTF_EEG", "NTF_ECG", "NTF_IMU", "NTF_BRTH", "NTF_IMPEDANCE",
@@ -1168,6 +1269,12 @@ class BleakProcess(multiprocessing.Process):
                 if key == "NTF_PPG_RAW":
                     map_key = "NTF_PPG"
 
+                # IMU 总开关同时控制 ACC/GYRO/QUAT/EULER
+                imu_sub_keys = ["NTF_GFORCE_ACC", "NTF_GFORCE_GYRO", "NTF_GFORCE_QUAT", "NTF_GFORCE_EULER"]
+                if map_key == "NTF_IMU":
+                    for sub in imu_sub_keys:
+                        ctx.notify_map[sub] = value
+
                 # 老版本 EMG 设备上 Gesture 与 EMG 互斥，自动切换
                 if not ctx.isNewEMG:
                     if map_key == "NTF_GEST" and value == "ON" and ctx.notify_map.get("NTF_EMG") == "ON":
@@ -1182,12 +1289,40 @@ class BleakProcess(multiprocessing.Process):
                         ctx.notify_map[map_key] = value
                         result = "OK"
                 else:
+                    # 新 EMG：Gesture 依赖 EMG 数据，关闭 EMG 时同步关闭 Gesture；打开 Gesture 时自动打开 EMG
+                    if map_key == "NTF_EMG" and value == "OFF":
+                        ctx.notify_map["NTF_GEST"] = "OFF"
+                    elif map_key == "NTF_GEST" and value == "ON" and ctx.notify_map.get("NTF_EMG") != "ON":
+                        ctx.notify_map["NTF_EMG"] = "ON"
                     ctx.notify_map[map_key] = value
                     result = "OK"
-                if result == "OK" and ctx.hasInit() and ctx.isDataTransfering:
+
+                # 单个 IMU 子开关变化时，同步更新 NTF_IMU 总开关的聚合状态
+                if map_key in imu_sub_keys:
+                    ctx.notify_map["NTF_IMU"] = "ON" if all(ctx.notify_map.get(k) == "ON" for k in imu_sub_keys) else "OFF"
+
+                if result == "OK" and ctx.hasInit():
                     ctx._buildNotifyDataFlag()
-                    needs_restart = True
-                    if ctx.getChipType() == BLEChipType.OYM:
+
+                    # 新 EMG 设备通过 function switch 控制 EMG/Gesture 输出，bit0=gesture, bit1=emg
+                    if ctx.isNewEMG and map_key in ("NTF_EMG", "NTF_GEST"):
+                        emg_bit = 1 if ctx.notify_map.get("NTF_EMG") == "ON" else 0
+                        gest_bit = 1 if (emg_bit and ctx.notify_map.get("NTF_GEST") == "ON") else 0
+                        func_switch = (emg_bit << 1) | gest_bit
+                        try:
+                            await ctx.gForce.set_function_switch(func_switch)
+                            await asyncio.sleep(0.5)
+                        except Exception as e:
+                            SdkLog.exception(_TAG, f"_do_set_param set_function_switch failed: {device_mac}")
+                            result = "ERROR: set_function_switch fail: " + str(e)
+                        if ctx.getChipType() == BLEChipType.OYM:
+                            oym_needs_subscribe = True
+                    elif was_streaming:
+                        needs_restart = True
+                        if ctx.getChipType() == BLEChipType.OYM:
+                            oym_needs_subscribe = True
+                    elif ctx.getChipType() == BLEChipType.OYM:
+                        # 未在传输时，直接更新 OYM 订阅掩码
                         try:
                             await ctx.gForce.set_subscription(ctx.notifyDataFlag)
                         except Exception as e:
@@ -1204,10 +1339,14 @@ class BleakProcess(multiprocessing.Process):
                     SdkLog.exception(_TAG, f"_do_set_param setFilter failed: {device_mac} {key}={value}")
                     result = "ERROR: " + str(e)
 
-        if needs_restart:
+        if needs_restart or oym_needs_subscribe:
             try:
-                await ctx.stop_streaming()
-                await ctx.start_streaming()
+                if was_streaming:
+                    await ctx.stop_streaming()
+                if oym_needs_subscribe and ctx.getChipType() == BLEChipType.OYM:
+                    await ctx.gForce.set_subscription(ctx.notifyDataFlag)
+                if was_streaming:
+                    await ctx.start_streaming()
             except Exception as e:
                 SdkLog.exception(_TAG, f"_do_set_param restart stream failed: {device_mac}")
                 result = "ERROR: restart stream fail: " + str(e)

{sensor_sdk-0.1.9 → sensor_sdk-0.2.1}/sensor/gforce.py

@@ -2,6 +2,7 @@ import asyncio
 import queue
 import struct
 import platform
+import time
 from contextlib import suppress
 from datetime import datetime
 from dataclasses import dataclass
@@ -453,6 +454,8 @@ class GForce:
         self.cmd_char = cmd_char
         self.data_char = data_char
         self.responses: Dict[Command, queue.Queue] = {}
+        self.last_command_failure_time: Optional[float] = None
+        self.last_command_failure_cmd: Optional[int] = None
         self.resolution = SampleResolution.BITS_8
         self._num_channels = 8
         self._device = device
@@ -1091,6 +1094,8 @@ class GForce:
                 timeout=2
             )
         except Exception as e:
+            self.last_command_failure_time = time.time()
+            self.last_command_failure_cmd = req.cmd
             SdkLog.exception(_TAG, f"_send_request write_gatt_char failed: {req.cmd}")
             if req.has_res:
                 self.responses[req.cmd] = None

{sensor_sdk-0.1.9 → sensor_sdk-0.2.1}/sensor/sensor_data_context.py

@@ -9,7 +9,7 @@ import struct
 import math
 import threading
 import time
-from typing import Deque, List
+from typing import Deque, List, Optional
 from concurrent.futures import ThreadPoolExecutor
 import csv
 from sensor import sensor_utils
@@ -30,6 +30,8 @@ QUAT_SCALE = 1 / 1073741824.0  # 2^30
 _MAX_CONCAT_BUFFER_SIZE = 64 * 1024  # 64KB
 # data 日志队列最大长度，写盘跟不上时丢弃日志而不是阻塞解析线程
 _DATA_LOG_QUEUE_MAXSIZE = 1000
+# 包序号最大允许跳变值，超过视为非法跳变/丢包
+_MAX_ALLOWED_PACKAGE_INDEX_DELTA = 100
 
 class SensorDataType(IntEnum):
     DATA_TYPE_EEG = 0
@@ -83,7 +85,13 @@ class ReadSamplesResult(IntEnum):
 
 
 class SensorProfileDataCtx:
-    def __init__(self, gForce: GForce, deviceMac: str, buf: Queue[bytes]):
+    def __init__(
+        self,
+        gForce: GForce,
+        deviceMac: str,
+        buf: Queue[bytes],
+        on_reconnect_request: Optional[callable] = None,
+    ):
         self.featureMap = 0
         self.notifyDataFlag: DataSubscription = 0
 
@@ -150,6 +158,15 @@ class SensorProfileDataCtx:
         self._watchdog_thread.daemon = True
         self._watchdog_thread.start()
 
+        # 非法跳变监控：持续超过阈值则重启数据通知
+        self._illegal_jump_start_time: Optional[float] = None
+        self._is_restarting_stream = False
+
+        # 命令失败导致异常断开后自动重连
+        self._on_reconnect_request = on_reconnect_request
+        self._disconnected_start_time: Optional[float] = None
+        self._reconnect_requested = False
+
     def close(self):
         self._is_running = False
         if self.debugCSVWriter != None:
@@ -188,10 +205,28 @@ class SensorProfileDataCtx:
                 pass
             self._watchdog_thread = None
 
+    async def _restart_streaming(self):
+        """非法跳变持续时重启数据通知。"""
+        if self._is_restarting_stream:
+            return
+        self._is_restarting_stream = True
+        try:
+            SdkLog.w(_TAG, f"Illegal package index jump persisted > 5s, restarting data notification for {self.deviceMac}")
+            await self.stop_streaming()
+            await self.start_streaming(self._rawDataBuffer)
+            self._illegal_jump_start_time = None
+        except Exception as e:
+            SdkLog.exception(_TAG, f"Restart streaming failed for {self.deviceMac}: {e}")
+        finally:
+            self._is_restarting_stream = False
+
     def _watchdog_loop(self):
         """守护线程：监控解析线程进度，防止卡死后内存无限增长。"""
         WATCHDOG_INTERVAL = 1.0  # 检查间隔
         WATCHDOG_TIMEOUT = 5.0   # 无进度报警阈值
+        ILLEGAL_JUMP_TIMEOUT = 5.0  # 非法跳变持续阈值
+        RECONNECT_AFTER_DISCONNECT = 3.0  # 断开后等待多久尝试重连
+        RECENT_CMD_FAILURE_WINDOW = 30.0  # 命令失败多久内视为相关
         RAW_BUF_CLEAR_THRESHOLD = 1500  # 超过此值且无进度时清空
 
         while not self._watchdog_stop_event.is_set():
@@ -229,6 +264,46 @@ class SensorProfileDataCtx:
                         self._concatDataBuffer.clear()
                         # 清空后更新时间戳，避免持续报警
                         self._last_progress_time = time.time()
+
+                # 非法跳变持续超过阈值则重启数据通知
+                if (self._illegal_jump_start_time is not None
+                        and not self._is_restarting_stream
+                        and self.isDataTransfering):
+                    jump_elapsed = time.time() - self._illegal_jump_start_time
+                    if jump_elapsed > ILLEGAL_JUMP_TIMEOUT:
+                        SdkLog.w(_TAG, f"Illegal jump persisted for {jump_elapsed:.1f}s, restarting stream for {self.deviceMac}")
+                        try:
+                            asyncio.run_coroutine_threadsafe(
+                                self._restart_streaming(), self.gForce.gforce_event_loop
+                            )
+                        except Exception as e:
+                            SdkLog.exception(_TAG, f"Failed to schedule stream restart for {self.deviceMac}: {e}")
+
+                # 命令失败后设备异常断开，触发自动重连
+                if self._on_reconnect_request is not None:
+                    client = getattr(self.gForce, "client", None)
+                    is_connected = getattr(client, "is_connected", False) if client is not None else False
+                    if is_connected:
+                        self._disconnected_start_time = None
+                        self._reconnect_requested = False
+                    else:
+                        if self._disconnected_start_time is None:
+                            self._disconnected_start_time = time.time()
+                        disconnected_elapsed = time.time() - self._disconnected_start_time
+                        cmd_fail_time = getattr(self.gForce, "last_command_failure_time", None)
+                        recent_cmd_failure = (
+                            cmd_fail_time is not None
+                            and (time.time() - cmd_fail_time) < RECENT_CMD_FAILURE_WINDOW
+                        )
+                        if (disconnected_elapsed > RECONNECT_AFTER_DISCONNECT
+                                and recent_cmd_failure
+                                and not self._reconnect_requested):
+                            SdkLog.w(_TAG, f"Device disconnected after command failure, scheduling reconnect for {self.deviceMac}")
+                            self._reconnect_requested = True
+                            try:
+                                self._on_reconnect_request()
+                            except Exception as e:
+                                SdkLog.exception(_TAG, f"Reconnect request failed for {self.deviceMac}: {e}")
             except Exception as e:
                 SdkLog.exception(_TAG, f"Watchdog error: {e}")
 
@@ -390,8 +465,12 @@ class SensorProfileDataCtx:
         config.batch_len = 128
 
         if isNewEMG:
-            await self.gForce.set_function_switch(0b11)
-    
+            # 新版 EMG：bit0=gesture，bit1=emg；Gesture 依赖 EMG，EMG 关闭时 Gesture 同步关闭
+            emg_bit = 1 if self.notify_map.get("NTF_EMG") == "ON" else 0
+            gest_bit = 1 if (emg_bit and self.notify_map.get("NTF_GEST") == "ON") else 0
+            await self.gForce.set_function_switch((emg_bit << 1) | gest_bit)
+            await asyncio.sleep(0.5)
+
         await self.gForce.set_emg_raw_data_config(config)
         await self.gForce.set_package_id(True)
 
@@ -404,6 +483,15 @@ class SensorProfileDataCtx:
         self.sensorDatas[SensorDataType.DATA_TYPE_EMG] = data
         self.isNewEMG = isNewEMG
 
+        # 新 EMG + OYM 芯片：默认只开 EMG，关闭 Gesture 和 IMU
+        if isNewEMG and self._chip_type == BLEChipType.OYM:
+            self.notify_map["NTF_GEST"] = "OFF"
+            self.notify_map["NTF_IMU"] = "OFF"
+            self.notify_map["NTF_GFORCE_ACC"] = "OFF"
+            self.notify_map["NTF_GFORCE_GYRO"] = "OFF"
+            self.notify_map["NTF_GFORCE_QUAT"] = "OFF"
+            self.notify_map["NTF_GFORCE_EULER"] = "OFF"
+
         # 老 EMG 设备不支持 FILTER
         if not isNewEMG:
             self.filter_map.clear()
@@ -1485,6 +1573,7 @@ class SensorProfileDataCtx:
                 if newPackageIndex <= 2 and lastPackageIndex >= maxPackageIndex - 2:
                     packageIndex = maxPackageIndex + 1 + newPackageIndex
                 elif newPackageIndex == lastPackageIndex:
+                    self._illegal_jump_start_time = None
                     return ReadSamplesResult.Repeated
                 elif newPackageIndex < lastPackageIndex:
                     SdkLog.i(_TAG, (
@@ -1494,10 +1583,12 @@ class SensorProfileDataCtx:
                         + "|CURR_IDX|" + str(newPackageIndex)
                         + "|DELTA|" + str(lastPackageIndex - newPackageIndex)
                     ))
+                    if self._illegal_jump_start_time is None:
+                        self._illegal_jump_start_time = time.time()
                     return ReadSamplesResult.Error
 
                 deltaPackageIndex = packageIndex - lastPackageIndex
-                if deltaPackageIndex > 20:
+                if deltaPackageIndex > _MAX_ALLOWED_PACKAGE_INDEX_DELTA:
                     SdkLog.i(_TAG, (
                         "Illegal package index jump|MAC|" + str(sensorData.deviceMac)
                         + "|TYPE|" + str(sensorData.dataType)
@@ -1505,6 +1596,8 @@ class SensorProfileDataCtx:
                         + "|CURR_IDX|" + str(newPackageIndex)
                         + "|DELTA|" + str(deltaPackageIndex)
                     ))
+                    if self._illegal_jump_start_time is None:
+                        self._illegal_jump_start_time = time.time()
                     return ReadSamplesResult.Error
 
                 lostPackageCounter = deltaPackageIndex - 1
@@ -1518,7 +1611,7 @@ class SensorProfileDataCtx:
                         + "|COUNT|" + str(lostSampleCount)
                     ))
 
-                    if lostPackageCounter < 20:
+                    if lostPackageCounter < _MAX_ALLOWED_PACKAGE_INDEX_DELTA:
                         self.readSamples(data, sensorData, 0, dataGap, lostSampleCount)
 
                     sensorData.lastPackageIndex = newPackageIndex - 1
@@ -1530,6 +1623,7 @@ class SensorProfileDataCtx:
                 self.readSamples(data, sensorData, dataOffset, dataGap, 0)
 
             sensorData.lastPackageCounter += 1
+            self._illegal_jump_start_time = None
         except Exception as e:
             SdkLog.exception(_TAG, "Unexpected error")
             return ReadSamplesResult.Error

{sensor_sdk-0.1.9 → sensor_sdk-0.2.1/sensor_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sensor-sdk
-Version: 0.1.9
+Version: 0.2.1
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye

{sensor_sdk-0.1.9 → sensor_sdk-0.2.1}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, "README.md"), "r", encoding="utf-8") as f
 
 setup(
     name="sensor-sdk",
-    version="0.1.9",
+    version="0.2.1",
     description="Python sdk for Synchroni",
     long_description=long_description,
     long_description_content_type="text/markdown",