sensor-sdk 0.0.5__py3-none-any.whl → 0.0.6__py3-none-any.whl

sensor/sensor_controller.py

@@ -9,7 +9,7 @@ from sensor import utils
 from sensor.sensor_profile import DeviceStateEx, SensorProfile
 import asyncio
 
-from sensor.utils import async_timer, start_loop, sync_timer, timer
+from sensor.utils import async_call, start_loop, sync_call, async_exec, timer
 from bleak import (
     BleakScanner,
     AdvertisementData,
@@ -38,16 +38,12 @@ class SensorController:
         初始化 SensorController 实例。
         """
         self._event_loop = asyncio.new_event_loop()
-        self._event_thread = threading.Thread(
-            target=start_loop, args=(self._event_loop,)
-        )
+        self._event_thread = threading.Thread(target=start_loop, args=(self._event_loop,))
         self._event_thread.daemon = True
         self._event_thread.name = "SensorController event"
         self._event_thread.start()
         self._gforce_event_loop = asyncio.new_event_loop()
-        self._gforce_event_thread = threading.Thread(
-            target=start_loop, args=(self._gforce_event_loop,)
-        )
+        self._gforce_event_thread = threading.Thread(target=start_loop, args=(self._gforce_event_loop,))
         self._gforce_event_thread.daemon = True
         self._gforce_event_thread.name = "BLE operation"
         self._gforce_event_thread.start()
@@ -72,10 +68,7 @@ class SensorController:
     def terminate(self):
         utils._terminated = True
         for sensor in self._sensor_profiles.values():
-            if (
-                sensor.deviceState == DeviceStateEx.Connected
-                or sensor.deviceState == DeviceStateEx.Ready
-            ):
+            if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
                 sensor._destroy()
 
     def _match_device(self, _device: bleak.BLEDevice, adv: AdvertisementData):
@@ -125,9 +118,7 @@ class SensorController:
         return self._device_callback != None
 
     @hasDeviceFoundCallback.setter
-    def onDeviceFoundCallback(
-        self, callback: Callable[[List[sensor_profile.BLEDevice]], None]
-    ):
+    def onDeviceFoundCallback(self, callback: Callable[[List[sensor_profile.BLEDevice]], None]):
         """
         设置扫描设备回调。
 
@@ -168,9 +159,7 @@ class SensorController:
 
     async def _async_scan(self, period):
         self._is_scanning = True
-        found_devices = await self._scanner.discover(
-            timeout=period / 1000, return_adv=True
-        )
+        found_devices = await self._scanner.discover(timeout=period / 1000, return_adv=True)
         self._is_scanning = False
         return self._process_ble_devices(found_devices)
 
@@ -182,7 +171,7 @@ class SensorController:
 
         :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
         """
-        return sync_timer(self._gforce_event_loop, 0, self._async_scan(period))
+        return sync_call(self._gforce_event_loop, self._async_scan(period))
 
     async def asyncScan(self, period) -> List[sensor_profile.BLEDevice]:
         """
@@ -192,7 +181,7 @@ class SensorController:
 
         :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
         """
-        return await async_timer(self._gforce_event_loop, 0, self._async_scan(period))
+        return await async_call(self._gforce_event_loop, self._async_scan(period))
 
     async def _device_scan_callback(self, devices: List[sensor_profile.BLEDevice]):
         if self._device_callback:
@@ -202,14 +191,12 @@ class SensorController:
                 print(e)
 
         if self._is_scanning:
-            timer(self._gforce_event_loop, 0, self._startScan())
+            async_exec(self._gforce_event_loop, self._startScan())
 
     async def _startScan(self) -> bool:
-        found_devices = await self._scanner.discover(
-            timeout=self._device_callback_period / 1000, return_adv=True
-        )
+        found_devices = await self._scanner.discover(timeout=self._device_callback_period / 1000, return_adv=True)
         devices = self._process_ble_devices(found_devices)
-        timer(self._event_loop, 0, self._device_scan_callback(devices))
+        async_exec(self._event_loop, self._device_scan_callback(devices))
 
     def startScan(self, periodInMs: int) -> bool:
         """
@@ -225,7 +212,7 @@ class SensorController:
         self._is_scanning = True
         self._device_callback_period = periodInMs
 
-        timer(self._gforce_event_loop, 0, self._startScan())
+        async_exec(self._gforce_event_loop, self._startScan())
         return True
 
     def stopScan(self) -> None:
@@ -237,9 +224,7 @@ class SensorController:
 
         self._is_scanning = False
 
-    def requireSensor(
-        self, device: sensor_profile.BLEDevice
-    ) -> Optional[SensorProfile]:
+    def requireSensor(self, device: sensor_profile.BLEDevice) -> Optional[SensorProfile]:
         """
         根据设备信息获取或创建SensorProfile。
 
@@ -271,10 +256,7 @@ class SensorController:
         """
         sensors: List[SensorProfile] = list()
         for sensor in self._sensor_profiles.values():
-            if (
-                sensor.deviceState == DeviceStateEx.Connected
-                or sensor.deviceState == DeviceStateEx.Ready
-            ):
+            if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
                 sensors.append(sensor)
 
         return sensors
@@ -287,10 +269,7 @@ class SensorController:
         """
         devices: List[sensor_profile.BLEDevice] = list()
         for sensor in self._sensor_profiles.values():
-            if (
-                sensor.deviceState == DeviceStateEx.Connected
-                or sensor.deviceState == DeviceStateEx.Ready
-            ):
+            if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
                 devices.append(sensor.BLEDevice)
 
         return devices

sensor/sensor_data_context.py

@@ -82,9 +82,7 @@ class SensorProfileDataCtx:
         return self._is_data_transfering
 
     def hasInit(self):
-        return (
-            not self._is_initing and self.featureMap != 0 and self.notifyDataFlag != 0
-        )
+        return not self._is_initing and self.featureMap != 0 and self.notifyDataFlag != 0
 
     def hasEMG(self):
         return (self.featureMap & FeatureMaps.GFD_FEAT_EMG.value) != 0
@@ -337,9 +335,7 @@ class SensorProfileDataCtx:
             if self.checkReadSamples(sensor, data, sensor_data_gyro, 9, 6):
                 self.sendSensorData(sensor_data_gyro, buf)
 
-    def checkReadSamples(
-        self, sensor, data: bytes, sensorData: SensorData, dataOffset: int, dataGap: int
-    ):
+    def checkReadSamples(self, sensor, data: bytes, sensorData: SensorData, dataOffset: int, dataGap: int):
         offset = 1
         v = data[0]
         if not self._is_data_transfering:
@@ -358,9 +354,7 @@ class SensorProfileDataCtx:
 
             deltaPackageIndex = packageIndex - lastPackageIndex
             if deltaPackageIndex > 1:
-                lostSampleCount = sensorData.packageSampleCount * (
-                    deltaPackageIndex - 1
-                )
+                lostSampleCount = sensorData.packageSampleCount * (deltaPackageIndex - 1)
                 lostLog = (
                     "MSG|LOST SAMPLE|MAC|"
                     + str(sensorData.deviceMac)
@@ -372,9 +366,7 @@ class SensorProfileDataCtx:
                 # print(lostLog)
                 if sensor._event_loop != None and sensor._on_error_callback != None:
                     try:
-                        sensor._event_loop.call_soon_threadsafe(
-                            sensor._on_error_callback, sensor, lostLog
-                        )
+                        sensor._event_loop.call_soon_threadsafe(sensor._on_error_callback, sensor, lostLog)
                     except Exception as e:
                         pass
 
@@ -418,18 +410,14 @@ class SensorProfileDataCtx:
                 channelSamples.append([])
 
         for sampleIndex in range(sampleCount):
-            for channelIndex, impedanceChannelIndex in enumerate(
-                range(sensorData.channelCount)
-            ):
+            for channelIndex, impedanceChannelIndex in enumerate(range(sensorData.channelCount)):
                 if (sensorData.channelMask & (1 << channelIndex)) != 0:
                     samples = channelSamples[channelIndex]
                     impedance = 0.0
                     saturation = 0.0
 
                     if sensorData.dataType == DataType.NTF_ECG:
-                        impedanceChannelIndex = self.sensorDatas[
-                            SensorDataType.DATA_TYPE_EEG
-                        ].channelCount
+                        impedanceChannelIndex = self.sensorDatas[SensorDataType.DATA_TYPE_EEG].channelCount
 
                     if impedanceChannelIndex < len(_impedanceData):
                         impedance = _impedanceData[impedanceChannelIndex]
@@ -461,11 +449,7 @@ class SensorProfileDataCtx:
                             )
                             offset += 2
                         elif sensorData.resolutionBits == 24:
-                            rawData = (
-                                (data[offset] << 16)
-                                | (data[offset + 1] << 8)
-                                | data[offset + 2]
-                            )
+                            rawData = (data[offset] << 16) | (data[offset + 1] << 8) | data[offset + 2]
                             rawData -= 8388608
                             offset += 3
 
@@ -802,9 +786,7 @@ class SensorProfileDataCtx:
 
         return crc8
 
-    def processUniversalData(
-        self, buf: Queue[SensorData], loop: asyncio.AbstractEventLoop, sensor, callback
-    ):
+    def processUniversalData(self, buf: Queue[SensorData], loop: asyncio.AbstractEventLoop, sensor, callback):
 
         while self._is_running:
             try:
@@ -832,16 +814,12 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = self.calc_crc8(
-                        self._concatDataBuffer[index + 2 : index + 2 + n]
-                    )
+                    calc_crc = self.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
                     if crc != calc_crc:
                         index += 1
                         continue
                     if self._is_data_transfering:
-                        data_package = bytes(
-                            self._concatDataBuffer[index + 2 : index + 2 + n]
-                        )
+                        data_package = bytes(self._concatDataBuffer[index + 2 : index + 2 + n])
                         self._processDataPackage(data_package, buf, sensor)
                         while self._is_running and self.isDataTransfering:
                             sensorData: SensorData = None
@@ -851,9 +829,7 @@ class SensorProfileDataCtx:
                                 break
                             if loop != None and sensorData != None and callback != None:
                                 try:
-                                    loop.call_soon_threadsafe(
-                                        callback, sensor, sensorData
-                                    )
+                                    loop.call_soon_threadsafe(callback, sensor, sensorData)
                                 except Exception as e:
                                     print(e)
 
@@ -869,19 +845,13 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = self.calc_crc8(
-                        self._concatDataBuffer[index + 2 : index + 2 + n]
-                    )
+                    calc_crc = self.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
                     if crc != calc_crc:
                         index += 1
                         continue
-                    data_package = bytes(
-                        self._concatDataBuffer[index + 2 : index + 2 + n]
-                    )
+                    data_package = bytes(self._concatDataBuffer[index + 2 : index + 2 + n])
                     if loop != None:
-                        loop.call_soon_threadsafe(
-                            self.gForce._on_cmd_response, None, data_package
-                        )
+                        loop.call_soon_threadsafe(self.gForce._on_cmd_response, None, data_package)
                     last_cut = index = index + 2 + n
                 else:
                     index += 1

sensor/sensor_profile.py

@@ -21,7 +21,7 @@ import threading
 
 from sensor.sensor_data_context import SensorProfileDataCtx
 from sensor.sensor_device import BLEDevice, DeviceInfo, DeviceStateEx
-from sensor.utils import async_timer, start_loop, sync_timer, timer
+from sensor.utils import async_call, start_loop, sync_call, async_exec, timer
 from contextlib import suppress
 from dataclasses import dataclass
 
@@ -78,10 +78,7 @@ class SensorProfile:
         self._destroy()
 
     def _destroy(self):
-        if (
-            self._device_state == DeviceStateEx.Connected
-            or self._device_state == DeviceStateEx.Ready
-        ):
+        if self._device_state == DeviceStateEx.Connected or self._device_state == DeviceStateEx.Ready:
             self.disconnect()
         if self._data_event_loop != None:
             try:
@@ -114,9 +111,7 @@ class SensorProfile:
             self._device_state = newState
             if self._event_loop != None and self._on_state_changed != None:
                 try:
-                    self._event_loop.call_soon_threadsafe(
-                        self._on_state_changed, self, newState
-                    )
+                    self._event_loop.call_soon_threadsafe(self._on_state_changed, self, newState)
                 except Exception as e:
                     print(e)
                     pass
@@ -162,9 +157,7 @@ class SensorProfile:
         return self._on_state_changed
 
     @onStateChanged.setter
-    def onStateChanged(
-        self, callback: Callable[["SensorProfile", DeviceStateEx], None]
-    ):
+    def onStateChanged(self, callback: Callable[["SensorProfile", DeviceStateEx], None]):
         """
         设置状态变化的回调函数。
 
@@ -229,9 +222,7 @@ class SensorProfile:
     async def _connect(self) -> bool:
         if self._event_thread == None:
             self._event_loop = asyncio.new_event_loop()
-            self._event_thread = threading.Thread(
-                target=start_loop, args=(self._event_loop,)
-            )
+            self._event_thread = threading.Thread(target=start_loop, args=(self._event_loop,))
             self._event_thread.daemon = True
             self._event_thread.name = self._device.Name + " event"
             self._event_thread.start()
@@ -249,35 +240,22 @@ class SensorProfile:
                 )
             elif self._adv.service_data.get(RFSTAR_SERVICE_GUID) != None:
                 # print("RFSTAR_SERVICE:" + self._detail_device.name)
