ros2-term 0.1.0__tar.gz

ros2_term-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+.claude
+.vscode
+
+# Virtual environments
+.venv
+
+

ros2_term-0.1.0/.old/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-0.1.0/.old/config.yaml

@@ -0,0 +1,3 @@
+
+
+refresh_interval: 5.0

ros2_term-0.1.0/.old/node_test.py

@@ -0,0 +1,19 @@
+import rclpy
+from rclpy.node import Node
+
+class NodeLister(Node):
+    def __init__(self):
+        super().__init__('node_lister')
+        # Get list of node names and namespaces
+        node_names = self.get_node_names_and_namespaces()
+        self.get_logger().info("Active nodes:")
+        for name, namespace in node_names:
+            self.get_logger().info(f"{namespace}/{name}")
+
+def main():
+    rclpy.init()
+    node = NodeLister()
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

ros2_term-0.1.0/.old/ros2_explorer.py

@@ -0,0 +1,326 @@
+import subprocess
+from textual.app import App, ComposeResult
+from textual.widget import Widget
+from textual.widgets import (
+    Header,
+    Footer,
+    Tree,
+    Label,
+    Markdown,
+    MarkdownViewer,
+    Input,
+    Button,
+    Tooltip,
+    Static
+)
+from textual.containers import Container, Horizontal
+from textual.screen import ModalScreen, Screen
+from textual.containers import Vertical
+from textual.message import Message
+from textual import events
+from textual.widgets._tree import TreeNode
+from textual.binding import Binding
+from rich.text import Text
+import re
+import yaml
+
+"""TODO 
+1. List count of nodes
+2. 
+
+# from remote_pdb import set_trace; set_trace(port=4444)
+"""
+
+def run_ros2_command(cmd: list[str]) -> list[str]:
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return result.stdout.strip().splitlines()
+    except subprocess.CalledProcessError as e:
+        return [f"Error: {e}"]
+
+class ToggleButton(Button):
+    def on_mount(self):
+        # Set initial state
+        self.state = False
+
+    def toggle(self):
+        # Toggle the state
+        self.state = True if self.state == False else False
+        self.log.info(f"State of {self.id} is {self.state}")
+        self.update_style()
+
+    def update_style(self):
+        # Change visual style based on state
+        if self.state == True:
+            self.add_class("active")
+        else:
+            self.remove_class("active")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if isinstance(event.button, ToggleButton):
+            event.button.toggle()
+
+
+HELP_TEXT = """
+# Help Menu
+
+Welcome to the **ROS2 TUI App**! Press 'q' to exit the help.
+
+## Key Bindings
+
+- `Ctrl+q`: Exit the app.
+- `Tab/Shift+Tab`: Go to next/previous widget.
+- `Space`: Expand a selection when in node/topic tree view. 
+- `Enter`: Go to link when a link is highlighted (or click on it directly).
+
+## Tips
+
+- Search boxes use semicolon (;) as a delimiter so you can search for multiple node/topic names 
+at once.
+
+## Configuration
+
+"""
+
+# Create the help screen as a modal
+class HelpScreen(ModalScreen):
+    CSS_PATH="app.css"
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Markdown(HELP_TEXT, id="help-markdown"),
+            Container(
+                Button("Close", id="close-button"),
+                id="button-container"
+            )
+        )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.app.pop_screen()
+
+    def on_key(self, event: events.Key) -> None:
+        if event.key == "q":
+            self.app.pop_screen()
+
+
+class Ros2NodeTree(Tree[str]):
+    """Tree widget to show ROS 2 nodes and their info."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.nodes = []
+        self.filtered_out = []
+        self.search_text = ""
+
+    def on_mount(self) -> None:
+
+        with open("config.yaml", "r") as f:
+            self.config = yaml.safe_load(f)
+
+        interval = float(self.config['refresh_interval'])
+
+        self.root.label = "ROS 2 Nodes"
+        self.set_interval(interval, self.load_nodes)
+        self.load_nodes()
+
+    def get_ros_node_names(self):
+        """Get the name of the ros node names that exist in top layer of the tree"""
+        return [str(child.label) for child in self.root.children]
+    
+    def get_child_node(self, name):
+        """Just looking at the top tree layer. Should ideally traverse the tree"""
+        for child in self.root.children:
+            if str(child.label) == name:
+                return child
+        return None
+
+
+    def load_nodes(self):
+        nodes = [x.strip() for x in run_ros2_command(["ros2", "node", "list"])]
+        
+        node_msg = "\n".join(nodes)
+        if "error:" in node_msg.lower():
+            self.root.remove_children()
+            self.root.add_leaf(Text(node_msg, style="white on red"))
+            return
+        
+        # Remove any existing children that are not in updated node list
+        for child in self.root.children:
+            if str(child.label) not in nodes:
+                child.remove()
+
+        # Do similar updates on list of nodes that are filtered out
+        self.filtered_out = [x for x in self.filtered_out if x in nodes]
+
+        # Add any missing children from updated node list
+        children = self.get_ros_node_names()
+        for node in nodes:
+            if node not in children:
+                self.root.add(Text(node.strip(), style="bold deep_sky_blue3"))
+
+        # Filter out any added nodes that don't meet the search criteria
+        self.filter_nodes()
+
+        self.root.expand()
+        self.nodes = nodes
+
+    def filter_nodes(self):
+        """From the search input, filter the shown ROS2 node names"""
+
+        case_button = self.screen.query_one("#case_insensitive", ToggleButton)
+        regex_button = self.screen.query_one("#regex_mode", ToggleButton)
+
+        if len(self.search_text) > 0:
+            search = self.search_text
+            case_insensitive = case_button.state
+            use_regex = regex_button.state
+        else:
+            search = ".*"
+            case_insensitive = False
+            use_regex = True
+
+        node_names = self.get_ros_node_names()
+        show = {}
+        for name in (node_names + self.filtered_out):
+            if use_regex:
+                flags = re.IGNORECASE if case_insensitive else 0
+                if re.search(search, name, flags):
+                    show[name] = True
+                else:
+                    show[name] = False
+            else:
+                if case_insensitive:
+                    name = name.lower()
+                    search = search.lower()
+                if search in name:
+                    show[name] = True
+                else:
+                    show[name] = False
+                
+        for name in show:
+            if show[name] and name not in node_names:
+                self.root.add(Text(name, style="bold deep_sky_blue3"))
+                if name in self.filtered_out:
+                    self.filtered_out.remove(name)
+
+            if not show[name] and name in node_names:
+                self.get_child_node(name).remove()
+                self.filtered_out.append(name)
+
+        # Sort node order
+        sorted_children = sorted(self.root.children, key=lambda child: str(child.label))
+        self.root._children = sorted_children
+
+
+    def on_key(self, event: events.Key) -> None:
+        if event.key:
+            pass
+
+    def parse_node_info(self, node_info: list[str]):
+        """Parse the output of 'ros2 node info <node>' """
+        key = None
+
+        target_keys = [
+            "Subscribers",
+            "Publishers",
+            "Service Servers",
+            "Service Clients",
+            "Action Servers",
+            "Action Clients",
+        ]
+        data = {k: [] for k in target_keys}
+
+        for line in node_info:
+            for k in target_keys:
+                if k in line:
+                    key = k
+                    break
+            else: # This else only executes if inner for loop completes
+                if key is not None and len(line.strip()) > 0:
+                    data[key].append(line.strip())
+
+        return data
+    
+    def add_node_info(self, parent: TreeNode, node_info: dict[str, list], expand=True):
+        parent.remove_children()
+        for key, value in node_info.items():
+            if len(value) > 0:
+                new_section = parent.add(Text(key, style="bold dark_turquoise"))
+                for v in value:
+                    new_section.add_leaf(v)
+                new_section.expand()
+            # else:
+            #     parent.add_leaf(f"No {key}")
+
+    def populate_node_info(self, selected_node: TreeNode):
+        node_name = selected_node.label
+        node_info = run_ros2_command(["ros2", "node", "info", str(node_name)])
+        self.log.info(node_info)
+
+        if not node_info or node_info[0].startswith("Error"):
+            selected_node.add_leaf(Text("Could not fetch node info", style="bold white on red"))
+            return
+
+        node_info_dict = self.parse_node_info(node_info)
+        self.add_node_info(selected_node, node_info_dict)
+
+
+    async def on_tree_node_expanded(self, event: Tree.NodeExpanded[str]) -> None:
+        selected_node = event.node
+        # from remote_pdb import set_trace; set_trace(port=4444)
+        if str(selected_node.label) in self.nodes:
+            self.populate_node_info(selected_node)
+
+
+class SearchBar(Widget):
+    def compose(self) -> ComposeResult:
+        # Horizontal layout for inline arrangement
+        with Horizontal():
+            yield Input(placeholder="Search...", id="search_input") #, compact=True)
+
+            # 'i' button (case insensitive)
+            yield ToggleButton("i", id="case_insensitive", tooltip="case insensitive", classes="search-button")
+
+            # 're' button (regex)
+            yield ToggleButton("re", id="regex_mode", tooltip="regex matching", classes="search-button")
+            
+    def on_input_changed(self, event: Input.Changed) -> None:
+
+        self.log(f"Search submitted: {event.value}")
+        tree = self.screen.query_one("#main_tree", Ros2NodeTree)
+        tree.search_text = event.value
+        tree.filter_nodes()
+
+
+class Ros2TUI(App):
+  
+    CSS_PATH = "app.css"
+
+    BINDINGS = [
+        ("h", "help", "Help"),
+        ("r", "refresh", "Refresh"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield SearchBar()
+        with Container(id="main"):
+            yield Ros2NodeTree(id="main_tree", label="root")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        # Focus the main_tree widget on startup
+        self.query_one("#main_tree").focus()
+
+    def action_help(self):
+        self.console.log("Help requested")
+        self.push_screen(HelpScreen())
+
+    def action_refresh(self):
+        self.console.log("Refresh requested")
+        tree = self.screen.query_one("#main_tree", Ros2NodeTree)
+        tree.load_nodes()
+
+
+if __name__ == "__main__":
+    app = Ros2TUI()
+    app.run()

ros2_term-0.1.0/CHANGELOG.md

@@ -0,0 +1,126 @@
+# Changelog
+
+## v2.0 - Complete Rewrite (Current)
+
+### ✅ Completed
+
+**Architecture Refactor:**
+- Replaced subprocess-based CLI calls with native `rclpy` + `ros2*.api` integration
+- Background ROS2 executor thread for non-blocking updates
+- Clean entity abstraction layer supporting all ROS2 entity types
+- Event-driven architecture with Textual messages
+
+**Tree-Based Layout (like old ros2_explorer.py):**
+- **Nodes view**: Expandable tree showing Publishers/Subscribers/Services/Actions under each node
+- **Topics view**: Expandable tree showing Publishers/Subscribers under each topic
+- **Services/Actions/Types views**: Flat list with namespace grouping
+- Right panel shows detailed info for selected items
+
+**Navigation:**
+- Clickable links between entities (node → topic → message type)
+- Browser-like history navigation (`b`/`f` keys for back/forward)
+- 20-item history buffer
+
+**Search:**
+- Search bar with case-insensitive toggle (`i` button)
+- Regex mode toggle (`re` button)
+- Live filtering of tree lists
+
+**View Switching:**
+- `1` - Nodes view
+- `2` - Topics view
+- `3` - Services view
+- `4` - Actions view
+- `5` - Message Types view
+
+**Auto-Refresh:**
+- Entity lists refresh every 2 seconds (configurable via `--refresh-rate`)
+- Burst refresh at startup (0s, 0.5s, 1.0s) for fast topic discovery
+- Info panels update every 5 seconds
+- Manual reload with `r` key
+
+**Topic Watching:**
+- `w` key to toggle watching a topic
+- Watched topics show spinning propeller indicator (speed matches publishing rate)
+- Propeller animation matches ros2 topic hz algorithm (1/mean(intervals), 10000 window)
+- Watch mode automatically shows Hz statistics
+- Watched topics use persistent subscriptions (reused for echo/hz/sample)
+- Auto-watch topics from loaded profile when discovered
+
+**Profile System:**
+- Auto-save current state (watched topics + view) to default profile
+- `p` key to save profile with custom name
+- `--profile <name>` to load specific profile on startup
+- `--continue` to resume last used profile
+- Profiles stored in `~/.config/ros2_term/`
+- Profile list shown in `--help` output
+
+**Topic Data Inspection:**
+- `h` key - Show Hz (publishing rate) for selected topic
+- `e` key - Echo (continuous) messages from topic
+- `s` key - Sample single message from topic
+- `a` key - Toggle array visibility in echo/sample output
+- Watched topics show Hz stats automatically
+
+**UI Improvements:**
+- In-place tree updates eliminate cursor flicker during refresh
+- Tree expansion state preserved when switching views
+- Path-based cursor tracking prevents jumping to wrong nodes
+- `c` key - Collapse all top-level tree nodes
+- `v` key - Toggle verbose mode (show/hide default ROS2 topics/services)
+- Smooth propeller animation (0.1s update interval)
+
+### 🚧 Pending Features
+
+From original notes:
+- Topic search in Node view with highlighting (Task #1)
+- Collapsible services/actions sections with persistent state (Task #4)
+- Topic echo screen with field selection (Task #2)
+
+### 📁 File Structure
+
+**New Files:**
+- `app.py` - Main application (replaces `ros2_explorer.py`)
+- `entity.py` - ROS2 entity types and info classes
+- `ros2_client.py` - Native ROS2 client using rclpy
+- `topic_watcher.py` - Topic watching system with Hz tracking and propeller animation
+- `config.py` - Profile management (save/load watched topics and views)
+- `widgets.py` - Reusable UI widgets (NodeTreePanel, TopicTreePanel, etc.)
+- `messages.py` - Custom Textual messages for events
+- `history.py` - Navigation history implementation
+- `search_bar.py` - Search bar widget with toggles
+- `profile_screen.py` - Modal screen for saving profiles
+
+**Legacy Files (can be deleted):**
+- `ros2_explorer.py` - Original implementation
+- `multi_screen.py` - Multi-screen example
+- `node_test.py` - rclpy test
+- `screens.py` - Legacy screen definitions (no longer used)
+
+**Config:**
+- `app.css` - Textual CSS styling
+
+### 🎯 Key Improvements
+
+1. **Performance**: Native rclpy APIs are much faster than subprocess calls
+2. **Flexibility**: Supports all ROS2 entity types, not just nodes
+3. **Navigation**: Clickable links and history make exploration intuitive
+4. **Filtering**: Real-time search with regex support
+5. **Architecture**: Clean separation of concerns, reusable components
+6. **Topic Monitoring**: Visual propeller indicators show topic activity at a glance
+7. **State Persistence**: Profiles preserve your workflow across sessions
+8. **Smooth UI**: In-place tree updates eliminate flicker and cursor jumping
+
+### 🐛 Known Issues
+
+None currently
+
+### 📝 Notes
+
+The layout now matches the old `ros2_explorer.py` style where:
+- Nodes expand to show their publishers/subscribers/services/actions
+- Topics expand to show their publishers/subscribers
+- Selecting a topic/service in the tree shows its details in the right panel
+- Selecting a node name under a topic shows that node's details
+
+This combines the best of both worlds: the familiar tree interface with modern architecture and full ROS2 support.

ros2_term-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: ros2-term
+Version: 0.1.0
+Summary: A terminal UI for inspecting ROS2 topics and nodes
+Author-email: Spencer Diehl <docdiehl@gmail.com>
+License: Apache-2.0
+Keywords: robotics,ros2,terminal,tui
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: numpy<2.0
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: textual>=8.2.3
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ROS2 Explorer TUI
+
+A Terminal User Interface (TUI) app for exploring ROS2 nodes, topics, services, actions, and message types.
+
+## Requirements
+
+- ROS2 Humble, Iron, or Jazzy already installed on system
+- pipx (`sudo apt install pipx`)
+
+## Installation
+
+Source your ROS2 installation first, then install with pipx:
+
+    source /opt/ros/humble/setup.bash   # or iron, jazzy, etc.
+    pipx install ros2-term
+
+Then run:
+
+    ros2-term
+
+**Note:** ROS2 must be sourced in any shell where you run `ros2-term`.
+
+### Command Line Options
+
+    ros2-term [--profile NAME] [--continue] [--refresh-rate SECONDS]
+
+- `--profile NAME` - Load specific profile on startup
+- `--continue` - Resume last used profile
+- `--refresh-rate SECONDS` - Set refresh interval (default: 2.0)
+- `--help` - Show available profiles and config location
+
+
+## Troubleshooting
+
+If you have multiple Python versions installed and see import errors related
+to ROS2 packages, force pipx to use the system Python explicitly:
+
+    pipx install ros2-term --python $(which python3)
+
+## Features
+
+- Tree views for nodes/topics with expandable details
+- **Topic watching** (`w`) with spinning propeller showing publish rate
+- **Topic inspection**: Hz (`h`), echo (`e`), sample (`s`)
+- **Profile system**: Auto-save/load watched topics and views
+- Clickable links between entities (node → topic → type)
+- History navigation (`b`/`f`)
+- Search with regex support
+- Native `rclpy` integration (no subprocess overhead)
+
+## Key Components
+
+- `ros2_client.py` - Native `rclpy` integration with background executor
+- `topic_watcher.py` - Hz tracking and propeller animation
+- `config.py` - Profile persistence
+- `widgets.py` - In-place tree updates (no flicker)
+
+### Keyboard Shortcuts
+
+| Key | Action | Visible in Footer |
+|-----|--------|-------------------|
+| `?` | Show help screen | ✓ |
+| `w` | Watch/unwatch topic | ✓ |
+| `h` | Show Hz for topic | ✓ |
+| `e` | Echo topic (continuous) | ✓ |
+| `s` | Sample topic (single msg) | ✓ |
+| `a` | Toggle array visibility | ✓ |
+| `r` | Reload current view | ✓ |
+| `b` | Navigate back in history | |
+| `f` | Navigate forward in history | |
+| `v` | Toggle verbose mode | |
+| `c` | Collapse all tree nodes | |
+| `p` | Save profile | |
+| `1` | View nodes | |
+| `2` | View topics | |
+| `3` | View services | |
+| `4` | View actions | |
+| `5` | View message types | |
+| `q` | Quit | |
+
+### Navigation
+
+- Arrow keys navigate tree, Enter expands/collapses
+- Click entity names in info panel to navigate
+- `b`/`f` for history navigation
+- Tree state preserved when switching views