siliconcompiler 0.32.3__py3-none-any.whl → 0.33.1__py3-none-any.whl

siliconcompiler/report/dashboard/cli/__init__.py

@@ -1,239 +1,18 @@
-import os
-import threading
-import logging
-import time
-
-from collections import deque
-from dataclasses import dataclass, field
-from typing import List, Dict
-
-from rich import box
-from rich.theme import Theme
-from rich.live import Live
-from rich.table import Table
-from rich.progress import Progress, BarColumn, TextColumn, MofNCompleteColumn
-from rich.console import Console
-from rich.console import Group
-from rich.padding import Padding
-
-from siliconcompiler import SiliconCompilerError, NodeStatus
 from siliconcompiler.report.dashboard import AbstractDashboard
-from siliconcompiler.flowgraph import nodes_to_execute, _get_flowgraph_execution_order, \
-    _get_flowgraph_node_inputs, _get_flowgraph_entry_nodes
-
-
-class LogBufferHandler(logging.Handler):
-    def __init__(self, n=50, event=None):
-        """
-        Initializes the handler.
-
-        Args:
-            n (int): Maximum number of lines to keep.
-            event (threading.Event): Optional event to trigger on every log line.
-        """
-        super().__init__()
-        self.buffer = deque(maxlen=n)
-        self.event = event
-        self._lock = threading.Lock()
-
-    def emit(self, record):
-        """
-        Processes a log record.
-
-        Args:
-            record (logging.LogRecord): The log record to process.
-        """
-        log_entry = self.format(record)
-        with self._lock:
-            self.buffer.append(log_entry)
-        if self.event:
-            self.event.set()
-
-    def get_lines(self, lines=None):
-        """
-        Retrieves the last logged lines.
-
-        Returns:
-            list: A list of the last logged lines.
-        """
-        with self._lock:
-            buffer_list = list(self.buffer)
-            if lines is None or lines > len(buffer_list):
-                return buffer_list
-            return buffer_list[-lines:]
-
-
-@dataclass
-class JobData:
-    total: int = 0
-    success: int = 0
-    error: int = 0
-    skipped: int = 0
-    finished: int = 0
-    jobname: str = ""
-    design: str = ""
-    runtime: float = 0.0
-    nodes: List[dict] = field(default_factory=list)
-
-
-@dataclass
-class SessionData:
-    total: int = 0
-    success: int = 0
-    error: int = 0
-    skipped: int = 0
-    finished: int = 0
-    runtime: float = 0.0
-    jobs: Dict[str, JobData] = field(default_factory=dict)
-
-
-@dataclass
-class Layout:
-    """
-    Layout class represents the configuration for a dashboard layout.
-
-    Attributes:
-        height (int): The total height of the layout.
-        width (int): The total width of the layout.
-        job_board_min (int): The minimum height allocated for the job board.
-        job_board_max (int): The maximum height allocated for the job board.
-        log_max (int): The maximum height allocated for the log section.
-        log_min (int): The minimum height allocated for the log section.
-        progress_bar_min (int): The minimum height allocated for the progress bar.
-        progress_bar_max (int): The maximum height allocated for the progress bar.
-        job_board_show_log (bool): A flag indicating whether to show the log in the job board.
-
-        __reserved (int): Reserved space for table headings and extra padding.
-
-    Methods:
-        available_height():
-            Calculates and returns the available height for other components in the layout
-            after accounting for reserved space, job board, and log sections.
-            Returns 0 if the total height is not set.
-    """
-
-    height: int = 0
-    width: int = 0
-
-    log_height = 0
-    job_board_height = 0
-    progress_bar_height = 0
-
-    job_board_show_log: bool = True
-    job_board_v_limit: int = 120
-
-    __progress_bar_height_default = 1
-    padding_log = 2
-    padding_progress_bar = 1
-    padding_job_board = 1
-    padding_job_board_header = 1
-
-    def update(self, height, width, visible_jobs, visible_bars):
-        self.height = height
-        self.width = width
-
-        min_required = (
-            max(visible_bars, self.__progress_bar_height_default)
-            + self.padding_progress_bar
-        )
-        if self.height < min_required:
-            self.progress_bar_height = 0
-            self.job_board_height = 0
-            self.log_height = 0
-            return
-
-        remaining_height = self.height
-
-        # Allocate progress bar space (highest priority)
-        self.progress_bar_height = max(visible_bars, self.__progress_bar_height_default)
-        if self.progress_bar_height > 0:
-            remaining_height -= self.progress_bar_height + self.padding_progress_bar
-
-        # Calculate job board requirements
-        job_board_min_space = self.padding_job_board_header + self.padding_job_board
-        job_board_max_nodes = remaining_height // 2
-        visible_jobs = min(visible_jobs, job_board_max_nodes)
-        if visible_jobs > 0:
-            job_board_full_space = visible_jobs + job_board_min_space
-        else:
-            job_board_full_space = 0
-
-        # Allocate job board space (second priority)
-        if remaining_height <= job_board_min_space:
-            self.job_board_height = 0
-            self.log_height = 0
-        elif remaining_height <= job_board_full_space:
-            self.job_board_height = remaining_height - job_board_min_space
-            self.log_height = 0
-        elif visible_jobs == 0:
-            self.job_board_height = 0
-            self.log_height = remaining_height
-        else:
-            self.job_board_height = visible_jobs
-            self.log_height = remaining_height - job_board_full_space - self.padding_log
-
-        if self.width < self.job_board_v_limit:
-            self.job_board_show_log = False
+from siliconcompiler.report.dashboard.cli.board import Board
 
 
 class CliDashboard(AbstractDashboard):
