dexcontrol 0.2.12__py3-none-any.whl → 0.3.1__py3-none-any.whl

dexcontrol/utils/os_utils.py

@@ -12,8 +12,11 @@
 
 import os
 import re
-from typing import Final
+from typing import Any, Final
 
+from loguru import logger
+
+import dexcontrol
 from dexcontrol.utils.constants import ROBOT_NAME_ENV_VAR
 
 
@@ -56,3 +59,168 @@ def get_robot_model() -> str:
         raise ValueError(f"Unknown robot model: {robot_model_abb}")
     model = robot_model_abb_mapping[robot_model_abb] + "-" + robot_name.split("-")[-1]
     return model
+
+
+def check_version_compatibility(
+    version_info: dict[str, Any], show_warnings: bool = True
+) -> None:
+    """Check version compatibility between client and server.
+
+    This function uses the new JSON-based version interface to:
+    1. Compare client library version with server's minimum required version
+    2. Check server component versions for compatibility
+    3. Provide clear guidance for version mismatches
+
+    Args:
+        version_info: Dictionary containing version information from get_version_info()
+        show_warnings: Whether to show warning messages (default: True)
+    """
+    validate_client_version(version_info)
+    validate_server_version(version_info)
+
+
+def validate_client_version(version_info: dict[str, Any]) -> None:
+    """Validate client library version against server requirements.
+
+    Args:
+        version_info: Dictionary containing server and client version information.
+    """
+
+    client_info = version_info.get("client", {})
+    min_required_version = client_info.get("minimal_version")
+
+    if not min_required_version:
+        logger.debug("No minimum version requirement from server")
+        return
+
+    # Get current library version
+    current_version = getattr(dexcontrol, "__version__", "unknown")
+
+    if current_version == "unknown":
+        logger.warning("Could not determine current library version")
+        return
+
+    # Compare versions
+    comparison = compare_versions(current_version, min_required_version)
+
+    if comparison < 0:
+        show_version_upgrade_warning(current_version, min_required_version)
+
+
+def show_version_upgrade_warning(current: str, required: str) -> None:
+    """Display version upgrade warning to user.
+
+    Args:
+        current: Current library version
+        required: Required minimum version
+    """
+    logger.error(
+        f"🚨 CLIENT VERSION TOO OLD! 🚨\n"
+        f"Current library version: {current}\n"
+        f"Minimum required version: {required}\n"
+        f"\n"
+        f"⚠️  Your dexcontrol library is outdated and may not work correctly!\n"
+        f"📦 Please update your library using: pip install --upgrade dexcontrol\n"
+    )
+
+
+def validate_server_version(version_info: dict[str, Any]) -> None:
+    """Validate server software versions against minimum requirements.
+
+    Args:
+        version_info: Dictionary containing server and client version information.
+    """
+    server_info = version_info.get("server", {})
+
+    if not server_info:
+        logger.debug("No server version information available")
+        return
+
+    # Check each component's software version
+    soc_info = server_info.get("soc", {})
+    software_version = soc_info.get("software_version", {})
+    if software_version is not None:
+        software_version_int = int(software_version)
+        if software_version_int < dexcontrol.MIN_SOC_SOFTWARE_VERSION:
+            show_server_version_warning(
+                [("soc", software_version_int)], dexcontrol.MIN_SOC_SOFTWARE_VERSION
+            )
+
+
+def show_server_version_warning(
+    components: list[tuple[str, int]], min_version: int
+) -> None:
+    """Display server version warning to user.
+
+    Args:
+        components: List of (component_name, version) tuples for components below minimum.
+        min_version: Minimum required server software version.
+    """
+    components_str = "\n".join(
+        f"  - {name}: version {version}" for name, version in components
+    )
+
+    logger.error(
+        f"🚨 SERVER VERSION TOO OLD! 🚨\n"
+        f"The following server components are below minimum version {min_version}:\n"
+        f"{components_str}\n"
+        f"\n"
+        f"⚠️  Your robot's firmware may be outdated and some features may not work correctly!\n"
+        f"📦 Please contact your robot admin or check https://github.com/dexmate-ai/vega-firmware.\n"
+    )
+
+
+def compare_versions(version1: str, version2: str) -> int:
+    """Compare two semantic version strings.
+
+    Args:
+        version1: First version string (e.g., "1.2.3")
+        version2: Second version string (e.g., "1.1.0")
+
+    Returns:
+        -1 if version1 < version2
+         0 if version1 == version2
+         1 if version1 > version2
+    """
+    try:
+        # Clean version strings (remove 'v' prefix, handle pre-release suffixes)
+        def clean_version(v: str) -> list[int]:
+            v = v.strip().lower()
+            if v.startswith("v"):
+                v = v[1:]
+            # Split by dots and take only numeric parts
+            parts = v.split(".")
+            numeric_parts = []
+            for part in parts:
+                # Remove any non-numeric suffixes (like -alpha, -rc1, etc.)
+                numeric_part = ""
+                for char in part:
+                    if char.isdigit():
+                        numeric_part += char
+                    else:
+                        break
+                if numeric_part:
+                    numeric_parts.append(int(numeric_part))
+            return numeric_parts
+
+        parts1 = clean_version(version1)
+        parts2 = clean_version(version2)
+
+        # Pad shorter version with zeros
+        max_len = max(len(parts1), len(parts2))
+        parts1.extend([0] * (max_len - len(parts1)))
+        parts2.extend([0] * (max_len - len(parts2)))
+
+        # Compare part by part
+        for p1, p2 in zip(parts1, parts2):
+            if p1 < p2:
+                return -1
+            elif p1 > p2:
+                return 1
+
+        return 0
+
+    except Exception as e:
+        logger.debug(f"Version comparison error: {e}")
+        # Fallback to string comparison
+        return -1 if version1 < version2 else (1 if version1 > version2 else 0)

