dexcontrol 0.2.10__py3-none-any.whl → 0.3.0__py3-none-any.whl

dexcontrol/core/hand.py

@@ -14,17 +14,24 @@ This module provides the Hand class for controlling a robotic hand through Zenoh
 communication. It handles joint position control and state monitoring.
 """
 
-from typing import Any
+from enum import Enum
+from typing import Any, cast
 
 import numpy as np
 import zenoh
 from jaxtyping import Float
 
 from dexcontrol.config.core.hand import HandConfig
-from dexcontrol.core.component import RobotJointComponent
+from dexcontrol.core.component import RobotComponent, RobotJointComponent
 from dexcontrol.proto import dexcontrol_msg_pb2
 
 
+class HandType(Enum):
+    UNKNOWN = "UNKNOWN"
+    HandF5D6_V1 = "HandF5D6_V1"
+    HandF5D6_V2 = "HandF5D6_V2"
+
+
 class Hand(RobotJointComponent):
     """Robot hand control class.
 
@@ -36,6 +43,7 @@ class Hand(RobotJointComponent):
         self,
         configs: HandConfig,
         zenoh_session: zenoh.Session,
+        hand_type: HandType = HandType.HandF5D6_V1,
     ) -> None:
         """Initialize the hand controller.
 
@@ -47,7 +55,7 @@ class Hand(RobotJointComponent):
         super().__init__(
             state_sub_topic=configs.state_sub_topic,
             control_pub_topic=configs.control_pub_topic,
-            state_message_type=dexcontrol_msg_pb2.HandState,
+            state_message_type=dexcontrol_msg_pb2.MotorStateWithCurrent,
             zenoh_session=zenoh_session,
             joint_name=configs.joint_name,
         )
@@ -64,45 +72,11 @@ class Hand(RobotJointComponent):
         Args:
             joint_pos: Joint positions as list or numpy array.
         """
-        control_msg = dexcontrol_msg_pb2.HandCommand()
+        control_msg = dexcontrol_msg_pb2.MotorPosCommand()
         joint_pos_array = self._convert_joint_cmd_to_array(joint_pos)
-        control_msg.joint_pos.extend(joint_pos_array.tolist())
+        control_msg.pos.extend(joint_pos_array.tolist())
         self._publish_control(control_msg)
 
