siliconcompiler 0.32.2__py3-none-any.whl → 0.33.0__py3-none-any.whl

siliconcompiler/remote/schema.py

@@ -1,117 +1,121 @@
-from siliconcompiler.schema.schema_cfg import scparam
-from siliconcompiler.schema import Schema
-from siliconcompiler.schema.utils import PerNode, Scope
+from siliconcompiler.schema import BaseSchema
+from siliconcompiler.schema import CommandLineSchema
+from siliconcompiler.schema import EditableSchema
+from siliconcompiler.schema import Parameter, Scope
 
 
 SCHEMA_VERSION = '0.0.2'
 
 
-def schema_cfg():
-    # Basic schema setup
-    cfg = {}
-
-    scparam(cfg, ['schemaversion'],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            defvalue=SCHEMA_VERSION,
-            require='all',
-            shorthelp="Schema version number",
-            lock=True,
-            switch="-schemaversion <str>",
-            example=["api: server.get('schemaversion')"],
-            schelp="""SiliconCompiler server schema version number.""")
-
-    scparam(cfg, ['option', 'port'],
-            sctype='int',
-            scope=Scope.GLOBAL,
-            defvalue=8080,
-            require='all',
-            shorthelp="Port number to run the server on.",
-            switch="-port <int>",
-            example=["cli: -port 8000",
-                     "api: server.set('option', 'port', 8080)"],
-            schelp="""Port number to run the server on.""")
-
-    scparam(cfg, ['option', 'cluster'],
-            sctype='enum',
-            enum=['local', 'slurm'],
-            scope=Scope.GLOBAL,
-            defvalue='local',
-            require='all',
-            shorthelp="Type of compute cluster to use.",
-            switch="-cluster <str>",
-            example=["cli: -cluster slurm",
-                     "api: server.set('option', 'clister', 'slurm')"],
-            schelp="""Type of compute cluster to use.""")
-
-    scparam(cfg, ['option', 'nfsmount'],
-            sctype='dir',
-            scope=Scope.GLOBAL,
-            defvalue='/nfs/sc_compute',
-            require='all',
-            shorthelp="Directory of mounted shared NFS storage.",
-            switch="-nfsmount <dir>",
-            example=["cli: -nfsmount ~/sc_server",
-                     "api: server.set('option', 'server', '~/sc_server')"],
-            schelp="""Directory of mounted shared NFS storage.""")
-
-    scparam(cfg, ['option', 'auth'],
-            sctype='bool',
-            scope=Scope.GLOBAL,
-            defvalue=False,
-            require='all',
-            shorthelp="Flag determining whether to enable authenticated and encrypted jobs.",
-            switch="-auth <bool>",
-            example=["cli: -auth true",
-                     "api: server.set('option', 'auth', True)"],
-            schelp="""Flag determining whether to enable authenticated and encrypted jobs.""")
-
-    scparam(cfg, ['option', 'cfg'],
-            sctype='[file]',
-            scope=Scope.JOB,
-            shorthelp="Configuration manifest",
-            switch="-cfg <file>",
-            example=["cli: -cfg mypdk.json",
-                     "api: chip.set('option', 'cfg', 'mypdk.json')"],
-            schelp="""
-            List of filepaths to JSON formatted schema configuration
-            manifests. The files are read in automatically when using the
-            command line application. In Python programs, JSON manifests
-            can be merged into the current working manifest using the
-            read_manifest() method.""")
-
-    scparam(cfg, ['option', 'loglevel'],
-            sctype='enum',
-            enum=["info", "warning", "error", "critical", "debug"],
-            pernode=PerNode.OPTIONAL,
-            scope=Scope.JOB,
-            defvalue='info',
-            shorthelp="Logging level",
-            switch="-loglevel <str>",
-            example=[
-                "cli: -loglevel info",
-                "api: server.set('option', 'loglevel', 'info')"],
-            schelp="""
-            Provides explicit control over the level of debug logging printed.""")
-
-    scparam(cfg, ['option', 'checkinterval'],
-            sctype='int',
-            defvalue=30,
-            shorthelp="Interval for client",
-            switch="-checkinterval <int>",
-            example=["cli: -checkinterval 10",
-                     "api: chip.set('option', 'checkinterval', 10)"],
-            schelp="""
-            Interval between checks to announce to clients""")
-
-    return cfg
-
-
-class ServerSchema(Schema):
-    def __init__(self, cfg=None, manifest=None, logger=None):
-        super().__init__(cfg=cfg,
-                         manifest=manifest,
-                         logger=logger)
-
-    def _init_schema_cfg(self):
-        return schema_cfg()
+class ServerSchema(BaseSchema, CommandLineSchema):
+    def __init__(self):
+        super().__init__()
+
+        schema = EditableSchema(self)
+
+        schema.insert(
+            'schemaversion',
+            Parameter(
+                'str',
+                scope=Scope.GLOBAL,
+                defvalue=SCHEMA_VERSION,
+                require='all',
+                shorthelp="Schema version number",
+                lock=True,
+                switch="-schemaversion <str>",
+                example=["api: server.get('schemaversion')"],
+                help="""SiliconCompiler server schema version number."""))
+
+        schema.insert(
+            'option', 'port',
+            Parameter(
+                'int',
+                scope=Scope.GLOBAL,
+                defvalue=8080,
+                require='all',
+                shorthelp="Port number to run the server on.",
+                switch="-port <int>",
+                example=["cli: -port 8000",
+                         "api: server.set('option', 'port', 8080)"],
+                help="""Port number to run the server on."""))
+
+        schema.insert(
+            'option', 'cluster',
+            Parameter(
+                '<local,slurm>',
+                scope=Scope.GLOBAL,
+                defvalue='local',
+                require='all',
+                shorthelp="Type of compute cluster to use.",
+                switch="-cluster <str>",
+                example=["cli: -cluster slurm",
+                         "api: server.set('option', 'clister', 'slurm')"],
+                help="""Type of compute cluster to use."""))
+
+        schema.insert(
+            'option', 'nfsmount',
+            Parameter(
+                'dir',
+                scope=Scope.GLOBAL,
+                defvalue='/nfs/sc_compute',
+                require='all',
+                shorthelp="Directory of mounted shared NFS storage.",
+                switch="-nfsmount <dir>",
+                example=["cli: -nfsmount ~/sc_server",
+                         "api: server.set('option', 'server', '~/sc_server')"],
+                help="""Directory of mounted shared NFS storage."""))
+
+        schema.insert(
+            'option', 'auth',
+            Parameter(
+                'bool',
+                scope=Scope.GLOBAL,
+                defvalue=False,
+                require='all',
+                shorthelp="Flag determining whether to enable authenticated and encrypted jobs.",
+                switch="-auth <bool>",
+                example=["cli: -auth true",
+                         "api: server.set('option', 'auth', True)"],
+                help="""Flag determining whether to enable authenticated and encrypted jobs."""))
+
+        schema.insert(
+            'option', 'cfg',
+            Parameter(
+                '[file]',
+                scope=Scope.JOB,
+                shorthelp="Configuration manifest",
+                switch="-cfg <file>",
+                example=["cli: -cfg mypdk.json",
+                         "api: chip.set('option', 'cfg', 'mypdk.json')"],
+                help="""
+                List of filepaths to JSON formatted schema configuration
+                manifests. The files are read in automatically when using the
+                command line application. In Python programs, JSON manifests
+                can be merged into the current working manifest using the
+                read_manifest() method."""))
+
+        schema.insert(
+            'option', 'loglevel',
+            Parameter(
+                '<info,warning,error,critical,debug>',
+                scope=Scope.JOB,
+                defvalue='info',
+                shorthelp="Logging level",
+                switch="-loglevel <str>",
+                example=[
+                        "cli: -loglevel info",
+                        "api: server.set('option', 'loglevel', 'info')"],
+                help="""
+                Provides explicit control over the level of debug logging printed."""))
+
+        schema.insert(
+            'option', 'checkinterval',
+            Parameter(
+                'int',
+                defvalue=30,
+                shorthelp="Interval for client",
+                switch="-checkinterval <int>",
+                example=["cli: -checkinterval 10",
+                         "api: chip.set('option', 'checkinterval', 10)"],
+                help="""
+                Interval between checks to announce to clients"""))

