robotframework-live-trace 0.1.0__py3-none-any.whl

RobotLiveTrace/__init__.py

@@ -0,0 +1,6 @@
+from RobotLiveTrace.listener import RobotLiveTrace
+from RobotLiveTrace.version import AUTHOR, VERSION
+
+__all__ = ["RobotLiveTrace"]
+__version = VERSION
+__author__ = AUTHOR

RobotLiveTrace/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-greek-cyrillic)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

RobotLiveTrace/gui.py

@@ -0,0 +1,470 @@
+import enum
+import queue
+from importlib.resources import files
+from multiprocessing.synchronize import Event
+from typing import Any
+
+import dearpygui.dearpygui as dpg  # type: ignore
+
+from RobotLiveTrace.message import Message
+from RobotLiveTrace.version import AUTHOR, VERSION
+
+
+class FontSize(enum.IntEnum):
+    TINY = 10
+    SMALL = 14
+    NORMAL = 18
+    LARGE = 24
+
+    def __str__(self) -> str:
+        return f"{self.name.title()} ({self.value}px)"
+
+
+class GUI:
+    def __init__(
+        self, message_queue: queue.Queue[Message], pause_event: Event | None = None
+    ) -> None:
+        self.message_queue = message_queue
+        self.pause_event = pause_event
+
+        self.all_nodes: list[int | str] = []
+        self.node_parents: dict[int | str, Any] = {}
+        self.node_search_text: dict[int | str, str] = {}
+        self.node_themes: dict[int | str, int] = {}
+        self.node_data: dict[int | str, dict[str, Any]] = {}
+        self.active_stack: list[int | str] = ["tree_container"]
+
+        self.font_sizes: dict[FontSize, int | str] = {}
+        self.default_font_size = FontSize.NORMAL
+        self.themes: dict[str, int] = {}
+
+        self.needs_filter_update = False
+        self.items_added_this_frame = False
+
+        self.prefixes = {
+            "start_suite": "[SUITE]",
+            "start_test": "[TEST]",
+            "start_user_keyword": "[USER-KW]",
+            "start_library_keyword": "[LIB-KW]",
+        }
+
+    def setup_icons(self) -> None:
+        pass
+        # if sys.platform == "win32":
+        #     icon_file = files("RobotLiveTrace").joinpath("icons/app_icon.ico")
+        #     dpg.set_viewport_small_icon(str(icon_file))
+
+    def setup_fonts(self) -> None:
+        font_file = files("RobotLiveTrace").joinpath("fonts/NotoSans-Regular.ttf")
+
+        # Setup fonts
+        with dpg.font_registry():
+            font_path = str(font_file)
+
+            for size in FontSize:
+                self.font_sizes[size] = dpg.add_font(font_path, size.value)
+
+    def setup_themes(self) -> None:
+        with dpg.theme() as self.themes["running"]:
+            with dpg.theme_component(dpg.mvTreeNode):
+                # Light Blue text for running keywords
+                dpg.add_theme_color(dpg.mvThemeCol_Text, (100, 200, 255, 255))
+
+        with dpg.theme() as self.themes["pass"]:
+            with dpg.theme_component(dpg.mvTreeNode):
+                # Green text for passed keywords
+                dpg.add_theme_color(dpg.mvThemeCol_Text, (50, 255, 50, 255))
+
+        with dpg.theme() as self.themes["fail"]:
+            with dpg.theme_component(dpg.mvTreeNode):
+                # Red text for failed keywords
+                dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 50, 50, 255))
+
+        with dpg.theme() as self.themes["log_warn"]:
+            with dpg.theme_component(dpg.mvTreeNode):
+                dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 200, 50, 255))
+
+        with dpg.theme() as self.themes["log_info"]:
+            with dpg.theme_component(dpg.mvTreeNode):
+                dpg.add_theme_color(dpg.mvThemeCol_Text, (180, 180, 180, 255))
+
+        with dpg.theme() as self.themes["highlight"]:
+            with dpg.theme_component(dpg.mvAll):
+                # Bright Yellow text so it pops out instantly
+                dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 255, 0, 255))
+
+    def setup_layout(self) -> None:
+        with dpg.window(
+            label="Call Stack",
+            tag="main_window",
+            width=1400,
+            height=800,
+            no_close=True,
+            no_collapse=True,
+            no_resize=True,
+            no_move=True,
+            no_title_bar=True,
+        ):
+            with dpg.menu_bar():
+                with dpg.menu(label="Menu"):
+                    with dpg.menu(
+                        label="Settings",
+                    ):
+                        dpg.add_combo(
+                            [str(size) for size in self.font_sizes],
+                            label="Font Size",
+                            default_value=str(self.default_font_size),
+                            width=150,
+                            callback=self.change_font_size,
+                        )
+
+                    dpg.add_menu_item(
+                        label="About RobotLiveTrace", callback=self.show_about
+                    )
+                    dpg.add_menu_item(
+                        label="About Dearpygui",
+                        callback=lambda: dpg.show_tool(dpg.mvTool_About),
+                    )
+                    dpg.add_menu_item(
+                        label="Exit", callback=lambda: dpg.stop_dearpygui()
+                    )
+
+            with dpg.group(horizontal=True):
+                dpg.add_checkbox(label="Pause Execution", callback=self.toggle_pause)
+                dpg.add_text(" | ")
+                dpg.add_checkbox(
+                    label="Auto-Scroll", tag="auto_scroll_toggle", default_value=True
+                )
+                dpg.add_text(" | ")
+                dpg.add_checkbox(
+                    label="Auto-Collapse Passed",
+                    tag="auto_collapse_toggle",
+                    default_value=True,
+                )
+                dpg.add_text(" | ")
+                dpg.add_button(label="Expand All", callback=self.expand_all)
+                dpg.add_button(label="Collapse All", callback=self.collapse_all)
+
+            with dpg.group(horizontal=True):
+                dpg.add_input_text(
+                    label="Filter (Name/Args)",
+                    tag="filter_input",
+                    callback=self.apply_filter,
+                    width=300,
+                )
+
+            dpg.add_separator()
+
+            with dpg.group(horizontal=True):
+                with dpg.child_window(
+                    tag="tree_container", width=900, resizable_x=True
+                ):
+                    pass
+
+                with dpg.child_window(tag="error_feed_container"):
+                    dpg.add_text("Error & Warning Feed", color=(255, 100, 100))
+                    dpg.add_separator()
+
+    def setup_extras(self) -> None:
+        with dpg.window(
+            label="About RobotLiveTrace",
+            tag="about_window",
+            width=400,
+            pos=(200, 200),
+            show=False,
+            no_resize=True,
+        ):
+            dpg.add_text("RobotLiveTrace", color=(100, 200, 255), wrap=380)
+            dpg.add_text(
+                "A real-time execution trace viewer for Robot Framework, built with DearPyGui.",
+                wrap=380,
+            )
+            dpg.add_separator()
+            dpg.add_text(f"Version: {VERSION}")
+            dpg.add_separator()
+            dpg.add_text("Authors:", color=(100, 200, 255))
+            dpg.add_text(f"{AUTHOR}")
+
+    #
+    # Callbacks
+    #
+    def toggle_pause(self, sender: int, app_data: Any):
+        if self.pause_event is None:
+            return
+
+        if app_data:
+            self.pause_event.clear()  # Block the listener process
+        else:
+            self.pause_event.set()  # Resume the listener process
+
+    def expand_all(self, sender: int, app_data: Any):
+        for node_id in self.all_nodes:
+            dpg.set_value(node_id, True)
+
+    def collapse_all(self, sender: int, app_data: Any):
+        for node_id in self.all_nodes:
+            dpg.set_value(node_id, False)
+
+    def apply_filter(self, sender: int | None = None, app_data: Any | None = None):
+        search_string = dpg.get_value("filter_input").lower()
+
+        if not search_string:
+            for node_id in self.all_nodes:
+                dpg.show_item(node_id)
+            return
+
+        matches = set()
+        for node_id, txt in self.node_search_text.items():
+            if search_string in txt:
+                matches.add(node_id)
+
+        visible_set = set(matches)
+        for node_id in matches:
+            curr = self.node_parents.get(node_id)
+            while curr and curr not in ("tree_container", "main_window"):
+                visible_set.add(curr)
+                dpg.set_value(
+                    curr, True
+                )  # Auto-expand the parent so we can see the match
+                curr = self.node_parents.get(curr)
+
+        for node_id in self.all_nodes:
+            if node_id in visible_set:
+                dpg.show_item(node_id)
+            else:
+                dpg.hide_item(node_id)
+
+    def jump_to_node(self, sender: int, app_data: Any, user_data: Any):
+        target_node = user_data
+
+        if target_node is None or not dpg.does_item_exist(target_node):
+            return
+
+        if app_data:
+            dpg.bind_item_theme(target_node, self.themes["highlight"])
+
+            curr = self.node_parents.get(target_node)
+            while curr and curr not in ("tree_container", "main_window"):
+                dpg.set_value(curr, True)
+                curr = self.node_parents.get(curr)
+
+            dpg.focus_item(target_node)
+        else:
+            original_theme = self.node_themes.get(target_node, self.themes["running"])
+            dpg.bind_item_theme(target_node, original_theme)
+
+    def change_font_size(self, sender, app_data):
+        if app_data is None:
+            return
+
+        for size, font_id in self.font_sizes.items():
+            if str(size) == app_data:
+                dpg.bind_font(font_id)
+                dpg.bind_item_font("main_window", font_id)
+                dpg.bind_item_font("about_window", font_id)
+                break
+
+    def show_about(self, sender: int, app_data: Any):
+        dpg.show_item("about_window")
+
+    #
+    # Message handling
+    #
+
+    def handle_start(
+        self,
+        action: str,
+        data: dict[str, Any],
+    ) -> None:
+        name = data.get("name", "Unknown")
+        args = data.get("args", [])
+
+        prefix = self.prefixes.get(action, "[*]")
+        parent_id = self.active_stack[-1]
+        base_label = f"{prefix} {name}"
+
+        node_id = dpg.add_tree_node(
+            label=base_label, parent=parent_id, default_open=True
+        )
+        dpg.bind_item_theme(node_id, self.themes["running"])
+        self.node_themes[node_id] = self.themes["running"]
+
+        self.all_nodes.append(node_id)
+        self.node_parents[node_id] = parent_id
+        self.node_search_text[node_id] = f"{name} {' '.join(args)}".lower()
+        self.needs_filter_update = True
+        self.items_added_this_frame = True
+
+        with dpg.tooltip(node_id):
+            dpg.add_text(
+                f"Type: {action.replace('start_', '').replace('_', ' ').title()}"
+            )
+            dpg.add_text(f"Name: {name}")
+
+            if args:
+                dpg.add_text(f"Args: {', '.join(args)}")
+
+            status_id = dpg.add_text("Status: Running...")
+            time_id = dpg.add_text("Elapsed Time: Running...")
+            dpg.add_separator()
+
+        self.active_stack.append(node_id)
+
+        self.node_data[node_id] = {
+            "label": base_label,
+            "status_id": status_id,
+            "time_id": time_id,
+        }
+
+    def handle_log(self, result: dict[str, Any]) -> None:
+        if len(self.active_stack) <= 1:
+            return
+
+        parent_id = self.active_stack[-1]
+
+        level = result.get("level", "<UNKNOWN>")
+        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}",
+            parent=parent_id,
+            leaf=True,
+        )
+
+        if level in ["WARN", "WARNING"]:
+            dpg.bind_item_theme(node_id, self.themes["log_warn"])
+            self.node_themes[node_id] = self.themes["log_warn"]
+        elif level in ["FAIL", "ERROR"]:
+            dpg.bind_item_theme(node_id, self.themes["fail"])
+            self.node_themes[node_id] = self.themes["fail"]
+        else:
+            dpg.bind_item_theme(node_id, self.themes["log_info"])
+            self.node_themes[node_id] = self.themes["log_info"]
+
+        self.all_nodes.append(node_id)
+        self.node_parents[node_id] = parent_id
+        self.node_search_text[node_id] = f"{level} {full_txt}".lower()
+        self.needs_filter_update = True
+        self.items_added_this_frame = True
+
+        with dpg.tooltip(node_id):
+            dpg.add_text(f"Level: {level}")
+            dpg.add_text(f"Time: {timestamp}")
+            dpg.add_text(full_txt, wrap=600)
+            dpg.add_separator()
+
+        # Error feed
+        if level in ["FAIL", "ERROR", "WARN", "WARNING"]:
+            parent_data = self.node_data.get(parent_id, {"label": "Unknown context"})
+            context_name = parent_data["label"]
+
+            error_item = dpg.add_selectable(
+                label=f"[{level}] {context_name}",
+                callback=self.jump_to_node,
+                user_data=node_id,
+                parent="error_feed_container",
+            )
+
+            if level in ["FAIL", "ERROR"]:
+                dpg.bind_item_theme(error_item, self.themes["fail"])
+            else:
+                dpg.bind_item_theme(error_item, self.themes["log_warn"])
+
+            dpg.add_text(clean_txt, wrap=440, parent="error_feed_container")
+            dpg.add_separator(parent="error_feed_container")
+
+    def handle_end(self, action: str, result: dict[str, Any]) -> None:
+        if len(self.active_stack) <= 1:
+            return
+
+        node_id = self.active_stack.pop()
+        node = self.node_data.get(node_id)
+
+        if node is None or not dpg.does_item_exist(node_id):
+            return
+
+        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"]
+
+            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"]
+
+        dpg.set_value(node["status_id"], f"Status: {status}")
+        dpg.set_value(node["time_id"], f"Elapsed Time: {elapsed} s")
+
+    def run(self) -> None:
+        dpg.create_context()
+        dpg.create_viewport(title="RobotLiveTrace", width=1400, height=800)
+        dpg.setup_dearpygui()
+
+        self.setup_icons()
+        self.setup_fonts()
+        self.setup_themes()
+        self.setup_layout()
+        self.setup_extras()
+
+        dpg.set_primary_window("main_window", True)
+        default_font = self.font_sizes[self.default_font_size]
+        dpg.bind_item_font("main_window", default_font)
+        dpg.bind_item_font("about_window", default_font)
+
+        dpg.show_viewport()
+
+        while dpg.is_dearpygui_running():
+            self.needs_filter_update = False
+            self.items_added_this_frame = False
+
+            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)
+            except queue.Empty:
+                pass
+
+            if self.needs_filter_update and dpg.get_value("filter_input"):
+                self.apply_filter()
+
+            if self.items_added_this_frame and dpg.get_value("auto_scroll_toggle"):
+                dpg.set_y_scroll("tree_container", 999999)
+                dpg.set_y_scroll("error_feed_container", 999999)
+
+            dpg.render_dearpygui_frame()
+
+        if self.pause_event is not None:
+            self.pause_event.set()  # Ensure listener isn't stuck waiting if GUI is closed
+
+        dpg.destroy_context()
+
+
+def run_gui(q: queue.Queue[Message], pause_event: Event | None = None):
+    gui = GUI(q, pause_event)
+    gui.run()
+
+
+if __name__ == "__main__":
+    run_gui(queue.Queue())

