yostlabs 2025.4.28__tar.gz → 2025.5.14__tar.gz

{yostlabs-2025.4.28 → yostlabs-2025.5.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yostlabs
-Version: 2025.4.28
+Version: 2025.5.14
 Summary: Python resources and API for 3Space sensors from Yost Labs Inc.
 Project-URL: Homepage, https://yostlabs.com/
 Project-URL: Repository, https://github.com/YostLabs/3SpacePythonPackage/tree/main

{yostlabs-2025.4.28 → yostlabs-2025.5.14}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "yostlabs"
 #If uploading again on the same day, add a fourth number
-version = "2025.04.28"
+version = "2025.05.14"
 authors = [
   { name="Yost Labs Inc.", email="techsupport@yostlabs.com" },
   { name="Andy Riedlinger", email="techsupport@yostlabs.com" },

{yostlabs-2025.4.28 → yostlabs-2025.5.14}/src/yostlabs/communication/ble.py

@@ -236,8 +236,17 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         return False
     
     @property
-    def name(self) -> str:
+    def name(self) -> str | None:
+        """
+        The name of the device. This may be the Address or the Local Name of the device
+        depending on how discovery was done.
+        May also be None
+        """
         return self.__name
+    
+    @property
+    def address(self) -> str:
+        return self.client.address    
 
     SCANNER = None
     SCANNER_EVENT_LOOP = None

{yostlabs-2025.4.28 → yostlabs-2025.5.14}/src/yostlabs/tss3/utils/parser.py

@@ -137,7 +137,7 @@ class ThreespaceBinaryParser:
             if "read_size" not in kwargs:
                 raise ValueError("Missing arguement 'read_size' when registering the fileReadBytes command with the binary parser")
             raise NotImplementedError("The fileReadBytes command has yet to be implemented for the ThreespaceBinaryParser")
-        elif cmd.info.num == THREESPACE_GET_STREAMING_BATCH_COMMAND_NUM:
+        elif cmd.info.num == THREESPACE_GET_STREAMING_BATCH_COMMAND_NUM and not isinstance(cmd, ThreespaceGetStreamingBatchCommand):
             if "stream_slots" not in kwargs:
                 raise ValueError("Missing arguement 'stream_slots' when registering the getStreamingBatch command with the binary parser")
             cmd = ThreespaceGetStreamingBatchCommand(kwargs['stream_slots'])
@@ -221,7 +221,6 @@ class ThreespaceBinaryParser:
             return None
         
         if self.header_info.checksum_enabled and not math.isnan(self.__parsing_msg_length): #Can validate checksum before parsing
-            print("Pre validating checksum")
             if not self.__peek_checksum():
                 #Data corruption/Misalignment error
                 if self.verbose and not self.misaligned:

{yostlabs-2025.4.28 → yostlabs-2025.5.14}/src/yostlabs/tss3/utils/streaming.py

@@ -1,4 +1,5 @@
-from yostlabs.tss3.api import ThreespaceSensor, StreamableCommands, ThreespaceCmdResult, threespaceGetHeaderLabels
+from yostlabs.tss3.api import ThreespaceSensor, StreamableCommands, ThreespaceCmdResult, threespaceGetHeaderLabels, \
+    ThreespaceGetStreamingBatchCommand, threespaceCommandGet
 
 from enum import Enum
 from typing import Any, Callable
@@ -17,6 +18,17 @@ class ThreespaceStreamingStatus(Enum):
     #disable the streaming manager for some reason
     Reset = 4
 
+#Used for when the callback signature changed to allow user data, but maintain backwards compatability
+def _api_compatible_callback(func: Callable):
+    arg_count = func.__code__.co_argcount
+    if hasattr(func, "__self__"): arg_count -= 1 #Do NOT count self
+
+    if arg_count == 1:
+        def without_userdata(status: ThreespaceStreamingStatus, user_data: Any):
+            return func(status)
+        return without_userdata
+    return func
+
 from typing import NamedTuple
 ThreespaceStreamingOption = NamedTuple("ThreespaceStreamingOption", [("cmd", StreamableCommands), ("param", int|None)])
 class ThreespaceStreamingManager:
@@ -44,6 +56,7 @@ class ThreespaceStreamingManager:
         hz: int = None
 
         only_newest: bool = False
+        user_data: Any = None
 
         @property
         def interval(self):
@@ -73,9 +86,12 @@ class ThreespaceStreamingManager:
         self.is_streaming = False #Store this seperately to attempt to allow using both the regular streaming and streaming manager via pausing and such
 
         #Set the initial streaming speed
-        self.interval = int(self.sensor.get_settings("stream_interval"))    
+        self.interval = int(self.sensor.get_settings("stream_interval"))   
+        self.desired_interval = self.interval 
 
-        self.dirty = False
+        #Registrations and update rate dirt are handled separately for some situations.
+        #Primarily, we want registration to succeed even if the update can't update the rate.
+        self.dirty_registrations = False
         self.validated = False
 
         #Control variable to manually control when updating happens here
@@ -86,6 +102,14 @@ class ThreespaceStreamingManager:
         self.max_interval = 0xFFFFFFFF
         self.min_interval = 1000000 / 2000
 
+    @property
+    def dirty(self):
+        return self.dirty_registrations or self.dirty_rate
+    
+    @property
+    def dirty_rate(self):
+        return self.desired_interval != self.interval
+
     @property
     def paused(self):
         return len(self.pausers) > 0
@@ -100,8 +124,8 @@ class ThreespaceStreamingManager:
         self.pausers.add(locker)
         if len(self.pausers) == 1 and self.is_streaming:
             self.__stop_streaming()
-            for callback in self.callbacks:
-                callback(ThreespaceStreamingStatus.Paused)
+            for callback in self.callbacks.values():
+                callback.func(ThreespaceStreamingStatus.Paused, callback.user_data)
         return True
 
     def resume(self, locker: object):
@@ -112,8 +136,8 @@ class ThreespaceStreamingManager:
 
         #Attempt to start again
         if len(self.pausers) == 0:
-            for callback in self.callbacks:
-                callback(ThreespaceStreamingStatus.Resumed)
+            for callback in self.callbacks.values():
+                callback.func(ThreespaceStreamingStatus.Resumed, callback.user_data)
             self.__apply_streaming_settings_and_update_state()
 
     def lock_modifications(self, locker: object):
@@ -138,7 +162,7 @@ class ThreespaceStreamingManager:
         self.block_updates = True
         values = list(self.callbacks.values()) #To prevent concurrent dict modification, cache this
         for cb in values:
-            cb.func(ThreespaceStreamingStatus.Reset)
+            cb.func(ThreespaceStreamingStatus.Reset, cb.user_data)
         self.block_updates = False
         self.lockers.clear()
         self.pausers.clear()
@@ -170,18 +194,18 @@ class ThreespaceStreamingManager:
                 #Let all the callbacks know the data was updated
                 for cb in self.callbacks.values():
                     if cb.only_newest: continue
-                    cb.func(ThreespaceStreamingStatus.Data)
+                    cb.func(ThreespaceStreamingStatus.Data, cb.user_data)
 
                 result = self.sensor.getOldestStreamingPacket()
             
             for cb in self.callbacks.values():
                 if cb.only_newest:
-                    cb.func(ThreespaceStreamingStatus.Data)
-                cb.func(ThreespaceStreamingStatus.DataEnd)
+                    cb.func(ThreespaceStreamingStatus.Data, cb.user_data)
+                cb.func(ThreespaceStreamingStatus.DataEnd, cb.user_data)
 
-    def register_callback(self, callback: Callable[[ThreespaceStreamingStatus],None], hz=None, only_newest=False):
+    def register_callback(self, callback: Callable[[ThreespaceStreamingStatus,Any],None], hz=None, only_newest=False, user_data=None):
         if callback in self.callbacks: return
-        self.callbacks[callback] = ThreespaceStreamingManager.Callback(callback, hz, only_newest)
+        self.callbacks[callback] = ThreespaceStreamingManager.Callback(_api_compatible_callback(callback), hz, only_newest, user_data=user_data)
         self.__update_streaming_speed()
 
     def unregister_callback(self, callback: Callable[[ThreespaceStreamingStatus],None]):
@@ -217,7 +241,11 @@ class ThreespaceStreamingManager:
             
             cmd.registrations.add(owner)
             if immediate_update and self.dirty:
-                return self.__apply_streaming_settings_and_update_state()
+                updated = self.__apply_streaming_settings_and_update_state()
+                if self.dirty_registrations:
+                    return updated
+                else: #The rate was dirty, that does not affect the registration process
+                    return True
             return True
         
         if self.locked: #Wasn't already registered, so don't allow new registrations
@@ -232,7 +260,7 @@ class ThreespaceStreamingManager:
         self.registered_commands[info] = ThreespaceStreamingManager.Command(command, param=param, slot=num_commands_registered)
         self.registered_commands[info].labels = self.sensor.getStreamingLabel(command.value).data
         self.registered_commands[info].registrations.add(owner)
-        self.dirty = True
+        self.dirty_registrations = True
         if immediate_update:
             return self.__apply_streaming_settings_and_update_state()
         return True
@@ -266,7 +294,7 @@ class ThreespaceStreamingManager:
             return
         
         #Remove the command from streaming since nothing owns it anymore
-        self.dirty = True
+        self.dirty_registrations = True
         if immediate_update:
             self.__apply_streaming_settings_and_update_state()
 
@@ -284,7 +312,7 @@ class ThreespaceStreamingManager:
             if owner in registered_command.registrations:
                 registered_command.registrations.remove(owner)
                 if len(registered_command.registrations) == 0:
-                    self.dirty = True
+                    self.dirty_registrations = True
         
         if self.dirty and immediate_update:
             self.__apply_streaming_settings_and_update_state()
@@ -327,7 +355,7 @@ class ThreespaceStreamingManager:
             self.__stop_streaming()
         
         #Clean up any registrations that need removed and activate any that need activated
-        if self.dirty:
+        if self.dirty_registrations:
             to_remove = []
             for k, v in self.registered_commands.items():
                 if len(v.registrations) == 0:
@@ -338,21 +366,24 @@ class ThreespaceStreamingManager:
                 del self.registered_commands[key]
                 if key in self.results:
                     del self.results[key]
-        self.dirty = False
+        self.dirty_registrations = False
 
         if self.num_commands_registered > 0:
             slots_string = self.__build_stream_slots_string()
-            err, num_successes = self.sensor.set_settings(stream_slots=slots_string, stream_interval=self.interval)
+            err, num_successes = self.sensor.set_settings(stream_slots=slots_string, stream_interval=self.desired_interval)
             if err:
                 self.validated = False
                 return False
+            self.interval = self.desired_interval
             if not self.paused and self.enabled: 
                 self.__start_streaming() #Re-enable
         
         self.validated = True
         return True
 
-    def __update_streaming_speed(self):        
+    def __update_streaming_speed(self): 
+        if self.locked: return #Don't update the desired speed if modifications are locked
+
         required_interval = None
         for callback in self.callbacks.values():
             if callback.interval is None: continue
@@ -360,13 +391,12 @@ class ThreespaceStreamingManager:
                 required_interval = callback.interval
 
         if required_interval is None: #Treat required as current to make sure the current interval is still valid
-            required_interval = self.interval 
+            required_interval = self.desired_interval 
 
         required_interval = min(self.max_interval, max(self.min_interval, required_interval))
-        if required_interval != self.interval:
-            print(f"Updating streaming speed from {1000000 / self.interval}hz to {1000000 / required_interval}hz")
-            self.interval = int(required_interval)
-            self.dirty = True
+        if required_interval != self.desired_interval:
+            print(f"Updating desired speed from {1000000 / self.desired_interval}hz to {1000000 / required_interval}hz")
+            self.desired_interval = int(required_interval)
             self.__apply_streaming_settings_and_update_state()
 
     def __start_streaming(self):
@@ -450,4 +480,29 @@ class ThreespaceStreamingManager:
             else:
                 slot_info.append(None)
         
-        return slot_info
+        return slot_info
+
+#Utility functions
+def get_stream_options_from_str(string: str):
+    options = []
+    slots = string.split(',')
+    for slot in slots:
+        slot = slot.split(':')
+        cmd = int(slot[0])
+        if cmd == 255: continue #Ignore 255
+
+        #Get the param if any
+        param = None
+        if len(slot) > 2:
+            raise Exception()
+        if len(slot) == 2:
+            param = int(slot[1])
+        
+        stream_option = ThreespaceStreamingOption(StreamableCommands(cmd), param)
+        options.append(stream_option)
+    
+    return options
+
+def stream_options_to_command(options: list[ThreespaceStreamingOption]):
+    commands = [threespaceCommandGet(v.cmd.value) for v in options]
+    return ThreespaceGetStreamingBatchCommand(commands)