siliconcompiler/remote/server.py

@@ -21,7 +21,7 @@ from siliconcompiler.schema import SCHEMA_VERSION as sc_schema_version
 from siliconcompiler.remote.schema import ServerSchema
 from siliconcompiler.remote import banner, JobStatus
 from siliconcompiler.scheduler.slurm import get_configuration_directory
-from siliconcompiler.flowgraph import nodes_to_execute
+from siliconcompiler.utils.flowgraph import nodes_to_execute
 
 
 # Compile validation code for API request bodies.
@@ -78,7 +78,7 @@ class Server:
         self.logger.addHandler(handler)
         self.logger.setLevel(schema_utils.translate_loglevel(loglevel))
 
-        self.schema = ServerSchema(logger=self.logger)
+        self.schema = ServerSchema()
 
         # Set up a dictionary to track running jobs.
         self.sc_jobs = {}
@@ -146,7 +146,6 @@ class Server:
             progname=progname,
             description=description,
             switchlist=switchlist,
-            input_map=None,
             additional_args=additional_args,
             version=Server.__version__,
             print_banner=print_banner,
@@ -508,5 +507,4 @@ class Server:
         self.schema.set(*keypath, value, field=field, clobber=clobber)
 
     def write_configuration(self, filepath):
-        with open(filepath, 'w') as f:
-            self.schema.write_json(f)
+        self.schema.write_manifest(filepath)

