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

dexcontrol/utils/subscribers/rtc.py

@@ -1,316 +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
-
-import asyncio
-import json
-import threading
-import time
-
-import numpy as np
-import websockets
-from aiortc import RTCPeerConnection, RTCSessionDescription
-from loguru import logger
-
-# Try to import uvloop for better performance
-try:
-    import uvloop  # type: ignore[import-untyped]
-
-    UVLOOP_AVAILABLE = True
-except ImportError:
-    uvloop = None  # type: ignore[assignment]
-    UVLOOP_AVAILABLE = False
-
-
-class RTCSubscriber:
-    """
-    Subscriber for receiving video data via RTC.
-
-    This class connects to a RTC peer through a signaling server,
-    receives a video stream, and makes the latest frame available.
-    """
-
-    def __init__(
-        self,
-        url: str,
-        name: str = "rtc_subscriber",
-        enable_fps_tracking: bool = True,
-        fps_log_interval: int = 100,
-    ):
-        """
-        Initialize the RTC subscriber.
-
-        Args:
-            url: WebSocket URL of the signaling server.
-            name: Name for logging purposes.
-            enable_fps_tracking: Whether to track and log FPS metrics.
-            fps_log_interval: Number of frames between FPS calculations.
-        """
-        self._url = url
-        self._name = name
-        self._pc = RTCPeerConnection()
-        self._latest_frame: np.ndarray | None = None
-        self._active = False
-        self._data_lock = threading.Lock()
-        self._stop_event = (
-            threading.Event()
-        )  # Use threading.Event for cross-thread communication
-        self._async_stop_event = None  # Will be created in the async context
-        self._websocket = None  # Store websocket reference for clean shutdown
-
-        # FPS tracking
-        self._enable_fps_tracking = enable_fps_tracking
-        self._fps_log_interval = fps_log_interval
-        self._frame_count = 0
-        self._fps = 0.0
-        self._last_fps_time = time.time()
-
-        self._thread = threading.Thread(target=self._run_event_loop, daemon=True)
-        self._thread.start()
-
-    def _run_event_loop(self):
-        """Run the asyncio event loop in a separate thread."""
-        try:
-            # Use uvloop if available for better performance
-            if UVLOOP_AVAILABLE and uvloop is not None:
-                # Create a new uvloop event loop for this thread
-                loop = uvloop.new_event_loop()
-                asyncio.set_event_loop(loop)
-                logger.debug(f"Using uvloop for {self._name}")
-
-                try:
-                    loop.run_until_complete(self._run())
-                finally:
-                    loop.close()
-            else:
-                # Use default asyncio event loop
-                asyncio.run(self._run())
-
-        except Exception as e:
-            logger.error(f"Event loop error for {self._name}: {e}")
-        finally:
-            with self._data_lock:
-                self._active = False
-
-    async def _run(self):
-        """
-        Connects to a RTC peer, receives video, and saves frames to disk.
-        """
-        # Create async stop event in the async context
-        self._async_stop_event = asyncio.Event()
-
-        # Start a task to monitor the threading stop event
-        monitor_task = asyncio.create_task(self._monitor_stop_event())
-
-        @self._pc.on("track")
-        async def on_track(track):
-            if track.kind == "video":
-                while (
-                    self._async_stop_event is not None
-                    and not self._async_stop_event.is_set()
-                ):
-                    try:
-                        frame = await asyncio.wait_for(
-                            track.recv(), timeout=1.0
-                        )  # Reduced timeout for faster shutdown response
-                        img = frame.to_ndarray(format="rgb24")
-                        with self._data_lock:
-                            self._latest_frame = img
-                            if not self._active:
-                                self._active = True
-                        self._update_fps_metrics()
-                    except asyncio.TimeoutError:
-                        # Check if we should stop before logging error
-                        if (
-                            self._async_stop_event is not None
-                            and not self._async_stop_event.is_set()
-                        ):
-                            logger.warning(
-                                f"Timeout: No frame received in 1 second from {self._url}"
-                            )
-                        continue
-                    except Exception as e:
-                        if (
-                            self._async_stop_event is not None
-                            and not self._async_stop_event.is_set()
-                        ):
-                            logger.error(f"Error receiving frame from {self._url}: {e}")
-                        break
-
-        @self._pc.on("connectionstatechange")
-        async def on_connectionstatechange():
-            if self._pc.connectionState == "failed":
-                logger.warning(f"RTC connection failed for {self._url}")
-                await self._pc.close()
-                if self._async_stop_event is not None:
-                    self._async_stop_event.set()
-
-        try:
-            async with websockets.connect(self._url) as websocket:
-                self._websocket = websocket
-
-                # Create an offer. The server's assertive codec control makes
-                # client-side preferences redundant and potentially conflicting.
-                self._pc.addTransceiver("video", direction="recvonly")
-                offer = await self._pc.createOffer()
-                await self._pc.setLocalDescription(offer)
-
-                # Send the offer to the server
-                await websocket.send(
-                    json.dumps(
-                        {
-                            "sdp": self._pc.localDescription.sdp,
-                            "type": self._pc.localDescription.type,
-                        }
-                    )
-                )
-
-                # Wait for the answer
-                response = json.loads(await websocket.recv())
-                if response["type"] == "answer":
-                    await self._pc.setRemoteDescription(
-                        RTCSessionDescription(
-                            sdp=response["sdp"], type=response["type"]
-                        )
-                    )
-                else:
-                    logger.error(
-                        f"Received unexpected message type: {response['type']} from {self._url}"
-                    )
-                    if self._async_stop_event is not None:
-                        self._async_stop_event.set()
-
-                # Wait until the stop event is set
-                if self._async_stop_event is not None:
-                    await self._async_stop_event.wait()
-
-        except websockets.exceptions.ConnectionClosed:
-            logger.info(f"WebSocket connection closed for {self._url}")
-        except Exception as e:
-            if not self._async_stop_event.is_set():
-                logger.error(f"Operation failed for {self._url}: {e}")
-        finally:
-            # Cancel the monitor task
-            monitor_task.cancel()
-            try:
-                await monitor_task
-            except asyncio.CancelledError:
-                pass
-
-            # Close websocket if still open
-            if self._websocket:
-                try:
-                    await self._websocket.close()
-                except Exception as e:
-                    logger.debug(f"Error closing websocket for {self._url}: {e}")
-
-            # Close peer connection if not already closed
-            if self._pc.connectionState != "closed":
-                try:
-                    await self._pc.close()
-                except Exception as e:
-                    logger.debug(f"Error closing peer connection for {self._url}: {e}")
-
-            with self._data_lock:
-                self._active = False
-
-    async def _monitor_stop_event(self):
-        """Monitor the threading stop event and set the async stop event when needed."""
-        while not self._stop_event.is_set():
-            await asyncio.sleep(0.1)  # Check every 100ms
-        if self._async_stop_event is not None:
-            self._async_stop_event.set()
-
-    def _update_fps_metrics(self) -> None:
-        """Update FPS tracking metrics.
-
-        Increments frame counter and recalculates FPS at specified intervals.
-        Only has an effect if fps_tracking was enabled during initialization.
-        """
-        if not self._enable_fps_tracking:
-            return
-
-        self._frame_count += 1
-        if self._frame_count >= self._fps_log_interval:
-            current_time = time.time()
-            elapsed = current_time - self._last_fps_time
-            self._fps = self._frame_count / elapsed
-            logger.info(f"{self._name} frequency: {self._fps:.2f} Hz")
-            self._frame_count = 0
-            self._last_fps_time = current_time
-
-    def get_latest_data(self) -> np.ndarray | None:
-        """
-        Get the latest video frame.
-
-        Returns:
-            Latest video frame as a numpy array (HxWxC RGB) if available, None otherwise.
-        """
-        with self._data_lock:
-            return self._latest_frame.copy() if self._latest_frame is not None else None
-
-    def is_active(self) -> bool:
-        """Check if the subscriber is actively receiving data."""
-        with self._data_lock:
-            return self._active
-
-    def wait_for_active(self, timeout: float = 5.0) -> bool:
-        """
-        Wait for the subscriber to start receiving data.
-
-        Args:
-            timeout: Maximum time to wait in seconds.
-
-        Returns:
-            True if subscriber becomes active, False if timeout is reached.
-        """
-        start_time = time.time()
-        while not self.is_active():
-            if time.time() - start_time > timeout:
-                logger.error(
-                    f"No data received from {self._name} at {self._url} after {timeout}s"
-                )
-                return False
-            time.sleep(0.1)
-        return True
-
-    def shutdown(self):
-        """Stop the subscriber and release resources."""
-
-        # Signal the async loop to stop
-        self._stop_event.set()
-
-        # Wait for the thread to finish with a reasonable timeout
-        if self._thread.is_alive():
-            self._thread.join(
-                timeout=10.0
-            )  # Increased timeout for more graceful shutdown
-
-            if self._thread.is_alive():
-                logger.warning(
-                    f"{self._name} thread did not shut down gracefully within timeout."
-                )
-
-        # Ensure active state is set to False
-        with self._data_lock:
-            self._active = False
-
-    @property
-    def name(self) -> str:
-        """Get the subscriber name."""
-        return self._name
-
-    @property
-    def fps(self) -> float:
-        """Get the current FPS measurement.
-
-        Returns:
-            Current frames per second measurement.
-        """
-        return self._fps

