lcm-cli 0.1.0__py3-none-any.whl

lcm_tools/commands/topic_list.py

@@ -0,0 +1,69 @@
+"""``lcm topic list`` — discover and list active LCM channels.
+
+Joins the LCM multicast group, listens for a configurable duration,
+and prints a table of all observed channels with their message counts,
+total sizes, and publisher addresses.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from lcm_tools.core.discovery import ChannelDiscovery
+from lcm_tools.display.stats_display import build_channel_table
+from lcm_tools.listener import run_listener
+from lcm_tools.protocol import DEFAULT_MC_ADDR, DEFAULT_MC_PORT
+
+_console = Console()
+
+
+def list_channels(
+    duration: float = typer.Option(
+        5.0,
+        "--duration",
+        "-d",
+        help="How many seconds to listen for channel activity.",
+    ),
+    lcm_url: str = typer.Option(
+        DEFAULT_MC_ADDR,
+        "--lcm-url",
+        help="LCM multicast address.",
+    ),
+    lcm_port: int = typer.Option(
+        DEFAULT_MC_PORT,
+        "--lcm-port",
+        help="LCM multicast port.",
+    ),
+) -> None:
+    """List active LCM channels (like ``ros2 topic list``)."""
+    discovery = ChannelDiscovery()
+
+    _console.print(
+        f"[bold]Discovering channels for {duration}s ...[/bold]  "
+        f"(multicast: {lcm_url}:{lcm_port})"
+    )
+
+    stop_event = run_listener(discovery.on_packet, mc_addr=lcm_url, mc_port=lcm_port)
+
+    try:
+        time.sleep(duration)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        stop_event.set()
+
+    channels = discovery.get_active_channels(stale_after=duration + 2.0)
+    if not channels:
+        _console.print("[yellow]No active channels found.[/yellow]")
+        _console.print(
+            "[dim]Hint: make sure a publisher is running and your "
+            "multicast routing is configured.[/dim]"
+        )
+        raise typer.Exit(code=0)
+
+    _console.print(build_channel_table(channels))

lcm_tools/commands/topic_stats.py

@@ -0,0 +1,87 @@
+"""``lcm topic stats`` — real-time per-channel statistics monitor.
+
+Joins the LCM multicast group and displays a continuously updating
+table of message frequency, bandwidth, message sizes, and cumulative
+data transfer for each observed channel.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.live import Live
+
+from lcm_tools.core.stats import StatsCollector
+from lcm_tools.display.stats_display import build_stats_table
+from lcm_tools.listener import run_listener
+from lcm_tools.protocol import DEFAULT_MC_ADDR, DEFAULT_MC_PORT
+
+_console = Console()
+
+
+def stats(
+    channel: Optional[str] = typer.Argument(
+        None,
+        help="Only monitor channels whose name contains this string. "
+        "Leave empty to monitor all channels.",
+    ),
+    duration: Optional[float] = typer.Option(
+        None,
+        "--duration",
+        "-d",
+        help="Stop after this many seconds. "
+        "Default: run until Ctrl+C.",
+    ),
+    lcm_url: str = typer.Option(
+        DEFAULT_MC_ADDR,
+        "--lcm-url",
+        help="LCM multicast address.",
+    ),
+    lcm_port: int = typer.Option(
+        DEFAULT_MC_PORT,
+        "--lcm-port",
+        help="LCM multicast port.",
+    ),
+) -> None:
+    """Show real-time channel statistics (like ``ros2 topic hz``)."""
+    collector = StatsCollector(channel_filter=channel)
+
+    filter_label = f"matching '{channel}'" if channel else "all"
+    _console.print(
+        f"[bold]Collecting stats for {filter_label} channels ...[/bold]  "
+        f"(multicast: {lcm_url}:{lcm_port}, Ctrl+C to stop)"
+    )
+
+    stop_event = run_listener(
+        collector.on_packet,
+        mc_addr=lcm_url,
+        mc_port=lcm_port,
+    )
+
+    start_time = time.monotonic()
+
+    try:
+        with Live(
+            build_stats_table(collector.snapshot()),
+            console=_console,
+            refresh_per_second=2,
+        ) as live:
+            while True:
+                time.sleep(0.5)
+                live.update(build_stats_table(collector.snapshot()))
+
+                if duration and (time.monotonic() - start_time) >= duration:
+                    break
+
+    except KeyboardInterrupt:
+        pass
+    finally:
+        stop_event.set()
+
+    # Print final snapshot
+    _console.print("\n[bold]Final Statistics:[/bold]")
+    _console.print(build_stats_table(collector.snapshot()))

