siliconcompiler 0.34.2__py3-none-any.whl → 0.34.3__py3-none-any.whl

siliconcompiler/report/dashboard/cli/board.py

@@ -1,9 +1,9 @@
-import os
-import threading
 import logging
+import os
+import math
 import queue
 import time
-import multiprocessing
+import threading
 
 from collections import deque
 from dataclasses import dataclass, field
@@ -22,27 +22,116 @@ from siliconcompiler import SiliconCompilerError, NodeStatus
 from siliconcompiler.utils.logging import SCColorLoggerFormatter
 from siliconcompiler.flowgraph import RuntimeFlowgraph
 
-import atexit
+
+class LogBuffer:
+    """
+    A buffer for storing log messages, designed to be thread-safe and to work
+    in conjunction with a `LogBufferHandler` for dashboard or UI display.
+    It uses a `collections.deque` to maintain a fixed-size history of log lines.
+    """
+    def __init__(self, queue: queue.Queue, n: int = 15, event: threading.Event = None):
+        """
+        Initializes the LogBuffer.
+
+        Args:
+            queue (queue.Queue): A thread-safe queue to push new log lines to.
+            n (int): The maximum number of log lines to retain in the buffer's history.
+                     Defaults to 15.
+            event (threading.Event, optional): An optional `threading.Event` object.
+                                             If provided, this event is set whenever
+                                             a new log line is added, signaling
+                                             consumers that new data is available.
+                                             Defaults to None.
+        """
+        self.queue = queue
+        self.buffer = deque(maxlen=n)
+        self.lock = threading.Lock()
+        if not event:
+            # Create dummy event
+            event = threading.Event()
+        self.event = event
+
+    def make_handler(self) -> logging.Handler:
+        """
+        Creates and returns a `LogBufferHandler` instance associated with this `LogBuffer`.
+
+        This handler can then be added to a Python logger to direct log messages
+        to this buffer.
+
+        Returns:
+            logging.Handler: An instance of `LogBufferHandler`.
+        """
+        return LogBufferHandler(self)
+
+    def add_line(self, line: str):
+        """
+        Adds a new log line to the internal queue and signals the event.
+
+        This method is called by the `LogBufferHandler` (or directly) to
+        append a processed log line to the buffer. It also sets the internal
+        threading event to notify any waiting consumers.
+
+        Args:
+            line (str): The log line (string) to add.
+        """
+        self.queue.put(line)
+        self.event.set()
+
+    def get_lines(self, lines: int = None) -> List[str]:
+        """
+        Retrieves the last logged lines from the buffer.
+
+        New lines are first moved from the internal queue to the buffer,
+        and then the requested number of lines are returned from the buffer's history.
+
+        Args:
+            lines (int, optional): The maximum number of recent lines to retrieve.
+                                   If None, all lines currently in the buffer are returned.
+                                   Defaults to None.
+
+        Returns:
+            list[str]: A list of the last logged lines.
+        """
+        new_lines = []
+        try:
+            for _ in range(self.queue.qsize()):
+                new_lines.append(self.queue.get_nowait())
+        except queue.Empty:
+            pass
+        if not self.queue.empty():
+            # Set event since queue is not empty
+            self.event.set()
+
+        with self.lock:
+            self.buffer.extend(new_lines)
+            buffer_list = list(self.buffer)
+
+            if lines is None or lines > len(buffer_list):
+                return buffer_list
+            return buffer_list[-lines:]
 
 
 class LogBufferHandler(logging.Handler):
-    def __init__(self, sync_queue, n=50, event=None):
+    """
+    A custom logging handler that buffers log records and processes them
+    for display in a dashboard or other UI, replacing console color codes
+    with a simplified markdown-like format.
+    """
+    def __init__(self, parent: LogBuffer):
         """
-        Initializes the handler.
+        Initializes the LogBufferHandler.
 
         Args:
-            n (int): Maximum number of lines to keep.
-            event (threading.Event): Optional event to trigger on every log line.
+            parent (LogBuffer): The parent `LogBuffer` instance to which processed
+                                log lines will be added.
         """
         super().__init__()