-                self._gforce = GForce(
-                    self._detail_device, RFSTAR_CMD_UUID, RFSTAR_DATA_UUID, True
-                )
+                self._gforce = GForce(self._detail_device, RFSTAR_CMD_UUID, RFSTAR_DATA_UUID, True)
                 self._data_event_loop = asyncio.new_event_loop()
-                self._data_event_thread = threading.Thread(
-                    target=start_loop, args=(self._data_event_loop,)
-                )
+                self._data_event_thread = threading.Thread(target=start_loop, args=(self._data_event_loop,))
                 self._data_event_thread.daemon = True
                 self._data_event_thread.name = self._detail_device.name + " data"
                 self._data_event_thread.start()
             else:
-                print(
-                    "Invalid device service uuid:"
-                    + self._detail_device.name
-                    + str(self._adv)
-                )
+                print("Invalid device service uuid:" + self._detail_device.name + str(self._adv))
                 return False
 
         if self._data_ctx == None and self._gforce != None:
-            self._data_ctx = SensorProfileDataCtx(
-                self._gforce, self._device.Address, self._raw_data_buf
-            )
+            self._data_ctx = SensorProfileDataCtx(self._gforce, self._device.Address, self._raw_data_buf)
         if self._data_ctx.isUniversalStream:
-            timer(self._data_event_loop, 0, self._process_universal_data())
+            async_exec(self._data_event_loop, self._process_universal_data())
 