-    def set_joint_pos(
-        self,
-        joint_pos: Float[np.ndarray, " N"] | list[float] | dict[str, float],
-        relative: bool = False,
-        wait_time: float = 0.0,
-        wait_kwargs: dict[str, float] | None = None,
-        exit_on_reach: bool = False,
-        exit_on_reach_kwargs: dict[str, Any] | None = None,
-    ) -> None:
-        """Send joint position control commands to the hand.
-
-        Args:
-            joint_pos: Joint positions as either:
-                - List of joint values [j1, j2, ..., jN]
-                - Numpy array with shape (N,)
-                - Dictionary mapping joint names to position values
-            relative: If True, the joint positions are relative to the current position.
-            wait_time: Time to wait after setting the joint positions.
-            wait_kwargs: Optional parameters for trajectory generation (not used in Hand).
-            exit_on_reach: If True, the function will exit when the joint positions are reached.
-            exit_on_reach_kwargs: Optional parameters for exit when the joint positions are reached.
-
-        Raises:
-            ValueError: If joint_pos dictionary contains invalid joint names.
-        """
-        super().set_joint_pos(
-            joint_pos,
-            relative,
-            wait_time,
-            wait_kwargs,
-            exit_on_reach,
-            exit_on_reach_kwargs,
-        )
-
     def open_hand(
         self,
         wait_time: float = 0.0,
@@ -152,6 +126,37 @@ class HandF5D6(Hand):
     the F5D6 hand model.
     """
 
+    def __init__(
+        self,
+        configs: HandConfig,
+        zenoh_session: zenoh.Session,
+        hand_type: HandType = HandType.HandF5D6_V1,
+    ) -> None:
+        super().__init__(configs, zenoh_session)
+
+        # Initialize touch sensor for F5D6_V2 hands
+        self._hand_type = hand_type
+        if self._hand_type == HandType.HandF5D6_V2:
+            self._touch_sensor = HandF5D6TouchSensor(
+                configs.touch_sensor_sub_topic, zenoh_session
+            )
+        elif self._hand_type == HandType.HandF5D6_V1:
+            self._touch_sensor = None
+        else:
+            raise ValueError(f"Invalid hand type: {self._hand_type}")
+
+    def get_finger_tip_force(self) -> Float[np.ndarray, "5"]:
+        """Get the force at the finger tips.
+
+        Returns:
+            Array of force values at the finger tips.
+        """
+        if self._touch_sensor is None:
+            raise ValueError(
+                f"Touch sensor not available for this hand type: {self._hand_type}"
+            )
+        return self._touch_sensor.get_fingertip_touch_net_force()
+
     def close_hand(
         self,
         wait_time: float = 0.0,
@@ -241,3 +246,33 @@ class HandF5D6(Hand):
             0
         ] * (1 - ratio)
         return intermediate_pos
+
+
+class HandF5D6TouchSensor(RobotComponent):
+    """Wrench sensor reader for the robot arm.
+
+    This class provides methods to read wrench sensor data through Zenoh communication.
+    """
+
+    def __init__(self, state_sub_topic: str, zenoh_session: zenoh.Session) -> None:
+        """Initialize the wrench sensor reader.
+
+        Args:
+            state_sub_topic: Topic to subscribe to for wrench sensor data.
+            zenoh_session: Active Zenoh communication session for message passing.
+        """
+        super().__init__(
+            state_sub_topic=state_sub_topic,
+            zenoh_session=zenoh_session,
+            state_message_type=dexcontrol_msg_pb2.HandTouchSensorState,
+        )
+
+    def get_fingertip_touch_net_force(self) -> Float[np.ndarray, "5"]:
+        """Get the complete wrench sensor state.
+
+        Returns:
+            Dictionary containing wrench values and button states.
+        """
+        state = self._get_state()
+        hand_touch_state = cast(dexcontrol_msg_pb2.HandTouchSensorState, state)
+        return np.array(hand_touch_state.force)

dexcontrol/core/head.py

@@ -55,27 +55,26 @@ class Head(RobotJointComponent):
         super().__init__(
             state_sub_topic=configs.state_sub_topic,
             control_pub_topic=configs.control_pub_topic,
-            state_message_type=dexcontrol_msg_pb2.HeadState,
+            state_message_type=dexcontrol_msg_pb2.MotorStateWithTorque,
             zenoh_session=zenoh_session,
             joint_name=configs.joint_name,
+            joint_limit=configs.joint_limit
+            if hasattr(configs, "joint_limit")
+            else None,
+            joint_vel_limit=configs.joint_vel_limit
+            if hasattr(configs, "joint_vel_limit")
+            else None,
             pose_pool=configs.pose_pool,
         )
 
         self.mode_querier: Final[zenoh.Querier] = zenoh_session.declare_querier(
             resolve_key_name(configs.set_mode_query), timeout=2.0
         )
-        self.default_vel: Final[float] = configs.default_vel
-        self.max_vel: Final[float] = configs.max_vel
-        assert self.max_vel > self.default_vel, (
-            "max_vel must be greater than default_vel"
-        )
-        self._joint_limit: Float[np.ndarray, "3 2"] = np.stack(
-            [configs.joint_limit_lower, configs.joint_limit_upper], axis=1
-        )
+        assert self._joint_vel_limit is not None, "joint_vel_limit is not set"
 
     def set_joint_pos(
         self,
-        joint_pos: Float[np.ndarray, "2"] | list[float] | dict[str, float],
+        joint_pos: Float[np.ndarray, "3"] | list[float] | dict[str, float],
         relative: bool = False,
         wait_time: float = 0.0,
         wait_kwargs: dict[str, float] | None = None,
@@ -87,7 +86,7 @@ class Head(RobotJointComponent):
         Args:
             joint_pos: Joint positions as either:
                 - List of joint values [j1, j2]
-                - Numpy array with shape (2,), in radians
+                - Numpy array with shape (3,), in radians
                 - Dictionary mapping joint names to position values
             relative: If True, the joint positions are relative to the current position.
             wait_time: Time to wait after sending command in seconds. If 0, returns
@@ -110,8 +109,8 @@ class Head(RobotJointComponent):
 
     def set_joint_pos_vel(
         self,
-        joint_pos: Float[np.ndarray, "2"] | list[float] | dict[str, float],
-        joint_vel: Float[np.ndarray, "2"]
+        joint_pos: Float[np.ndarray, "3"] | list[float] | dict[str, float],
+        joint_vel: Float[np.ndarray, "3"]
         | list[float]
         | dict[str, float]
         | float
@@ -126,11 +125,11 @@ class Head(RobotJointComponent):
         Args:
             joint_pos: Joint positions as either:
                 - List of joint values [j1, j2]
-                - Numpy array with shape (2,), in radians
+                - Numpy array with shape (3,), in radians
                 - Dictionary mapping joint names to position values
             joint_vel: Optional joint velocities as either:
                 - List of joint values [v1, v2]
-                - Numpy array with shape (2,), in rad/s
+                - Numpy array with shape (3,), in rad/s
                 - Dictionary mapping joint names to velocity values
                 - Single float value to be applied to all joints
                 If None, velocities are calculated based on default velocity setting.
@@ -155,10 +154,19 @@ class Head(RobotJointComponent):
         joint_pos = self._convert_joint_cmd_to_array(joint_pos)
         joint_vel = self._process_joint_velocities(joint_vel, joint_pos)
 
+        if self._joint_limit is not None:
+            joint_pos = np.clip(
+                joint_pos, self._joint_limit[:, 0], self._joint_limit[:, 1]
+            )
+        if self._joint_vel_limit is not None:
+            joint_vel = np.clip(
+                joint_vel, -self._joint_vel_limit, self._joint_vel_limit
+            )
+
         # Create and send control message
-        control_msg = dexcontrol_msg_pb2.HeadCommand()
-        control_msg.joint_pos.extend(joint_pos.tolist())
-        control_msg.joint_vel.extend(joint_vel.tolist())
+        control_msg = dexcontrol_msg_pb2.MotorPosVelCommand()
+        control_msg.pos.extend(joint_pos.tolist())
+        control_msg.vel.extend(joint_vel.tolist())
         self._publish_control(control_msg)
 
         # Wait if specified
@@ -194,15 +202,16 @@ class Head(RobotJointComponent):
 
         for reply in replies:
             if reply.ok is not None and reply.ok.payload is not None:
-                logger.info(reply.ok.payload.to_string())
+                # TODO: handle the reply message of head mode
+                pass
         time.sleep(0.5)
 
-    def get_joint_limit(self) -> Float[np.ndarray, "3 2"]:
+    def get_joint_limit(self) -> Float[np.ndarray, "3 2"] | None:
         """Get the joint limits of the head.
 
         Returns:
             Array of joint limits with shape (3, 2), where the first column contains
-            lower limits and the second column contains upper limits.
+            lower limits and the second column contains upper limits, or None if not configured.
         """
         return self._joint_limit
 
@@ -229,7 +238,7 @@ class Head(RobotJointComponent):
 
     def _process_joint_velocities(
         self,
-        joint_vel: Float[np.ndarray, "2"]
+        joint_vel: Float[np.ndarray, "3"]
         | list[float]
         | dict[str, float]
         | float
@@ -251,14 +260,18 @@ class Head(RobotJointComponent):
             motion_norm = np.linalg.norm(joint_motion)
 
             if motion_norm < 1e-6:  # Avoid division by zero
-                return np.zeros(2, dtype=np.float32)
+                return np.zeros(3, dtype=np.float32)
 
-            # Scale velocities by default velocity
-            return (joint_motion / motion_norm) * self.default_vel
+            default_vel = (
+                2.5 if self._joint_vel_limit is None else np.min(self._joint_vel_limit)
+            )
+            return (joint_motion / motion_norm) * default_vel
 
         if isinstance(joint_vel, (int, float)):
             # Single value - apply to all joints
-            return np.full(2, joint_vel, dtype=np.float32)
+            return np.full(3, joint_vel, dtype=np.float32)
 
-        # Convert to array and clip to max velocity
-        return self._convert_joint_cmd_to_array(joint_vel, clip_value=self.max_vel)
+        # Convert to array and clip to velocity limits
+        return self._convert_joint_cmd_to_array(
+            joint_vel, clip_value=self._joint_vel_limit
+        )

dexcontrol/core/misc.py

@@ -11,13 +11,14 @@
 """Miscellaneous robot components module.
 
 This module provides classes for various auxiliary robot components such as Battery,
-EStop (emergency stop), and UltraSonicSensor.
+EStop (emergency stop), ServerLogSubscriber, and UltraSonicSensor.
 """
 
+import json
 import os
 import threading
 import time
-from typing import TypeVar
+from typing import Any, TypeVar, cast
 
 import zenoh
 from google.protobuf.message import Message
@@ -95,6 +96,14 @@ class Battery(RobotComponent):
                 - power: Power consumption in Watts
         """
         state = self._get_state()
+        if state is None:
+            return {
+                "percentage": 0.0,
+                "temperature": 0.0,
+                "current": 0.0,
+                "voltage": 0.0,
+                "power": 0.0,
+            }
         return {
             "percentage": float(state.percentage),
             "temperature": float(state.temperature),
@@ -111,6 +120,11 @@ class Battery(RobotComponent):
         table.add_column("Parameter", style="cyan")
         table.add_column("Value")
 
+        if state is None:
+            table.add_row("Status", "[red]No battery data available[/]")
+            self._console.print(table)
+            return
+
         battery_style = self._get_battery_level_style(state.percentage)
         table.add_row("Battery Level", f"[{battery_style}]{state.percentage:.1f}%[/]")
 
@@ -120,7 +134,7 @@ class Battery(RobotComponent):
         power = state.current * state.voltage
         power_style = self._get_power_style(power)
         table.add_row(
-            "Power",
+            "Power Consumption",
             f"[{power_style}]{power:.2f}W[/] ([blue]{state.current:.2f}A[/] "
             f"× [blue]{state.voltage:.2f}V[/])",
         )
@@ -213,10 +227,14 @@ class EStop(RobotComponent):
             configs: EStop configuration containing subscription topics.
             zenoh_session: Active Zenoh session for communication.
         """
+        self._enabled = configs.enabled
         super().__init__(
             configs.state_sub_topic, zenoh_session, dexcontrol_msg_pb2.EStopState
         )
         self._estop_query_name = configs.estop_query_name
+        if not self._enabled:
+            logger.warning("EStop monitoring is DISABLED via configuration")
+            return
         self._shutdown_event = threading.Event()
         self._monitor_thread = threading.Thread(target=self._estop_monitor, daemon=True)
         self._monitor_thread.start()
@@ -264,18 +282,40 @@ class EStop(RobotComponent):
                 - software_estop_enabled: Software EStop enabled
         """
         state = self._get_state()
+        state = cast(dexcontrol_msg_pb2.EStopState, state)
+        if state is None:
+            return {
+                "button_pressed": False,
+                "software_estop_enabled": False,
+            }
+        button_pressed = (
+            state.left_button_pressed
+            or state.right_button_pressed
+            or state.waist_button_pressed
+            or state.wireless_button_pressed
+        )
         return {
-            "button_pressed": state.button_pressed,
+            "button_pressed": button_pressed,
             "software_estop_enabled": state.software_estop_enabled,
         }
 
     def is_button_pressed(self) -> bool:
         """Checks if the EStop button is pressed."""
-        return self._get_state().button_pressed
+        state = self._get_state()
+        state = cast(dexcontrol_msg_pb2.EStopState, state)
+        button_pressed = (
+            state.left_button_pressed
+            or state.right_button_pressed
+            or state.waist_button_pressed
+            or state.wireless_button_pressed
+        )
+        return button_pressed
 
     def is_software_estop_enabled(self) -> bool:
         """Checks if the software EStop is enabled."""
-        return self._get_state().software_estop_enabled
+        state = self._get_state()
+        state = cast(dexcontrol_msg_pb2.EStopState, state)
+        return state.software_estop_enabled
 
     def activate(self) -> None:
         """Activates the software emergency stop (E-Stop)."""
@@ -291,30 +331,29 @@ class EStop(RobotComponent):
 
     def shutdown(self) -> None:
         """Shuts down the EStop component and stops monitoring thread."""
-        self._shutdown_event.set()
-        if self._monitor_thread and self._monitor_thread.is_alive():
-            self._monitor_thread.join(timeout=2.0)  # Extended timeout
-            if self._monitor_thread.is_alive():
-                logger.warning("EStop monitor thread did not terminate cleanly")
+        if self._enabled:
+            self._shutdown_event.set()
+            if self._monitor_thread and self._monitor_thread.is_alive():
+                self._monitor_thread.join(timeout=2.0)  # Extended timeout
+                if self._monitor_thread.is_alive():
+                    logger.warning("EStop monitor thread did not terminate cleanly")
         super().shutdown()
 
     def show(self) -> None:
         """Displays the current EStop status as a formatted table with color indicators."""
-        state = self._get_state()
-
         table = Table(title="E-Stop Status")
         table.add_column("Parameter", style="cyan")
         table.add_column("Value")
 
-        button_style = "bold red" if state.button_pressed else "bold dark_green"
-        table.add_row("Button Pressed", f"[{button_style}]{state.button_pressed}[/]")
+        button_pressed = self.is_button_pressed()
+        button_style = "bold red" if button_pressed else "bold dark_green"
+        table.add_row("Button Pressed", f"[{button_style}]{button_pressed}[/]")
 
-        software_style = (
-            "bold red" if state.software_estop_enabled else "bold dark_green"
-        )
+        if_software_estop_enabled = self.is_software_estop_enabled()
+        software_style = "bold red" if if_software_estop_enabled else "bold dark_green"
         table.add_row(
             "Software E-Stop Enabled",
-            f"[{software_style}]{state.software_estop_enabled}[/]",
+            f"[{software_style}]{if_software_estop_enabled}[/]",
         )
 
         console = Console()
@@ -387,9 +426,12 @@ class Heartbeat:
         Returns:
             Decoded heartbeat timestamp value in seconds.
         """
-        timestamp = int.from_bytes(data.to_bytes(), byteorder="little")
-        # convert it from microseconds to seconds
-        return timestamp / 1000000.0
+        # Decode UTF-8 string and convert to float
+        # Publisher sends: str(self.timecount_now).encode() in milliseconds
+        timestamp_str = data.to_bytes().decode("utf-8")
+        timestamp_ms = float(timestamp_str)
+        # Convert from milliseconds to seconds
+        return timestamp_ms / 1000.0
 
     def _heartbeat_monitor(self) -> None:
         """Background thread that continuously monitors heartbeat signal."""
@@ -527,6 +569,52 @@ class Heartbeat:
             return False
         return self._subscriber.is_active()
 
+    @staticmethod
+    def _format_uptime(seconds: float) -> str:
+        """Convert seconds to human-readable uptime format with high resolution.
+
+        Args:
+            seconds: Total seconds of uptime.
+
+        Returns:
+            Human-readable string like "1mo 2d 3h 45m 12s 345ms".
+        """
+        # Calculate months (assuming 30 days per month)
+        months = int(seconds // (86400 * 30))
+        remaining = seconds % (86400 * 30)
+
+        # Calculate days
+        days = int(remaining // 86400)
+        remaining = remaining % 86400
+
+        # Calculate hours
+        hours = int(remaining // 3600)
+        remaining = remaining % 3600
+
+        # Calculate minutes
+        minutes = int(remaining // 60)
+        remaining = remaining % 60
+
+        # Calculate seconds and milliseconds
+        secs = int(remaining)
+        milliseconds = int((remaining - secs) * 1000)
+
+        parts = []
+        if months > 0:
+            parts.append(f"{months}mo")
+        if days > 0:
+            parts.append(f"{days}d")
+        if hours > 0:
+            parts.append(f"{hours}h")
+        if minutes > 0:
+            parts.append(f"{minutes}m")
+        if secs > 0:
+            parts.append(f"{secs}s")
+        if milliseconds > 0 or not parts:
+            parts.append(f"{milliseconds}ms")
+
+        return " ".join(parts)
+
     def shutdown(self) -> None:
         """Shuts down the heartbeat monitor and stops monitoring thread."""
         if not self._enabled:
@@ -567,12 +655,13 @@ class Heartbeat:
             active_style = "bold dark_green" if status["is_active"] else "bold red"
             table.add_row("Signal Active", f"[{active_style}]{status['is_active']}[/]")
 
-        # Last heartbeat value
+        # Last heartbeat value (robot uptime)
         last_value = status["last_value"]
         if last_value is not None:
-            table.add_row("Last Value", f"[blue]{last_value:.6f}s[/]")
+            uptime_str = self._format_uptime(last_value)
+            table.add_row("Robot Driver Uptime", f"[blue]{uptime_str}[/]")
         else:
-            table.add_row("Last Value", "[red]No data[/]")
+            table.add_row("Robot Driver Uptime", "[red]No data[/]")
 
         # Time since last heartbeat
         time_since = status["time_since_last"]
@@ -590,3 +679,145 @@ class Heartbeat:
 
         console = Console()
         console.print(table)
+
+
+class ServerLogSubscriber:
+    """Server log subscriber that monitors and displays server log messages.
+
+    This class subscribes to the "logs" topic and handles incoming log messages
+    from the robot server. It provides formatted display of server logs with
+    proper error handling and validation.
+
+    The server sends log information via the "logs" topic as JSON with format:
+    {"timestamp": "ISO8601", "message": "text", "source": "robot_server"}
+
+    Attributes:
+        _zenoh_session: Zenoh session for communication.
+        _log_subscriber: Zenoh subscriber for log messages.
+    """
+
+    def __init__(self, zenoh_session: zenoh.Session) -> None:
+        """Initialize the ServerLogSubscriber.
+
+        Args:
+            zenoh_session: Active Zenoh session for communication.
+        """
+        self._zenoh_session = zenoh_session
+        self._log_subscriber = None
+        self._initialize()
+
+    def _initialize(self) -> None:
+        """Initialize the log subscriber with error handling."""
+
+        def log_handler(sample):
+            """Handle incoming log messages from the server."""
+            if not self._is_valid_log_sample(sample):
+                return
+
+            try:
+                log_data = self._parse_log_payload(sample.payload)
+                if log_data:
+                    self._display_server_log(log_data)
+            except Exception as e:
+                logger.warning(f"Failed to process server log: {e}")
+
+        try:
+            # Subscribe to server logs topic
+            self._log_subscriber = self._zenoh_session.declare_subscriber(
+                "logs", log_handler
+            )
+            logger.debug("Server log subscriber initialized")
+        except Exception as e:
+            logger.warning(f"Failed to initialize server log subscriber: {e}")
+            self._log_subscriber = None
+
+    def _is_valid_log_sample(self, sample) -> bool:
+        """Check if log sample is valid.
+
+        Args:
+            sample: Zenoh sample to validate.
+
+        Returns:
+            True if sample is valid, False otherwise.
+        """
+        if sample is None or sample.payload is None:
+            logger.debug("Received empty log sample")
+            return False
+        return True
+
+    def _parse_log_payload(self, payload) -> dict[str, str] | None:
+        """Parse log payload and return structured data.
+
+        Args:
+            payload: Raw payload from Zenoh sample.
+
+        Returns:
+            Parsed log data as dictionary or None if parsing fails.
+        """
+        try:
+            payload_str = payload.to_bytes().decode("utf-8")
+            if not payload_str.strip():
+                logger.debug("Received empty log payload")
+                return None
+
+            log_data = json.loads(payload_str)
+
+            if not isinstance(log_data, dict):
+                logger.warning(
+                    f"Invalid log data format: expected dict, got {type(log_data)}"
+                )
+                return None
+
+            return log_data
+        except (json.JSONDecodeError, UnicodeDecodeError) as e:
+            logger.warning(f"Failed to parse log payload: {e}")
+            return None
+
+    def _display_server_log(self, log_data: dict[str, str]) -> None:
+        """Display formatted server log message.
+
+        Args:
+            log_data: Parsed log data dictionary.
+        """
+        # Extract log information with safe defaults
+        timestamp = log_data.get("timestamp", "")
+        message = log_data.get("message", "")
+        source = log_data.get("source", "unknown")
+
+        # Validate critical fields
+        if not message:
+            logger.debug("Received log with empty message")
+            return
+
+        # Log the server message with clear identification
+        logger.info(f"[SERVER_LOG] [{timestamp}] [{source}] {message}")
+
+    def is_active(self) -> bool:
+        """Check if the log subscriber is active.
+
+        Returns:
+            True if subscriber is active, False otherwise.
+        """
+        return self._log_subscriber is not None
+
+    def shutdown(self) -> None:
+        """Clean up the log subscriber and release resources."""
+        if self._log_subscriber is not None:
+            try:
+                self._log_subscriber.undeclare()
+                self._log_subscriber = None
+            except Exception as e:
+                logger.error(f"Error cleaning up log subscriber: {e}")
+
+    def get_status(self) -> dict[str, Any]:
+        """Get the current status of the log subscriber.
+
+        Returns:
+            Dictionary containing status information:
+                - is_active: Whether the subscriber is active
+                - topic: The topic being subscribed to
+        """
+        return {
+            "is_active": self.is_active(),
+            "topic": "logs",
+        }