-        self.queue = sync_queue
-        self.buffer = deque(maxlen=n)
-        self.event = event
-        self._lock = threading.Lock()
+        self._parent = parent
 
     def emit(self, record):
         """
-        Processes a log record.
+        Processes a log record, formats it, replaces console color codes,
+        and adds the transformed line to the parent `LogBuffer`.
 
         Args:
             record (logging.LogRecord): The log record to process.
@@ -58,31 +147,27 @@ class LogBufferHandler(logging.Handler):
                 (SCColorLoggerFormatter.red.replace("[", "\\["), "[red]"),
                 (SCColorLoggerFormatter.bold_red.replace("[", "\\["), "[bold red]")):
             log_entry = log_entry.replace(color, replacement)
-        self.queue.put(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:
-            while not self.queue.empty():
-                try:
-                    self.buffer.append(self.queue.get_nowait())
-                except queue.Empty:
-                    break
-            buffer_list = list(self.buffer)
-            if lines is None or lines > len(buffer_list):
-                return buffer_list
-            return buffer_list[-lines:]
+        self._parent.add_line(log_entry)
 
 
 @dataclass
 class JobData:
+    """
+    A data class to hold information about a single job's progress and status.
+
+    Attributes:
+        total (int): The total number of nodes in the job.
+        success (int): The number of successfully completed nodes.
+        error (int): The number of nodes that resulted in an error.
+        skipped (int): The number of skipped nodes.
+        finished (int): The total number of finished nodes (success or error).
+        jobname (str): The name of the job.
+        design (str): The name of the design associated with the job.
+        runtime (float): The total runtime of the job so far.
+        complete (bool): A flag indicating if the job has completed.
+        nodes (List[dict]): A list of dictionaries, each containing detailed
+                            information about a single node in the flowgraph.
+    """
     total: int = 0
     success: int = 0
     error: int = 0
@@ -97,6 +182,20 @@ class JobData:
 
 @dataclass
 class SessionData:
+    """
+    A data class to hold aggregated information about the entire run session,
+    which may include multiple jobs.
+
+    Attributes:
+        total (int): The total number of nodes across all jobs.
+        success (int): The total number of successfully completed nodes across all jobs.
+        error (int): The total number of nodes that resulted in an error across all jobs.
+        skipped (int): The total number of skipped nodes across all jobs.
+        finished (int): The total number of finished nodes across all jobs.
+        runtime (float): The maximum runtime among all jobs.
+        jobs (Dict[str, JobData]): A dictionary mapping job identifiers to their
+                                   corresponding JobData objects.
+    """
     total: int = 0
     success: int = 0
     error: int = 0
@@ -109,69 +208,85 @@ class SessionData:
 @dataclass
 class Layout:
     """
-    Layout class represents the configuration for a dashboard layout.
+    Manages the dynamic layout of the dashboard, calculating the height
+    of different sections based on terminal size and content.
 
     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): The total height of the terminal.