-        if (
-            self.deviceState == DeviceStateEx.Connected
-            or self.deviceState == DeviceStateEx.Ready
-        ):
+        if self.deviceState == DeviceStateEx.Connected or self.deviceState == DeviceStateEx.Ready:
             return True
         self._set_device_state(DeviceStateEx.Connecting)
 
@@ -311,7 +289,7 @@ class SensorProfile:
         :return:            bool: 如果连接成功，返回 True；否则返回 False。
 
         """
-        result = sync_timer(self._gforce_event_loop, 0, self._connect())
+        result = sync_call(self._gforce_event_loop, self._connect())
         return result
 
     async def asyncConnect(self) -> bool:
@@ -321,7 +299,7 @@ class SensorProfile:
         :return:            bool: 如果连接成功，返回 True；否则返回 False。
 
         """
-        return await async_timer(self._gforce_event_loop, 0, self._connect())
+        return await async_call(self._gforce_event_loop, self._connect())
 
     async def _waitForDisconnect(self) -> bool:
         while self.deviceState != DeviceStateEx.Disconnected:
@@ -329,10 +307,7 @@ class SensorProfile:
         return True
 
     async def _disconnect(self) -> bool:
-        if (
-            self.deviceState != DeviceStateEx.Connected
-            and self.deviceState != DeviceStateEx.Ready
-        ):
+        if self.deviceState != DeviceStateEx.Connected and self.deviceState != DeviceStateEx.Ready:
             return True
         if self._data_ctx == None:
             return False
