rosight 0.1.0__py3-none-any.whl

rosight/__init__.py

@@ -0,0 +1,5 @@
+"""Rosight — a lazygit-inspired terminal UI for ROS 2."""
+
+from rosight.version import __version__
+
+__all__ = ["__version__"]

rosight/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m rosight`` to launch the TUI."""
+
+from rosight.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rosight/app.py

@@ -0,0 +1,277 @@
+"""Top-level Textual application.
+
+Holds the :class:`RosBackend`, the panel registry, and the global key
+bindings. Each panel is implemented as a self-contained widget under
+``rosight.widgets`` and registered here.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.reactive import reactive
+from textual.widgets import Footer, Header, TabbedContent, TabPane
+
+from rosight.config import Config, load_user_state, save_user_state
+from rosight.ros.backend import RosBackend, RosUnavailable
+from rosight.widgets.actions_panel import ActionsPanel
+from rosight.widgets.bags_panel import BagsPanel
+from rosight.widgets.command_palette import CommandPalette
+from rosight.widgets.help_screen import HelpScreen
+from rosight.widgets.interfaces_panel import InterfacesPanel
+from rosight.widgets.nodes_panel import NodesPanel
+from rosight.widgets.params_panel import ParamsPanel
+from rosight.widgets.plot_panel import PlotPanel
+from rosight.widgets.services_panel import ServicesPanel
+from rosight.widgets.status_bar import StatusBar
+from rosight.widgets.tf_panel import TfPanel
+from rosight.widgets.topics_panel import TopicsPanel
+
+log = logging.getLogger(__name__)
+
+
+class RosightApp(App[int]):
+    """Main Textual application."""
+
+    CSS_PATH = "app.tcss"
+    TITLE = "Rosight"
+    SUB_TITLE = "ROS 2 TUI"
+
+    BINDINGS = [
+        Binding("q,ctrl+c", "quit", "Quit"),
+        Binding("?", "help", "Help"),
+        Binding(":", "command", "Command"),
+        Binding("r", "refresh", "Refresh"),
+        Binding("1", "tab('topics')", "Messages", show=False),
+        Binding("2", "tab('nodes')", "Nodes", show=False),
+        Binding("3", "tab('services')", "Services", show=False),
+        Binding("4", "tab('actions')", "Actions", show=False),
+        Binding("5", "tab('params')", "Params", show=False),
+        Binding("6", "tab('plot')", "Plot", show=False),
+        Binding("7", "tab('tf')", "TF", show=False),
+        Binding("8", "tab('bags')", "Bags", show=False),
+        Binding("9", "tab('interfaces')", "Interfaces", show=False),
+    ]
+
+    backend_ok: reactive[bool] = reactive(False)
+
+    def __init__(
+        self,
+        config: Config | None = None,
+        *,
+        ros: RosBackend | None = None,
+    ) -> None:
+        super().__init__()
+        self.config: Config = config or Config()
+        self._owns_ros = ros is None
+        self.ros: RosBackend = ros or RosBackend(
+            domain_id=self.config.ros.domain_id,
+            default_depth=self.config.ros.queue_depth,
+        )
+
+    # --------------- compose / lifecycle ---------------
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        with TabbedContent(initial="topics", id="main-tabs"):
+            with TabPane("Messages", id="topics"):
+                yield TopicsPanel()
+            with TabPane("Nodes", id="nodes"):
+                yield NodesPanel()
+            with TabPane("Services", id="services"):
+                yield ServicesPanel()
+            with TabPane("Actions", id="actions"):
+                yield ActionsPanel()
+            with TabPane("Params", id="params"):
+                yield ParamsPanel()
+            with TabPane("Plot", id="plot"):
+                yield PlotPanel()
+            with TabPane("TF", id="tf"):
+                yield TfPanel()
+            with TabPane("Bags", id="bags"):
+                yield BagsPanel()
+            with TabPane("Interfaces", id="interfaces"):
+                yield InterfacesPanel()
+        with Vertical(id="bottom-bar"):
+            yield StatusBar(id="status")
+            yield Footer()
+
+    async def on_mount(self) -> None:
+        # Restore the theme the user last picked via Ctrl+P → Change theme.
+        # Failures are silent: if the state file is missing or names a theme
+        # Textual no longer ships, we just stay on the default.
+        try:
+            state = load_user_state()
+            saved = state.get("theme")
+            if isinstance(saved, str) and self.get_theme(saved) is not None:
+                self.theme = saved
+        except Exception:
+            log.debug("could not restore theme", exc_info=True)
+
+        # Persist on every subsequent theme change.
+        try:
+            self.theme_changed_signal.subscribe(self, self._on_theme_changed)
+        except Exception:
+            log.debug("could not subscribe to theme_changed_signal", exc_info=True)
+
+        # Try to start the ROS backend; downgrade to a banner on failure.
+        if self._owns_ros:
+            try:
+                self.ros.start()
+                self.backend_ok = True
+            except RosUnavailable as e:
+                self.backend_ok = False
+                self.notify(str(e), title="ROS 2 unavailable", severity="warning", timeout=10)
+            except Exception:
+                log.exception("ROS backend failed to start")
+                self.backend_ok = False
+                self.notify(
+                    "ROS backend failed to start — see logs.",
+                    title="error",
+                    severity="error",
+                )
+        else:
+            self.backend_ok = self.ros.started
+
+        self.set_interval(self.config.ui.discovery_period, self._refresh_status)
+
+    def _on_theme_changed(self, theme) -> None:
+        """Persist the chosen theme so it survives restarts."""
+        try:
+            name = getattr(theme, "name", None) or self.theme
+            if not isinstance(name, str):
+                return
+            state = load_user_state()
+            state["theme"] = name
+            save_user_state(state)
+        except Exception:
+            log.debug("could not persist theme", exc_info=True)
+
+    async def on_unmount(self) -> None:
+        if self._owns_ros:
+            try:
+                self.ros.stop()
+            except Exception:
+                log.exception("ros stop failed")
+
+    # --------------- actions ---------------
+
+    def action_help(self) -> None:
+        self.push_screen(HelpScreen())
+
+    def action_command(self) -> None:
+        self.push_screen(CommandPalette(), self._on_command_submitted)
+
+    def action_refresh(self) -> None:
+        self.push_status("refresh requested")
+        # Each panel polls on a timer; nothing else needed.
+
+    def action_tab(self, tab_id: str) -> None:
+        try:
+            self.query_one(TabbedContent).active = tab_id
+        except Exception:
+            pass
+
+    # --------------- helpers exposed to panels ---------------
+
+    def push_status(self, msg: str) -> None:
+        try:
+            bar = self.query_one("#status", StatusBar)
+            bar.message = msg
+        except Exception:
+            log.info(msg)
+        log.info("status: %s", msg)
+
+    def add_plot_series(self, topic: str, field_path: str) -> None:
+        """Forward field-selected events from the topics panel to plot."""
+        try:
+            panel = self.query_one(PlotPanel)
+            panel.add_series(topic, field_path)
+            self.action_tab("plot")
+        except Exception:
+            log.exception("could not add plot series")
+
+    # --------------- background tickers ---------------
+
+    def _refresh_status(self) -> None:
+        bar = self.query_one("#status", StatusBar)
+        bar.backend_ok = self.backend_ok and self.ros.started
+        bar.domain_id = self.ros.domain_id
+        if not self.ros.started:
+            return
+        try:
+            bar.topics = len(self.ros.list_topics())
+            bar.nodes = len(self.ros.list_nodes())
+            bar.services = len(self.ros.list_services())
+            bar.actions = len(self.ros.list_actions())
+            bar.subs = len(self.ros.active_subscriptions())
+        except Exception:
+            log.debug("status refresh failed", exc_info=True)
+
+    # --------------- command palette ---------------
+
+    def _on_command_submitted(self, raw: str | None) -> None:
+        if not raw:
+            return
+        parts = raw.strip().split()
+        cmd, args = parts[0], parts[1:]
+        if cmd in ("q", "quit", "exit"):
+            self.exit(0)
+        elif cmd == "topic" and args:
+            self.action_tab("topics")
+            try:
+                tp = self.query_one(TopicsPanel)
+                tp.filter_text = args[0]
+            except Exception:
+                pass
+        elif cmd == "node" and args:
+            self.action_tab("nodes")
+        elif cmd == "param" and len(args) >= 1:
+            self.action_tab("params")
+        elif cmd == "plot" and len(args) >= 2:
+            topic, path = args[0], args[1]
+            self.add_plot_series(topic, path)
+        elif cmd == "record":
+            self.action_tab("bags")
+        elif cmd == "help":
+            self.action_help()
+        elif cmd == "domain" and args:
+            self._switch_domain(args[0])
+        else:
+            self.push_status(f"unknown command: {raw}")
+
+    def _switch_domain(self, raw_id: str) -> None:
+        """Re-init the rclpy backend on a new ROS_DOMAIN_ID.
+
+        Tears down the executor + node + context and reconnects on the
+        target domain. Any subscriptions are lost — panels rediscover and
+        the user can re-subscribe.
+        """
+        try:
+            new_id = int(raw_id)
+        except ValueError:
+            self.notify(f"invalid domain id: {raw_id!r}", severity="warning", title="Domain")
+            return
+        if not 0 <= new_id <= 232:  # ROS_DOMAIN_ID range
+            self.notify(
+                f"domain id {new_id} outside valid range 0..232",
+                severity="warning",
+                title="Domain",
+            )
+            return
+        try:
+            self.ros.set_domain_id(new_id)
+            self.backend_ok = self.ros.started
+            self.notify(
+                f"now on ROS_DOMAIN_ID={new_id}\n(subscriptions cleared)",
+                title="Domain",
+            )
+        except RosUnavailable as e:
+            self.backend_ok = False
+            self.notify(str(e), title="ROS 2 unavailable", severity="warning")
+        except Exception as e:
+            log.exception("set_domain_id failed")
+            self.notify(f"failed to switch domain: {e}", severity="error")

