BulletLab 0.1.2__py3-none-any.whl

bulletlab/ui/panels/console.py

@@ -0,0 +1,189 @@
+"""
+ConsolePanel – interactive Python command console in the BulletLab UI.
+
+Provides a single-line input field and a scrollable output log. Commands
+are executed via exec() in a configurable namespace, making robot objects
+and sim directly accessible.
+
+Example::
+
+    from bulletlab.ui.panels.console import ConsolePanel
+
+    console = ConsolePanel(namespace={"sim": sim, "robot": robot})
+    console.render()
+"""
+
+from __future__ import annotations
+
+import traceback
+from collections import deque
+from typing import Any
+
+try:
+    import imgui
+
+    _HAS_IMGUI = True
+except ImportError:  # pragma: no cover
+    imgui = None  # type: ignore[assignment]
+    _HAS_IMGUI = False
+
+
+class ConsolePanel:
+    """Interactive Python console panel.
+
+    Executes commands via ``exec()`` in a provided namespace, with output
+    captured and displayed in a scrollable log.
+
+    Args:
+        namespace: Dictionary of variables available in the console namespace.
+            Typically includes ``sim``, ``robot``, ``telemetry``, etc.
+        max_history: Maximum number of output lines to retain.
+
+    Example::
+
+        console = ConsolePanel(namespace={"sim": sim, "robot": robot})
+        console.execute("robot.links['wheel'].mass = 5")
+    """
+
+    def __init__(
+        self,
+        namespace: dict[str, Any] | None = None,
+        max_history: int = 200,
+    ) -> None:
+        self._namespace: dict[str, Any] = namespace if namespace is not None else {}
+        self._history: deque[str] = deque(maxlen=max_history)
+        self._input_buf: list[str] = [""]  # mutable for imgui input
+        self._cmd_history: list[str] = []
+        self._cmd_index: int = -1
+        self._scroll_to_bottom: bool = False
+
+        # Add some helpful builtins
+        import builtins
+        self._namespace.setdefault("__builtins__", builtins)
+
+    # ------------------------------------------------------------------
+    # API
+    # ------------------------------------------------------------------
+
+    def update_namespace(self, updates: dict[str, Any]) -> None:
+        """Update the console execution namespace.
+
+        Args:
+            updates: Key-value pairs to add or overwrite.
+
+        Example::
+
+            console.update_namespace({"robot": new_robot})
+        """
+        self._namespace.update(updates)
+
+    def execute(self, command: str) -> None:
+        """Execute a Python command string in the console namespace.
+
+        Appends both the command and the result/error to the output log.
+
+        Args:
+            command: Python source code to execute.
+
+        Example::
+
+            console.execute("robot.links['wheel'].mass = 10")
+        """
+        command = command.strip()
+        if not command:
+            return
+
+        self._history.append(f">>> {command}")
+        self._cmd_history.append(command)
+        self._cmd_index = -1
+
+        try:
+            # Try eval first (for expressions)
+            try:
+                result = eval(command, self._namespace)  # noqa: S307
+                if result is not None:
+                    self._history.append(f"    {result!r}")
+            except SyntaxError:
+                # Pass namespace as both globals AND locals so that
+                # assignments (x = 42) are written back into the shared dict.
+                exec(command, self._namespace, self._namespace)  # noqa: S102
+        except Exception:
+            for line in traceback.format_exc().splitlines():
+                self._history.append(f"  {line}")
+
+        self._scroll_to_bottom = True
+
+    def log(self, message: str) -> None:
+        """Append an informational message to the console log.
+
+        Args:
+            message: Text to display in the log.
+        """
+        self._history.append(f"# {message}")
+        self._scroll_to_bottom = True
+
+    # ------------------------------------------------------------------
+    # Render
+    # ------------------------------------------------------------------
+
+    def render(self) -> None:
+        """Draw the console panel contents.
+
+        Must be called inside an active ImGui window context.
+        """
+        if not _HAS_IMGUI:
+            return
+
+        # Output area (child window for scrolling)
+        avail_height = imgui.get_content_region_available()[1] - 30
+        imgui.begin_child(
+            "console_output",
+            width=0,
+            height=max(avail_height, 50),
+            border=True,
+        )
+
+        for line in self._history:
+            if line.startswith(">>>"):
+                imgui.text_colored(line, 0.4, 0.9, 0.4, 1.0)
+            elif line.startswith("  Traceback") or "Error" in line:
+                imgui.text_colored(line, 1.0, 0.3, 0.3, 1.0)
+            elif line.startswith("#"):
+                imgui.text_colored(line, 0.6, 0.6, 1.0, 1.0)
+            else:
+                imgui.text(line)
+
+        if self._scroll_to_bottom:
+            imgui.set_scroll_here_y(1.0)
+            self._scroll_to_bottom = False
+
+        imgui.end_child()
+
+        # Input field
+        imgui.push_item_width(-65)
+        enter_pressed = False
+
+        # We need to use input_text - imgui binding style
+        input_flags = imgui.INPUT_TEXT_ENTER_RETURNS_TRUE
+        changed, new_text = imgui.input_text(
+            "##console_input",
+            self._input_buf[0],
+            256,
+            flags=input_flags,
+        )
+        self._input_buf[0] = new_text
+
+        if changed:  # Enter was pressed
+            enter_pressed = True
+
+        imgui.pop_item_width()
+        imgui.same_line()
+
+        if imgui.button("Run##console_run") or enter_pressed:
+            cmd = self._input_buf[0].strip()
+            if cmd:
+                self.execute(cmd)
+                self._input_buf[0] = ""
+
+    def __repr__(self) -> str:
+        return f"ConsolePanel(history={len(self._history)} lines)"