@@ -348,7 +323,7 @@ class SensorProfile:
         :return:            bool: 如果断开连接成功，返回 True;否则返回 False。
 
         """
-        return sync_timer(self._gforce_event_loop, 0, self._disconnect())
+        return sync_call(self._gforce_event_loop, self._disconnect())
 
     async def asyncDisconnect(self) -> bool:
         """
@@ -357,7 +332,7 @@ class SensorProfile:
         :return:            bool: 如果断开连接成功，返回 True;否则返回 False。
 
         """
-        return await async_timer(self._gforce_event_loop, 0, self._disconnect())
+        return await async_call(self._gforce_event_loop, self._disconnect())
 
     async def _process_data(self):
         while self._data_ctx._is_running and self._data_ctx.isDataTransfering:
@@ -368,23 +343,15 @@ class SensorProfile:
                     sensorData = self._data_buffer.get_nowait()
                 except Exception as e:
                     break
-                if (
-                    self._event_loop != None
-                    and sensorData != None
-                    and self._on_data_callback != None
-                ):
+                if self._event_loop != None and sensorData != None and self._on_data_callback != None:
                     try:
-                        self._event_loop.call_soon_threadsafe(
-                            self._on_data_callback, self, sensorData
-                        )
+                        self._event_loop.call_soon_threadsafe(self._on_data_callback, self, sensorData)
                     except Exception as e:
                         print(e)
                 self._data_buffer.task_done()
 
     async def _process_universal_data(self):
-        self._data_ctx.processUniversalData(
-            self._data_buffer, self._event_loop, self, self._on_data_callback
-        )
+        self._data_ctx.processUniversalData(self._data_buffer, self._event_loop, self, self._on_data_callback)
 
     async def _startDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
@@ -399,9 +366,7 @@ class SensorProfile:
 
         if self._data_event_loop == None:
             self._data_event_loop = asyncio.new_event_loop()
-            self._data_event_thread = threading.Thread(
-                target=start_loop, args=(self._data_event_loop,)
-            )
+            self._data_event_thread = threading.Thread(target=start_loop, args=(self._data_event_loop,))
             self._data_event_thread.daemon = True
             self._data_event_thread.name = self.BLEDevice.Name + " data"
             self._data_event_thread.start()
@@ -410,7 +375,7 @@ class SensorProfile:
         self._data_buffer.queue.clear()
         self._data_ctx.clear()
         if not self._data_ctx.isUniversalStream:
-            timer(self._data_event_loop, 0, self._process_data())
+            async_exec(self._data_event_loop, self._process_data())
         return result
 
     def startDataNotification(self) -> bool:
@@ -420,7 +385,7 @@ class SensorProfile:
         :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
         """
