ros2-term 0.1.0__py3-none-any.whl

ros2_term/app.css

@@ -0,0 +1,76 @@
+Screen {
+    layout: vertical;
+}
+
+/* Multi-screen layout */
+.container {
+    height: 100%;
+    background: $panel;
+}
+
+#left-panel-container {
+    width: 50%;
+}
+
+NodeTreePanel, TopicTreePanel, RosEntityListPanel {
+    padding-left: 2;
+    width: 100%;
+}
+
+RosEntityInfoPanel, RosTypeDefinitionPanel {
+    padding: 1 2;
+}
+
+#main {
+    width: 70%;
+    border-left: inner $primary;
+}
+
+#main-upper {
+    border-bottom: inner $primary;
+}
+
+.main-half {
+    height: 50%;
+}
+
+/* ------------------------------------------------- */
+SearchBar {
+    max-width: 100%;
+    height: 5;
+    padding: 0 1;
+    border: solid green;
+}
+
+SearchBar Input {
+    width: 1fr;
+    min-width: 10;
+}
+
+SearchBar .search-button {
+    width: 4;
+    margin-left: 1;
+    min-width: 4;
+    text-style: bold;
+}
+
+SearchBar .search-button.hover {
+    background: $surface;
+}
+
+SearchBar .search-button.active {
+    background: $secondary;
+    text-style: bold;
+}
+
+/* ------------------------------------------------- */
+
+#close-button {
+    width: 30;
+    margin: 1;
+    color: white;
+}
+
+#button-container {
+    align-horizontal: center;
+}

ros2_term/app.py