lcm_tools/core/__init__.py

@@ -0,0 +1 @@
+"""LCM core modules package."""

lcm_tools/core/discovery.py

@@ -0,0 +1,135 @@
+"""Channel and node discovery by sniffing LCM multicast traffic.
+
+LCM has no centralized registry or daemon, so there is no built-in
+mechanism to discover active channels or publishers.  This module
+implements passive discovery by listening to all multicast traffic
+and recording metadata about each observed channel and sender.
+
+Nodes are identified by their UDP source address (IP:port), since
+LCM does not have a native "node name" concept like ROS2.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set, Tuple
+
+from lcm_tools.protocol import PacketInfo, extract_fingerprint
+
+
+@dataclass
+class ChannelInfo:
+    """Metadata about a single observed LCM channel."""
+
+    name: str
+    first_seen: float = 0.0
+    last_seen: float = 0.0
+    msg_count: int = 0
+    total_bytes: int = 0
+    fingerprint: Optional[int] = None
+    publishers: Set[str] = field(default_factory=set)
+
+    @property
+    def avg_msg_size(self) -> float:
+        return self.total_bytes / self.msg_count if self.msg_count > 0 else 0.0
+
+
+@dataclass
+class NodeInfo:
+    """A publisher node identified by its UDP source address."""
+
+    address: str  # "ip:port"
+    channels: Set[str] = field(default_factory=set)
+    msg_count: int = 0
+    total_bytes: int = 0
+    first_seen: float = 0.0
+    last_seen: float = 0.0
+
+
+class ChannelDiscovery:
+    """Passive discovery of LCM channels and publisher nodes.
+
+    Thread-safe: can be fed packets from a listener thread while
+    being queried from the main thread.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._channels: Dict[str, ChannelInfo] = {}
+        self._nodes: Dict[str, NodeInfo] = {}  # key = "ip:port"
+
+    def on_packet(self, pkt: PacketInfo) -> None:
+        """Process a received LCM packet for discovery purposes."""
+        now = time.time()
+        sender_key = f"{pkt.sender_addr[0]}:{pkt.sender_addr[1]}"
+
+        with self._lock:
+            # Update node info
+            if sender_key not in self._nodes:
+                self._nodes[sender_key] = NodeInfo(
+                    address=sender_key, first_seen=now
+                )
+            node = self._nodes[sender_key]
+            node.msg_count += 1
+            node.total_bytes += pkt.packet_size
+            node.last_seen = now
+
+            # Only process packets that have a channel (skip mid-fragments)
+            if not pkt.has_channel:
+                return
+
+            channel = pkt.channel
+            assert channel is not None
+            node.channels.add(channel)
+
+            # Update channel info
+            if channel not in self._channels:
+                self._channels[channel] = ChannelInfo(
+                    name=channel, first_seen=now
+                )
+            ch_info = self._channels[channel]
+            ch_info.last_seen = now
+            ch_info.msg_count += 1
+            ch_info.total_bytes += pkt.packet_size
+            ch_info.publishers.add(sender_key)
+
+            # Try to extract fingerprint from first message
+            if ch_info.fingerprint is None and pkt.payload:
+                fp = extract_fingerprint(pkt.payload)
+                if fp is not None:
+                    ch_info.fingerprint = fp
+
+    def get_active_channels(
+        self, stale_after: float = 10.0
+    ) -> List[ChannelInfo]:
+        """Return channels that have been active within *stale_after* seconds."""
+        now = time.time()
+        with self._lock:
+            return [
+                ch
+                for ch in sorted(self._channels.values(), key=lambda c: c.name)
+                if now - ch.last_seen < stale_after
+            ]
+
+    def get_all_channels(self) -> List[ChannelInfo]:
+        """Return all ever-observed channels."""
+        with self._lock:
+            return sorted(self._channels.values(), key=lambda c: c.name)
+
+    def get_nodes(self, stale_after: float = 10.0) -> List[NodeInfo]:
+        """Return nodes that have been active within *stale_after* seconds."""
+        now = time.time()
+        with self._lock:
+            return [
+                node
+                for node in sorted(self._nodes.values(), key=lambda n: n.address)
+                if now - node.last_seen < stale_after
+            ]
+
+    def get_all_nodes(self) -> List[NodeInfo]:
+        """Return all ever-observed nodes."""
+        with self._lock:
+            return sorted(self._nodes.values(), key=lambda n: n.address)