-        return sync_timer(self._gforce_event_loop, 0, self._startDataNotification())
+        return sync_call(self._gforce_event_loop, self._startDataNotification())
 
     async def asyncStartDataNotification(self) -> bool:
         """
@@ -429,9 +394,7 @@ class SensorProfile:
         :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
         """
-        return await async_timer(
-            self._gforce_event_loop, 0, self._startDataNotification()
-        )
+        return await async_call(self._gforce_event_loop, self._startDataNotification())
 
     async def _stopDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
@@ -453,7 +416,7 @@ class SensorProfile:
         :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
 
         """
-        return sync_timer(self._gforce_event_loop, 0, self._stopDataNotification())
+        return sync_call(self._gforce_event_loop, self._stopDataNotification())
 
     async def asyncStopDataNotification(self) -> bool:
         """
@@ -462,18 +425,14 @@ class SensorProfile:
         :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
 
         """
-        return await async_timer(
-            self._gforce_event_loop, 0, self._stopDataNotification()
-        )
+        return await async_call(self._gforce_event_loop, self._stopDataNotification())
 
     async def _refresh_power(self):
         self._power = await self._gforce.get_battery_level()
 
         if self._event_loop != None and self._on_power_changed != None:
             try:
-                self._event_loop.call_soon_threadsafe(
-                    self._on_power_changed, self, self._power
-                )
+                self._event_loop.call_soon_threadsafe(self._on_power_changed, self, self._power)
             except Exception as e:
                 print(e)
 
@@ -512,16 +471,13 @@ class SensorProfile:
         :return:            bool: 初始化结果。True 表示成功，False 表示失败。
 
         """