-    __status_color_map = {
-        NodeStatus.PENDING: "blue",
-        NodeStatus.QUEUED: "blue",
-        NodeStatus.RUNNING: "orange4",
-        NodeStatus.SUCCESS: "green",
-        NodeStatus.ERROR: "red",
-        NodeStatus.SKIPPED: "bright_black",
-        NodeStatus.TIMEOUT: "red",
-    }
-    __theme = Theme(
-        {
-            # Text colors
-            "text.primary": "white",
-            "text.secondary": "cyan",
-            # Background colors
-            "background.primary": "grey15",
-            "background.secondary": "dark_blue",
-            # Highlight and accent colors
-            "highlight": "green",
-            "accent": " cyan",
-            # Status colors
-            "error": "red",
-            "warning": "yellow",
-            "success": "green",
-            # Node status colors
-            **{f"node.{status}": color for status, color in __status_color_map.items()},
-            # Custom style for headers
-            "header": "bold underline cyan",
-        }
-    )
-
-    __JOB_BOARD_HEADER = True
-
-    __JOB_BOARD_BOX = box.SIMPLE_HEAD
 
     def __init__(self, chip):
         super().__init__(chip)
 
-        self._render_event = threading.Event()
-        self._render_stop_event = threading.Event()
-        self._render_thread = None
-
-        self._render_data = SessionData()
-        self._render_data_lock = threading.Lock()
-
-        self._console = Console(theme=CliDashboard.__theme)
-        self._layout = Layout()
+        self._dashboard = Board()
 
         self.__logger_console = None
 
-        if not self.__JOB_BOARD_HEADER:
-            self._layout.padding_job_board_header = 0
-
         self._logger = chip.logger
 
-        self._metrics = ("warnings", "errors")
-
     def set_logger(self, logger):
         """
         Sets the logger for the dashboard.
@@ -242,27 +21,20 @@ class CliDashboard(AbstractDashboard):
             logger (logging.Logger): The logger to set.
         """
         self._logger = logger
-        if self._logger:
-            self.__log_handler = LogBufferHandler(n=120, event=self._render_event)
+        if self._logger and self._dashboard._active:
             # Hijack the console
             self._logger.removeHandler(self._chip.logger._console)
             self.__logger_console = self._chip.logger._console
-            self._chip.logger._console = self.__log_handler
-            self._logger.addHandler(self.__log_handler)
+            self._chip.logger._console = self._dashboard._log_handler
+            self._logger.addHandler(self._dashboard._log_handler)
             self._chip._init_logger_formats()
 
     def open_dashboard(self):
         """Starts the dashboard rendering thread if it is not already running."""
 
