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

dexcontrol/sensors/ultrasonic.py

@@ -8,21 +8,21 @@
 # 2. Commercial License
 #    For commercial licensing terms, contact: contact@dexmate.ai
 
-"""Ultrasonic sensor implementations using Zenoh subscribers.
+"""Ultrasonic sensor implementations using DexComm subscribers.
 
-This module provides ultrasonic sensor classes that use the generic
-subscriber for distance measurements.
+This module provides ultrasonic sensor classes that use DexComm's
+Raw API for distance measurements.
 """
 
 import numpy as np
-import zenoh
+from dexcomm.serialization import deserialize_protobuf
+from dexcomm.serialization.protobuf import control_msg_pb2
 
-from dexcontrol.proto import dexcontrol_msg_pb2
-from dexcontrol.utils.subscribers import ProtobufZenohSubscriber
+from dexcontrol.comm import create_subscriber
 
 
 class UltrasonicSensor:
-    """Ultrasonic sensor using Zenoh subscriber.
+    """Ultrasonic sensor using DexComm subscriber.
 
     This sensor provides distance measurements from ultrasonic sensors
     """
@@ -30,24 +30,18 @@ class UltrasonicSensor:
     def __init__(
         self,
         configs,
-        zenoh_session: zenoh.Session,
     ) -> None:
         """Initialize the ultrasonic sensor.
 
         Args:
             configs: Configuration for the ultrasonic sensor.
-            zenoh_session: Active Zenoh session for communication.
         """
         self._name = configs.name
 