-        return sync_timer(
+        return sync_call(
             self._gforce_event_loop,
-            0,
             self._init(packageSampleCount, powerRefreshInterval),
             120,
         )
 
-    async def asyncInit(
-        self, packageSampleCount: int, powerRefreshInterval: int
-    ) -> bool:
+    async def asyncInit(self, packageSampleCount: int, powerRefreshInterval: int) -> bool:
         """
         初始化数据采集。
 
@@ -531,9 +487,8 @@ class SensorProfile:
         :return:            bool: 初始化结果。True 表示成功，False 表示失败。
 
         """
-        return await async_timer(
+        return await async_call(
             self._gforce_event_loop,
-            0,
             self._init(packageSampleCount, powerRefreshInterval),
             120,
         )

sensor/utils.py

@@ -9,8 +9,7 @@ _TIMEOUT = 10
 
 
 async def delay(_time: float, function) -> any:
-    if _time > 0:
-        await asyncio.sleep(_time)
+    await asyncio.sleep(_time)
     return await function
 
 
@@ -24,32 +23,34 @@ def timer(_loop: asyncio.AbstractEventLoop, _delay: float, function):
         pass
 
 
-def sync_timer(
-    _loop: asyncio.AbstractEventLoop, _delay: float, function, _timeout=_TIMEOUT
-) -> any:
+def async_exec(_loop: asyncio.AbstractEventLoop, function):
+    if _loop == None:
+        return
+    try:
+        asyncio.run_coroutine_threadsafe(function, _loop)
+    except Exception as e:
+        print(e)
+        pass
+
+
+def sync_call(_loop: asyncio.AbstractEventLoop, function, _timeout=_TIMEOUT) -> any:
     if _loop == None:
         return
 
     try:
-        f = asyncio.run_coroutine_threadsafe(
-            asyncio.wait_for(delay(_delay, function), _delay + _timeout), _loop
-        )
+        f = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _loop)
         return f.result(timeout=_timeout)
     except Exception as e:
         print(e)
         pass
 
 
-async def async_timer(
-    _loop: asyncio.AbstractEventLoop, _delay: float, function, _timeout=_TIMEOUT
-) -> any:
+async def async_call(_loop: asyncio.AbstractEventLoop, function, _timeout=_TIMEOUT) -> any:
     if _loop == None:
         return
 
     try:
-        f = asyncio.run_coroutine_threadsafe(
-            asyncio.wait_for(delay(_delay, function), _delay + _timeout), _loop
-        )
+        f = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _loop)
     except Exception as e:
         print(e)
         pass

{sensor_sdk-0.0.5.dist-info → sensor_sdk-0.0.6.dist-info}/METADATA

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

sensor_sdk-0.0.6.dist-info/RECORD