RobotLiveTrace/listener.py

@@ -0,0 +1,112 @@
+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()

RobotLiveTrace/message.py

@@ -0,0 +1,7 @@
+from typing import Any, TypedDict
+
+
+class Message(TypedDict):
+    action: str
+    data: dict[str, Any] | None
+    result: dict[str, Any] | None

RobotLiveTrace/version.py

@@ -0,0 +1,8 @@
+from importlib.metadata import metadata, version
+
+_metadata = metadata("robotframework-live-trace")
+
+VERSION = version("robotframework-live-trace")
+AUTHOR = _metadata["Author"]
+AUTHOR_EMAIL = _metadata["Author-email"]
+DESCRIPTION = _metadata["Summary"]

robotframework_live_trace-0.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: robotframework-live-trace
+Version: 0.1.0
+Summary: A live trace visualization for Robot Framework test runs.
+Keywords: robotframework,automation,testautomation,testing,debugging,visualization,trace,live
+Author: Manuel Ketterer
+Author-email: Manuel Ketterer <ps3udonym4@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Tool
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+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: robotframework>=7.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/iDentitY4/robotframework-live-trace
+Project-URL: Repository, https://github.com/iDentitY4/robotframework-live-trace.git
+Project-URL: Issues, https://github.com/iDentitY4/robotframework-live-trace/issues
+Description-Content-Type: text/markdown
+
+# 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.dist-info/RECORD