dexcontrol/utils/zenoh_utils.py

@@ -1,122 +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
-
-"""Zenoh utilities for dexcontrol.
-
-This module provides general utility functions for working with Zenoh
-communication framework.
-"""
-
-import json
-import time
-
-import numpy as np
-import zenoh
-from loguru import logger
-
-from dexcontrol.utils.os_utils import resolve_key_name
-
-
-def query_zenoh_json(
-    zenoh_session: zenoh.Session,
-    topic: str,
-    timeout: float = 2.0,
-    max_retries: int = 1,
-    retry_delay: float = 0.5,
-) -> dict | None:
-    """Query Zenoh for JSON information with retry logic.
-
-    Args:
-        zenoh_session: Active Zenoh session for communication.
-        topic: Zenoh topic to query.
-        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 Zenoh topic: {resolved_topic}")
-
-    for attempt in range(max_retries + 1):
-        try:
-            # Add delay before retry (except first attempt)
-            if attempt > 0:
-                delay = retry_delay * (2 ** (attempt - 1))  # Exponential backoff
-                logger.debug(f"Retry {attempt}/{max_retries} after {delay}s delay...")
-                time.sleep(delay)
-
-            # Try to get the info
-            for reply in zenoh_session.get(resolved_topic, timeout=timeout):
-                if reply.ok:
-                    response = json.loads(reply.ok.payload.to_bytes())
-                    return response
-            else:
-                # No valid reply received
-                if attempt < max_retries:
-                    logger.debug(f"No reply on attempt {attempt + 1}, will retry...")
-                else:
-                    logger.error(
-                        f"No valid reply received on topic '{resolved_topic}' after {max_retries + 1} attempts."
-                    )
-
-        except StopIteration:
-            if attempt < max_retries:
-                logger.debug(f"Query timed out on attempt {attempt + 1}, will retry...")
-            else:
-                logger.error(f"Query timed out after {max_retries + 1} attempts.")
-        except Exception as e:
-            if attempt < max_retries:
-                logger.debug(
-                    f"Query failed on attempt {attempt + 1}: {e}, will retry..."
-                )
-            else:
-                logger.error(f"Query failed after {max_retries + 1} attempts: {e}")
-
-    return None
-
-
-def compute_ntp_stats(offsets: list[float], rtts: list[float]) -> dict[str, float]:
-    """Compute NTP statistics, removing outliers based on RTT median and std.
-
-    Args:
-        offsets: List of offset values (seconds).
-        rtts: List of round-trip time values (seconds).
-
-    Returns:
-        Dictionary with computed statistics (mean, std, min, max, sample_count) for offset and rtt.
-    """
-    offsets_np = np.array(offsets)
-    rtts_np = np.array(rtts)
-    if len(rtts_np) < 3:
-        mask = np.ones_like(rtts_np, dtype=bool)
-    else:
-        median = np.median(rtts_np)
-        std = np.std(rtts_np)
-        mask = np.abs(rtts_np - median) <= 2 * std
-    offsets_filtered = offsets_np[mask]
-    rtts_filtered = rtts_np[mask]
-
-    def safe_stat(arr, func):
-        return float(func(arr)) if len(arr) > 0 else 0.0
-
-    stats = {
-        "offset (mean)": safe_stat(offsets_filtered, np.mean),
-        "offset (std)": safe_stat(offsets_filtered, np.std),
-        "offset (min)": safe_stat(offsets_filtered, np.min),
-        "offset (max)": safe_stat(offsets_filtered, np.max),
-        "round_trip_time (mean)": safe_stat(rtts_filtered, np.mean),
-        "round_trip_time (std)": safe_stat(rtts_filtered, np.std),
-        "round_trip_time (min)": safe_stat(rtts_filtered, np.min),
-        "round_trip_time (max)": safe_stat(rtts_filtered, np.max),
-        "sample_count": int(len(offsets_filtered)),
-    }
-    return stats

dexcontrol-0.2.12.dist-info/RECORD

@@ -1,75 +0,0 @@
-dexcontrol/__init__.py,sha256=9y7PGcWv9KYcLg7nH54FQv2vv0Q_GeVy3wcFa4Yf_gs,1692
-dexcontrol/robot.py,sha256=Ab-9HhfPiqKq4gGNoBUUMKqYsjPK4u9KW2ykPlbKe4A,51914
-dexcontrol/apps/dualsense_teleop_base.py,sha256=Dw1z-2HA5D7DPKutZxlOdXsN9vpk4gS6XzJsL5ZQLM0,12702
-dexcontrol/config/__init__.py,sha256=UVLNpzGD14e8g68rUZFXTh0B7FRx6uS0Eg_MecjinYM,520
-dexcontrol/config/vega.py,sha256=UE5XAdk5IpYj-LgLUzbAvr6Zi83e4XYPAvXdgM9z3VY,8239
-dexcontrol/config/core/__init__.py,sha256=Ym2R1hr1iMKQuXcg16BpZfQtTb0hQ5Q7smUIMlwKfho,637
-dexcontrol/config/core/arm.py,sha256=5hN1dQMe2H6oufaqgtZqx9vuB969DxM26leJqPsKEiA,1471
-dexcontrol/config/core/chassis.py,sha256=163hO4lVVaW7r9dvNleH0cdDds_GfO15EepnjloeT9U,868
-dexcontrol/config/core/hand.py,sha256=bGRO-_usaFP0GU6jgB6Lm3Z07DMqMVO_tiB5j4c8Cu4,954
-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=VTC8OPLEhBmnQpWdbPTOAr1JGeKOEekLc1Vew62yVtk,2969
-dexcontrol/config/sensors/cameras/__init__.py,sha256=UcY9soHfHTEZL4VX705yH7RM6jWf3Mqd8MWJMp59big,454
-dexcontrol/config/sensors/cameras/luxonis_camera.py,sha256=e3I5jiIbyAK2HjM8E0VRUOdYODTMjaA_zRH7Du9D8qI,1648
-dexcontrol/config/sensors/cameras/rgb_camera.py,sha256=MN4SjyZlfbrQ3JKDDkT8HhC0Aiyc0bWfDLt4ik0Xcvs,1448
-dexcontrol/config/sensors/cameras/zed_camera.py,sha256=cPXR84m2P3P2-qls1usHCbR6iz-l9gaBjjXyDmTXoiE,1836
-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=wbRm7G4v3ByVwscZ9rEu_IpmBdqZoI6gKXDphDeNN5Q,15360
-dexcontrol/core/chassis.py,sha256=tB-tsx6MjKJDOtQxBf7PIX0L1JwgnsXUzmNPC1VKsQU,23165
-dexcontrol/core/component.py,sha256=mkYH7W7tWIWnfWfXmCUQulzaZ7VfrwYI0ET_L7pPw2k,34779
-dexcontrol/core/hand.py,sha256=wd__YB5wcM-LlksEm3PatXhy665zLnu9nV_9x85WxIA,8649
-dexcontrol/core/head.py,sha256=iz9umFxiizYzK49BdML1i6pKM_i8kbk44tH0uu_TaVM,10512
-dexcontrol/core/misc.py,sha256=0YNJCrTJS1yCT9N-p9us5I7uSiAK470k8nWgJu638X4,25153
-dexcontrol/core/torso.py,sha256=4MB5EojHnlBpUaHzcZOh4IkKcjI6pSluXmpb5RpmdV4,8932
-dexcontrol/proto/dexcontrol_msg_pb2.py,sha256=YgPlHnOZbVfCuTdfK1DD0t4yf6qeDf-ximl4qY5YeWo,6397
-dexcontrol/proto/dexcontrol_msg_pb2.pyi,sha256=5sI3nH1hhLPAg_UpNk5Mgh5bt5YrzcoPj1tCL6bT45s,10865
-dexcontrol/proto/dexcontrol_query_pb2.py,sha256=n5EazrveRw2UXFM-J5n5c7NVfr8LzaPigmOns4UOI9k,5946
-dexcontrol/proto/dexcontrol_query_pb2.pyi,sha256=0Lr0wYPGHhhNeAK24JJ2A7bzZ7q-r5ssOI2_ZfoYzVk,7108
-dexcontrol/sensors/__init__.py,sha256=3DtVBwX5E3RPPjfCh2elnqk6uIWB_ukIqPQgBPZ7w7g,1008
-dexcontrol/sensors/manager.py,sha256=Qsbs9zZ4TvJgyn8yuI85wOU6mqgBQEus_MYSXj7wA9w,7025
-dexcontrol/sensors/ultrasonic.py,sha256=WAHvHh64iQ0HfqVf-Oo0Rg8R32Cdk5d8k8kDSwa3Xrc,3258
-dexcontrol/sensors/camera/__init__.py,sha256=w7-w58fAsV57lSb4ANC8tn8YbY5o1GVymw3p2agNJEE,684
-dexcontrol/sensors/camera/luxonis_camera.py,sha256=OeKoX7JL2ogbNJa7JPYkPT4LHKg8Wby5PPtoMQcFo8c,6307
-dexcontrol/sensors/camera/rgb_camera.py,sha256=UaEk8aszHeBRg5xMQlHxZk2KMP7wU3m6UnE_qgh6V4Q,5892
-dexcontrol/sensors/camera/zed_camera.py,sha256=hrnTrON0WieCkJ7i2pvO6nUjHOD_N8po9arl9jbqtuQ,15501
-dexcontrol/sensors/imu/__init__.py,sha256=bBC7_NSLJ5qLMvUYu2-9yXKO2bRpQLC0HyywBwnbM0A,768
-dexcontrol/sensors/imu/chassis_imu.py,sha256=a_PMH2I2UVHZ2xIqGac2M4xFIDgiUopjUOjD87xNFL0,5058
-dexcontrol/sensors/imu/zed_imu.py,sha256=kNXdOq0STucWG5Vvy6AWL3Hs4JZB6dxtfhCsjEWnRGY,5251
-dexcontrol/sensors/lidar/__init__.py,sha256=frF16HmeQnfbvH0dVJ4pPjD4TySF13wCk-O9L3Memeg,317
-dexcontrol/sensors/lidar/rplidar.py,sha256=HpPeO2lqGDGGrnR3j4rZ6suw_pc07Rhsfti9GCCi-1M,4499
-dexcontrol/utils/__init__.py,sha256=ayMZ6xNlA9xKfS_XRr8bWcoXW4-8Jg_25XSbMd5Jx58,468
-dexcontrol/utils/constants.py,sha256=6SG5HoSo7V-DlWH7cdNaMJtZs05dWrqYWIuKpmXfdI0,792
-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=CC2st_Pb0C5cWfCg-i1P5bgBx3ZBX4LWVUiBq63dNeo,1852
-dexcontrol/utils/pb_utils.py,sha256=_6nFLKwAtq56vYXMZ6YmHnMfL5SarD96MVEA-9cxXns,3178
-dexcontrol/utils/rate_limiter.py,sha256=wFNaJ1fh-GO6zItuksKd_DSxLA1esE71WAiNDLpGsU0,6176
-dexcontrol/utils/rtc_utils.py,sha256=o2F9puC7CdAPnqiVq2vzomFZ7hMHljwtAbp9UiLhxJY,4426
-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/utils/zenoh_utils.py,sha256=83BSwWM0RZQP5Zey4Py83P_QC-vuk1qyk2Ac5iuschA,4264
-dexcontrol/utils/subscribers/__init__.py,sha256=Sqa-PPElwdUKxdh9BbU5MSqnf_i7BFqANrzVUXYUNuQ,1380
-dexcontrol/utils/subscribers/base.py,sha256=t4zcps_kjFG1wj6WSrZ4HJg0Bxcdnu-C8NkVVupmNVg,9769
-dexcontrol/utils/subscribers/camera.py,sha256=0kaeoKjKCxRQ5iaKK3r_94xEaVxNDBAMd2ZHL6X1kWU,11201
-dexcontrol/utils/subscribers/decoders.py,sha256=X39NY7zNEUlOaG0b1Eooc1T7U5SCQ3rZ2ddaz12fi0o,2134
-dexcontrol/utils/subscribers/generic.py,sha256=EKRutiu2zJBfzNIHCfYEfkcGE6QQTJmkOEMRRvEXJXA,3704
-dexcontrol/utils/subscribers/imu.py,sha256=Us4ZWzLfqujg16jvrNIoHcvUyxbRCv6mZlaAizvX6uo,5925
-dexcontrol/utils/subscribers/lidar.py,sha256=OlmORIf-dBO4LV4u6pWccoxh-nYTAtGlIfhjj-sG1F4,5691
-dexcontrol/utils/subscribers/protobuf.py,sha256=gtE2b9ZtR2UXftKA5nX7bvTLkj8AeXDYZMqe4B3t5BQ,3696
-dexcontrol/utils/subscribers/rtc.py,sha256=mxD-IIeQwluvq0_D63lQJJEXrJsIc6yxX7uD0PDh08k,11350
-dexcontrol-0.2.12.dist-info/METADATA,sha256=3O9vIN5nR0U_mpL2QAb7Enr_eRzUbSI3Zk49Vv_HFpI,36840
-dexcontrol-0.2.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dexcontrol-0.2.12.dist-info/licenses/LICENSE,sha256=0J2KCMNNnW5WZPK5x8xUiCxApBf7h83693ggSJYiue0,31745
-dexcontrol-0.2.12.dist-info/RECORD,,