@@ -0,0 +1,14 @@
+sensor/__init__.py,sha256=L1VyAP0EDEnJIMeMTzp4iXHSRUUHyHScF_GIl3iYKRI,123
+sensor/gforce.py,sha256=z-w9POiw5rtj6AgTvwFAI6tZt_5jv_3eSiKt_0jA1Ps,25229
+sensor/sensor_controller.py,sha256=lNi7i3T_aAHEJvv963OvVv_PNAYy_5-BwXD82XNvnGg,10028
+sensor/sensor_data.py,sha256=Hu7Ql0LgQ7V24xYZhaLrKPwU4KWZeWE655v8Gy8xphY,3934
+sensor/sensor_data_context.py,sha256=7GQwthoAH-qJsimWwCf8JcQAP8TivG3X0lwxfyHabo4,28575
+sensor/sensor_device.py,sha256=LCjBzm2TuOh2KpHsFTjm1sF8hzwvS22LhF_ueAct0Jo,2848
+sensor/sensor_profile.py,sha256=SFecXPCauvadRJdssu9iWMgCdxRinTqGlzLAQsZ8-k8,19625
+sensor/utils.py,sha256=ybmByBldCQ_x-sVtjA2mdXWo0QOafPAupfnWAxLrkV0,1773
+sensor_sdk-0.0.6.dist-info/LICENSE.txt,sha256=8CSivOpub3IuXODTyqBRI91AxouJZk02YrcKuOAkWu8,1111
+sensor_sdk-0.0.6.dist-info/METADATA,sha256=JP3HgNyVlwNe2AkT7LMm1PCVAxGtLr4XrdkfHZKBmL0,8374
+sensor_sdk-0.0.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+sensor_sdk-0.0.6.dist-info/top_level.txt,sha256=Ftq49B6bH0Ffdc7c8LkcyakHo6lsg_snlBbpEUoILSk,7
+sensor_sdk-0.0.6.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+sensor_sdk-0.0.6.dist-info/RECORD,,

sensor_sdk-0.0.5.dist-info/RECORD

@@ -1,14 +0,0 @@
-sensor/__init__.py,sha256=L1VyAP0EDEnJIMeMTzp4iXHSRUUHyHScF_GIl3iYKRI,123
-sensor/gforce.py,sha256=z-w9POiw5rtj6AgTvwFAI6tZt_5jv_3eSiKt_0jA1Ps,25229
-sensor/sensor_controller.py,sha256=p4AFR_x6qer2PHqbQiVEJOU4xPcqT0WcOvZJJyb946w,10301
-sensor/sensor_data.py,sha256=Hu7Ql0LgQ7V24xYZhaLrKPwU4KWZeWE655v8Gy8xphY,3934
-sensor/sensor_data_context.py,sha256=Mf09kF5SA8jqSgNHZhSHvnV6KXxOuKC1U_unrsBiFd8,29285
-sensor/sensor_device.py,sha256=LCjBzm2TuOh2KpHsFTjm1sF8hzwvS22LhF_ueAct0Jo,2848
-sensor/sensor_profile.py,sha256=40p0YvkzsGcGgOoNePtOIVwiCKRa7B0NyprN1jHXDBA,20384
-sensor/utils.py,sha256=9hcEVjAf9kUbsdgKiKZT0B2QDsBLBx5gocrNdBCYjpE,1707
-sensor_sdk-0.0.5.dist-info/LICENSE.txt,sha256=8CSivOpub3IuXODTyqBRI91AxouJZk02YrcKuOAkWu8,1111
-sensor_sdk-0.0.5.dist-info/METADATA,sha256=hGZJafML055JDFdYkbnEHNElcMgl_J-1ymzKEeL_lRc,8374
-sensor_sdk-0.0.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-sensor_sdk-0.0.5.dist-info/top_level.txt,sha256=Ftq49B6bH0Ffdc7c8LkcyakHo6lsg_snlBbpEUoILSk,7
-sensor_sdk-0.0.5.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-sensor_sdk-0.0.5.dist-info/RECORD,,