@@ -0,0 +1,12 @@
+RobotLiveTrace/__init__.py,sha256=4IA0BaMwnO68NbtBl4oPOoGX4rbnSW5jtFxst-iKeX8,172
+RobotLiveTrace/fonts/NotoSans-Regular.ttf,sha256=_owCL0jY3Snxe3RNFvk0b0NX4W99T3vliwAK58KRthQ,629024
+RobotLiveTrace/fonts/OFL.txt,sha256=5R1p9eQ8rNg6tuXz8aRwBTgK4IttEI1ES-SeeG0SdFg,4396
+RobotLiveTrace/gui.py,sha256=zq-jl6bMFS8Om8clOQheZT-ppw60ZMqK_8T_fsHd8XA,16613
+RobotLiveTrace/listener.py,sha256=8e60UVjjS-83jy8sWrZ_ZJ7hkKMKqw5YJUNpacNTS9Q,3344
+RobotLiveTrace/message.py,sha256=9tuWVCawBAk-_pRtl8IA6JvmIana15T3tPRdy1DXf2A,144
+RobotLiveTrace/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+RobotLiveTrace/version.py,sha256=qGwhkekw26U9Quq7deXGrNpYpudf9V8I68l6HwUV0Us,253
+robotframework_live_trace-0.1.0.dist-info/licenses/LICENSE,sha256=m7951ToKKAjyCB698isbjN9P5sFZg-2O5AEPbumusvQ,1071
+robotframework_live_trace-0.1.0.dist-info/WHEEL,sha256=o6xtdofIa8Zz80kUveEHMWeAWtEyZSzYS1bbyKDCgzA,80
+robotframework_live_trace-0.1.0.dist-info/METADATA,sha256=rHzwss0i0BJFFBsHQu4PpwPeYELGt-jZQOqbKftcgeI,4549
+robotframework_live_trace-0.1.0.dist-info/RECORD,,

robotframework_live_trace-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.10.4
+Root-Is-Purelib: true
+Tag: py3-none-any

robotframework_live_trace-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Manuel Ketterer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.