-        # Create the generic subscriber with JSON decoder
-        self._subscriber = ProtobufZenohSubscriber(
+        # Create the protobuf subscriber using our clean DexComm integration
+        self._subscriber = create_subscriber(
             topic=configs.topic,
-            zenoh_session=zenoh_session,
-            message_type=dexcontrol_msg_pb2.UltrasonicState,
-            name=f"{self._name}_subscriber",
-            enable_fps_tracking=configs.enable_fps_tracking,
-            fps_log_interval=configs.fps_log_interval,
+            deserializer=lambda data: deserialize_protobuf(data, control_msg_pb2.UltrasonicState),
         )
 
 
@@ -61,7 +55,8 @@ class UltrasonicSensor:
         Returns:
             True if receiving data, False otherwise.
         """
-        return self._subscriber.is_active()
+        data = self._subscriber.get_latest()
+        return data is not None
 
     def wait_for_active(self, timeout: float = 5.0) -> bool:
         """Wait for the ultrasonic sensor to start receiving data.
@@ -72,7 +67,8 @@ class UltrasonicSensor:
         Returns:
             True if sensor becomes active, False if timeout is reached.
         """
-        return self._subscriber.wait_for_active(timeout)
+        msg = self._subscriber.wait_for_message(timeout)
+        return msg is not None
 
     def get_obs(self) -> np.ndarray | None:
         """Get observation data for the ultrasonic sensor.
@@ -84,7 +80,7 @@ class UltrasonicSensor:
             Numpy array of distances in meters with shape (4,) in the order:
             [front_left, front_right, back_left, back_right].
         """
-        data = self._subscriber.get_latest_data()
+        data = self._subscriber.get_latest()
         if data is not None:
             obs = [
                 data.front_left,
@@ -96,15 +92,6 @@ class UltrasonicSensor:
 
         return None
 
-    @property
-    def fps(self) -> float:
-        """Get the current FPS measurement.
-
-        Returns:
-            Current frames per second measurement.
-        """
-        return self._subscriber.fps
-
     @property
     def name(self) -> str:
         """Get the sensor name.

dexcontrol/utils/__init__.py

@@ -7,14 +7,3 @@
 #
 # 2. Commercial License
 #    For commercial licensing terms, contact: contact@dexmate.ai
-
-from .subscribers import (
-    BaseZenohSubscriber,
-    DecoderFunction,
-    GenericZenohSubscriber,
-    ProtobufZenohSubscriber,
-    json_decoder,
-    protobuf_decoder,
-    raw_bytes_decoder,
-    string_decoder,
-)

dexcontrol/utils/comm_helper.py

@@ -0,0 +1,110 @@
+# 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
+
+"""Communication helper utilities for DexControl using DexComm.
+
+This module provides simple helper functions for DexControl's communication
+needs using the DexComm library's Raw API.
+"""
+
+import json
+import time
+from pathlib import Path
+
+from dexcomm import ZenohConfig, call_service
+from dexcomm.serialization import deserialize_json
+from loguru import logger
+
+import dexcontrol
+from dexcontrol.utils.os_utils import resolve_key_name
+
+
+def get_robot_config() -> ZenohConfig:
+    """Get DexComm configuration for robot communication.
+
+    This checks for the robot's Zenoh configuration file and creates
+    appropriate DexComm config.
+
+    Returns:
+        ZenohConfig instance configured for the robot.
+    """
+    config_path = dexcontrol.COMM_CFG_PATH
+
+    if config_path and config_path != Path("/tmp/no_config") and config_path.exists():
+        logger.debug(f"Loading config from: {config_path}")
+        return ZenohConfig.from_file(config_path)
+    else:
+        logger.debug("No config file found, using default peer mode")
+        return ZenohConfig.default_peer()
+
+
+def get_zenoh_config_path() -> Path | None:
+    """Get robot config only if not using default SessionManager.
+
+    DexComm's SessionManager will automatically use the config from
+    environment variables if available, so we only need to provide
+    config explicitly if we have a specific robot config file.
+
+    Returns:
+        path to the config file
+    """
+    config_path = dexcontrol.COMM_CFG_PATH
+    return config_path
+
+
+def query_json_service(
+    topic: str,
+    timeout: float = 2.0,
+    max_retries: int = 1,
+    retry_delay: float = 0.5,
+) -> dict | None:
+    """Query for JSON information using DexComm with retry logic.
+
+    Args:
+        topic: Topic to query (will be resolved with robot namespace).
+        timeout: Maximum time to wait for a response in seconds.
+        max_retries: Maximum number of retry attempts.
+        retry_delay: Initial delay between retries (doubles each retry).
+
+    Returns:
+        Dictionary containing the parsed JSON response if successful, None otherwise.
+    """
+    resolved_topic = resolve_key_name(topic)
+    logger.debug(f"Querying topic: {resolved_topic}")
+
+    current_delay = retry_delay
+    for attempt in range(max_retries + 1):
+        try:
+            data = call_service(
+                resolved_topic,
+                timeout=timeout,
+                config=get_zenoh_config_path(),
+                request_serializer=None,
+                response_deserializer=deserialize_json,
+            )
+
+            if data:
+                logger.debug(f"Successfully received JSON data from {resolved_topic}")
+                return data
+
+        except json.JSONDecodeError as e:
+            logger.warning(f"Failed to parse JSON response from {resolved_topic}: {e}")
+        except Exception as e:
+            logger.warning(
+                f"Query failed for {resolved_topic} (attempt {attempt + 1}/{max_retries + 1}): {e}"
+            )
+
+        if attempt < max_retries:
+            logger.debug(f"Retrying in {current_delay:.1f} seconds...")
+            time.sleep(current_delay)
+            current_delay *= 2  # Exponential backoff
+
+    logger.error(f"Failed to query {resolved_topic} after {max_retries + 1} attempts")
+    return None

dexcontrol/utils/constants.py

@@ -16,7 +16,7 @@ from typing import Final
 ROBOT_NAME_ENV_VAR: Final[str] = "ROBOT_NAME"
 
 # Environment variable for communication config path
-COMM_CFG_PATH_ENV_VAR: Final[str] = "DEXMATE_COMM_CFG_PATH"
+COMM_CFG_PATH_ENV_VAR: Final[str] = "ZENOH_CONFIG"
 
 # Environment variable to disable heartbeat monitoring
 DISABLE_HEARTBEAT_ENV_VAR: Final[str] = "DEXCONTROL_DISABLE_HEARTBEAT"

dexcontrol/utils/error_code.py

@@ -10,8 +10,6 @@
 
 """Error code interpretation utilities for robot components."""
 
-from typing import Dict
-
 
 class ErrorCodeInterpreter:
     """Interprets error codes for different robot components."""
@@ -139,7 +137,7 @@ class ErrorCodeInterpreter:
 
     @classmethod
     def _interpret_bitmask_errors(
-        cls, error_code: int, error_dict: Dict[int, str]
+        cls, error_code: int, error_dict: dict[int, str]
     ) -> str:
         """
         Interpret bitmask-style error codes.
@@ -220,7 +218,7 @@ def get_error_description(component: str, error_code: int) -> str:
     return ErrorCodeInterpreter.interpret_error(component, error_code)
 
 
-def get_multiple_errors(components_errors: Dict[str, int]) -> Dict[str, str]:
+def get_multiple_errors(components_errors: dict[str, int]) -> dict[str, str]:
     """
     Get error descriptions for multiple components.
 

dexcontrol/utils/os_utils.py

@@ -12,8 +12,12 @@
 
 import os
 import re
-from typing import Final
+from importlib.metadata import version
+from typing import Any, Final
 
+from loguru import logger
+
+import dexcontrol
 from dexcontrol.utils.constants import ROBOT_NAME_ENV_VAR
 
 
@@ -48,11 +52,175 @@ def get_robot_model() -> str:
         raise ValueError(
             f"Robot name is not set, please set the environment variable {ROBOT_NAME_ENV_VAR}"
         )
-    if not re.match(r"^dm/[a-zA-Z0-9]{12}-(?:\d+|rc\d+)$", robot_name):
+    if not re.match(r"^dm/[a-zA-Z0-9]{12}-(?:\d+p?|rc\d+)$", robot_name):
         raise ValueError(f"Robot name is not in the correct format: {robot_name}")
-
     robot_model_abb = robot_name.split("/")[-1].split("-")[0][:2]
     if robot_model_abb not in robot_model_abb_mapping:
         raise ValueError(f"Unknown robot model: {robot_model_abb}")
-    model = robot_model_abb_mapping[robot_model_abb] + "-" + robot_name.split("-")[-1]
+    model = (
+        robot_model_abb_mapping[robot_model_abb] + "-" + robot_name.split("-")[-1][0]
+    )
     return model
+
+
+def check_version_compatibility(version_info: dict[str, Any]) -> 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 using importlib.metadata
+    current_version = version("dexcontrol")
+
+    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

@@ -13,35 +13,13 @@
 from enum import Enum
 from typing import Any, Literal
 
-from dexcontrol.proto import dexcontrol_query_pb2
+from dexcomm.serialization.protobuf import control_query_pb2
 
 TYPE_SOFTWARE_VERSION = dict[
     Literal["hardware_version", "software_version", "main_hash", "compile_time"], Any
 ]
 
 
-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."""
 
@@ -50,7 +28,7 @@ class ComponentStatus(Enum):
     ERROR = 2
 
 
-def status_to_enum(status: dexcontrol_query_pb2.ComponentStatus) -> ComponentStatus:
+def status_to_enum(status: control_query_pb2.ComponentStatus) -> ComponentStatus:
     """Convert a ComponentStatus protobuf message to a ComponentStatus enum.
 
     Args:
@@ -63,9 +41,9 @@ def status_to_enum(status: dexcontrol_query_pb2.ComponentStatus) -> ComponentSta
         ValueError: If the status value is not recognized.
     """
     status_map = {
-        dexcontrol_query_pb2.ComponentStatus.NORMAL: ComponentStatus.NORMAL,
-        dexcontrol_query_pb2.ComponentStatus.NA: ComponentStatus.NA,
-        dexcontrol_query_pb2.ComponentStatus.ERROR: ComponentStatus.ERROR,
+        control_query_pb2.ComponentStatus.NORMAL: ComponentStatus.NORMAL,
+        control_query_pb2.ComponentStatus.NA: ComponentStatus.NA,
+        control_query_pb2.ComponentStatus.ERROR: ComponentStatus.ERROR,
     }
 
     if status not in status_map:
@@ -75,7 +53,7 @@ def status_to_enum(status: dexcontrol_query_pb2.ComponentStatus) -> ComponentSta
 
 
 def status_to_dict(
-    status_msg: dexcontrol_query_pb2.ComponentStates,
+    status_msg: control_query_pb2.ComponentStates,
 ) -> dict[str, dict[str, Any]]:
     """Convert a ComponentStates protobuf message to a dictionary.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dexcontrol
-Version: 0.2.12
+Version: 0.3.4
 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,13 +202,13 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 Requires-Python: <3.14,>=3.10
 Requires-Dist: aiortc
+Requires-Dist: dexcomm>=0.1.18
 Requires-Dist: eclipse-zenoh>=1.2.0
 Requires-Dist: hydra-core==1.3.2
 Requires-Dist: jaxtyping>=0.2.38
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: numpy>=1.26.4
 Requires-Dist: opencv-python>=4.11.0
-Requires-Dist: protobuf>=6.31.0
 Requires-Dist: rich
 Requires-Dist: uvloop>=0.17.0; sys_platform != 'win32'
 Requires-Dist: websockets
@@ -231,7 +231,7 @@ Requires-Dist: dexmotion>=0.2.1; extra == 'example'
 Requires-Dist: dualsense-controller>=0.3.1; extra == 'example'
 Requires-Dist: matplotlib>=3.8.0; extra == 'example'
 Requires-Dist: pytransform3d==3.13.0; extra == 'example'
-Requires-Dist: ruckig; extra == 'example'
+Requires-Dist: scipy>=1.16.1; extra == 'example'
 Requires-Dist: tyro; extra == 'example'
 Description-Content-Type: text/markdown
 
@@ -253,6 +253,19 @@ 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.
+
+**📋 See [CHANGELOG.md](./CHANGELOG.md) for detailed release notes and version history.**
+
 ## 📄 Licensing
 
 This project is **dual-licensed**:

dexcontrol-0.3.4.dist-info/RECORD

@@ -0,0 +1,62 @@
+dexcontrol/__init__.py,sha256=SqdTD3v-qOX6oOGNUcLWEzc5EzY_morOB3TEs-7yv6Y,1955
+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/rtc.py,sha256=I5CQz2RuSdE4MyKYraDoQ1E1MSbyYA-rp1kmjxRX9T0,13072
+dexcontrol/comm/subscribers.py,sha256=3rD_YUC5DH3rH_JN8iGjgIkblXcl_pI51dVQ4iQOQQc,8900
+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=iwAFy6C7fxwp8t5ieJNMq1Iulq-OB2L0mzpQCEgl9W0,16211
+dexcontrol/core/chassis.py,sha256=vllwQQB7DUere4Y77qrKhOa_GAckPXmNlW_HfPkz9YE,24188
+dexcontrol/core/component.py,sha256=qXhGsNwa9EHO5DaGybylgFoGJmUUppNznH5JHmH08sQ,36296
+dexcontrol/core/hand.py,sha256=P_UGAqT71j_9k_wP_YQZep_cU5bR0loIxdRb3IH42w8,9595
+dexcontrol/core/head.py,sha256=axqxiqdec9TDpYCt9_QSvhEu2Dy3bf2n196FGkpt710,9925
+dexcontrol/core/misc.py,sha256=AjOgLRSvQqxGC6VsJiewtkOchzawpqW3VZ7eTrNt8iI,30867
+dexcontrol/core/robot_query_interface.py,sha256=IiIpPNQ9uMopuo0z4m0ErrQtbY8RtwBOkj4dLPXOLlM,17628
+dexcontrol/core/torso.py,sha256=XSNu5O8DmbtBVVcJtGr6JFdYrs8vgNFkJkK1gAC43II,8767
+dexcontrol/sensors/__init__.py,sha256=Dp06cuO_3xC6i4u5rHqfK5NqlIC5kaCue_bAtTC6JEE,960
+dexcontrol/sensors/manager.py,sha256=uhP_matbXMzG_HQv9fmcGbw_rm9xloMoKUeNe3KBmTU,6590
+dexcontrol/sensors/ultrasonic.py,sha256=uFiPl0js49PFcx9yLSUesFdm1U9IsR8KCtoDtEn1E6k,2890
+dexcontrol/sensors/camera/__init__.py,sha256=Vwe98I4Lvdv3F2UslOzKkeUkt5Rl2jSqbKlU6gIBeF0,609
+dexcontrol/sensors/camera/base_camera.py,sha256=flmpoLP8rC-NZg7TFHFLqXJNHRT45jwqsVPk-L1G6oc,4808
+dexcontrol/sensors/camera/rgb_camera.py,sha256=Mcd51BXOBatfK5fcIjsNuJsClXhdnVR2ck-wgyJYKnQ,6363
+dexcontrol/sensors/camera/zed_camera.py,sha256=BYLAlxuHSZKTVpHMP2eKwWfbHOxWXhT18VG3aXAN0sY,14164
+dexcontrol/sensors/imu/__init__.py,sha256=bBC7_NSLJ5qLMvUYu2-9yXKO2bRpQLC0HyywBwnbM0A,768
+dexcontrol/sensors/imu/chassis_imu.py,sha256=RzaY6VhhGEjzrFNxDcXL43SdIwoozW5PctKdUxfc_2k,5565
+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=PDB_Qyo39BdtR0d5-k0zPkAq6nwGV9eGMMXo3i7CFDw,3541
+dexcontrol/utils/constants.py,sha256=uzR6AW5LNU3Otmf0G8M4yg-0iaHLhKtJ5e-OPuqxr9g,783
+dexcontrol/utils/error_code.py,sha256=MQJHfM76YgRmE_7rAj0qSSHQf9P71oRUBa50m-3-Pwc,7296
+dexcontrol/utils/io_utils.py,sha256=4TYV33ufECo8fuQivrZR9vtSdwWYUiPvpAUSneEzOOs,850
+dexcontrol/utils/os_utils.py,sha256=LBye18I-I7mDYuTf_zDB5k-KQAx7Pt11ibgyH5F36mc,7586
+dexcontrol/utils/pb_utils.py,sha256=fMJJQgfCPtGlij0KdLHnPjElW0_DCwPpuSM2VMqhrK4,2504
+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.4.dist-info/METADATA,sha256=THlzSihnxku-i8wXM0q8fFUeITImxjX8KNv2lvI6D6g,37338
+dexcontrol-0.3.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dexcontrol-0.3.4.dist-info/licenses/LICENSE,sha256=0J2KCMNNnW5WZPK5x8xUiCxApBf7h83693ggSJYiue0,31745
+dexcontrol-0.3.4.dist-info/RECORD,,

{dexcontrol-0.2.12.dist-info → dexcontrol-0.3.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any