siliconcompiler/report/__init__.py

@@ -1,7 +1,8 @@
 from .summary_image import _generate_summary_image, _open_summary_image
 from .html_report import _generate_html_report, _open_html_report
 from .summary_table import _show_summary_table
-from .dashboard import Dashboard
+from .dashboard.web import WebDashboard
+# from .dashboard import Dashboard
 
 __all__ = [
     "_generate_summary_image",
@@ -9,5 +10,5 @@ __all__ = [
     "_generate_html_report",
     "_open_html_report",
     "_show_summary_table",
-    "Dashboard"
+    "WebDashboard"
 ]

siliconcompiler/report/dashboard/__init__.py

@@ -1,190 +1,81 @@
-import os
-import time
-import tempfile
-import json
+from abc import ABC, abstractmethod
+from enum import Enum
 
-import multiprocessing
-import subprocess
-import atexit
-import shutil
-import fasteners
-import signal
-import socketserver
 
-from siliconcompiler.report.dashboard import utils
+class DashboardType(Enum):
+    WEB = 'web'
+    CLI = 'cli'
 
-try:
-    from streamlit.web import bootstrap
-    from streamlit import config as _config
-except ModuleNotFoundError:
-    bootstrap = None
-    _config = None
 
+class AbstractDashboard(ABC):
+    """
+    Abstract base class defining the interface for dashboard implementations.
+    Any concrete dashboard implementation should inherit from this class and
+    implement all abstract methods.
+    """
 
-class Dashboard():
-    __port = 8501
+    @abstractmethod
+    def __init__(self, chip):
+        """
+        Initialize the dashboard.
 
-    @staticmethod
-    def __signal_handler(signal, frame):
-        # used to avoid issues during shutdown
-        pass
-
-    def __init__(self, chip, port=None, graph_chips=None):
-        if not bootstrap:
-            raise NotImplementedError('streamlit is not available')
-
-        if not port:
-            port = Dashboard.get_next_port()
-        if not port:
-            port = Dashboard.__port
-
-        self.__dashboard = None
-        self.__chip = chip
-        self.__directory = tempfile.mkdtemp(prefix='sc_dashboard_',
-                                            suffix=f'_{self.__chip.design}')
-        self.__manifest = os.path.join(self.__directory, 'manifest.json')
-        self.__manifest_lock = os.path.join(self.__directory, 'manifest.lock')
-        self.__port = port
-        dirname = os.path.dirname(__file__)
-        self.__streamlit_file = os.path.join(dirname, 'viewer.py')
-
-        self.__streamlit_args = [
-            ("browser.gatherUsageStats", False),
-            ("browser.serverPort", self.__port),
-            ("logger.level", 'error'),
-            ("runner.fastReruns", True),
-            ("server.port", self.__port),
-            ("client.toolbarMode", "viewer")
-        ]
-
-        # pass in a json object called __graph_chips
-        # the key is the chip_name and value is the filepath
-        # if another argument is passed
-
-        # use of list is to preserve order
-        self.__graph_chips = []
-        graph_chips_config = []
-        if graph_chips:
-            for chip_object_and_name in graph_chips:
-                chip_file_path = \
-                    os.path.join(self.__directory,
-                                 f"{chip_object_and_name['name']}.json")
-                self.__graph_chips.append({
-                    'chip': chip_object_and_name['chip'],
-                    'name': chip_file_path
-                })
-                graph_chips_config.append({
-                    "path": chip_file_path,
-                    "cwd": utils.get_chip_cwd(
-                        chip_object_and_name['chip'],
-                        chip_object_and_name['cfg_path'])
-                })
-
-        self.__config = {
-            "manifest": self.__manifest,
-            "lock": self.__manifest_lock,
-            "graph_chips": graph_chips_config
-        }
-
-        self.__sleep_time = 0.5
-        self.__signal_handler = None
-
-        self.__lock = fasteners.InterProcessLock(self.__manifest_lock)
-
-        atexit.register(self.__cleanup)
+        Args:
+            chip: The chip object to display in the dashboard
+        """
+        self._chip = chip
 
+    @abstractmethod
     def open_dashboard(self):
-        with open(self.__get_config_file(), 'w') as f:
-            json.dump(self.__config, f, indent=4)
-
-        self.update_manifest()
-
-        self.update_graph_manifests()
-
-        self.__dashboard = multiprocessing.Process(
-            target=self._run_streamlit_bootstrap)
-
-        self.__signal_handler = signal.signal(signal.SIGINT, Dashboard.__signal_handler)
-
-        self.__dashboard.start()
-
-    def update_manifest(self):
-        if not self.__manifest:
-            return
+        """
+        Open and start the dashboard service.
+        """
+        pass
 
-        new_file = f"{self.__manifest}.new.json"
-        self.__chip.write_manifest(new_file)
+    @abstractmethod
+    def update_manifest(self, payload=None):
+        """
+        Update the manifest file with the latest chip information.
 
-        with self.__lock:
-            shutil.move(new_file, self.__manifest)
+        Args:
+            payload (dict): Dictionary of metadata to pass along to dashboard.
+                {"starttimes" {<node>: time, ...}}
+        """
+        pass
 
+    @abstractmethod
     def update_graph_manifests(self):
-        for chip_object_and_name in self.__graph_chips:
-            chip = chip_object_and_name['chip']
-            file_path = chip_object_and_name['name']
-            chip.write_manifest(file_path)
-
-    def __get_config_file(self):
-        return os.path.join(self.__directory, 'config.json')
+        """
+        Update the manifest files for all graph chips.
+        """
+        pass
 
+    @abstractmethod
     def is_running(self):
-        if self.__dashboard is None:
-            return False
+        """
+        Check if the dashboard is currently running.
 
-        if self.__dashboard.is_alive():
-            return True
+        Returns:
+            bool: True if the dashboard is running, False otherwise
+        """
+        pass
 
-        self.__dashboard = None
-        self.__manifest = None
-        return False
+    @abstractmethod
+    def end_of_run(self):
+        """
+        Announce that a run has completed
+        """
+        pass
 
+    @abstractmethod
     def stop(self):
-        if not self.is_running():
-            return
-
-        while self.__dashboard.is_alive():
-            self.__dashboard.terminate()
-            self._sleep()
-
-        if self.__signal_handler:
-            signal.signal(signal.SIGINT, self.__signal_handler)
-
-        self.__dashboard = None
-        self.__manifest = None
-        self.__signal_handler = None
+        """
+        Stop the dashboard service if it's running.
+        """
+        pass
 
+    @abstractmethod
     def wait(self):
-        self.__dashboard.join()
-
-    def _sleep(self):
-        time.sleep(self.__sleep_time)
-
-    def _run_streamlit_bootstrap(self):
-        for config, val in self.__streamlit_args:
-            _config.set_option(config, val)
-
-        bootstrap.run(self.__streamlit_file,
-                      False,
-                      [self.__get_config_file()],
-                      flag_options={})
-
-    def __run_streamlit_subproc(self):
-        cmd = ['streamlit', 'run',
-               self.__streamlit_file, self.__get_config_file()]
-        for config, val in self.__streamlit_args:
-            cmd.append(f'--{config}')
-            cmd.append(val)
-
-        subprocess.Popen(cmd)
-
-    def __cleanup(self):
-        self.stop()
-
-        if os.path.exists(self.__directory):
-            shutil.rmtree(self.__directory)
-
-    @staticmethod
-    def get_next_port():
-        with socketserver.TCPServer(("localhost", 0), None) as s:
-            return s.server_address[1]
-        return None
+        """
+        Wait for the dashboard service to terminate.
+        """
+        pass

siliconcompiler/report/dashboard/cli/__init__.py

@@ -0,0 +1,79 @@
+from siliconcompiler.report.dashboard import AbstractDashboard
+from siliconcompiler.report.dashboard.cli.board import Board
+
+
+class CliDashboard(AbstractDashboard):
+
+    def __init__(self, chip):
+        super().__init__(chip)
+
+        self._dashboard = Board()
+
+        self.__logger_console = None
+
+        self._logger = chip.logger
+
+    def set_logger(self, logger):
+        """
+        Sets the logger for the dashboard.
+
+        Args:
+            logger (logging.Logger): The logger to set.
+        """
+        self._logger = logger
+        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._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."""
+
+        self.set_logger(self._logger)
+
+        self._dashboard.open_dashboard()
+
+    def update_manifest(self, payload=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.
+        """
+        starttimes = None
+        if payload and "starttimes" in payload:
+            starttimes = payload["starttimes"]
+        self._dashboard.update_manifest(self._chip, starttimes=starttimes)
+
+    def update_graph_manifests(self):
+        """Placeholder method for updating graph manifests. Currently not implemented."""
+        pass
+
+    def is_running(self):
+        """Returns True to indicate that the dashboard is running."""
+        return self._dashboard.is_running()
+
+    def end_of_run(self):
+        """
+        Stops the dashboard rendering thread and ensures all rendering operations are completed.
+        """
+        self._dashboard.end_of_run(self._chip)
+
+    def stop(self):
+        """
+        Stops the dashboard rendering thread and ensures all rendering operations are completed.
+        """
+        self._dashboard.end_of_run(self._chip)
+
+        # Restore logger
+        if self.__logger_console:
+            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()
+            self.__logger_console = None
+
+    def wait(self):
+        """Waits for the dashboard rendering thread to finish."""
+        self._dashboard.wait()