+        width (int): The total width of the terminal.
+        log_height (int): The calculated height for the log display area.
+        job_board_height (int): The calculated height for the job status board.
+        progress_bar_height (int): The calculated height for the progress bar section.
+        job_board_show_log (bool): Flag to determine if the log file column is shown.
+        job_board_v_limit (int): Width threshold to switch to a more compact view.
     """
 
     height: int = 0
     width: int = 0
 
-    log_height = 0
-    job_board_height = 0
-    progress_bar_height = 0
+    log_height: int = 0
+    job_board_height: int = 0
+    progress_bar_height: int = 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
+    padding_progress_bar: int = 1
+    padding_job_board: int = 1
+    padding_job_board_header: int = 1
 
-    def update(self, height, width, visible_jobs, visible_bars):
+    def update(self, height: int, width: int, visible_jobs: int, visible_bars: int):
+        """
+        Recalculates the layout dimensions based on the current terminal size and content.
+
+        This method implements the logic to intelligently allocate vertical space
+        to the progress bars, job board, and log view.
+
+        Args:
+            height (int): The current terminal height.
+            width (int): The current terminal width.
+            visible_jobs (int): The number of job nodes to be displayed.
+            visible_bars (int): The number of progress bars to be displayed.
+        """
         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
+        if self.height < 3:
+            self.progress_bar_height = self.height - self.padding_progress_bar - 1
             self.job_board_height = 0
             self.log_height = 0
-            return
+
+        # target sizes
+        target_jobs = 0.25 * self.height
+        target_bars = 0.50 * self.height
+        # 25 % for log
+
+        # Adjust targets based on progress bars
+        if visible_bars < target_bars:
+            remainder = target_bars - visible_bars
+            target_bars = visible_bars
+            target_jobs += 0.75 * remainder
+        target_bars = int(math.ceil(target_bars))
+
+        # Adjust targets based on jobs
+        if visible_jobs < target_jobs:
+            target_jobs = visible_jobs
+        target_jobs = int(math.ceil(target_jobs))
 
         remaining_height = self.height
 
         # Allocate progress bar space (highest priority)
-        self.progress_bar_height = max(visible_bars, self.__progress_bar_height_default)
+        self.progress_bar_height = max(min(target_bars, 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)
+        visible_jobs = min(min(target_jobs, visible_jobs), job_board_max_nodes)
         if visible_jobs > 0:
             job_board_full_space = visible_jobs + job_board_min_space
         else:
@@ -190,24 +305,21 @@ class Layout:
         else:
             self.job_board_height = visible_jobs
             self.log_height = remaining_height - job_board_full_space - self.padding_log
+        if self.log_height < 0:
+            self.log_height = 0
 
         if self.width < self.job_board_v_limit:
             self.job_board_show_log = False
 
 
-class BoardSingleton(type):
-    _instances = {}
-    _lock = multiprocessing.Lock()
-
-    def __call__(cls, *args, **kwargs):
-        with cls._lock:
-            if cls not in cls._instances:
-                cls._instances[cls] = super(BoardSingleton, cls).__call__(*args, **kwargs)
-                cls._instances[cls]._init_singleton()
-        return cls._instances[cls]
-
+class Board:
+    """
+    The main class for rendering the live dashboard UI.
 
-class Board(metaclass=BoardSingleton):
+    This class orchestrates the display of job progress, logs, and status updates
+    in the terminal using the `rich` library. It runs in a separate thread to
+    provide a non-blocking UI.
+    """
     __status_color_map = {
         NodeStatus.PENDING: "blue",
         NodeStatus.QUEUED: "blue",
@@ -243,20 +355,22 @@ class Board(metaclass=BoardSingleton):
 
     __JOB_BOARD_BOX = box.SIMPLE_HEAD
 
-    def __init__(self):
-        pass
+    def __init__(self, manager):
+        """
+        Initializes the Board.
 
-    def _init_singleton(self):
+        Args:
+            manager: A multiprocessing.Manager object to create shared state
+                     (events, dicts, locks) between processes.
+        """
         self._console = Console(theme=Board.__theme)
 
         self.live = Live(
             console=self._console,
-            screen=False,
-            auto_refresh=True,
+            screen=True,
+            auto_refresh=True
         )
 
-        atexit.register(self._stop_on_exit)
-
         self._active = self._console.is_terminal
         if not self._active:
             self._console = None
@@ -264,34 +378,39 @@ class Board(metaclass=BoardSingleton):
 
         self._layout = Layout()
 
-        # Manager to thread data
-        self._manager = multiprocessing.Manager()
-
-        self._render_event = self._manager.Event()
-        self._render_stop_event = self._manager.Event()
+        self._render_event = manager.Event()
+        self._render_stop_event = manager.Event()
         self._render_thread = None
 
         # Holds thread job data
-        self._board_info = self._manager.Namespace()
+        self._board_info = manager.Namespace()
         self._board_info.data_modified = False
-        self._job_data = self._manager.dict()
-        self._job_data_lock = self._manager.Lock()
+        self._job_data = manager.dict()
+        self._job_data_lock = manager.Lock()
 
         self._render_data = SessionData()
         self._render_data_lock = threading.Lock()
 
-        self._log_handler_queue = self._manager.Queue()
+        self._log_handler_queue = manager.Queue()
+
+        self._log_handler = LogBuffer(self._log_handler_queue, n=120, event=self._render_event)
 
-        self._log_handler = LogBufferHandler(
-            self._log_handler_queue, n=120, event=self._render_event)
+        # Sleep time for the dashboard
+        self._dwell = 0.1
 
         if not self.__JOB_BOARD_HEADER:
             self._layout.padding_job_board_header = 0
 
         self._metrics = ("warnings", "errors")
 
-    def _stop_on_exit(self):
-        self.stop()
+    def make_log_hander(self) -> logging.Handler:
+        """
+        Creates and returns a logging handler that directs logs to this board.
+
+        Returns:
+            logging.Handler: The log handler instance.
+        """
+        return self._log_handler.make_handler()
 
     def open_dashboard(self):
         """Starts the dashboard rendering thread if it is not already running."""
@@ -312,8 +431,12 @@ class Board(metaclass=BoardSingleton):
 
     def update_manifest(self, chip, starttimes=None):
         """