dexcontrol/utils/pb_utils.py

@@ -20,28 +20,6 @@ TYPE_SOFTWARE_VERSION = dict[
 ]
 
 
-def software_version_to_dict(
-    version_msg: dexcontrol_query_pb2.SoftwareVersion,
-) -> dict[str, TYPE_SOFTWARE_VERSION]:
-    """Convert a SoftwareVersion protobuf message to a dictionary.
-
-    Args:
-        version_msg: SoftwareVersion protobuf message.
-
-    Returns:
-        Dictionary containing version information with component names as keys.
-    """
-    return {
-        key: {
-            "hardware_version": value.hardware_version,
-            "software_version": value.software_version,
-            "main_hash": value.main_hash,
-            "compile_time": value.compile_time,
-        }
-        for key, value in version_msg.firmware_version.items()
-    }
-
-
 class ComponentStatus(Enum):
     """Enum representing the status of a component."""
 

{dexcontrol-0.2.12.dist-info → dexcontrol-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dexcontrol
-Version: 0.2.12
+Version: 0.3.1
 Summary: A Python library of Sensing and Control for Dexmate's Robot
 Project-URL: Repository, https://github.com/dexmate-ai/dexcontrol
 Author-email: Dexmate <contact@dexmate.ai>
@@ -202,6 +202,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 Requires-Python: <3.14,>=3.10
 Requires-Dist: aiortc
+Requires-Dist: dexcomm>=0.1.2
 Requires-Dist: eclipse-zenoh>=1.2.0
 Requires-Dist: hydra-core==1.3.2
 Requires-Dist: jaxtyping>=0.2.38
@@ -253,6 +254,17 @@ To run the examples in this repo, you can try:
 pip install dexcontrol[example]
 ```
 
+## ⚠️ Version Compatibility
+
+**Important:** `dexcontrol >= 0.3.0` requires robot firmware with SoC version `286` or higher.
+
+**Before upgrading, check your current firmware version:**
+```shell
+dextop firmware info
+```
+
+If your firmware is outdated, please update it before installing the new version to ensure full compatibility. Please contact the Dexmate team if you do not know how to do it.
+
 ## 📄 Licensing
 
 This project is **dual-licensed**:

dexcontrol-0.3.1.dist-info/RECORD

@@ -0,0 +1,68 @@
+dexcontrol/__init__.py,sha256=IjeenMFvYyasRDb58qzVHdftwTH_nRgKDVLSmhH7g-k,2009
+dexcontrol/robot.py,sha256=mXezG10UMVBYynE-WD5_XBOjvnjVBhYZjarP_W09TPs,40471
+dexcontrol/apps/dualsense_teleop_base.py,sha256=HJ5aB9zaXdEUQtkd8Vrd0dQqYZrKH1nEjcSGSlDpYD4,12686
+dexcontrol/comm/__init__.py,sha256=YV8Sfv15vuUUqR2lg_H97RCHWUaOblxbI5NgigP4kzc,1272
+dexcontrol/comm/base.py,sha256=PjrEiK7fhGvJ6snaWziSeoNHiRe5I9JDiOs_ptLQC1s,12241
+dexcontrol/comm/rtc.py,sha256=kGFppq3ewXIY4OQ92cExf7AohoSrLImYyb_zBFpUswI,13118
+dexcontrol/comm/subscribers.py,sha256=eg_rdgEUDU8dMPpNsLYJhupxB52fKs7MJmfX9ung66Q,8946
+dexcontrol/config/__init__.py,sha256=UVLNpzGD14e8g68rUZFXTh0B7FRx6uS0Eg_MecjinYM,520
+dexcontrol/config/vega.py,sha256=Uh14vBOZoMAmFXQgjh-IK9x_W0j8YvqgUsoDNHx1ZsE,8443
+dexcontrol/config/core/__init__.py,sha256=Ym2R1hr1iMKQuXcg16BpZfQtTb0hQ5Q7smUIMlwKfho,637
+dexcontrol/config/core/arm.py,sha256=5hN1dQMe2H6oufaqgtZqx9vuB969DxM26leJqPsKEiA,1471
+dexcontrol/config/core/chassis.py,sha256=2FjyFujg2q7aw8J9BklNM7eeLxscY9BSTlBvz-tLwOM,1092
+dexcontrol/config/core/hand.py,sha256=r6XVyGCuwv7MFmaMLn7l3iPZUH376NZSmtsfLnznAgw,1033
+dexcontrol/config/core/head.py,sha256=SLwZE-lYEOk8XAmW-Ex7VkLF2w5HLItwsA3Dc7n5FtE,1061
+dexcontrol/config/core/misc.py,sha256=zHkJ144b6kbmMFE63wy_fgfo_6V-4XmM19hr6BUtQ0Y,1567
+dexcontrol/config/core/torso.py,sha256=DCTFgN1_Gn4THkKy23sIHOedACQtQ7cET3g4AmkVPco,1460
+dexcontrol/config/sensors/__init__.py,sha256=bYPMLxbbn5QeuPyA6OPGDS2JTYpnVvaZJT8PeILFjQY,252
+dexcontrol/config/sensors/vega_sensors.py,sha256=m_Z5ywKxGBvP7pUr6dxLNnGEPI2jWt2hDtxln4uFnY8,2675
+dexcontrol/config/sensors/cameras/__init__.py,sha256=GmwRW9ovZ_JcpD2QmzTO_in_LRBoRDorjMVGY6XgGI8,383
+dexcontrol/config/sensors/cameras/rgb_camera.py,sha256=MN4SjyZlfbrQ3JKDDkT8HhC0Aiyc0bWfDLt4ik0Xcvs,1448
+dexcontrol/config/sensors/cameras/zed_camera.py,sha256=UGAjXlOu5E0M3vjMSIOqdvNjK8mhx52OIDgs5RksqUc,1895
+dexcontrol/config/sensors/imu/__init__.py,sha256=fW-DlevCvf_W8HV_fvLe9yIe-XL5op2mggoTKh-6fGQ,328
+dexcontrol/config/sensors/imu/chassis_imu.py,sha256=3OlTTBH6k1QGM5c5bcg8NL3XUXzYA8gCLM8lpCq2KFM,559
+dexcontrol/config/sensors/imu/zed_imu.py,sha256=y-dPI-XS6Kyq0WOf0wwuc2BgVnMN2hwCMxb0Vmwt4O4,550
+dexcontrol/config/sensors/lidar/__init__.py,sha256=j8vFkF675Z7zKtCztJcyG7oSA_XqrD8OeQLEK0GACug,288
+dexcontrol/config/sensors/lidar/rplidar.py,sha256=ybuT_f1ADWF3oGH1gi6D2F80TbJEm4vbm68Fe108OAA,541
+dexcontrol/config/sensors/ultrasonic/__init__.py,sha256=-q83RhIMZJGVFVPYaA4hOugoG6wZw8EL6wJg7-HTSxU,294
+dexcontrol/config/sensors/ultrasonic/ultrasonic.py,sha256=7b4dm1QOhy5_5RFVpY-frXZyDzqok0K1u7ed9gf3PL0,552
+dexcontrol/core/__init__.py,sha256=bYPMLxbbn5QeuPyA6OPGDS2JTYpnVvaZJT8PeILFjQY,252
+dexcontrol/core/arm.py,sha256=j7uffgdQ_6gaavRE8WOVs56n5e3f_-6CrhRkSiNriRE,16231
+dexcontrol/core/chassis.py,sha256=cxiZv86v9vWSGoWJLZZFn-vEo4OCDlh5S-J9Z0iED0c,24189
+dexcontrol/core/component.py,sha256=J7TscC7u4io38gS9SNaRvnBBH48LgKF6dRbSeHzl2Vk,36346
+dexcontrol/core/hand.py,sha256=yRimScGR0wdL6nPaoEO2M1okc7tYBXMIwriLjpOs35g,9596
+dexcontrol/core/head.py,sha256=Dd-Wk4-BiUM8q9LnTU017fijCwDT9QhFsU4v9Hqeo-E,9932
+dexcontrol/core/misc.py,sha256=nCY-rOslBZyx1w7QUfu6M7VZvMeiTfWg2eFTjYAbI-M,30809
+dexcontrol/core/robot_query_interface.py,sha256=fccYDYK1zd6AqftEU46gbpsIZginRj_RDmvKa3DoSC8,17506
+dexcontrol/core/torso.py,sha256=xOLfhivwNM-JR8nw6Lg1FdctXlmX-qvjD2nUgHm5iKw,8762
+dexcontrol/proto/dexcontrol_msg_pb2.py,sha256=pIbSlweIVSU3hN13kZxPycySU_OYXPoHRuDh7NIBXho,5289
+dexcontrol/proto/dexcontrol_msg_pb2.pyi,sha256=1KpTJnLq6KG2eijZ_vlFq1JsTPeCeLz1IdmoUhW6Tec,8722
+dexcontrol/proto/dexcontrol_query_pb2.py,sha256=KXPCAaKb2n55MBxmhIaFvAoqbS9XsKD6RdztGNe0occ,6230
+dexcontrol/proto/dexcontrol_query_pb2.pyi,sha256=CGwwceF5Ibt9U3R8x2e7GjVNv2GyuD5WM_nyN4YF2wQ,7822
+dexcontrol/sensors/__init__.py,sha256=Dp06cuO_3xC6i4u5rHqfK5NqlIC5kaCue_bAtTC6JEE,960
+dexcontrol/sensors/manager.py,sha256=bvoKH6NIHEjfWsnffoUaNU14CDPkgOV06NL7NwY6s2U,6762
+dexcontrol/sensors/ultrasonic.py,sha256=1rXzA_5w5Lf6TgLvPLnNyiIAMS_cuTuJusLWEBkc_fc,2882
+dexcontrol/sensors/camera/__init__.py,sha256=Vwe98I4Lvdv3F2UslOzKkeUkt5Rl2jSqbKlU6gIBeF0,609
+dexcontrol/sensors/camera/base_camera.py,sha256=JqVb1b82CxMH1FleGobr5dxN18sbDaqotE8RuivGAJo,4741
+dexcontrol/sensors/camera/rgb_camera.py,sha256=w_SLJuJvbQgsq_h3DHNrTk8ofn8XEoX18GPCc-19g1g,6344
+dexcontrol/sensors/camera/zed_camera.py,sha256=zOLwszwk3lvlyajEvfPgEhrKrHhQeVBxyLH1ECOD9Gc,13590
+dexcontrol/sensors/imu/__init__.py,sha256=bBC7_NSLJ5qLMvUYu2-9yXKO2bRpQLC0HyywBwnbM0A,768
+dexcontrol/sensors/imu/chassis_imu.py,sha256=kRP7jAeDDim2C0gIV7xG31VSBO4dnXUZDMfh0JOzNDs,5611
+dexcontrol/sensors/imu/zed_imu.py,sha256=rGT0S2TIj0JGdlJMQKNldtCclOYunCmS0xdzvjAhq9A,5628
+dexcontrol/sensors/lidar/__init__.py,sha256=frF16HmeQnfbvH0dVJ4pPjD4TySF13wCk-O9L3Memeg,317
+dexcontrol/sensors/lidar/rplidar.py,sha256=MrmxP99-YsfoRlYUZTCcmvNbF-YCOLynhoe2tCMpDnE,4191
+dexcontrol/utils/__init__.py,sha256=bYPMLxbbn5QeuPyA6OPGDS2JTYpnVvaZJT8PeILFjQY,252
+dexcontrol/utils/comm_helper.py,sha256=5KZPCc_HA3tnptlYlyYLjbi7H17BXqR_bwt9Fy_FjlQ,3572
+dexcontrol/utils/constants.py,sha256=uzR6AW5LNU3Otmf0G8M4yg-0iaHLhKtJ5e-OPuqxr9g,783
+dexcontrol/utils/error_code.py,sha256=iy840qnWn9wv_nVqyEDP8-l2CuXlPH2xXXW0k-5cHKk,7321
+dexcontrol/utils/io_utils.py,sha256=4TYV33ufECo8fuQivrZR9vtSdwWYUiPvpAUSneEzOOs,850
+dexcontrol/utils/motion_utils.py,sha256=p4kXQm_YorISDC2crrpY0gwCVw_yQCPv-acxPUSfh8w,7172
+dexcontrol/utils/os_utils.py,sha256=F9cyAfI-h4JXT3HOlms2nxe6WI1CZuOA3QHUYQA7pk4,7560
+dexcontrol/utils/pb_utils.py,sha256=zN4pMS9GV9OTj1TmhcWTaDmfmgttyIDFJEuOE5tbCS0,2508
+dexcontrol/utils/timer.py,sha256=1sOYYEapbZ5aBqJwknClsxgjDx0FDRQuGEdcTGnYTCI,3948
+dexcontrol/utils/trajectory_utils.py,sha256=TURFb0DeDey0416z4L7AXiWcKJYsgg_bB5AE_JPSpXY,1879
+dexcontrol/utils/viz_utils.py,sha256=rKtZfu32-9D9CS4cSiil-oLub_MiKTJV6hURvJbKd0s,6295
+dexcontrol-0.3.1.dist-info/METADATA,sha256=-otrrBbT0NmHoVdhTJBMgfH34R93nxQpgtkhuFHOwRc,37269
+dexcontrol-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dexcontrol-0.3.1.dist-info/licenses/LICENSE,sha256=0J2KCMNNnW5WZPK5x8xUiCxApBf7h83693ggSJYiue0,31745
+dexcontrol-0.3.1.dist-info/RECORD,,

dexcontrol/config/sensors/cameras/luxonis_camera.py

@@ -1,51 +0,0 @@
-# Copyright (C) 2025 Dexmate Inc.
-#
-# This software is dual-licensed:
-#
-# 1. GNU Affero General Public License v3.0 (AGPL-3.0)
-#    See LICENSE-AGPL for details
-#
-# 2. Commercial License
-#    For commercial licensing terms, contact: contact@dexmate.ai
-
-from dataclasses import dataclass, field
-
-
-@dataclass
-class LuxonisCameraConfig:
-    """Configuration for LuxonisCameraSensor (wrist camera).
-
-    Attributes:
-        _target_: Target sensor class for Hydra instantiation.
-        name: Logical name of the camera.
-        enable: Whether this sensor is enabled.
-        enable_fps_tracking: Enable FPS tracking logs.
-        fps_log_interval: Frames between FPS logs.
-        subscriber_config: Topics for RGB and Depth Zenoh subscribers.
-    """
-
-    _target_: str = "dexcontrol.sensors.camera.luxonis_camera.LuxonisCameraSensor"
-    name: str = "wrist_camera"
-    enable: bool = False
-    enable_fps_tracking: bool = False
-    fps_log_interval: int = 30
-
-    # Note: Resolution is set by the publisher (dexsensor). The publisher now defaults
-    # to 720p to match common Luxonis sensor capabilities (e.g., OV9782 supports 720p/800p).
-    # These subscribers only define topics to consume.
-    subscriber_config: dict = field(
-        default_factory=lambda: {
-            "left_rgb": {
-                "enable": True,
-                "topic": "camera/wrist/left_rgb",
-            },
-            "right_rgb": {
-                "enable": True,
-                "topic": "camera/wrist/right_rgb",
-            },
-            "depth": {
-                "enable": False,
-                "topic": "camera/wrist/depth",
-            },
-        }
-    )

dexcontrol/sensors/camera/luxonis_camera.py

@@ -1,169 +0,0 @@
-# Copyright (C) 2025 Dexmate Inc.
-#
-# This software is dual-licensed:
-#
-# 1. GNU Affero General Public License v3.0 (AGPL-3.0)
-#    See LICENSE-AGPL for details
-#
-# 2. Commercial License
-#    For commercial licensing terms, contact: contact@dexmate.ai
-
-"""Luxonis wrist camera sensor using RGB and depth Zenoh subscribers.
-
-This sensor mirrors the high-level API of other camera sensors. It subscribes to
-RGB (JPEG over Zenoh) and depth streams published by dexsensor's Luxonis camera
-pipeline and exposes a simple interface for getting images.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Dict, Optional, Union
-
-import numpy as np
-import zenoh
-
-from dexcontrol.config.sensors.cameras.luxonis_camera import LuxonisCameraConfig
-from dexcontrol.utils.subscribers.camera import (
-    DepthCameraSubscriber,
-    RGBCameraSubscriber,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class LuxonisCameraSensor:
-    """RGBD camera sensor wrapper for Luxonis/OAK wrist camera.
-
-    Provides access to RGB and depth frames via dedicated Zenoh subscribers.
-    """
-
-    def __init__(
-        self,
-        configs: LuxonisCameraConfig,
-        zenoh_session: zenoh.Session,
-    ) -> None:
-        self._name = configs.name
-        self._configs = configs
-        self._zenoh_session = zenoh_session
-
-        # Support left and right RGB streams + depth, mirroring ZED structure
-        self._subscribers: Dict[str, Optional[Union[RGBCameraSubscriber, DepthCameraSubscriber]]] = {}
-
-        subscriber_config = configs.subscriber_config
-
-        try:
-            # Create subscribers for left_rgb, right_rgb, depth (configurable enables)
-            stream_defs: Dict[str, Dict[str, Any]] = {
-                "left_rgb": subscriber_config.get("left_rgb", {}),
-                "right_rgb": subscriber_config.get("right_rgb", {}),
-                "depth": subscriber_config.get("depth", {}),
-            }
-
-            for stream_name, cfg in stream_defs.items():
-                if not cfg or not cfg.get("enable", False):
-                    self._subscribers[stream_name] = None
-                    continue
-                topic = cfg.get("topic")
-                if not topic:
-                    logger.warning(f"'{self._name}': No topic configured for '{stream_name}'")
-                    self._subscribers[stream_name] = None
-                    continue
-
-                if stream_name == "depth":
-                    self._subscribers[stream_name] = DepthCameraSubscriber(
-                        topic=topic,
-                        zenoh_session=self._zenoh_session,
-                        name=f"{self._name}_{stream_name}_subscriber",
-                        enable_fps_tracking=configs.enable_fps_tracking,
-                        fps_log_interval=configs.fps_log_interval,
-                    )
-                else:
-                    self._subscribers[stream_name] = RGBCameraSubscriber(
-                        topic=topic,
-                        zenoh_session=self._zenoh_session,
-                        name=f"{self._name}_{stream_name}_subscriber",
-                        enable_fps_tracking=configs.enable_fps_tracking,
-                        fps_log_interval=configs.fps_log_interval,
-                    )
-
-        except Exception as e:
-            logger.error(f"Error creating Luxonis wrist camera subscribers: {e}")
-
-    # Lifecycle
-    def shutdown(self) -> None:
-        for sub in self._subscribers.values():
-            if sub:
-                sub.shutdown()
-        logger.info(f"'{self._name}' sensor shut down.")
-
-    # Status
-    def is_active(self) -> bool:
-        return any(sub.is_active() for sub in self._subscribers.values() if sub is not None)
-
-    def wait_for_active(self, timeout: float = 5.0, require_both: bool = False) -> bool:
-        subs = [s for s in self._subscribers.values() if s is not None]
-        if not subs:
-            return False
-        if require_both:
-            return all(s.wait_for_active(timeout) for s in subs)
-        return any(s.wait_for_active(timeout) for s in subs)
-
-    # Data access
-    def get_obs(
-        self, obs_keys: Optional[list[str]] = None, include_timestamp: bool = False
-    ) -> Dict[str, Optional[np.ndarray]]:
-        """Get latest images.
-
-        obs_keys can include any of: ["left_rgb", "right_rgb", "depth"]. If None, returns
-        all available. If include_timestamp is True and the underlying subscriber returns
-        (image, timestamp), that tuple is forwarded; otherwise only the image is returned.
-        """
-        keys_to_fetch = obs_keys or self.available_streams
-
-        out: Dict[str, Optional[np.ndarray]] = {}
-        for key in keys_to_fetch:
-            sub = self._subscribers.get(key)
-            data = sub.get_latest_data() if sub else None
-            is_tuple_or_list = isinstance(data, (tuple, list))
-            if include_timestamp:
-                if not is_tuple_or_list and data is not None:
-                    logger.warning(f"Timestamp is not available yet for {key} stream.")
-                out[key] = data
-            else:
-                out[key] = data[0] if is_tuple_or_list else data
-        return out
-
-    def get_rgb(self) -> Optional[np.ndarray]:
-        # Backward-compat: return left_rgb if available else right_rgb
-        for key in ("left_rgb", "right_rgb"):
-            sub = self._subscribers.get(key)
-            if sub:
-                data = sub.get_latest_data()
-                return data[0] if isinstance(data, (tuple, list)) else data
-        return None
-
-    def get_depth(self) -> Optional[np.ndarray]:
-        sub = self._subscribers.get("depth")
-        if not sub:
-            return None
-        data = sub.get_latest_data()
-        return data[0] if isinstance(data, (tuple, list)) else data
-
-    # Properties
-    @property
-    def fps(self) -> Dict[str, float]:
-        return {name: sub.fps for name, sub in self._subscribers.items() if sub is not None}
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def available_streams(self) -> list:
-        return [name for name, sub in self._subscribers.items() if sub is not None]
-
-    @property
-    def active_streams(self) -> list:
-        return [name for name, sub in self._subscribers.items() if sub and sub.is_active()]
-