rosight/app.tcss

@@ -0,0 +1,70 @@
+/* rosight — Textual stylesheet */
+
+Screen {
+    background: $background;
+    color: $text;
+}
+
+Header {
+    dock: top;
+    height: 1;
+    background: $primary 30%;
+    color: $text;
+}
+
+#bottom-bar {
+    dock: bottom;
+    height: 2;
+    layout: vertical;
+}
+
+Footer {
+    dock: initial;
+    height: 1;
+    background: $primary 20%;
+    color: $text;
+}
+
+TabbedContent {
+    height: 1fr;
+}
+
+TabPane {
+    padding: 0;
+    height: 1fr;
+}
+
+DataTable > .datatable--header {
+    background: $primary 40%;
+    color: $text;
+    text-style: bold;
+}
+
+DataTable > .datatable--cursor {
+    background: $accent 35%;
+}
+
+Tree {
+    background: $surface;
+}
+
+Input {
+    background: $surface;
+    border: tall $primary 30%;
+}
+
+Input:focus {
+    border: tall $accent;
+}
+
+Static.dim {
+    color: $text-muted;
+}
+
+#detail-header {
+    text-style: bold;
+}
+
+ToastRack > Toast {
+    background: $primary 70%;
+}

rosight/cli.py

@@ -0,0 +1,87 @@
+"""Command-line entry point for ``rosight``."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from rosight.config import Config, config_path, load_config
+from rosight.version import __version__
+
+
+def _setup_logging(level: str, log_file: Path | None) -> None:
+    handlers: list[logging.Handler] = []
+    if log_file is not None:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        handlers.append(logging.FileHandler(log_file, encoding="utf-8"))
+    logging.basicConfig(
+        level=level.upper(),
+        format="%(asctime)s %(levelname)-7s %(name)s: %(message)s",
+        handlers=handlers or [logging.NullHandler()],
+    )
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        prog="rosight",
+        description="lazygit-style terminal UI for ROS 2",
+    )
+    p.add_argument(
+        "-c",
+        "--config",
+        type=Path,
+        help=f"path to config TOML (default: {config_path()})",
+    )
+    p.add_argument("--domain-id", type=int, help="override ROS_DOMAIN_ID")
+    p.add_argument("--node-name", default="rosight", help="rclpy node name")
+    p.add_argument(
+        "--log-level",
+        default="INFO",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+    )
+    p.add_argument(
+        "--log-file",
+        type=Path,
+        help="path to a log file (default: stderr suppressed)",
+    )
+    p.add_argument(
+        "--no-ros",
+        action="store_true",
+        help="skip ROS 2 initialisation (useful for UI-only debugging)",
+    )
+    p.add_argument("-V", "--version", action="version", version=f"rosight {__version__}")
+    return p.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    _setup_logging(args.log_level, args.log_file)
+
+    try:
+        cfg: Config = load_config(args.config)
+    except ValueError as e:
+        print(f"config error: {e}", file=sys.stderr)
+        return 2
+
+    if args.domain_id is not None:
+        from dataclasses import replace
+
+        cfg = replace(cfg, ros=replace(cfg.ros, domain_id=args.domain_id))
+
+    # Defer Textual import to keep --version fast.
+    from rosight.app import RosightApp
+    from rosight.ros.backend import RosBackend
+
+    ros = None
+    if args.no_ros:
+        ros = RosBackend(node_name=args.node_name, domain_id=cfg.ros.domain_id)
+        # leave it un-started; the app will downgrade gracefully.
+
+    app = RosightApp(config=cfg, ros=ros)
+    return app.run() or 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rosight/config.py

@@ -0,0 +1,153 @@
+"""User configuration loading.
+
+Configuration lives at ``$XDG_CONFIG_HOME/rosight/config.toml`` (falling back
+to ``~/.config/rosight/config.toml``). Missing files are not an error — the
+defaults are applied automatically.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+from typing import Any
+
+from platformdirs import user_config_dir
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+CONFIG_FILENAME = "config.toml"
+
+
+@dataclass(frozen=True, slots=True)
+class PlotConfig:
+    window_seconds: float = 30.0
+    max_points: int = 5_000
+    refresh_hz: float = 15.0
+    show_legend: bool = True
+
+
+@dataclass(frozen=True, slots=True)
+class StatsConfig:
+    window_seconds: float = 5.0
+    max_samples: int = 4096
+
+
+@dataclass(frozen=True, slots=True)
+class UIConfig:
+    theme: str = "rosight-dark"
+    refresh_hz: float = 10.0
+    discovery_period: float = 1.0  # how often to refresh topic/node lists
+    vim_keys: bool = True
+
+
+@dataclass(frozen=True, slots=True)
+class RosConfig:
+    domain_id: int | None = None  # None -> inherit ROS_DOMAIN_ID
+    qos_profile: str = "auto"  # auto | sensor_data | reliable | best_effort
+    queue_depth: int = 10
+
+
+@dataclass(frozen=True, slots=True)
+class Config:
+    ui: UIConfig = field(default_factory=UIConfig)
+    plot: PlotConfig = field(default_factory=PlotConfig)
+    stats: StatsConfig = field(default_factory=StatsConfig)
+    ros: RosConfig = field(default_factory=RosConfig)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Config:
+        """Build a Config from a parsed TOML dict, ignoring unknown keys."""
+        return cls(
+            ui=_merge(UIConfig(), data.get("ui", {})),
+            plot=_merge(PlotConfig(), data.get("plot", {})),
+            stats=_merge(StatsConfig(), data.get("stats", {})),
+            ros=_merge(RosConfig(), data.get("ros", {})),
+        )
+
+
+def _merge(default: Any, overrides: dict[str, Any]) -> Any:
+    """Replace dataclass fields with values from a mapping; ignore unknowns."""
+    if not overrides:
+        return default
+    valid = {f.name for f in default.__dataclass_fields__.values()}  # type: ignore[attr-defined]
+    filtered = {k: v for k, v in overrides.items() if k in valid}
+    return replace(default, **filtered)
+
+
+def config_path() -> Path:
+    """Return the resolved config file path (does not require it to exist)."""
+    base = os.environ.get("ROSIGHT_CONFIG")
+    if base:
+        return Path(base).expanduser()
+    return Path(user_config_dir("rosight")) / CONFIG_FILENAME
+
+
+def load_config(path: Path | None = None) -> Config:
+    """Load configuration from ``path`` (or the default location).
+
+    Returns defaults if the file does not exist. Raises ``ValueError`` only
+    if the file exists but is malformed.
+    """
+    p = path or config_path()
+    if not p.exists():
+        return Config()
+    try:
+        with p.open("rb") as f:
+            data = tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        raise ValueError(f"Invalid TOML in {p}: {e}") from e
+    return Config.from_dict(data)
+
+
+# ---------------------------------------------------------------------------
+# Runtime user state (theme choice, ...). Kept separate from ``config.toml``
+# so the user's hand-written config is never rewritten by the app.
+# ---------------------------------------------------------------------------
+
+STATE_FILENAME = "state.toml"
+
+
+def state_path() -> Path:
+    return Path(user_config_dir("rosight")) / STATE_FILENAME
+
+
+def load_user_state() -> dict[str, Any]:
+    """Return the persisted user-state dict (theme, etc.). Empty on miss."""
+    p = state_path()
+    if not p.exists():
+        return {}
+    try:
+        with p.open("rb") as f:
+            return tomllib.load(f)
+    except Exception:
+        return {}
+
+
+def save_user_state(state: dict[str, Any]) -> None:
+    """Atomically replace the state file with ``state``.
+
+    Best-effort: failure to write (read-only FS, etc.) is silently swallowed
+    so we never crash the app over a cosmetic preference.
+    """
+    p = state_path()
+    try:
+        p.parent.mkdir(parents=True, exist_ok=True)
+        tmp = p.with_suffix(p.suffix + ".tmp")
+        with tmp.open("w", encoding="utf-8") as f:
+            for k, v in state.items():
+                if isinstance(v, str):
+                    escaped = v.replace("\\", "\\\\").replace('"', '\\"')
+                    f.write(f'{k} = "{escaped}"\n')
+                elif isinstance(v, bool):
+                    f.write(f"{k} = {'true' if v else 'false'}\n")
+                elif isinstance(v, (int, float)):
+                    f.write(f"{k} = {v}\n")
+        tmp.replace(p)
+    except Exception:
+        pass

rosight/ros/__init__.py

@@ -0,0 +1,17 @@
+"""ROS 2 backend abstractions used by the TUI.
+
+Importing this package does **not** import ``rclpy``. The backend lazily
+imports rclpy inside :class:`RosBackend.start` so the rest of the package
+(and the test suite) can run without a ROS 2 installation.
+"""
+
+from rosight.ros.backend import RosBackend, RosUnavailable, ros_available
+from rosight.ros.stats import BandwidthMonitor, RateMonitor
+
+__all__ = [
+    "BandwidthMonitor",
+    "RateMonitor",
+    "RosBackend",
+    "RosUnavailable",
+    "ros_available",
+]