-        Updates the manifest file with the latest data from the chip object.
-        This ensures that the dashboard reflects the current state of the chip.
+        Updates the dashboard with the latest data from a chip object's manifest.
+
+        Args:
+            chip: The SiliconCompiler chip object.
+            starttimes (dict, optional): A dictionary mapping (step, index) tuples
+                                         to their start times. Defaults to None.
         """
 
         if not self._active:
@@ -321,13 +444,24 @@ class Board(metaclass=BoardSingleton):
 
         self._update_render_data(chip, starttimes=starttimes)
 
-    def is_running(self):
-        """Returns True to indicate that the dashboard is running."""
+    def is_running(self) -> bool:
+        """
+        Checks if the dashboard rendering thread is currently active.
+
+        Returns:
+            bool: True if the dashboard is running, False otherwise.
+        """
 
         if not self._active:
             return False
 
-        with self._job_data_lock:
+        try:
+            with self._job_data_lock:
+                if not self._render_thread:
+                    return False
+
+                return self._render_thread.is_alive()
+        except BrokenPipeError:
             if not self._render_thread:
                 return False
 
@@ -335,7 +469,10 @@ class Board(metaclass=BoardSingleton):
 
     def end_of_run(self, chip):
         """
-        Stops the dashboard rendering thread and ensures all rendering operations are completed.
+        Signals that the run has completed, performing a final update.
+
+        Args:
+            chip: The SiliconCompiler chip object at the end of the run.
         """
 
         if not self._active:
@@ -345,7 +482,7 @@ class Board(metaclass=BoardSingleton):
 
     def stop(self):
         """
-        Stops the dashboard rendering thread and ensures all rendering operations are completed.
+        Stops the dashboard rendering thread and cleans up the terminal display.
         """
         if not self.is_running():
             return
@@ -362,6 +499,10 @@ class Board(metaclass=BoardSingleton):
 
         # Restore terminal
         self.live.stop()
+
+        # Print final render to avoid losing it
+        if self.live._screen:
+            self._console.print(self._get_rendable())
         self._console.show_cursor()
 
     def wait(self):
@@ -372,12 +513,12 @@ class Board(metaclass=BoardSingleton):
         self._render_thread.join()
 
     @staticmethod
-    def format_status(status: str):
+    def format_status(status: str) -> str:
         """
-        Formats the status of a node for display in the dashboard.
+        Formats a node status string with rich-compatible color markup.
 
         Args:
-            status (str): The status of the node (e.g., 'running', 'success', 'error').
+            status (str): The status of the node (e.g., 'RUNNING', 'SUCCESS').
 
         Returns:
             str: A formatted string with the status styled for display.
@@ -385,25 +526,37 @@ class Board(metaclass=BoardSingleton):
         return f"[node.{status.lower()}]{status.upper()}[/]"
 
     @staticmethod
-    def format_node(design, jobname, step, index, multi_job) -> str:
+    def format_node(design: str, jobname: str, step: str, index: int, multi_job: bool) -> str:
         """
-        Formats a node's information for display in the dashboard.
+        Formats a node's identifier 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.
+            multi_job (bool): Flag indicating if multiple jobs are running, which
+                              determines the format of the identifier.
 
         Returns:
-            str: A formatted string with the node's information styled for display.
+            str: A formatted string representing the node.
         """
         if multi_job:
             return f"{design}/{jobname}/{step}/{index}"
         else:
             return f"{step}/{index}"
 
