yostlabs 2025.10.6__tar.gz → 2025.10.29__tar.gz

{yostlabs-2025.10.6 → yostlabs-2025.10.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yostlabs
-Version: 2025.10.6
+Version: 2025.10.29
 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
@@ -16,6 +16,7 @@ Requires-Python: >=3.10
 Requires-Dist: async-timeout
 Requires-Dist: bleak
 Requires-Dist: numpy
+Requires-Dist: pybluez2
 Requires-Dist: pyserial
 Description-Content-Type: text/markdown
 

{yostlabs-2025.10.6 → yostlabs-2025.10.29}/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.10.06"
+version = "2025.10.29"
 authors = [
   { name="Yost Labs Inc.", email="techsupport@yostlabs.com" },
   { name="Andy Riedlinger", email="techsupport@yostlabs.com" },
@@ -24,7 +24,8 @@ dependencies = [
   "pyserial",
   "numpy",
   "bleak",
-  "async-timeout"
+  "async-timeout",
+  "pybluez2"
 ]
 
 [project.urls]

{yostlabs-2025.10.6 → yostlabs-2025.10.29}/src/yostlabs/communication/ble.py

@@ -7,6 +7,7 @@ from bleak.backends.device import BLEDevice
 from bleak.backends.scanner import AdvertisementData
 from bleak.backends.characteristic import BleakGATTCharacteristic
 from bleak.exc import BleakDeviceNotFoundError
+from dataclasses import dataclass
 
 #Services
 NORDIC_UART_SERVICE_UUID = "6e400001-b5a3-f393-e0a9-e50e24dcca9e"
@@ -23,6 +24,12 @@ HARDWARE_REVISION_STRING_UUID = "00002a27-0000-1000-8000-00805f9b34fb"
 SERIAL_NUMBER_STRING_UUID = "00002a25-0000-1000-8000-00805f9b34fb"
 MANUFACTURER_NAME_STRING_UUID = "00002a29-0000-1000-8000-00805f9b34fb"
 
+@dataclass
+class ThreespaceBLENordicUartProfile:
+    SERVICE_UUID: str
+    RX_UUID: str
+    TX_UUID: str
+
 class TssBLENoConnectionError(Exception): ...
 
 def ylBleEventLoopThread(loop: asyncio.AbstractEventLoop):
@@ -36,6 +43,9 @@ class ThreespaceBLEComClass(ThreespaceComClass):
     EVENT_LOOP = None
     EVENT_LOOP_THREAD = None
 
+    DEFAULT_PROFILE = ThreespaceBLENordicUartProfile(NORDIC_UART_SERVICE_UUID, NORDIC_UART_RX_UUID, NORDIC_UART_TX_UUID)
+    REGISTERED_PROFILES: list[ThreespaceBLENordicUartProfile] = [DEFAULT_PROFILE]
+
     @classmethod
     def __lazy_event_loop_init(cls):
         if cls.EVENT_LOOP is None:
@@ -43,7 +53,7 @@ class ThreespaceBLEComClass(ThreespaceComClass):
             cls.EVENT_LOOP_THREAD = threading.Thread(target=ylBleEventLoopThread, args=(cls.EVENT_LOOP,), daemon=True)
             cls.EVENT_LOOP_THREAD.start()
 
-    def __init__(self, ble: BleakClient | BLEDevice | str, discover_name: bool = True, discovery_timeout=5, error_on_disconnect=True):
+    def __init__(self, ble: BleakClient | BLEDevice | str, discover_name: bool = True, discovery_timeout=5, error_on_disconnect=True, adv: AdvertisementData = None, profile: ThreespaceBLENordicUartProfile=None):
         """
         Parameters
         ----------
@@ -54,6 +64,7 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         if it is expected that the sensor will frequently go in and out of range and the user wishes to preserve data (such as streaming)
         """
         self.__lazy_event_loop_init()
+        self.adv = adv
         bleak_options = { "timeout": discovery_timeout, "disconnected_callback": self.__on_disconnect }
         if isinstance(ble, BleakClient):    #Actual client
             self.client = ble
@@ -76,6 +87,20 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         else:
             raise TypeError("Invalid type for creating a ThreespaceBLEComClass:", type(ble), ble)
 
+        #Select the profile
+        self.profile = profile
+        if self.profile is None:
+            if self.adv is not None and len(self.adv.service_uuids) > 0:
+                for service_uuid in self.adv.service_uuids:
+                    self.profile = self.get_profile(service_uuid)
+                    if self.profile is not None:
+                        break
+                if self.profile is None:
+                    self.profile = ThreespaceBLEComClass.DEFAULT_PROFILE
+                    raise Exception(f"Unknown Service UUIDS: {self.adv.service_uuids}")
+            else:
+                self.profile = ThreespaceBLEComClass.DEFAULT_PROFILE
+
         self.__timeout = self.DEFAULT_TIMEOUT
 
         self.buffer = bytearray()
@@ -101,7 +126,7 @@ class ThreespaceBLEComClass(ThreespaceComClass):
     async def __async_open(self):
         self.data_read_event = asyncio.Event()
         await self.client.connect()
-        await self.client.start_notify(NORDIC_UART_TX_UUID, self.__on_data_received)
+        await self.client.start_notify(self.profile.TX_UUID, self.__on_data_received)
 
     def open(self):
         #If trying to open while already open, this infinitely loops
@@ -151,7 +176,7 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         while start_index < len(bytes):
             end_index = min(len(bytes), start_index + self.max_packet_size) #Can only send max_packet_size data per call to write_gatt_char
             asyncio.run_coroutine_threadsafe(
-                self.client.write_gatt_char(NORDIC_UART_RX_UUID, bytes[start_index:end_index], response=False),
+                self.client.write_gatt_char(self.profile.RX_UUID, bytes[start_index:end_index], response=False),
                 self.EVENT_LOOP).result()
             start_index = end_index
     
@@ -244,8 +269,16 @@ class ThreespaceBLEComClass(ThreespaceComClass):
     def address(self) -> str:
         return self.client.address    
 
-    SCANNER = None
+    @classmethod
+    def get_profile(cls, service_uuid: str):
+        for profile in cls.REGISTERED_PROFILES:
+            if profile.SERVICE_UUID == service_uuid:
+                return profile
+        return None
+
+    SCANNER: BleakScanner = None
     SCANNER_LOCK = None
+    SCANNER_RUNNING = False
 
     SCANNER_CONTINOUS = False   #Controls if scanning will continously run
     SCANNER_TIMEOUT = 5         #Controls the scanners timeout
@@ -255,23 +288,94 @@ class ThreespaceBLEComClass(ThreespaceComClass):
     #Format: Address - dict = { device: ..., adv: ..., last_found: ... }
     discovered_devices: dict[str,dict] = {}
 
+    @classmethod
+    def set_profiles(cls, profiles: list[ThreespaceBLENordicUartProfile]):
+        cls.REGISTERED_PROFILES = profiles
+        if cls.SCANNER is not None:
+            asyncio.run_coroutine_threadsafe(cls.create_scanner(), cls.EVENT_LOOP).result()
+            cls.__remove_unused_profiles()
+
+    @classmethod
+    def register_profile(cls, profile: ThreespaceBLENordicUartProfile):        
+        if any(v.SERVICE_UUID == profile.SERVICE_UUID for v in cls.REGISTERED_PROFILES): return
+        cls.REGISTERED_PROFILES.append(profile)
+        if cls.SCANNER is not None:
+            asyncio.run_coroutine_threadsafe(cls.create_scanner(), cls.EVENT_LOOP).result()
+    
+    @classmethod
+    def unregister_profile(cls, service_uuid: str|ThreespaceBLENordicUartProfile):
+        if isinstance(service_uuid, ThreespaceBLENordicUartProfile):
+            service_uuid = service_uuid.SERVICE_UUID
+        index = None
+        for i in range(len(cls.REGISTERED_PROFILES)):
+            if cls.REGISTERED_PROFILES[i].SERVICE_UUID == service_uuid:
+                index = i
+                break
+        del cls.REGISTERED_PROFILES[index]
+        if cls.SCANNER is not None:
+            asyncio.run_coroutine_threadsafe(cls.create_scanner(), cls.EVENT_LOOP).result()
+            cls.__remove_unused_profiles()
+
+    @classmethod
+    def __remove_unused_profiles(cls):
+        if cls.SCANNER is None: return
+        to_remove = []
+        valid_service_uuids = [v.SERVICE_UUID for v in cls.REGISTERED_PROFILES]
+        with cls.SCANNER_LOCK:
+            for address in cls.discovered_devices:
+                adv: AdvertisementData = cls.discovered_devices[address]["adv"]
+                if not any(uuid in valid_service_uuids for uuid in adv.service_uuids):
+                    to_remove.append(address)
+            for address in to_remove:
+                del cls.discovered_devices[address]
+
+    #Scanner should be created inside of the Async Context that will use it
+    @classmethod
+    async def create_scanner(cls):
+        uuids = [v.SERVICE_UUID for v in cls.REGISTERED_PROFILES]
+        restart_scanner = cls.SCANNER_RUNNING
+        with cls.SCANNER_LOCK:
+            if restart_scanner:
+                await cls.__async_stop_scanner()
+            cls.SCANNER = BleakScanner(detection_callback=cls.__detection_callback, service_uuids=uuids)
+            if restart_scanner:
+                await cls.__async_start_scanner()
+
     @classmethod
     def __lazy_init_scanner(cls):
         cls.__lazy_event_loop_init()
         if cls.SCANNER is None:
             cls.SCANNER_LOCK = threading.Lock()
-            #Scanner should be created inside of the Async Context that will use it
-            async def create_scanner():
-                cls.SCANNER = BleakScanner(detection_callback=cls.__detection_callback, service_uuids=[NORDIC_UART_SERVICE_UUID])
-            asyncio.run_coroutine_threadsafe(create_scanner(), cls.EVENT_LOOP).result()
-
-            
+            asyncio.run_coroutine_threadsafe(cls.create_scanner(), cls.EVENT_LOOP).result()
 
     @classmethod
     def __detection_callback(cls, device: BLEDevice, adv: AdvertisementData):
         with cls.SCANNER_LOCK:
             cls.discovered_devices[device.address] = {"device": device, "adv": adv, "last_found": time.time()}
     
+    @classmethod
+    async def __async_start_scanner(cls):
+        if cls.SCANNER_RUNNING: return
+        await cls.SCANNER.start()
+        cls.SCANNER_RUNNING = True
+
+    @classmethod
+    async def __async_stop_scanner(cls):
+        if not cls.SCANNER_RUNNING: return
+        await cls.SCANNER.stop()
+        cls.SCANNER_RUNNING = False        
+
+    @classmethod
+    def __start_scanner(cls):
+        if cls.SCANNER_RUNNING: return
+        asyncio.run_coroutine_threadsafe(cls.__async_start_scanner(), cls.EVENT_LOOP).result()
+    
+    @classmethod
+    def __stop_scanner(cls):
+        if not cls.SCANNER_RUNNING: return
+        asyncio.run_coroutine_threadsafe(cls.__async_stop_scanner(), cls.EVENT_LOOP).result()
+        cls.__stop_scanner()
+
     @classmethod
     def set_scanner_continous(cls, continous: bool):
         """
@@ -285,9 +389,9 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         cls.__lazy_init_scanner()
         cls.SCANNER_CONTINOUS = continous
         if continous: 
-            asyncio.run_coroutine_threadsafe(cls.SCANNER.start(), cls.EVENT_LOOP).result()
+            cls.__start_scanner()
         else: 
-            asyncio.run_coroutine_threadsafe(cls.SCANNER.stop(), cls.EVENT_LOOP).result()
+            cls.__stop_scanner()
 
     @classmethod
     def update_nearby_devices(cls):
@@ -338,4 +442,4 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         cls.update_nearby_devices()
         with cls.SCANNER_LOCK:
             for device_info in cls.discovered_devices.values():
-                yield(ThreespaceBLEComClass(device_info["device"]))
+                yield(ThreespaceBLEComClass(device_info["device"], adv=device_info["adv"]))

yostlabs-2025.10.29/src/yostlabs/communication/bluetooth.py

@@ -0,0 +1,203 @@
+from yostlabs.communication.socket import ThreespaceSocketComClass
+import bluetooth
+import time
+import threading
+
+from dataclasses import dataclass
+from typing import Callable, Generator
+
+@dataclass
+class COD:
+    raw: int
+    services: list[str]
+    major_class: str
+    minor_class: str
+
+def decode_class_of_device(cod: int) -> dict:
+    """Decode a Bluetooth Class of Device (CoD) integer into its components."""
+
+    # Service Class bit masks (11 bits total)
+    services = {
+        0x002000: "Limited Discoverable Mode",
+        0x004000: "Positioning (Location Identification)",
+        0x008000: "Networking",
+        0x010000: "Rendering",
+        0x020000: "Capturing",
+        0x040000: "Object Transfer",
+        0x080000: "Audio",
+        0x100000: "Telephony",
+        0x200000: "Information",
+    }
+
+    # Major Device Classes (5 bits)
+    major_classes = {
+        0x00: "Miscellaneous",
+        0x01: "Computer",
+        0x02: "Phone",
+        0x03: "LAN/Network Access Point",
+        0x04: "Audio/Video",
+        0x05: "Peripheral",
+        0x06: "Imaging",
+        0x07: "Wearable",
+        0x08: "Toy",
+        0x09: "Health",
+        0x1F: "Uncategorized",
+    }
+
+    # Minor Class mappings for some major classes (for simplicity)
+    minor_classes = {
+        0x01: {
+            0x00: "Uncategorized",
+            0x01: "Desktop workstation",
+            0x02: "Server-class computer",
+            0x03: "Laptop",
+            0x04: "Handheld PC/PDA",
+            0x05: "Palm-size PC/PDA",
+        },
+        0x02: {
+            0x00: "Uncategorized",
+            0x01: "Cellular",
+            0x02: "Cordless",
+            0x03: "Smartphone",
+            0x04: "Wired modem or voice gateway",
+            0x05: "Common ISDN access",
+        },
+        0x05: {
+            0x00: "Uncategorized",
+            0x01: "Keyboard",
+            0x02: "Pointing device",
+            0x03: "Combo keyboard/pointing device",
+        },
+    }
+
+    # Extract fields
+    service_bits = cod & 0xFFE000  # top 11 bits
+    major_class = (cod >> 8) & 0x1F
+    minor_class = (cod >> 2) & 0x3F
+
+    # Decode services
+    decoded_services = [name for bit, name in services.items() if service_bits & bit]
+
+    # Decode major class
+    major_name = major_classes.get(major_class, "Unknown")
+
+    # Decode minor class (context-dependent)
+    minor_name = minor_classes.get(major_class, {}).get(minor_class, f"Minor code {minor_class}")
+
+    return COD(cod, decoded_services or ["None"], major_name, minor_name)
+
+@dataclass
+class ScannerResult:
+    address: str
+    name: str
+    class_of_device: COD
+
+class Scanner:
+
+    def __init__(self, interval=5):
+        self.enabled = False
+        self.done = True
+
+        self.nearby = None
+        self.thread = None
+        self.updated = False
+        self.duration = int(interval / 1.2)
+
+    def start(self):
+        if not self.done: return
+        self.thread = threading.Thread(target=self.process, daemon=True)
+        self.enabled = True
+        self.done = False
+        self.updated = False
+        self.thread.start()
+
+    def stop(self):
+        self.enabled = False
+
+    def get_most_recent(self):
+        if not self.updated: return None
+        self.updated = False
+        return self.nearby
+
+    @property
+    def is_running(self):
+        return self.done
+
+    def process(self):
+        while self.enabled:
+            nearby = bluetooth.discover_devices(duration=self.duration, lookup_names=True, lookup_class=True)
+            self.nearby = [ScannerResult(addr, name, decode_class_of_device(cod)) for addr, name, cod in nearby]
+            self.updated = True
+        self.done = True
+
+class ThreespaceBluetoothComClass(ThreespaceSocketComClass):
+
+    SCANNER = None
+
+    def __init__(self, addr: str, name: str = None, connection_timeout=None):
+        super().__init__(bluetooth.BluetoothSocket(bluetooth.Protocols.RFCOMM), (addr, 1), connection_timeout=connection_timeout)
+        self.address = addr
+        self.__name = name or addr
+    
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    @classmethod
+    def __lazy_init_scanner(cls):
+        if cls.SCANNER is None:
+            cls.SCANNER = Scanner()
+            cls.SCANNER.start()
+
+    @staticmethod
+    def __default_filter(result: ScannerResult):
+        return result.class_of_device.major_class == "Wearable" and result.class_of_device.minor_class == "Minor code 0"
+
+    @staticmethod
+    def auto_detect(wait_for_update=True, filter: Callable[[ScannerResult],bool] = None) -> Generator["ThreespaceBluetoothComClass", None, None]:
+        """
+        Returns a list of com classes of the same type called on nearby
+        """
+        cls = ThreespaceBluetoothComClass
+        cls.__lazy_init_scanner()
+        if filter is None: 
+            filter = cls.__default_filter
+        if wait_for_update:
+            cls.SCANNER.updated = False
+            while not cls.SCANNER.updated: time.sleep(0.1)
+        if cls.SCANNER.nearby is None: return
+        for device_info in cls.SCANNER.nearby:
+            if not filter(device_info): continue
+            name = device_info.name or None
+            yield ThreespaceBluetoothComClass(device_info.address, name)
+
+
+if __name__ == "__main__":
+    from yostlabs.tss3.api import ThreespaceSensor
+
+    com = None
+    for device in ThreespaceBluetoothComClass.auto_detect():
+        com = device
+
+    if com is None:
+        print("Failed to detect a bluetooth sensor")
+        exit()
+    print("Connecting to:", com.name)
+
+    sensor = ThreespaceSensor(com, verbose=True)
+
+    sensor.set_settings(stream_slots=0)
+    print(sensor.get_settings("stream_slots", "stream_hz"))
+    print(sensor.getTaredOrientation())
+
+    sensor.startStreaming()
+
+    start_time = time.perf_counter()
+    while time.perf_counter() - start_time < 5:
+        sensor.updateStreaming()
+        packet = sensor.getOldestStreamingPacket()
+        while packet is not None:
+            print(packet)
+            packet = sensor.getOldestStreamingPacket()
+    sensor.stopStreaming()
+    sensor.cleanup()

{yostlabs-2025.10.6 → yostlabs-2025.10.29}/src/yostlabs/communication/serial.py

@@ -1,16 +1,27 @@
 from yostlabs.communication.base import *
 import serial
 import serial.tools.list_ports
+from serial.tools.list_ports_common import ListPortInfo
 import time
 
-
 class ThreespaceSerialComClass(ThreespaceComClass):
-
     PID_V3_MASK = 0x3000
-    PID_BOOTLOADER = 0x1000
 
     VID = 0x2476
 
+    PID_BOOTLOADER = 0x1000
+    PID_EMBED = 0x3040
+    PID_DL = 0x3050
+    PID_LX = 0x3090
+
+    PID_TO_STR_DICT = {
+        PID_EMBED: "EM",
+        PID_DL: "DL",
+        PID_BOOTLOADER: "BOOT",
+        PID_LX: "LX"
+    }
+
+
     DEFAULT_BAUDRATE = 115200
     DEFAULT_TIMEOUT = 2
 
@@ -18,12 +29,11 @@ class ThreespaceSerialComClass(ThreespaceComClass):
         if isinstance(ser, serial.Serial):
             self.ser = ser
         elif isinstance(ser, str):
-            self.ser = serial.Serial(ser, baudrate=ThreespaceSerialComClass.DEFAULT_BAUDRATE, timeout=ThreespaceSerialComClass.DEFAULT_TIMEOUT)
+            self.ser = serial.Serial(None, baudrate=ThreespaceSerialComClass.DEFAULT_BAUDRATE, timeout=ThreespaceSerialComClass.DEFAULT_TIMEOUT)
+            self.ser.port = ser
         else:
             raise TypeError("Invalid type for creating a ThreespaceSerialComClass:", type(ser), ser)
 
-        self.ser = ser
-
         self.peek_buffer = bytearray()
         self.peek_length = 0
 
@@ -120,6 +130,22 @@ class ThreespaceSerialComClass(ThreespaceComClass):
     @property
     def name(self) -> str:
         return self.ser.port
+    
+    @property
+    def suffix(self) -> str:
+        return self.pid_to_str(self.get_port_info().pid) 
+    
+    def get_port_info(self):
+        ports = serial.tools.list_ports.comports()
+        for port in ports:
+            if port.device == self.ser.port:
+                return port
+        return None
+
+    @staticmethod
+    def is_threespace_port(port: ListPortInfo):
+        cls = ThreespaceSerialComClass
+        return port.vid == cls.VID and (port.pid & cls.PID_V3_MASK == cls.PID_V3_MASK or port.pid == cls.PID_BOOTLOADER)
 
     #This is not part of the ThreespaceComClass interface, but is useful as a utility for those directly using the ThreespaceSerialComClass
     @staticmethod 
@@ -127,7 +153,7 @@ class ThreespaceSerialComClass(ThreespaceComClass):
         cls = ThreespaceSerialComClass
         ports = serial.tools.list_ports.comports()
         for port in ports:
-            if port.vid == cls.VID and (port.pid & cls.PID_V3_MASK == cls.PID_V3_MASK or port.pid == cls.PID_BOOTLOADER): 
+            if cls.is_threespace_port(port):
                 yield port
 
     @staticmethod
@@ -139,7 +165,12 @@ class ThreespaceSerialComClass(ThreespaceComClass):
         cls = ThreespaceSerialComClass
         ports = serial.tools.list_ports.comports()
         for port in ports:
-            if port.vid == cls.VID and (port.pid & cls.PID_V3_MASK == cls.PID_V3_MASK or port.pid == cls.PID_BOOTLOADER): 
+            if cls.is_threespace_port(port):
                 ser = serial.Serial(None, baudrate=default_baudrate, timeout=default_timeout) #By setting port as None, can create an object without immediately opening the port
                 ser.port = port.device #Now assign the port, allowing the serial object to exist without being opened yet
-                yield ThreespaceSerialComClass(ser)
+                yield ThreespaceSerialComClass(ser)
+
+    @classmethod
+    def pid_to_str(cls, pid):
+        if pid not in cls.PID_TO_STR_DICT: return "Unknown"
+        return cls.PID_TO_STR_DICT[pid]

yostlabs-2025.10.29/src/yostlabs/communication/socket.py

@@ -0,0 +1,118 @@
+from yostlabs.communication.base import *
+import socket
+import time
+from typing import Callable
+
+class ThreespaceSocketComClass(ThreespaceComClass):
+
+    """
+    Inheriting classes must implement auto_detect() functionality.
+    Should also implement 'name' functionality
+    """
+
+    def __init__(self, sock: socket.socket, *connection_params, connection_timeout=None):
+        self.socket = sock
+        self._opened = False
+
+        self.buffer = bytearray()
+        self.__timeout = 2
+        self.__connection_timeout = connection_timeout
+        self.__connection_params = connection_params
+
+    @property
+    def timeout(self) -> float:
+        return self.__timeout
+    
+    @timeout.setter
+    def timeout(self, timeout: float):
+        self.__timeout = timeout
+
+    def open(self):
+        if self._opened: return True
+        try:
+            if self.__connection_timeout is None:
+                self.socket.setblocking(True)
+            else:
+                self.socket.settimeout(self.__connection_timeout)
+            self.socket.connect(*self.__connection_params)
+        except Exception as e:
+            try:
+                self.socket.close()
+            except: pass
+            print(e)
+            return False
+        self._opened = True
+        return True
+
+    def close(self):
+        if not self._opened: return
+        self.socket.close()
+        self._opened = False
+
+    def check_open(self):
+        return self._opened
+
+    def write(self, bytes: bytes):
+        self.socket.send(bytes)
+
+    def read(self, num_bytes: int):
+        self.__update_while(lambda: len(self.buffer) < num_bytes)
+        amount = min(len(self.buffer), num_bytes)
+        result = self.buffer[:amount]
+        del self.buffer[:amount]
+        return result
+    
+    def peek(self, num_bytes: int):
+        self.__update_while(lambda: len(self.buffer) < num_bytes)
+        amount = min(len(self.buffer), num_bytes)
+        return self.buffer[:amount]
+        
+    def read_until(self, expected: bytes):
+        self.__update_while(lambda: expected not in self.buffer)
+        if expected in self.buffer:
+            length = self.buffer.index(expected) + len(expected)
+            result = self.buffer[:length]
+            del self.buffer[:length]
+        else:
+            result = self.buffer.copy()
+            self.buffer.clear()
+        return result
+    
+    def peek_until(self, expected: bytes, max_length: int = None):
+        self.__update_while(lambda: expected not in self.buffer and (max_length is None or len(self.buffer) < max_length))
+        if expected in self.buffer:
+            length = self.buffer.index(expected) + len(expected)
+            if max_length is not None:
+                length = min(length, max_length)
+            result = self.buffer[:length]
+        else:
+            length = len(self.buffer)
+            if max_length is not None:
+                length = min(length, max_length)
+            result = self.buffer[length]
+        return result
+
+    def __update_while(self, condition: Callable):
+        start_time = time.perf_counter()
+        while condition():
+            self.__update_buffer()
+            if time.perf_counter() - start_time >= self.timeout:
+                return
+
+    def __update_buffer(self, max_bytes: int = 1000):
+        self.socket.setblocking(False)
+        try:
+            self.buffer += self.socket.recv(max_bytes)
+        except BlockingIOError:
+            return False
+        self.socket.settimeout(self.timeout)
+        return True
+
+    @property
+    def length(self):
+        while self.__update_buffer(): pass
+        return len(self.buffer)
+
+    @property
+    def reenumerates(self) -> bool:
+        return False

{yostlabs-2025.10.6 → yostlabs-2025.10.29}/src/yostlabs/tss3/api.py

@@ -421,6 +421,8 @@ class StreamableCommands(Enum):
     GetGpsHdop = 218
     GetGpsSattelites = 219
 
+    GetLedColor = 238
+
     GetButtonState = 250
 
 THREESPACE_AWAIT_COMMAND_FOUND = 0
@@ -1674,7 +1676,8 @@ class ThreespaceSensor:
     def getStreamingLabel(self, cmd_num: int) -> ThreespaceCmdResult[str]: ...
     def setCursor(self, cursor_index: int) -> ThreespaceCmdResult[None]: ...
     def getLastLogCursorInfo(self) -> ThreespaceCmdResult[tuple[int,str]]: ...
-    def pauseLogStreaming(self, pause: bool) -> ThreespaceCmdResult[None]: ...           
+    def pauseLogStreaming(self, pause: bool) -> ThreespaceCmdResult[None]: ...  
+    def getLedColor(self) -> ThreespaceCmdResult[list[float]]: ...           
 
 THREESPACE_GET_STREAMING_BATCH_COMMAND_NUM = 84
 THREESPACE_START_STREAMING_COMMAND_NUM = 85
@@ -1817,6 +1820,8 @@ _threespace_commands: list[ThreespaceCommand] = [
     ThreespaceCommand("softwareReset", THREESPACE_SOFTWARE_RESET_COMMAND_NUM, "", "", custom_func=ThreespaceSensor._ThreespaceSensor__softwareReset),
     ThreespaceCommand("enterBootloader", THREESPACE_ENTER_BOOTLOADER_COMMAND_NUM, "", "", custom_func=ThreespaceSensor._ThreespaceSensor__enterBootloader),
 
+    ThreespaceCommand("getLedColor", 238, "", "fff"),
+
     ThreespaceCommand("getButtonState", 250, "", "b"),
 ]
 

{yostlabs-2025.10.6 → yostlabs-2025.10.29}/src/yostlabs/tss3/consts.py

@@ -61,4 +61,6 @@ THREESPACE_SN_FAMILY_TO_NAME = {
     0x15 : THREESPACE_FAMILY_BLUETOOTH,
     0x16 : THREESPACE_FAMILY_DATA_LOGGER,
     0x17 : THREESPACE_FAMILY_MICRO_USB
-}
+}
+
+THREESPACE_ERR_COMMIT_FS_LOCKED=8