bulletlab/ui/panels/explorer.py

@@ -0,0 +1,144 @@
+"""
+ExplorerPanel – displays the simulation scene tree.
+
+Shows the hierarchy: Simulation → Robots → Joints / Links.
+Clicking an item fires a selection callback that the PropertiesPanel
+(and other panels) can subscribe to.
+
+Example::
+
+    from bulletlab.ui.panels.explorer import ExplorerPanel
+
+    explorer = ExplorerPanel(sim=sim, robots=[robot])
+    # In your render loop:
+    explorer.render()
+    selected = explorer.selected_object
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Optional
+
+try:
+    import imgui
+
+    _HAS_IMGUI = True
+except ImportError:  # pragma: no cover
+    imgui = None  # type: ignore[assignment]
+    _HAS_IMGUI = False
+
+if TYPE_CHECKING:
+    from bulletlab.core.simulation import Simulation
+    from bulletlab.robot.robot import Robot
+
+
+class ExplorerPanel:
+    """Renders a tree view of the simulation scene.
+
+    Args:
+        sim: The :class:`~bulletlab.core.simulation.Simulation` instance.
+        robots: List of robots to display in the tree.
+        on_select: Optional callback called with the selected object
+            whenever the user clicks on a tree item.
+
+    Example::
+
+        explorer = ExplorerPanel(sim=sim, robots=[robot])
+        explorer.render()
+        selected = explorer.selected_object
+    """
+
+    def __init__(
+        self,
+        sim: "Simulation",
+        robots: list["Robot"] | None = None,
+        on_select: Callable[[Any], None] | None = None,
+    ) -> None:
+        self._sim = sim
+        self._robots: list["Robot"] = robots or []
+        self._on_select = on_select
+        self._selected: Any = None
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    @property
+    def selected_object(self) -> Any:
+        """The currently selected object (Robot, Joint, Link, or None)."""
+        return self._selected
+
+    def add_robot(self, robot: "Robot") -> None:
+        """Add a robot to the explorer tree.
+
+        Args:
+            robot: The robot to add.
+        """
+        if robot not in self._robots:
+            self._robots.append(robot)
+
+    def render(self) -> None:
+        """Draw the explorer panel contents.
+
+        Must be called inside an active ImGui window context.
+
+        Example::
+
+            imgui.begin("Explorer")
+            explorer.render()
+            imgui.end()
+        """
+        if not _HAS_IMGUI:
+            return
+
+        # Simulation node
+        sim_open = imgui.tree_node("Simulation##root")
+        if imgui.is_item_clicked():
+            self._select(self._sim)
+        if sim_open:
+            for robot in self._robots:
+                self._render_robot(robot)
+            imgui.tree_pop()
+
+    def _render_robot(self, robot: "Robot") -> None:
+        """Render tree node for a single robot."""
+        robot_label = f"\U0001F916 {robot.name}##robot_{id(robot)}"
+        robot_open = imgui.tree_node(robot_label)
+        if imgui.is_item_clicked():
+            self._select(robot)
+
+        if robot_open:
+            # Joints subtree
+            joints_open = imgui.tree_node(f"Joints ({len(robot.joints)})##joints_{id(robot)}")
+            if joints_open:
+                for name, joint in robot.joints.items():
+                    clicked = imgui.selectable(
+                        f"  \U0001F517 {name}##joint_{id(joint)}",
+                        self._selected is joint,
+                    )[0]
+                    if clicked:
+                        self._select(joint)
+                imgui.tree_pop()
+
+            # Links subtree
+            links_open = imgui.tree_node(f"Links ({len(robot.links)})##links_{id(robot)}")
+            if links_open:
+                for name, link in robot.links.items():
+                    clicked = imgui.selectable(
+                        f"  \U0001F9F1 {name}##link_{id(link)}",
+                        self._selected is link,
+                    )[0]
+                    if clicked:
+                        self._select(link)
+                imgui.tree_pop()
+
+            imgui.tree_pop()
+
+    def _select(self, obj: Any) -> None:
+        """Handle selection of an object."""
+        self._selected = obj
+        if self._on_select is not None:
+            self._on_select(obj)
+
+    def __repr__(self) -> str:
+        return f"ExplorerPanel(robots={[r.name for r in self._robots]})"

bulletlab/ui/panels/plots.py

@@ -0,0 +1,143 @@
+"""
+PlotsPanel – renders inline live plots using ImGui's plot_lines primitive.
+
+Displays sparkline-style charts for telemetry channel histories directly
+inside the BulletLab ImGui control window. These are lightweight inline
+plots (not PyQtGraph). For full-featured windowed plots, use LivePlot.
+
+Example::
+
+    from bulletlab.ui.panels.plots import PlotsPanel
+    from bulletlab.telemetry import TelemetryManager
+
+    telemetry = TelemetryManager()
+    telemetry.watch("Speed", lambda: robot.speed)
+
+    plots = PlotsPanel(telemetry)
+    plots.render()
+"""
+
+from __future__ import annotations
+
+import array
+from typing import TYPE_CHECKING
+
+try:
+    import imgui
+
+    _HAS_IMGUI = True
+except ImportError:  # pragma: no cover
+    imgui = None  # type: ignore[assignment]
+    _HAS_IMGUI = False
+
+if TYPE_CHECKING:
+    from bulletlab.telemetry.manager import TelemetryManager
+
+
+class PlotsPanel:
+    """Renders inline sparkline plots for all telemetry channels.
+
+    Uses ImGui's built-in ``plot_lines`` which requires no external
+    plotting library. For production-quality plots, use
+    :class:`~bulletlab.plotting.live_plot.LivePlot`.
+
+    Args:
+        telemetry: The :class:`~bulletlab.telemetry.manager.TelemetryManager`
+            providing channel histories.
+        plot_height: Height of each individual sparkline in pixels.
+        max_display: Maximum number of channels to plot simultaneously.
+
+    Example::
+
+        plots_panel = PlotsPanel(telemetry)
+        plots_panel.render()
+    """
+
+    def __init__(
+        self,
+        telemetry: "TelemetryManager",
+        plot_height: float = 60.0,
+        max_display: int = 8,
+    ) -> None:
+        self._telemetry = telemetry
+        self._plot_height = plot_height
+        self._max_display = max_display
+
+    def render(self) -> None:
+        """Draw the plots panel contents.
+
+        Must be called inside an active ImGui window context.
+        """
+        if not _HAS_IMGUI:
+            return
+
+        channels = self._telemetry.channels
+        if not channels:
+            imgui.text_colored("No channels to plot.", 0.5, 0.5, 0.5, 1.0)
+            imgui.text("Add channels with telemetry.watch(...)")
+            return
+
+        shown = 0
+        for name, channel in channels.items():
+            if shown >= self._max_display:
+                imgui.text_colored(
+                    f"... and {len(channels) - shown} more channels",
+                    0.5, 0.5, 0.5, 1.0,
+                )
+                break
+
+            values = channel.values
+            if not values:
+                imgui.text(f"{name}: (no data)")
+                shown += 1
+                continue
+
+            # Build a contiguous C-float buffer.
+            # imgui.plot_lines() requires a bytes-like / buffer object —
+            # a plain Python list raises TypeError.
+            float_vals: list[float] = []
+            for v in values:
+                try:
+                    float_vals.append(float(v))
+                except (TypeError, ValueError):
+                    float_vals.append(0.0)
+
+            if not float_vals:
+                shown += 1
+                continue
+
+            buf = array.array("f", float_vals)   # contiguous single-precision floats
+
+            latest = float_vals[-1]
+            unit = channel.unit
+            unit_str = f" {unit}" if unit else ""
+            vmin = min(float_vals)
+            vmax = max(float_vals)
+            overlay = f"{latest:.3f}{unit_str}"
+            avail_w = imgui.get_content_region_available()[0]
+
+            try:
+                imgui.plot_lines(
+                    f"##{name}_plot",
+                    buf,
+                    overlay_text=overlay,
+                    scale_min=vmin - abs(vmin) * 0.1 - 1e-6,
+                    scale_max=vmax + abs(vmax) * 0.1 + 1e-6,
+                    graph_size=(avail_w, self._plot_height),
+                )
+            except Exception:
+                # Graceful fallback if this imgui version's plot_lines binding
+                # uses a different signature
+                imgui.text(f"{name}: {latest:.4f}{unit_str}")
+                shown += 1
+                continue
+
+            imgui.text_colored(
+                f"{name}: {latest:.4f}{unit_str}  [{vmin:.3f} – {vmax:.3f}]",
+                0.7, 0.9, 0.7, 1.0,
+            )
+            imgui.separator()
+            shown += 1
+
+    def __repr__(self) -> str:
+        return f"PlotsPanel(channels={self._telemetry.channel_names})"