-    def _render_log(self, layout):
+    def _render_log(self, layout: Layout):
+        """
+        Renders the log message area of the dashboard.
+
+        Args:
+            layout (Layout): The current layout object containing dimensions.
+
+        Returns:
+            rich.group.Group or None: A renderable Group object for the log
+                                      area, or None if there's no space.
+        """
         if layout.log_height == 0:
             return None
 
@@ -420,12 +573,16 @@ class Board(metaclass=BoardSingleton):
 
         return Group(table, Padding("", (0, 0)))
 
-    def _render_job_dashboard(self, layout):
+    def _render_job_dashboard(self, layout: Layout):
         """
-        Creates a table of jobs and their statuses for display in the dashboard.
+        Renders the main job status board.
+
+        Args:
+            layout (Layout): The current layout object containing dimensions.
 
         Returns:
-            Group: A Rich Group object containing tables for each job.
+            rich.group.Group or None: A renderable Group containing the job table,
+                                      or None if there is no space or no data.
         """
         # Don't render anything if there is not enough space
         if layout.job_board_height == 0:
@@ -477,13 +634,12 @@ class Board(metaclass=BoardSingleton):
             job = job_data[chipid]
             node = job.nodes[node_idx]
 
-            if (
-                layout.job_board_show_log
-                and os.path.exists(node["log"])
-            ):
-                log_file = "[bright_black]{}[/]".format(node['log'])
-            else:
-                log_file = None
+            log_file = None
+            if layout.job_board_show_log:
+                for log in node["log"]:
+                    if os.path.exists(log):
+                        log_file = "[bright_black]{}[/]".format(log)
+                        break
 
             if node["time"]["duration"] is not None:
                 duration = f'{node["time"]["duration"]:.1f}s'
@@ -513,21 +669,19 @@ class Board(metaclass=BoardSingleton):
             return Group(table, Padding("", (0, 0)))
         return Group(Padding("", (0, 0)), table, Padding("", (0, 0)))
 
-    def _render_progress_bar(self, layout):
+    def _render_progress_bar(self, layout: Layout):
         """
-        Creates progress bars showing job completion for display in the dashboard.
+        Renders the progress bar section of the dashboard.
+
+        Args:
+            layout (Layout): The current layout object containing dimensions.
 
         Returns:
-            Group: A Rich Group object containing progress bars for each job.
+            rich.group.Group or rich.padding.Padding: A renderable object for the
+                                                      progress bars.
         """
         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
 
         ref_time = time.time()
         runtimes = {}
@@ -545,6 +699,24 @@ class Board(metaclass=BoardSingleton):
 
         runtime_width = len(f"{max([0, *runtimes.values()]):.1f}")
 
+        job_info = []
+        for name, job in job_data.items():
+            done = job.finished == job.total
+            job_info.append(
+                (done, f"{job.design}/{job.jobname}", job.total, job.success, runtimes[name]))
+
+        while len(job_info) > layout.progress_bar_height:
+            for job in job_info:
+                if job[0]:
+                    # complete complete and can be removed
+                    job_info.remove(job)
+                    break
+            # remove first job
+            del job_info[0]
+
+        if not job_info:
+            return Padding("", (0, 0))
+
         progress = Progress(
             TextColumn("[progress.description]{task.description}"),
             MofNCompleteColumn(),
@@ -552,48 +724,23 @@ class Board(metaclass=BoardSingleton):
             TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
             TextColumn(f" {{task.fields[runtime]:>{runtime_width}.1f}}s")
         )
-        nodes = 0
-        for name, job in job_data.items():
-            nodes += len(job.nodes)
+        for _, name, total, success, runtime in job_info:
             progress.add_task(
-                f"[text.primary]Progress ({job.design}/{job.jobname}):",
-                total=job.total,
-                completed=job.success,
-                runtime=runtimes[name]
+                f"[text.primary]Progress ({name}):",
+                total=total,
+                completed=success,
+                runtime=runtime
             )
 