@@ -0,0 +1,558 @@
+from __future__ import annotations
+
+import argparse
+import warnings
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, ScrollableContainer, Vertical
+from textual.widgets import Footer, Static
+
+from ros2_term.lib.config import ProfileConfig
+from ros2_term.lib.entity import RosEntity, RosEntityType
+from ros2_term.lib.history import History
+from ros2_term.lib.messages import RosEntitySelected
+from ros2_term.lib.ros2_client import ROS2Client
+from ros2_term.lib.topic_watcher import TopicWatcher
+
+from ros2_term.ui.search_bar import SearchBar, SearchChanged
+from ros2_term.ui.help_screen import HelpScreen
+from ros2_term.ui.profile_screen import ProfileSaveScreen
+from ros2_term.ui.widgets import (
+    RosEntityInfoPanel,
+    RosEntityListPanel,
+    RosTypeDefinitionPanel,
+    NodeTreePanel,
+    TopicTreePanel,
+)
+
+warnings.simplefilter("ignore", ResourceWarning)
+
+
+class ROS2Explorer(App):
+    """TUI app for exploring ROS2 nodes, topics, services, actions, and types."""
+
+    TITLE = "ROS2 Explorer"
+    CSS_PATH = "app.css"
+
+    DEFAULT_REFRESH_RATE = 2.0
+
+    BINDINGS = [
+        # Show in footer
+        Binding("?", "help", "Help", key_display="?"),
+        Binding("w", "watch_topic", "Watch", key_display="w"),
+        Binding("h", "show_hz", "Hz", key_display="h"),
+        Binding("e", "echo_topic", "Echo", key_display="e"),
+        Binding("s", "sample_topic", "Sample", key_display="s"),
+        Binding("a", "toggle_arrays", "Toggle Arrays", key_display="a"),
+        Binding("r", "reload", "Reload", key_display="r"),
+        # Hide from footer (still functional, documented in help)
+        Binding("b", "back", "Back", key_display="b", show=False),
+        Binding("f", "forward", "Forward", key_display="f", show=False),
+        Binding("v", "toggle_verbose", "Verbose", key_display="v", show=False),
+        Binding("p", "save_profile", "Save Profile", key_display="p", show=False),
+        Binding("c", "collapse_all", "Collapse All", key_display="c", show=False),
+        Binding("1", "show_nodes", "Nodes", key_display="1", show=False),
+        Binding("2", "show_topics", "Topics", key_display="2", show=False),
+        Binding("3", "show_services", "Services", key_display="3", show=False),
+        Binding("4", "show_actions", "Actions", key_display="4", show=False),
+        Binding("5", "show_msg_types", "Msg Types", key_display="5", show=False),
+        Binding("q", "quit", "Quit", key_display="q", show=False),
+    ]
+
+    def __init__(self, profile_name: str | None = None, refresh_rate: float = None) -> None:
+        super().__init__()
+        self._ros_client: ROS2Client | None = None
+        self._topic_watcher: TopicWatcher | None = None
+        self._profile_config = ProfileConfig()
+        self._current_profile: str | None = profile_name
+        self._watch_list: set[str] = set()  # Topics that should be watched when discovered
+        self._refresh_rate = refresh_rate or self.DEFAULT_REFRESH_RATE
+        self._history: History[RosEntity] = History(20)
+        self._current_entity_type = RosEntityType.Node
+        self._left_panel_container: Vertical | None = None
+        self._current_tree_panel: Static | None = None
+        self._info_panel: RosEntityInfoPanel | None = None
+        self._definition_panel: RosTypeDefinitionPanel | None = None
+        self._verbose_mode: bool = False
+        self._current_topic: str | None = None  # Track selected topic for hz/echo
+        # Store tree expansion state per panel type
+        self._tree_states: dict = {
+            RosEntityType.Node: {"expanded": set(), "selected": None},
+            RosEntityType.Topic: {"expanded": set(), "selected": None},
+        }
+
+    def compose(self) -> ComposeResult:
+        """Compose the app layout."""
+        yield SearchBar(id="search-bar")
+        with Horizontal(classes="container"):
+            # Left panel container (will be swapped based on view)
+            with Vertical(id="left-panel-container") as container:
+                self._left_panel_container = container
+                # Will be populated in on_mount
+
+            # Info/definition panels on the right
+            with Vertical(id="main"):
+                with ScrollableContainer(
+                    id="main-upper", classes="main-half"
+                ) as info_container:
+                    pass  # Will be populated in on_mount
+                with ScrollableContainer(
+                    id="def-container", classes="main-half"
+                ) as def_container:
+                    pass  # Will be populated in on_mount
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Initialize ROS2 client and create initial widgets."""
+        try:
+            self._ros_client = ROS2Client()
+            self._topic_watcher = TopicWatcher(self._ros_client)
+        except Exception as e:
+            self.exit(message=f"Failed to initialize ROS2 client: {e}")
+            return
+
+        # Load profile immediately to get view and watch list
+        if self._current_profile:
+            self._load_profile(self._current_profile)
+
+        # Create and mount initial tree panel based on current entity type
+        if self._current_entity_type == RosEntityType.Node:
+            self._current_tree_panel = NodeTreePanel(
+                self._ros_client, self._topic_watcher, refresh_rate=self._refresh_rate
+            )
+        elif self._current_entity_type == RosEntityType.Topic:
+            self._current_tree_panel = TopicTreePanel(
+                self._ros_client, self._topic_watcher, refresh_rate=self._refresh_rate
+            )
+        else:
+            self._current_tree_panel = RosEntityListPanel(
+                self._ros_client, self._current_entity_type, refresh_rate=self._refresh_rate
+            )
+        self._left_panel_container.mount(self._current_tree_panel)
+
+        # Mount info panel
+        self._info_panel = RosEntityInfoPanel(
+            self._ros_client, None, update_interval=5.0
+        )
+        self.query_one("#main-upper").mount(self._info_panel)
+
+        # Mount definition panel
+        self._definition_panel = RosTypeDefinitionPanel(
+            self._ros_client, self._topic_watcher
+        )
+        self.query_one("#def-container").mount(self._definition_panel)
+
+        # Set up interval to refresh propeller animation
+        self.set_interval(0.1, self._refresh_propellers)
+
+        # Set initial focus on the tree panel without auto-scrolling
+        self._current_tree_panel.focus(scroll_visible=False)
+
+    def should_watch_topic(self, topic_name: str) -> bool:
+        """Check if a topic should be watched (is in watch list)."""
+        return topic_name in self._watch_list
+
+    def watch_discovered_topic(self, topic_name: str) -> None:
+        """Watch a topic that was just discovered (called from tree panels)."""
+        if topic_name in self._watch_list and not self._topic_watcher.is_watched(topic_name):
+            try:
+                self._topic_watcher.watch_topic(topic_name)
+            except Exception:
+                pass  # Silently fail, will retry on next discovery
+
+    def _save_tree_state(self) -> None:
+        """Save current tree panel's expanded state."""
+        if not self._current_tree_panel or self._current_entity_type not in self._tree_states:
+            return
+
+        if hasattr(self._current_tree_panel, 'root'):
+            expanded = set()
+            for node in self._current_tree_panel.root.children:
+                if node.is_expanded and node.data:
+                    expanded.add(node.data.get("name"))
+            self._tree_states[self._current_entity_type]["expanded"] = expanded
+
+            # Save selected node path
+            if self._current_tree_panel.cursor_node and self._current_tree_panel.cursor_node.data:
+                # Build path from root to selected node
+                path = []
+                current = self._current_tree_panel.cursor_node
+                root = self._current_tree_panel.root
+                while current and current != root:
+                    path.insert(0, {
+                        "type": current.data.get("type") if current.data else None,
+                        "name": current.data.get("name") if current.data else None,
+                        "label": str(current.label)
+                    })
+                    current = current.parent
+
+                self._tree_states[self._current_entity_type]["selected"] = {
+                    "path": path
+                }
+
+    def _restore_tree_state(self) -> None:
+        """Restore tree panel's expanded state after it's mounted."""
+        if not self._current_tree_panel or self._current_entity_type not in self._tree_states:
+            return
+
+        if hasattr(self._current_tree_panel, 'set_initial_state'):
+            state = self._tree_states[self._current_entity_type]
+            self._current_tree_panel.set_initial_state(
+                expanded=state.get("expanded", set()),
+                selected=state.get("selected")
+            )
+
+    def _switch_entity_type(self, entity_type: RosEntityType) -> None:
+        """Switch to viewing a different entity type."""
+        # Save state of current panel before switching
+        self._save_tree_state()
+
+        self._current_entity_type = entity_type
+
+        # Remove old tree panel
+        if self._current_tree_panel:
+            self._current_tree_panel.remove()
+
+        # Create appropriate new panel based on entity type
+        if entity_type == RosEntityType.Node:
+            self._current_tree_panel = NodeTreePanel(
+                self._ros_client, self._topic_watcher, refresh_rate=self._refresh_rate
+            )
+        elif entity_type == RosEntityType.Topic:
+            self._current_tree_panel = TopicTreePanel(
+                self._ros_client, self._topic_watcher, refresh_rate=self._refresh_rate
+            )
+        else:
+            # For services, actions, and types, use flat list
+            self._current_tree_panel = RosEntityListPanel(
+                self._ros_client, entity_type, refresh_rate=self._refresh_rate
+            )
+
+        # Mount the new panel
+        self._left_panel_container.mount(self._current_tree_panel)
+
+        # Restore saved state
+        self._restore_tree_state()
+
+        # Clear info panel
+        if self._info_panel:
+            self._info_panel._entity = None
+            self._info_panel.update("")
+        if self._definition_panel:
+            if entity_type.has_definition():
+                self._definition_panel.display = True
+            else:
+                self._definition_panel.display = False
+
+    def show_ros_entity(self, entity: RosEntity, append_history: bool = True) -> None:
+        """Navigate to a specific ROS entity - shows info without switching views."""
+        # Just show the entity info in the right panel, don't switch views
+        # This allows viewing topic details from node view, node details from topic view, etc.
+
+        # Track if this is a topic for hz/echo commands
+        if entity.type == RosEntityType.Topic:
+            self._current_topic = entity.name
+
+            # If topic is watched, automatically show hz stats
+            if self._topic_watcher and self._topic_watcher.is_watched(entity.name):
+                if self._definition_panel:
+                    self._definition_panel.show_watched_topic_hz(entity.name)
+                    self._definition_panel.display = True
+        else:
+            self._current_topic = None
+
+        if self._info_panel:
+            self._info_panel.set_entity(entity)
+        if self._definition_panel and entity.type.has_definition():
+            # Only set entity if it's not a watched topic (we already handled that above)
+            if not (entity.type == RosEntityType.Topic and
+                    self._topic_watcher and self._topic_watcher.is_watched(entity.name)):
+                self._definition_panel.set_entity(entity)
+            self._definition_panel.display = True
+        else:
+            if self._definition_panel:
+                # Only hide if it's not a watched topic
+                if not (entity.type == RosEntityType.Topic and
+                        self._topic_watcher and self._topic_watcher.is_watched(entity.name)):
+                    self._definition_panel.display = False
+
+        if append_history:
+            self._history.append(entity)
+
+    def on_ros_entity_selected(self, event: RosEntitySelected) -> None:
+        """Handle entity selection from clickable links or tree."""
+        self.show_ros_entity(event.entity)
+
+    def on_search_changed(self, event: SearchChanged) -> None:
+        """Handle search criteria changes."""
+        search_bar = self.query_one("#search-bar", SearchBar)
+
+        # Set filter function on the current tree panel
+        if self._current_tree_panel and hasattr(self._current_tree_panel, "set_filter"):
+            self._current_tree_panel.set_filter(lambda name: search_bar.matches(name))
+
+    def action_back(self) -> None:
+        """Navigate back in history."""
+        if entity := self._history.back():
+            self.show_ros_entity(entity, append_history=False)
+
+    def action_forward(self) -> None:
+        """Navigate forward in history."""
+        if entity := self._history.forward():
+            self.show_ros_entity(entity, append_history=False)
+
+    def action_reload(self) -> None:
+        """Reload the current entity list."""
+        if self._current_tree_panel and hasattr(
+            self._current_tree_panel, "update_items"
+        ):
+            self._current_tree_panel.update_items()
+
+    def action_collapse_all(self) -> None:
+        """Collapse all top-level tree nodes."""
+        if self._current_tree_panel and hasattr(self._current_tree_panel, 'root'):
+            for node in self._current_tree_panel.root.children:
+                node.collapse()
+
+    def action_toggle_verbose(self) -> None:
+        """Toggle verbose mode to show/hide default ROS2 topics/services/actions."""
+        self._verbose_mode = not self._verbose_mode
+
+        # Update the tree panel's verbose mode
+        if self._current_tree_panel and hasattr(
+            self._current_tree_panel, "set_verbose_mode"
+        ):
+            self._current_tree_panel.set_verbose_mode(self._verbose_mode)
+
+        # Update the info panel's verbose mode
+        if self._info_panel and hasattr(self._info_panel, "set_verbose_mode"):
+            self._info_panel.set_verbose_mode(self._verbose_mode)
+
+        # Notify user
+        mode_text = "ON" if self._verbose_mode else "OFF"
+        self.notify(f"Verbose mode: {mode_text}")
+
+    def action_show_nodes(self) -> None:
+        """Show nodes view."""
+        self._switch_entity_type(RosEntityType.Node)
+        self._auto_save_profile()
+
+    def action_show_topics(self) -> None:
+        """Show topics view."""
+        self._switch_entity_type(RosEntityType.Topic)
+        self._auto_save_profile()
+
+    def action_show_services(self) -> None:
+        """Show services view."""
+        self._switch_entity_type(RosEntityType.Service)
+        self._auto_save_profile()
+
+    def action_show_actions(self) -> None:
+        """Show actions view."""
+        self._switch_entity_type(RosEntityType.Action)
+        self._auto_save_profile()
+
+    def action_show_msg_types(self) -> None:
+        """Show message types view."""
+        self._switch_entity_type(RosEntityType.MsgType)
+        self._auto_save_profile()
+
+    def action_show_hz(self) -> None:
+        """Show Hz (publishing rate) for the selected topic."""
+        if not self._current_topic:
+            self.notify("Please select a topic first", severity="warning")
+            return
+
+        if self._definition_panel:
+            # Check if topic is watched
+            if self._topic_watcher and self._topic_watcher.is_watched(self._current_topic):
+                # Show watched topic hz (uses existing subscription)
+                self._definition_panel.show_watched_topic_hz(self._current_topic)
+            else:
+                # Show hz for unwatched topic (creates temp subscription)
+                self._definition_panel.show_hz(self._current_topic)
+            self._definition_panel.display = True
+
+    def action_echo_topic(self) -> None:
+        """Start continuous echo of the selected topic."""
+        if not self._current_topic:
+            self.notify("Please select a topic first", severity="warning")
+            return
+
+        if self._definition_panel:
+            self._definition_panel.start_echo(self._current_topic, continuous=True)
+            self._definition_panel.display = True
+
+    def action_sample_topic(self) -> None:
+        """Sample a single message from the selected topic."""
+        if not self._current_topic:
+            self.notify("Please select a topic first", severity="warning")
+            return
+
+        if self._definition_panel:
+            self._definition_panel.start_echo(self._current_topic, continuous=False)
+            self._definition_panel.display = True
+
+    def action_toggle_arrays(self) -> None:
+        """Toggle array visibility in echo/sample output."""
+        if self._definition_panel:
+            self._definition_panel.toggle_arrays()
+
+    def action_watch_topic(self) -> None:
+        """Toggle watching the selected topic."""
+        if not self._current_topic:
+            self.notify("Please select a topic first", severity="warning")
+            return
+
+        if not self._topic_watcher:
+            self.notify("Topic watcher not initialized", severity="error")
+            return
+
+        try:
+            is_watched = self._topic_watcher.toggle_watch(self._current_topic)
+            if is_watched:
+                # Add to watch list
+                self._watch_list.add(self._current_topic)
+                # Automatically show hz display when watching
+                if self._definition_panel:
+                    self._definition_panel.show_watched_topic_hz(self._current_topic)
+                    self._definition_panel.display = True
+            else:
+                # Remove from watch list
+                self._watch_list.discard(self._current_topic)
+            # else: unwatched, no action needed (user sees propeller disappear)
+
+            # Auto-save to default profile
+            self._auto_save_profile()
+        except Exception as e:
+            self.notify(f"Failed to watch topic: {e}", severity="error")
+
+    def action_save_profile(self) -> None:
+        """Save current watched topics to a profile (prompts for name)."""
+        if not self._topic_watcher:
+            self.notify("Topic watcher not initialized", severity="error")
+            return
+
+        # Show profile save screen to get name
+        self.push_screen(
+            ProfileSaveScreen(self._current_profile),
+            self._handle_profile_save
+        )
+
+    def _handle_profile_save(self, profile_name: str | None) -> None:
+        """Handle the profile save after user enters name."""
+        if not profile_name:
+            return  # User cancelled
+
+        watched = self._topic_watcher.get_watched_topics()
+        current_view = self._current_entity_type.name
+
+        try:
+            self._profile_config.save_profile(profile_name, watched, current_view)
+            self._current_profile = profile_name
+            self.notify(f"Saved profile '{profile_name}' ({len(watched)} topics)")
+        except Exception as e:
+            self.notify(f"Failed to save profile: {e}", severity="error")
+
+    def _auto_save_profile(self) -> None:
+        """Auto-save to default profile silently."""
+        if not self._topic_watcher:
+            return
+
+        watched = self._topic_watcher.get_watched_topics()
+        current_view = self._current_entity_type.name
+
+        try:
+            self._profile_config.save_profile("default", watched, current_view)
+        except Exception:
+            pass  # Silently fail on auto-save
+
+    def _load_profile(self, profile_name: str) -> None:
+        """Load profile - sets view and watch list."""
+        try:
+            data = self._profile_config.load_profile(profile_name)
+            if not data:
+                return
+
+            current_view = data.get("current_view", "Node")
+            watched_topics = data.get("watched_topics", [])
+
+            # Restore the view
+            try:
+                entity_type = RosEntityType[current_view]
+                self._current_entity_type = entity_type
+            except (KeyError, ValueError):
+                pass
+
+            # Store watch list - topics will be watched as they're discovered
+            self._watch_list = set(watched_topics)
+        except Exception:
+            pass
+
+    def _refresh_propellers(self) -> None:
+        """Refresh the propeller display for watched topics."""
+        if self._current_tree_panel and hasattr(self._current_tree_panel, "refresh_propellers"):
+            self._current_tree_panel.refresh_propellers()
+
+    def action_help(self) -> None:
+        """Show help screen."""
+        self.push_screen(HelpScreen())
+
+    async def action_quit(self) -> None:
+        """Quit the application."""
+        if self._topic_watcher:
+            self._topic_watcher.cleanup()
+        if self._ros_client:
+            self._ros_client.terminate()
+        await super().action_quit()
+
+
+def main():
+    # Get available profiles for help text
+    config = ProfileConfig()
+    profiles = config.list_profiles()
+    profile_list = ", ".join(profiles) if profiles else "none"
+
+    epilog = f"Available profiles: {profile_list}\nProfile location: {config.config_dir}"
+
+    parser = argparse.ArgumentParser(
+        description="ROS2 Terminal UI for exploring nodes, topics, services, and actions",
+        epilog=epilog,
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument(
+        "--profile",
+        type=str,
+        help="Profile name to load (without .json extension)",
+    )
+    parser.add_argument(
+        "--continue",
+        dest="continue_last",
+        action="store_true",
+        help="Continue from the last used profile",
+    )
+    parser.add_argument(
+        "--refresh-rate",
+        type=float,
+        default=2.0,
+        help="Refresh rate in seconds for updating topics/nodes list (default: 2.0)",
+    )
+
+    args = parser.parse_args()
+
+    # Determine which profile to use
+    profile_name = None
+    if args.continue_last:
+        config = ProfileConfig()
+        profile_name = config.get_last_profile()
+        if not profile_name:
+            profile_name = "default"
+    elif args.profile:
+        profile_name = args.profile
+
+    app = ROS2Explorer(profile_name=profile_name, refresh_rate=args.refresh_rate)
+    app.run()
+
+if __name__ == "__main__":
+    main()