-        if not self.is_running():
-            self.set_logger(self._logger)
-            self._update_render_data()
+        self.set_logger(self._logger)
 
-            self._render_thread = threading.Thread(target=self._render, daemon=True)
-            self._render_event.clear()
-            self._render_stop_event.clear()
-
-            self._render_thread.start()
+        self._dashboard.open_dashboard()
 
     def update_manifest(self, payload=None):
         """
@@ -272,8 +44,7 @@ class CliDashboard(AbstractDashboard):
         starttimes = None
         if payload and "starttimes" in payload:
             starttimes = payload["starttimes"]
-        self._update_render_data(starttimes=starttimes)
-        self._render_event.set()
+        self._dashboard.update_manifest(self._chip, starttimes=starttimes)
 
     def update_graph_manifests(self):
         """Placeholder method for updating graph manifests. Currently not implemented."""
@@ -281,32 +52,25 @@ class CliDashboard(AbstractDashboard):
 
     def is_running(self):
         """Returns True to indicate that the dashboard is running."""
-        if not self._render_thread:
-            return False
-
-        return self._render_thread.is_alive()
+        return self._dashboard.is_running()
 
     def end_of_run(self):
         """
         Stops the dashboard rendering thread and ensures all rendering operations are completed.
         """
-        self.stop()
+        self._dashboard.end_of_run(self._chip)
 
     def stop(self):
         """
         Stops the dashboard rendering thread and ensures all rendering operations are completed.
         """
-        if not self.is_running():
-            return
+        self._dashboard.end_of_run(self._chip)
 
-        self._render_stop_event.set()
-        self._render_event.set()
-        # Wait for rendering to finish
-        self.wait()
+        self._dashboard.stop()
 
         # Restore logger
         if self.__logger_console:
-            self._logger.removeHandler(self.__log_handler)
+            self._logger.removeHandler(self._dashboard._log_handler)
             self._chip.logger._console = self.__logger_console
             self._logger.addHandler(self.__logger_console)
             self._chip._init_logger_formats()
@@ -314,475 +78,4 @@ class CliDashboard(AbstractDashboard):
 
     def wait(self):
         """Waits for the dashboard rendering thread to finish."""
-        if not self.is_running():
-            return
-
-        self._render_thread.join()
-
-    @staticmethod
-    def format_status(status: str):
-        """
-        Formats the status of a node for display in the dashboard.
-
-        Args:
-            status (str): The status of the node (e.g., 'running', 'success', 'error').
-
-        Returns:
-            str: A formatted string with the status styled for display.
-        """
-        return f"[node.{status.lower()}]{status.upper()}[/]"
-
-    @staticmethod
-    def format_node(design, jobname, step, index) -> str:
-        """
-        Formats a node's information for display in the dashboard.
-
-        Args:
-            design (str): The design name.
-            jobname (str): The job name.
-            step (str): The step name.
-            index (int): The step index.
-
-        Returns:
-            str: A formatted string with the node's information styled for display.
-        """
-        return f"{design}/{jobname}/{step}/{index}"
-
-    def _render_log(self, layout):
-        if not self._logger or layout.log_height == 0:
-            return None
-
-        table = Table(box=None)
-        table.add_column(overflow="ellipsis", no_wrap=True, vertical="bottom")
-        table.show_edge = False
-        table.show_lines = False
-        table.show_footer = False
-        table.show_header = False
-        for line in self.__log_handler.get_lines(layout.log_height):
-            table.add_row(f"[bright_black]{line}[/]")
-        while table.row_count < layout.log_height:
-            table.add_row("")
-
-        return Group(table, Padding("", (0, 0)))
-
-    def _render_job_dashboard(self, layout):
-        """
-        Creates a table of jobs and their statuses for display in the dashboard.
-
-        Returns:
-            Group: A Rich Group object containing tables for each job.
-        """
-        # Don't render anything if there is not enough space
-        if layout.job_board_height == 0:
-            return None
-
-        with self._render_data_lock:
-            job_data = self._render_data.jobs.copy()  # Access jobs from SessionData
-
-        if self.__JOB_BOARD_HEADER:
-            table_box = self.__JOB_BOARD_BOX
-        else:
-            table_box = None
-
-        table = Table(box=table_box, pad_edge=False)
-        table.show_edge = False
-        table.show_lines = False
-        table.show_footer = False
-        table.show_header = self.__JOB_BOARD_HEADER
-        table.add_column("Status")
-        table.add_column("Node")
-        table.add_column("Time", justify="right")
-        for metric in self._metrics:
-            table.add_column(metric.capitalize(), justify="right")
-        if layout.job_board_show_log:
-            table.add_column("Log")
-
-        table_data = []
-
-        for jobname, job in job_data.items():
-            if not job.nodes:
-                continue
-
-            for node in job.nodes:
-                if (
-                    layout.job_board_show_log
-                    and os.path.exists(node["log"])
-                ):
-                    log_file = "[bright_black]{}[/]".format(node['log'])
-                else:
-                    log_file = None
-
-                if node["time"]["duration"] is not None:
-                    duration = f'{node["time"]["duration"]:.1f}s'
-                elif node["time"]["start"] is not None:
-                    duration = f'{time.time() - node["time"]["start"]:.1f}s'
-                else:
-                    duration = ""
-
-                table_data.append((node["status"], node["step"], node["index"], (
-                    CliDashboard.format_status(node["status"]),
-                    CliDashboard.format_node(
-                        job.design, job.jobname, node["step"], node["index"]
-                    ),
-                    duration,
-                    *node["metrics"],
-                    log_file
-                )))
-
-        def job_data_fits(table_data):
-            return len(table_data) <= layout.job_board_height
-
-        def remove_pending(table_data, keep_nodes):
-            if not keep_nodes:
-                keep_nodes = set()
-            for n in range(len(table_data)):
-                if NodeStatus.is_waiting(table_data[-n][0]):
-                    if (table_data[-n][1], table_data[-n][2]) not in keep_nodes:
-                        table_data.pop(-n)
-                        return table_data
-            return table_data
-
-        def remove_success(table_data, keep_nodes):
-            if not keep_nodes:
-                keep_nodes = set()
-            for n in range(len(table_data)):
-                if NodeStatus.is_success(table_data[n][0]):
-                    if (table_data[n][1], table_data[n][2]) not in keep_nodes:
-                        table_data.pop(n)
-                        return table_data
-            return table_data
-
-        def count_table_data(table_data):
-            pending = 0
-            done = 0
-            for status, _, _, _ in table_data:
-                if NodeStatus.is_done(status):
-                    done += 1
-                elif NodeStatus.is_waiting(status):
-                    pending += 1
-            return pending, done
-
-        running_nodes = set([
-            (step, index) for status, step, index, _ in table_data
-            if NodeStatus.is_running(status)])
-
-        done_nodes = set([
-            (step, index) for status, step, index, _ in table_data
-            if NodeStatus.is_done(status)])
-
-        flow = self._chip.get('option', 'flow')
-        entry_nodes = set([node for node in _get_flowgraph_entry_nodes(self._chip, flow)
-                           if node not in running_nodes and node not in done_nodes])
-
-        input_nodes = set()
-        for step, index in running_nodes:
-            input_nodes.update(_get_flowgraph_node_inputs(self._chip, flow, (step, index)))
-        input_nodes.update(entry_nodes)
-
-        output_nodes = set()
-        for step, index in nodes_to_execute(self._chip):
-            for in_node in self._chip.get('flowgraph', flow, step, index, 'input'):
-                if in_node in running_nodes:
-                    output_nodes.add((step, index))
-        output_nodes.update(entry_nodes)
-
-        # order:
-        # loop:
-        #     remove pending, 1+ removed from running
-        #     remove success, 1+ removed from running
-        # loop:
-        #     remove pending, any
-        #     remove success, any
-        # trim running to fit
-
-        while True:
-            if job_data_fits(table_data):
-                break
-            start_len = len(table_data)
-            pending, done = count_table_data(table_data)
-            if pending >= done:
-                table_data = remove_pending(table_data, output_nodes)
-            else:
-                table_data = remove_success(table_data, input_nodes)
-            if len(table_data) == start_len:
-                break
-
-        while True:
-            if job_data_fits(table_data):
-                break
-            start_len = len(table_data)
-            pending, done = count_table_data(table_data)
-            if pending >= done:
-                table_data = remove_pending(table_data, None)
-            else:
-                table_data = remove_success(table_data, None)
-            if len(table_data) == start_len:
-                break
-
-        if not job_data_fits(table_data):
-            # trim to fit
-            table_data = table_data[0:layout.job_board_height]
-
-        for _, _, _, row_data in table_data:
-            table.add_row(*row_data)
-
-        if table.row_count == 0:
-            return None
-
-        if self.__JOB_BOARD_HEADER:
-            return Group(table, Padding("", (0, 0)))
-        return Group(Padding("", (0, 0)), table, Padding("", (0, 0)))
-
-    def _render_progress_bar(self, layout):
-        """
-        Creates progress bars showing job completion for display in the dashboard.
-
-        Returns:
-            Group: A Rich Group object containing progress bars for each job.
-        """
-        with self._render_data_lock:
-            job_data = self._render_data.jobs.copy()
-            done = self._render_data.finished > 0 \
-                and self._render_data.total == self._render_data.finished \
-                and self._render_data.success == self._render_data.total
-
-        if done:
-            return None
-
-        progress = Progress(
-            TextColumn("[progress.description]{task.description}"),
-            MofNCompleteColumn(),
-            BarColumn(bar_width=60),
-            TextColumn("[progress.percentage]{task.percentage:>3.0f}%")
-        )
-        nodes = 0
-        for _, job in job_data.items():
-            nodes += len(job.nodes)
-            progress.add_task(
-                f"[text.primary]Progress ({job.design}/{job.jobname}):",
-                total=job.total,
-                completed=job.success,
-            )
-
-        if nodes == 0:
-            return Padding("", (0, 0))
-
-        return Group(progress, Padding("", (0, 0)))
-
-    def _render_final(self, layout):
-        """
-        Creates a summary of the final results, including runtime, passed, and failed jobs.
-
-        Returns:
-            Padding: A Rich Padding object containing the summary text.
-        """
-        with self._render_data_lock:
-            success = self._render_data.success
-            error = self._render_data.error
-            total = self._render_data.total
-            finished = self._render_data.finished
-            runtime = self._render_data.runtime
-
-        if finished != 0 and finished == total:
-            return Padding(
-                f"[text.primary]Results {runtime:.2f}s\n"
-                f"     [success]{success} passed[/]\n"
-                f"     [error]{error} failed[/]\n"
-            )
-
-        return self._render_log(layout)
-
-    def _render(self):
-        """
-        Main rendering method for the TUI. Continuously updates the dashboard
-        with the latest data until the stop event is set.
-        """
-        live = None
-        try:
-            live = Live(
-                self._get_rendable(),
-                console=self._console,
-                screen=False,
-                # transient=True,
-                auto_refresh=True,
-                # refresh_per_second=60,
-            )
-            live.start()
-
-            while not self._render_stop_event.is_set():
-                if self._render_event.wait(timeout=0.2):
-                    self._render_event.clear()
-
-                if self._render_stop_event.is_set():
-                    break
-
-                live.update(self._get_rendable(), refresh=True)
-        finally:
-            try:
-                if live:
-                    live.update(self._get_rendable(), refresh=True)
-                    live.stop()
-                else:
-                    self._console.print(self._get_rendable())
-            finally:
-                # Restore the prompt
-                print("\033[?25h", end="")
-
-    def _update_layout(self):
-        with self._render_data_lock:
-            visible_progress_bars = len(self._render_data.jobs)
-            visible_jobs_count = self._render_data.total - self._render_data.skipped
-
-        self._layout.update(
-            self._console.height,
-            self._console.width,
-            visible_jobs_count,
-            visible_progress_bars,
-        )
-
-        return self._layout
-
-    def _get_rendable(self):
-        """
-        Combines all dashboard components (job table, progress bars, final summary)
-        into a single renderable group.
-
-        Returns:
-            Group: A Rich Group object containing all dashboard components.
-        """
-
-        layout = self._update_layout()
-
-        new_table = self._render_job_dashboard(layout)
-        new_bar = self._render_progress_bar(layout)
-        footer = self._render_final(layout)
-
-        items = []
-        if new_table:
-            items.extend([new_table])
-
-        if new_bar:
-            items.extend([new_bar])
-
-        if footer:
-            items.extend([footer])
-
-        return Group(*items)
-
-    def _update_render_data(self, starttimes=None):
-        """
-        Updates the render data with the latest job and node information from the chip object.
-        This data is used to populate the dashboard.
-        """
-
-        job_data = self._get_job(starttimes=starttimes)
-
-        with self._render_data_lock:
-            self._render_data.jobs[self._chip] = job_data
-            self._render_data.total = sum(
-                job.total for job in self._render_data.jobs.values()
-            )
-            self._render_data.success = sum(
-                job.success for job in self._render_data.jobs.values()
-            )
-            self._render_data.error = sum(
-                job.error for job in self._render_data.jobs.values()
-            )
-            self._render_data.skipped = sum(
-                job.skipped for job in self._render_data.jobs.values()
-            )
-            self._render_data.finished = sum(
-                job.finished for job in self._render_data.jobs.values()
-            )
-            self._render_data.runtime = max(
-                job.runtime for job in self._render_data.jobs.values()
-            )
-
-    def _get_job(self, chip=None, starttimes=None) -> JobData:
-        chip = chip or self._chip
-
-        if not starttimes:
-            starttimes = {}
-
-        nodes = []
-        try:
-            flow = chip.get("option", "flow")
-            if not flow:
-                raise SiliconCompilerError("dummy error")
-            execnodes = nodes_to_execute(chip)
-            for nodeset in _get_flowgraph_execution_order(chip, flow):
-                for node in nodeset:
-                    if node not in execnodes:
-                        continue
-                    nodes.append(node)
-        except SiliconCompilerError:
-            pass
-
-        design = chip.get("design")
-        jobname = chip.get("option", "jobname")
-
-        job_data = JobData()
-        job_data.jobname = jobname
-        job_data.design = design
-        totaltimes = [
-            self._chip.get("metric", "totaltime", step=step, index=index) or 0
-            for step, index in nodes
-        ]
-        if not totaltimes:
-            totaltimes = [0]
-        job_data.runtime = max(totaltimes)
-
-        for step, index in nodes:
-            status = self._chip.get("record", "status", step=step, index=index)
-            if not status:
-                status = NodeStatus.PENDING
-
-            job_data.total += 1
-            if NodeStatus.is_error(status):
-                job_data.error += 1
-            if NodeStatus.is_success(status):
-                job_data.success += 1
-            if NodeStatus.is_done(status):
-                job_data.finished += 1
-
-            if status == NodeStatus.SKIPPED:
-                job_data.skipped += 1
-                continue
-
-            starttime = None
-            duration = None
-            if NodeStatus.is_done(status):
-                duration = self._chip.get("metric", "tasktime", step=step, index=index)
-            if (step, index) in starttimes:
-                starttime = starttimes[(step, index)]
-
-            node_metrics = []
-            for metric in self._metrics:
-                value = self._chip.get('metric', metric,
-                                       step=step, index=index)
-                if value is None:
-                    node_metrics.append("")
-                else:
-                    node_metrics.append(str(value))
-
-            job_data.nodes.append(
-                {
-                    "step": step,
-                    "index": index,
-                    "status": status,
-                    "time": {
-                        "start": starttime,
-                        "duration": duration
-                    },
-                    "metrics": node_metrics,
-                    "log": os.path.join(
-                        os.path.relpath(
-                            self._chip.getworkdir(step=step, index=index),
-                            self._chip.cwd,
-                        ),
-                        f"{step}.log",
-                    ),
-                }
-            )
-
-        return job_data
+        self._dashboard.wait()