-        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.
+        Main rendering loop for the dashboard.
+
+        This method runs in a separate thread. It waits for update events,
+        fetches the latest data, re-renders the components, and updates the
+        live display.
         """
 
         def update_data():
@@ -618,7 +765,7 @@ class Board(metaclass=BoardSingleton):
 
             while not check_stop_event():
                 try:
-                    if self._render_event.wait(timeout=0.2):
+                    if self._render_event.wait(timeout=self._dwell):
                         self._render_event.clear()
                 except:  # noqa E722
                     # Catch any multiprocessing errors
@@ -629,6 +776,7 @@ class Board(metaclass=BoardSingleton):
 
                 update_data()
                 self.live.update(self._get_rendable(), refresh=True)
+                time.sleep(self._dwell)
 
         finally:
             update_data()
@@ -637,7 +785,13 @@ class Board(metaclass=BoardSingleton):
             else:
                 self._console.print(self._get_rendable())
 
-    def _update_layout(self):
+    def _update_layout(self) -> Layout:
+        """
+        Updates the layout dimensions based on the current data and console size.
+
+        Returns:
+            Layout: The updated layout object.
+        """
         with self._render_data_lock:
             visible_progress_bars = len(self._render_data.jobs)
             visible_jobs_count = self._render_data.total - self._render_data.skipped
@@ -652,6 +806,10 @@ class Board(metaclass=BoardSingleton):
         return self._layout
 
     def _update_rendable_data(self):
+        """
+        Transfers job data from the shared multiprocessing dictionary to the
+        local render data object, aggregating session-wide statistics.
+        """
         jobs = {}
         with self._job_data_lock:
             if self._board_info.data_modified:
@@ -688,18 +846,20 @@ class Board(metaclass=BoardSingleton):
 
     def _get_rendable(self):
         """
-        Combines all dashboard components (job table, progress bars, final summary)
-        into a single renderable group.
+        Assembles the final renderable object for the `rich.live` display.
+
+        It gets the latest layout, renders each component (job board, progress bars, log),
+        and combines them into a single `rich.group.Group`.
 
         Returns:
-            Group: A Rich Group object containing all dashboard components.
+            rich.group.Group: The complete, renderable dashboard layout.
         """
 
         layout = self._update_layout()
 
         new_table = self._render_job_dashboard(layout)
         new_bar = self._render_progress_bar(layout)
-        footer = self._render_final(layout)
+        footer = self._render_log(layout)
 
         items = []
         if new_table:
@@ -715,8 +875,13 @@ class Board(metaclass=BoardSingleton):
 
     def _update_render_data(self, chip, starttimes=None, complete=False):
         """
-        Updates the render data with the latest job and node information from the chip object.
-        This data is used to populate the dashboard.
+        Extracts job and node information from a chip object and updates the
+        shared job data dictionary, triggering a render event.
+
+        Args:
+            chip: The SiliconCompiler chip object.
+            starttimes (dict, optional): Dictionary of node start times. Defaults to None.
+            complete (bool, optional): Flag indicating if the job is complete. Defaults to False.
         """
 
         if not chip:
@@ -735,6 +900,21 @@ class Board(metaclass=BoardSingleton):
             self._render_event.set()
 
     def _get_job(self, chip, starttimes=None) -> JobData:
+        """
+        Parses a chip object to extract detailed information about the flowgraph,
+        node statuses, timings, and metrics.
+
+        This method calculates node display priority based on run status and
+        dependencies.
+
+        Args:
+            chip: The SiliconCompiler chip object to parse.
+            starttimes (dict, optional): A dictionary of node start times.
+                                         Defaults to None.
+
+        Returns:
+            JobData: A data object populated with the extracted information.
+        """
         if not starttimes:
             starttimes = {}
 
@@ -881,13 +1061,18 @@ class Board(metaclass=BoardSingleton):
                         "duration": duration
                     },
                     "metrics": node_metrics,
-                    "log": os.path.join(
+                    "log": [os.path.join(
                         os.path.relpath(
                             chip.getworkdir(step=step, index=index),
                             chip.cwd,
                         ),
-                        f"{step}.log",
-                    ),
+                        f"{step}.log"),
+                        os.path.join(
+                            os.path.relpath(
+                                chip.getworkdir(step=step, index=index),
+                                chip.cwd,
+                            ),
+                            f"sc_{step}_{index}.log")],
                     "print": {
                         "order": nodeorder[(step, index)],
                         "priority": node_priority[(step, index)]