robotframework-live-trace 0.1.0__tar.gz → 0.2.0__tar.gz

{robotframework_live_trace-0.1.0 → robotframework_live_trace-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-live-trace
-Version: 0.1.0
+Version: 0.2.0
 Summary: A live trace visualization for Robot Framework test runs.
 Keywords: robotframework,automation,testautomation,testing,debugging,visualization,trace,live
 Author: Manuel Ketterer
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Software Development :: Debuggers
-Requires-Dist: dearpygui>=2.2
+Requires-Dist: dearpygui>=2.0
 Requires-Dist: robotframework>=7.0
 Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/iDentitY4/robotframework-live-trace
@@ -29,26 +29,28 @@ Project-URL: Repository, https://github.com/iDentitY4/robotframework-live-trace.
 Project-URL: Issues, https://github.com/iDentitY4/robotframework-live-trace/issues
 Description-Content-Type: text/markdown
 
-# Robotframework Live Trace
+# Robot Framework Live Trace
 
-A real-time, cross-platform execution visualization dashboard for Robot Framework.
+A real-time, cross-platform test execution visualization for Robot Framework powered by [DearPyGui](https://github.com/hoffstadt/DearPyGui).
 
-Built on top of [Dear PyGui](https://github.com/hoffstadt/DearPyGui) and the Robot Framework Listener API (v3), this tool runs a high-performance, hardware-accelerated GUI in a completely isolated process. It allows you to monitor deeply nested keyword call stacks, inspect live arguments, and trace failures exactly as they happen without blocking your test execution.
+> Nothing has such power to broaden the mind as the ability to investigate systematically and truly all that comes under thy observation. - Marcus Aurelius
+
+![Demo Screenshot of RobotLiveTrace GUI](/images/demo-1.png)
 
 ## Features
 
-* **Live Execution Tree**: Watch your Suites, Tests, and Keywords expand and collapse in real-time.
-* **Dedicated Error Feed**: A split-pane chronological feed of all `WARN`, `ERROR`, and `FAIL` logs. Click any error to instantly expand the tree and highlight the exact keyword that caused it.
-* **Interactive Tooltips**: Hover over any keyword to see its execution time, status, and input arguments.
-* **Execution Control**: Pause and resume the active Robot Framework test run directly from the GUI.
-* **Smart Filtering**: Instantly search massive execution trees by keyword name, argument, or log message.
+* **Live Execution Tree**: Watch your Suites, Tests, Keywords, and control structures such as `FOR` and `IF` expand and collapse in real-time. Keywords that can't be found are shown too, and anything that didn't run is grayed out.
+* **Error Feed**: A split-pane chronological feed of all `WARN`, `ERROR`, and `FAIL` logs. Click any error to instantly expand the tree and highlight the exact keyword that caused it.
+* **Tooltips**: Hover over any keyword to see its execution time, status, and input arguments.
+* **Execution Control**: Pause and resume the active Robot Framework test run directly from the GUI, or pause automatically when a failure happens.
+* **Search and Filtering**: Instantly search large execution trees by keyword name, argument, or log message.
 * **Process Isolated**: Runs in a separate `multiprocessing` process, dodging the Python GIL and ensuring your test timings are not affected by GUI rendering overhead.
 
 ## Requirements
 
 * Python 3.10+
 * Robot Framework >= 7.0 *(Requires the V3 Listener API)*
-* Dear PyGui >= 2.2
+* Dear PyGui >= 2.0
 
 ## Installation
 
@@ -65,6 +67,14 @@ pip install robotframework-live-trace
 
 ```
 
+### RHEL, Rocky and AlmaLinux 9
+
+Dear PyGui 2.1 and newer need a newer `libstdc++` than these systems ship, so importing them fails with an error like ``version `GLIBCXX_3.4.30' not found``. Install Dear PyGui 2.0.0 instead (available for Python 3.13 and older):
+
+```bash
+pip install robotframework-live-trace "dearpygui==2.0.0"
+```
+
 ## Usage
 
 You do not need to modify your Robot Framework test files. Simply pass the listener to the `robot` command:
@@ -81,8 +91,9 @@ The Dear PyGui dashboard will open immediately, and the test execution will begi
 The top control bar provides several ways to manage large test executions:
 
 * **Pause**: Freezes the Robot Framework execution thread. Uncheck to resume.
+* **Pause on Failure**: Pauses where a keyword or control structure fails, and checks **Pause** so you can inspect it. Uncheck **Pause** to resume. This includes failures that are handled later, such as by `TRY/EXCEPT` or `Run Keyword And Ignore Error`, because they can't be told apart when they happen.
 * **Auto-Scroll**: Automatically scrolls the tree and error feed to the bottom as new keywords and logs arrive.
-* **Auto-Collapse Passed**: When a test or suite finishes with a `PASS` status, it will automatically collapse its tree node to keep the UI clean. Failed nodes will remain expanded.
+* **Auto-Collapse Passed**: When a keyword, test or suite finishes with a `PASS` or `NOT RUN` status, it will automatically collapse its tree node to keep the UI clean. Failed nodes will remain expanded.
 * **Expand All / Collapse All**: Instantly open or close all currently rendered tree nodes.
 * **Filter (Name/Args/Logs)**: Type to instantly hide non-matching keywords. The tree will automatically expand parents to reveal deeply nested matches.
 

robotframework_live_trace-0.2.0/README.md

@@ -0,0 +1,78 @@
+# Robot Framework Live Trace
+
+A real-time, cross-platform test execution visualization for Robot Framework powered by [DearPyGui](https://github.com/hoffstadt/DearPyGui).
+
+> Nothing has such power to broaden the mind as the ability to investigate systematically and truly all that comes under thy observation. - Marcus Aurelius
+
+![Demo Screenshot of RobotLiveTrace GUI](/images/demo-1.png)
+
+## Features
+
+* **Live Execution Tree**: Watch your Suites, Tests, Keywords, and control structures such as `FOR` and `IF` expand and collapse in real-time. Keywords that can't be found are shown too, and anything that didn't run is grayed out.
+* **Error Feed**: A split-pane chronological feed of all `WARN`, `ERROR`, and `FAIL` logs. Click any error to instantly expand the tree and highlight the exact keyword that caused it.
+* **Tooltips**: Hover over any keyword to see its execution time, status, and input arguments.
+* **Execution Control**: Pause and resume the active Robot Framework test run directly from the GUI, or pause automatically when a failure happens.
+* **Search and Filtering**: Instantly search large execution trees by keyword name, argument, or log message.
+* **Process Isolated**: Runs in a separate `multiprocessing` process, dodging the Python GIL and ensuring your test timings are not affected by GUI rendering overhead.
+
+## Requirements
+
+* Python 3.10+
+* Robot Framework >= 7.0 *(Requires the V3 Listener API)*
+* Dear PyGui >= 2.0
+
+## Installation
+
+Install the package directly from PyPI:
+
+```bash
+uv add robotframework-live-trace
+```
+
+or using pip:
+
+```bash
+pip install robotframework-live-trace
+
+```
+
+### RHEL, Rocky and AlmaLinux 9
+
+Dear PyGui 2.1 and newer need a newer `libstdc++` than these systems ship, so importing them fails with an error like ``version `GLIBCXX_3.4.30' not found``. Install Dear PyGui 2.0.0 instead (available for Python 3.13 and older):
+
+```bash
+pip install robotframework-live-trace "dearpygui==2.0.0"
+```
+
+## Usage
+
+You do not need to modify your Robot Framework test files. Simply pass the listener to the `robot` command:
+
+```bash
+robot --listener RobotLiveTrace my_tests/
+
+```
+
+The Dear PyGui dashboard will open immediately, and the test execution will begin. When the test suite finishes, the window will remain open so you can inspect the final call stack. Close the window to exit robotframework.
+
+## UI Controls
+
+The top control bar provides several ways to manage large test executions:
+
+* **Pause**: Freezes the Robot Framework execution thread. Uncheck to resume.
+* **Pause on Failure**: Pauses where a keyword or control structure fails, and checks **Pause** so you can inspect it. Uncheck **Pause** to resume. This includes failures that are handled later, such as by `TRY/EXCEPT` or `Run Keyword And Ignore Error`, because they can't be told apart when they happen.
+* **Auto-Scroll**: Automatically scrolls the tree and error feed to the bottom as new keywords and logs arrive.
+* **Auto-Collapse Passed**: When a keyword, test or suite finishes with a `PASS` or `NOT RUN` status, it will automatically collapse its tree node to keep the UI clean. Failed nodes will remain expanded.
+* **Expand All / Collapse All**: Instantly open or close all currently rendered tree nodes.
+* **Filter (Name/Args/Logs)**: Type to instantly hide non-matching keywords. The tree will automatically expand parents to reveal deeply nested matches.
+
+## Contributing
+
+Contributions, issues, and feature requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## License
+
+Distributed under the MIT License. See [LICENSE](LICENSE) for more information.
+
+### Third-Party Assets
+* **Noto Sans Font**: This package bundles the "Noto Sans" font. The font is licensed under the SIL Open Font License, Version 1.1. The full license text can be found in [src/RobotLiveTrace/fonts/OFL.txt](src/RobotLiveTrace/fonts/OFL.txt).

robotframework_live_trace-0.2.0/pyproject.toml

@@ -0,0 +1,64 @@
+[project]
+name = "robotframework-live-trace"
+version = "0.2.0"
+description = "A live trace visualization for Robot Framework test runs."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+dependencies = [
+    "dearpygui>=2.0",
+    "robotframework>=7.0",
+]
+keywords = [
+    "robotframework",
+    "automation",
+    "testautomation",
+    "testing",
+    "debugging",
+    "visualization",
+    "trace",
+    "live",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Robot Framework",
+    "Framework :: Robot Framework :: Tool",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Debuggers",
+]
+
+[[project.authors]]
+name = "Manuel Ketterer"
+email = "ps3udonym4@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/iDentitY4/robotframework-live-trace"
+Repository = "https://github.com/iDentitY4/robotframework-live-trace.git"
+Issues = "https://github.com/iDentitY4/robotframework-live-trace/issues"
+
+[build-system]
+requires = ["uv_build>=0.13.7,<0.14.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "RobotLiveTrace"
+
+[tool.ty.rules]
+unused-type-ignore-comment = "ignore"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "ruff>=0.15.2",
+    "ty>=0.0.18",
+]

robotframework_live_trace-0.1.0/pyproject.toml → robotframework_live_trace-0.2.0/pyproject.toml.orig

@@ -1,13 +1,13 @@
 [project]
 name = "robotframework-live-trace"
-version = "0.1.0"
+version = "0.2.0"
 description = "A live trace visualization for Robot Framework test runs."
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [{ name = "Manuel Ketterer", email = "ps3udonym4@gmail.com" }]
 requires-python = ">=3.10"
-dependencies = ["dearpygui>=2.2", "robotframework>=7.0"]
+dependencies = ["dearpygui>=2.0", "robotframework>=7.0"]
 keywords = [
     "robotframework",
     "automation",
@@ -41,7 +41,7 @@ Repository = "https://github.com/iDentitY4/robotframework-live-trace.git"
 Issues = "https://github.com/iDentitY4/robotframework-live-trace/issues"
 
 [build-system]
-requires = ["uv_build>=0.10.4,<0.11.0"]
+requires = ["uv_build>=0.13.7,<0.14.0"]
 build-backend = "uv_build"
 
 [tool.uv.build-backend]

{robotframework_live_trace-0.1.0 → robotframework_live_trace-0.2.0}/src/RobotLiveTrace/__init__.py

@@ -2,5 +2,5 @@ from RobotLiveTrace.listener import RobotLiveTrace
 from RobotLiveTrace.version import AUTHOR, VERSION
 
 __all__ = ["RobotLiveTrace"]
-__version = VERSION
+__version__ = VERSION
 __author__ = AUTHOR

{robotframework_live_trace-0.1.0 → robotframework_live_trace-0.2.0}/src/RobotLiveTrace/gui.py

@@ -20,12 +20,25 @@ class FontSize(enum.IntEnum):
         return f"{self.name.title()} ({self.value}px)"
 
 
+STATUS_THEMES = {"PASS": "pass", "NOT RUN": "not_run", "SKIP": "log_warn"}
+
+
+def preview(text: str) -> str:
+    """Shorten text to one line so it doesn't break the UI layout."""
+    single_line = text.replace("\n", " ")
+    return single_line if len(single_line) < 80 else single_line[:77] + "..."
+
+
 class GUI:
     def __init__(
-        self, message_queue: queue.Queue[Message], pause_event: Event | None = None
+        self,
+        message_queue: queue.Queue[Message],
+        pause_event: Event | None = None,
+        pause_on_failure_event: Event | None = None,
     ) -> None:
         self.message_queue = message_queue
         self.pause_event = pause_event
+        self.pause_on_failure_event = pause_on_failure_event
 
         self.all_nodes: list[int | str] = []
         self.node_parents: dict[int | str, Any] = {}
@@ -46,6 +59,7 @@ class GUI:
             "start_test": "[TEST]",
             "start_user_keyword": "[USER-KW]",
             "start_library_keyword": "[LIB-KW]",
+            "start_invalid_keyword": "[INVALID-KW]",
         }
 
     def setup_icons(self) -> None:
@@ -88,6 +102,11 @@ class GUI:
             with dpg.theme_component(dpg.mvTreeNode):
                 dpg.add_theme_color(dpg.mvThemeCol_Text, (180, 180, 180, 255))
 
+        with dpg.theme() as self.themes["not_run"]:
+            with dpg.theme_component(dpg.mvTreeNode):
+                # Dim gray text for keywords and branches that didn't run
+                dpg.add_theme_color(dpg.mvThemeCol_Text, (120, 120, 120, 255))
+
         with dpg.theme() as self.themes["highlight"]:
             with dpg.theme_component(dpg.mvAll):
                 # Bright Yellow text so it pops out instantly
@@ -130,7 +149,16 @@ class GUI:
                     )
 
             with dpg.group(horizontal=True):
-                dpg.add_checkbox(label="Pause Execution", callback=self.toggle_pause)
+                dpg.add_checkbox(
+                    label="Pause Execution",
+                    tag="pause_toggle",
+                    callback=self.toggle_pause,
+                )
+                dpg.add_text(" | ")
+                dpg.add_checkbox(
+                    label="Pause on Failure",
+                    callback=self.toggle_pause_on_failure,
+                )
                 dpg.add_text(" | ")
                 dpg.add_checkbox(
                     label="Auto-Scroll", tag="auto_scroll_toggle", default_value=True
@@ -197,6 +225,20 @@ class GUI:
         else:
             self.pause_event.set()  # Resume the listener process
 
+    def toggle_pause_on_failure(self, sender: int, app_data: Any):
+        if self.pause_on_failure_event is None:
+            return
+
+        if app_data:
+            self.pause_on_failure_event.set()
+        else:
+            self.pause_on_failure_event.clear()
+
+    def sync_pause_toggle(self) -> None:
+        # The listener can pause on its own when a failure happens
+        if self.pause_event is not None:
+            dpg.set_value("pause_toggle", not self.pause_event.is_set())
+
     def expand_all(self, sender: int, app_data: Any):
         for node_id in self.all_nodes:
             dpg.set_value(node_id, True)
@@ -279,9 +321,9 @@ class GUI:
         name = data.get("name", "Unknown")
         args = data.get("args", [])
 
-        prefix = self.prefixes.get(action, "[*]")
+        prefix = self.prefixes.get(action, "")
         parent_id = self.active_stack[-1]
-        base_label = f"{prefix} {name}"
+        base_label = preview(f"{prefix} {name}".strip())
 
         node_id = dpg.add_tree_node(
             label=base_label, parent=parent_id, default_open=True
@@ -299,7 +341,7 @@ class GUI:
             dpg.add_text(
                 f"Type: {action.replace('start_', '').replace('_', ' ').title()}"
             )
-            dpg.add_text(f"Name: {name}")
+            dpg.add_text(f"Name: {name}", wrap=600)
 
             if args:
                 dpg.add_text(f"Args: {', '.join(args)}")
@@ -326,13 +368,10 @@ class GUI:
         full_txt = result.get("message", "<MISSING LOG MESSAGE>")
         timestamp = result.get("timestamp", "<NO TIMESTAMP>")
 
-        # Truncate text for the tree label so it doesn't break the UI layout
-        # Replace newlines with spaces for a cleaner single-line preview
         clean_txt = full_txt.replace("\n", " ")
-        display_txt = clean_txt if len(clean_txt) < 80 else clean_txt[:77] + "..."
 
         node_id = dpg.add_tree_node(
-            label=f"[{level}] {display_txt}",
+            label=f"[{level}] {preview(full_txt)}",
             parent=parent_id,
             leaf=True,
         )
@@ -392,19 +431,28 @@ class GUI:
         status = result.get("status", "UNKNOWN")
         elapsed = result.get("elapsed_time", 0.0)
 
-        if status == "PASS":
-            dpg.bind_item_theme(node_id, self.themes["pass"])
-            self.node_themes[node_id] = self.themes["pass"]
+        theme = self.themes[STATUS_THEMES.get(status, "fail")]
+        dpg.bind_item_theme(node_id, theme)
+        self.node_themes[node_id] = theme
 
-            if dpg.get_value("auto_collapse_toggle"):
-                dpg.set_value(node_id, False)
-        else:
-            dpg.bind_item_theme(node_id, self.themes["fail"])
-            self.node_themes[node_id] = self.themes["fail"]
+        if status in ("PASS", "NOT RUN") and dpg.get_value("auto_collapse_toggle"):
+            dpg.set_value(node_id, False)
 
         dpg.set_value(node["status_id"], f"Status: {status}")
         dpg.set_value(node["time_id"], f"Elapsed Time: {elapsed} s")
 
+    def handle_message(self, msg: Message) -> None:
+        action = msg.get("action", "unknown")
+        data = msg.get("data", None)
+        result = msg.get("result", None)
+
+        if action.startswith("start_") and data is not None:
+            self.handle_start(action, data=data)
+        elif action == "log_message" and result is not None:
+            self.handle_log(result)
+        elif action.startswith("end_") and result is not None:
+            self.handle_end(action, result)
+
     def run(self) -> None:
         dpg.create_context()
         dpg.create_viewport(title="RobotLiveTrace", width=1400, height=800)
@@ -429,23 +477,12 @@ class GUI:
 
             try:
                 while True:
-                    msg: Message = self.message_queue.get_nowait()
-                    action = msg.get("action", "unknown")
-                    data = msg.get("data", None)
-                    result = msg.get("result", None)
-
-                    if action.startswith("start_") and data is not None:
-                        self.handle_start(
-                            action,
-                            data=data,
-                        )
-                    elif action == "log_message" and result is not None:
-                        self.handle_log(result)
-                    elif action.startswith("end_") and result is not None:
-                        self.handle_end(action, result)
+                    self.handle_message(self.message_queue.get_nowait())
             except queue.Empty:
                 pass
 
+            self.sync_pause_toggle()
+
             if self.needs_filter_update and dpg.get_value("filter_input"):
                 self.apply_filter()
 
@@ -461,8 +498,12 @@ class GUI:
         dpg.destroy_context()
 
 
-def run_gui(q: queue.Queue[Message], pause_event: Event | None = None):
-    gui = GUI(q, pause_event)
+def run_gui(
+    q: queue.Queue[Message],
+    pause_event: Event | None = None,
+    pause_on_failure_event: Event | None = None,
+):
+    gui = GUI(q, pause_event, pause_on_failure_event)
     gui.run()
 
 

robotframework_live_trace-0.2.0/src/RobotLiveTrace/listener.py

@@ -0,0 +1,225 @@
+import multiprocessing
+import queue
+from collections.abc import Callable
+from typing import Any
+
+from robot.model import ModelObject  # type: ignore
+from robot.utils import safe_str  # type: ignore
+
+from RobotLiveTrace.message import Message
+
+
+# These only hold IF and TRY branches, so showing them would just add a tree level.
+_BRANCH_CONTAINERS = ("IF/ELSE ROOT", "TRY/EXCEPT ROOT")
+
+
+def _body_item_name(data: Any) -> str:
+    if data.type != "ITERATION":
+        return str(data)
+
+    # FOR iterations have assigned values, WHILE iterations have none
+    values = getattr(data, "assign", {})
+    assigned = ", ".join(f"{name} = {safe_str(v)}" for name, v in values.items())
+    return f"ITERATION    {assigned}".rstrip()
+
+
+def _load_run_gui() -> Callable[..., None]:
+    """Import the GUI on demand so a broken Dear PyGui install gets a clear error."""
+    try:
+        from RobotLiveTrace.gui import run_gui
+    except ImportError as error:
+        raise ImportError(
+            f"RobotLiveTrace could not load Dear PyGui: {error}\n"
+            "If this mentions GLIBC or GLIBCXX (for example on RHEL, Rocky or "
+            "AlmaLinux 9), install a compatible version with: "
+            'pip install "dearpygui==2.0.0"'
+        ) from error
+
+    return run_gui
+
+
+class RobotLiveTrace:
+    """A Robot Framework listener that provides a real-time execution trace viewer.
+
+    Usage:
+        To use this listener, run your Robot Framework tests with the --listener
+        option:
+
+        `robot --listener RobotLiveTrace path/to/tests.robot`
+    """
+
+    ROBOT_LISTENER_API_VERSION = 3
+
+    def __init__(self):
+        run_gui = _load_run_gui()
+
+        self.message_queue = multiprocessing.Queue()
+        self.pause_event = multiprocessing.Event()
+        self.pause_event.set()
+        self.pause_on_failure_event = multiprocessing.Event()
+        self.last_failure_id = ""
+
+        self.gui_process = multiprocessing.Process(
+            target=run_gui,
+            args=(self.message_queue, self.pause_event, self.pause_on_failure_event),
+        )
+        self.gui_process.start()
+
+    def _wait_and_send(
+        self,
+        action: str,
+        data: dict[str, Any] | None = None,
+        result: dict[str, Any] | None = None,
+    ):
+        """
+        Helper method to enforce pausing and send a message to the GUI.
+        """
+
+        if not self.gui_process.is_alive():
+            return
+
+        while not self.pause_event.is_set():
+            if not self.gui_process.is_alive():
+                return
+            self.pause_event.wait(timeout=0.2)
+
+        message: Message = {
+            "action": action,
+            "data": data,
+            "result": result,
+        }
+
+        try:
+            self.message_queue.put(message)
+        except (queue.Full, ValueError):
+            pass
+
+    def _send_start(self, action: str, data: Any):
+        # Only send what the GUI displays. Arguments are converted to strings
+        # because libraries can pass any object, including ones that can't be
+        # pickled, when calling keywords programmatically.
+        payload: dict[str, Any] = {"name": data.name}
+        args = getattr(data, "args", ())
+        if args:
+            payload["args"] = [safe_str(arg) for arg in args]
+
+        self._wait_and_send(action, data=payload)
+
+    def _send_end(self, action: str, result: Any):
+        self._wait_and_send(
+            action,
+            result={
+                "status": result.status,
+                "elapsed_time": result.elapsed_time.total_seconds(),
+            },
+        )
+
+    def _pause_if_failure_started_here(self, result: Any):
+        """Request a pause, which takes effect when the next event is sent.
+
+        A failure also ends every parent as failed. IDs are hierarchical, so an
+        item whose ID prefixes the previous failure's ID is only passing it on.
+        """
+        if result.status != "FAIL":
+            return
+
+        passed_on = self.last_failure_id.startswith(f"{result.id}-")
+        self.last_failure_id = result.id
+
+        if not passed_on and self.pause_on_failure_event.is_set():
+            self.pause_event.clear()
+
+    def _send_keyword_end(self, action: str, result: Any):
+        self._send_end(action, result)
+        self._pause_if_failure_started_here(result)
+
+    def start_suite(self, data: ModelObject, result: ModelObject):
+        self._send_start("start_suite", data)
+
+    def end_suite(self, data: ModelObject, result: ModelObject):
+        self._send_end("end_suite", result)
+
+    def start_test(self, data: ModelObject, result: ModelObject):
+        self._send_start("start_test", data)
+
+    def end_test(self, data: ModelObject, result: ModelObject):
+        self._send_end("end_test", result)
+
+    def start_user_keyword(
+        self,
+        data: ModelObject,
+        implementation: ModelObject,
+        result: ModelObject,
+    ):
+        self._send_start("start_user_keyword", data)
+
+    def end_user_keyword(
+        self,
+        data: ModelObject,
+        implementation: ModelObject,
+        result: ModelObject,
+    ):
+        self._send_keyword_end("end_user_keyword", result)
+
+    def start_library_keyword(
+        self,
+        data: ModelObject,
+        implementation: ModelObject,
+        result: ModelObject,
+    ):
+        self._send_start("start_library_keyword", data)
+
+    def end_library_keyword(
+        self,
+        data: ModelObject,
+        implementation: ModelObject,
+        result: ModelObject,
+    ):
+        self._send_keyword_end("end_library_keyword", result)
+
+    def start_invalid_keyword(
+        self,
+        data: ModelObject,
+        implementation: ModelObject,
+        result: ModelObject,
+    ):
+        self._send_start("start_invalid_keyword", data)
+
+    def end_invalid_keyword(
+        self,
+        data: ModelObject,
+        implementation: ModelObject,
+        result: ModelObject,
+    ):
+        self._send_keyword_end("end_invalid_keyword", result)
+
+    def start_body_item(self, data: Any, result: ModelObject):
+        """Called for everything without its own method, such as FOR and IF."""
+        if data.type not in _BRANCH_CONTAINERS:
+            self._wait_and_send(
+                f"start_{data.type.lower()}", data={"name": _body_item_name(data)}
+            )
+
+    def end_body_item(self, data: Any, result: Any):
+        if data.type not in _BRANCH_CONTAINERS:
+            self._send_keyword_end(f"end_{data.type.lower()}", result)
+
+    def log_message(self, message: Any):
+        result = {"level": message.level, "message": message.message}
+        if message.timestamp:
+            result["timestamp"] = message.timestamp.isoformat()
+
+        self._wait_and_send("log_message", result=result)
+
+    def close(self):
+        # We join the process here. This intentionally blocks Robot Framework
+        # from completely exiting until you manually close the GUI window,
+        # allowing you to inspect the final call stack tree.
+
+        self.message_queue.cancel_join_thread()
+
+        if self.gui_process.is_alive():
+            print(
+                "RobotLiveTrace is open. Close the GUI window to exit Robot Framework."
+            )
+            self.gui_process.join()

robotframework_live_trace-0.1.0/README.md

@@ -1,67 +0,0 @@
-# Robotframework Live Trace
-
-A real-time, cross-platform execution visualization dashboard for Robot Framework.
-
-Built on top of [Dear PyGui](https://github.com/hoffstadt/DearPyGui) and the Robot Framework Listener API (v3), this tool runs a high-performance, hardware-accelerated GUI in a completely isolated process. It allows you to monitor deeply nested keyword call stacks, inspect live arguments, and trace failures exactly as they happen without blocking your test execution.
-
-## Features
-
-* **Live Execution Tree**: Watch your Suites, Tests, and Keywords expand and collapse in real-time.
-* **Dedicated Error Feed**: A split-pane chronological feed of all `WARN`, `ERROR`, and `FAIL` logs. Click any error to instantly expand the tree and highlight the exact keyword that caused it.
-* **Interactive Tooltips**: Hover over any keyword to see its execution time, status, and input arguments.
-* **Execution Control**: Pause and resume the active Robot Framework test run directly from the GUI.
-* **Smart Filtering**: Instantly search massive execution trees by keyword name, argument, or log message.
-* **Process Isolated**: Runs in a separate `multiprocessing` process, dodging the Python GIL and ensuring your test timings are not affected by GUI rendering overhead.
-
-## Requirements
-
-* Python 3.10+
-* Robot Framework >= 7.0 *(Requires the V3 Listener API)*
-* Dear PyGui >= 2.2
-
-## Installation
-
-Install the package directly from PyPI:
-
-```bash
-uv add robotframework-live-trace
-```
-
-or using pip:
-
-```bash
-pip install robotframework-live-trace
-
-```
-
-## Usage
-
-You do not need to modify your Robot Framework test files. Simply pass the listener to the `robot` command:
-
-```bash
-robot --listener RobotLiveTrace my_tests/
-
-```
-
-The Dear PyGui dashboard will open immediately, and the test execution will begin. When the test suite finishes, the window will remain open so you can inspect the final call stack. Close the window to exit robotframework.
-
-## UI Controls
-
-The top control bar provides several ways to manage large test executions:
-
-* **Pause**: Freezes the Robot Framework execution thread. Uncheck to resume.
-* **Auto-Scroll**: Automatically scrolls the tree and error feed to the bottom as new keywords and logs arrive.
-* **Auto-Collapse Passed**: When a test or suite finishes with a `PASS` status, it will automatically collapse its tree node to keep the UI clean. Failed nodes will remain expanded.
-* **Expand All / Collapse All**: Instantly open or close all currently rendered tree nodes.
-* **Filter (Name/Args/Logs)**: Type to instantly hide non-matching keywords. The tree will automatically expand parents to reveal deeply nested matches.
-
-## Contributing
-
-Contributions, issues, and feature requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md)
-
-## License
-
-Distributed under the MIT License. See [LICENSE](LICENSE) for more information.
-
-### Third-Party Assets
-* **Noto Sans Font**: This package bundles the "Noto Sans" font. The font is licensed under the SIL Open Font License, Version 1.1. The full license text can be found in [src/RobotLiveTrace/fonts/OFL.txt](src/RobotLiveTrace/fonts/OFL.txt).

robotframework_live_trace-0.1.0/src/RobotLiveTrace/listener.py

@@ -1,112 +0,0 @@
-import multiprocessing
-import queue
-
-from robot.model import ModelObject  # type: ignore
-
-from RobotLiveTrace.gui import run_gui
-from RobotLiveTrace.message import Message
-
-
-class RobotLiveTrace:
-    """ """
-
-    ROBOT_LISTENER_API_VERSION = 3
-
-    def __init__(self):
-        self.message_queue = multiprocessing.Queue()
-        self.pause_event = multiprocessing.Event()
-        self.pause_event.set()
-
-        self.gui_process = multiprocessing.Process(
-            target=run_gui, args=(self.message_queue, self.pause_event)
-        )
-        self.gui_process.start()
-
-    def _wait_and_send(
-        self,
-        action: str,
-        data: ModelObject | None = None,
-        result: ModelObject | None = None,
-    ):
-        """
-        Helper method to enforce pausing and serialize data.
-        """
-
-        if not self.gui_process.is_alive():
-            return
-
-        while not self.pause_event.is_set():
-            if not self.gui_process.is_alive():
-                return
-            self.pause_event.wait(timeout=0.2)
-
-        message: Message = {
-            "action": action,
-            "data": data.to_dict() if data else None,
-            "result": result.to_dict() if result else None,
-        }
-
-        try:
-            self.message_queue.put(message)
-        except (queue.Full, ValueError):
-            pass
-
-    def start_suite(self, data: ModelObject, result: ModelObject):
-        self._wait_and_send("start_suite", data=data, result=result)
-
-    def end_suite(self, data: ModelObject, result: ModelObject):
-        self._wait_and_send("end_suite", data=data, result=result)
-
-    def start_test(self, data: ModelObject, result: ModelObject):
-        self._wait_and_send("start_test", data=data, result=result)
-
-    def end_test(self, data: ModelObject, result: ModelObject):
-        self._wait_and_send("end_test", data=data, result=result)
-
-    def start_user_keyword(
-        self,
-        data: ModelObject,
-        implementation: ModelObject,
-        result: ModelObject,
-    ):
-        self._wait_and_send("start_user_keyword", data=data, result=result)
-
-    def end_user_keyword(
-        self,
-        data: ModelObject,
-        implementation: ModelObject,
-        result: ModelObject,
-    ):
-        self._wait_and_send("end_user_keyword", data=data, result=result)
-
-    def start_library_keyword(
-        self,
-        data: ModelObject,
-        implementation: ModelObject,
-        result: ModelObject,
-    ):
-        self._wait_and_send("start_library_keyword", data=data, result=result)
-
-    def end_library_keyword(
-        self,
-        data: ModelObject,
-        implementation: ModelObject,
-        result: ModelObject,
-    ):
-        self._wait_and_send("end_library_keyword", data=data, result=result)
-
-    def log_message(self, message: ModelObject):
-        self._wait_and_send("log_message", result=message)
-
-    def close(self):
-        # We join the process here. This intentionally blocks Robot Framework
-        # from completely exiting until you manually close the GUI window,
-        # allowing you to inspect the final call stack tree.
-
-        self.message_queue.cancel_join_thread()
-
-        if self.gui_process.is_alive():
-            print(
-                "RobotLiveTrace is open. Close the GUI window to exit Robot Framework."
-            )
-            self.gui_process.join()