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

siliconcompiler/record.py

@@ -18,11 +18,17 @@ from siliconcompiler import _metadata
 
 
 class RecordTime(Enum):
+    """
+    Enumeration of time record types.
+    """
     START = "starttime"
     END = "endtime"
 
 
 class RecordTool(Enum):
+    """
+    Enumeration of tool record types.
+    """
     EXITCODE = "toolexitcode"
     VERSION = "toolversion"
     PATH = "toolpath"
@@ -30,14 +36,31 @@ class RecordTool(Enum):
 
 
 class RecordSchema(BaseSchema):
+    """
+    A class for managing run record data.
+    """
     __TIMEFORMAT = "%Y-%m-%d %H:%M:%S.%f"
 
     def __init__(self):
+        """
+        Initializes the RecordSchema object.
+        """
         super().__init__()
 
         schema_record(self)
 
     def _from_dict(self, manifest, keypath, version=None):
+        """
+        Constructs a schema from a dictionary.
+
+        Args:
+            manifest (dict): Dictionary to construct from.
+            keypath (list): List of keys representing the path to the current dictionary.
+            version (str, optional): Version of the manifest. Defaults to None.
+
+        Returns:
+            dict: The constructed dictionary.
+        """
         ret = super()._from_dict(manifest, keypath, version)
 
         # Correct for change specification
@@ -51,7 +74,7 @@ class RecordSchema(BaseSchema):
 
     def clear(self, step, index, keep=None):
         '''
-        Clear all saved metrics for a given step and index
+        Clear all saved metrics for a given step and index.
 
         Args:
             step (str): Step name to clear.
@@ -339,11 +362,25 @@ class RecordSchema(BaseSchema):
             info = shlex.join(info)
         self.set(type.value, info, step=step, index=index)
 
+    @classmethod
+    def _getdict_type(cls) -> str:
+        """
+        Returns the meta data for getdict
+        """
+
+        return RecordSchema.__name__
+
 
 ###########################################################################
 # Run Record
 ###########################################################################
 def schema_record(schema):
+    """
+    Adds record schema parameters to the given schema.
+
+    Args:
+        schema (EditableSchema): The schema to modify.
+    """
     schema = EditableSchema(schema)
     records = {'userid': ['userid',
                           'wiley',

siliconcompiler/remote/__init__.py

@@ -36,12 +36,15 @@ class JobStatus():
     UNKNOWN = "unknown"
 
 
-from siliconcompiler.remote.client import Client, ConfigureClient # noqa E402
+from siliconcompiler.remote.client import Client, ConfigureClient, ClientScheduler # noqa E402
+from siliconcompiler.remote.server import Server # noqa E402
 
 
 __all__ = [
     "NodeStatus",
     "JobStatus",
     "Client",
-    "ConfigureClient"
+    "ConfigureClient",
+    "ClientScheduler",
+    "Server"
 ]

siliconcompiler/remote/client.py

@@ -1,34 +1,37 @@
 # Copyright 2020 Silicon Compiler Authors. All Rights Reserved.
 
 import json
+import multiprocessing
 import os
 import requests
 import shutil
 import time
-import urllib.parse
 import tarfile
 import tempfile
-import multiprocessing
 
 import os.path
+import urllib.parse
 
 from siliconcompiler import utils, SiliconCompilerError
 from siliconcompiler import NodeStatus as SCNodeStatus
+
 from siliconcompiler._metadata import default_server
-from siliconcompiler.remote import JobStatus, NodeStatus
-from siliconcompiler.report.dashboard import DashboardType
 from siliconcompiler.flowgraph import RuntimeFlowgraph
-from siliconcompiler.scheduler.scheduler import Scheduler
+from siliconcompiler.report.dashboard import DashboardType
+from siliconcompiler.scheduler import Scheduler
 from siliconcompiler.schema import Journal
+
 from siliconcompiler.utils.logging import get_console_formatter
 
+from siliconcompiler.remote import JobStatus, NodeStatus
+
 # Step name to use while logging
 remote_step_name = 'remote'
 
 
 class ClientScheduler(Scheduler):
     def run_core(self):
-        Client(self._Scheduler__chip).run()
+        Client(self.project).run()
 
     def configure_nodes(self):
         return
@@ -732,6 +735,8 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
 
         # Done: try to fetch any node results which still haven't been retrieved.
         self.__logger.info('Remote job completed! Retrieving final results...')
+        if not self.__setup_information_fetched:
+            self.__schedule_fetch_result(None)
         for node, node_info in self.__node_information.items():
             if not node_info["fetched"]:
                 self.__schedule_fetch_result(node)

siliconcompiler/remote/schema.py

@@ -1,13 +1,11 @@
-from siliconcompiler.schema import BaseSchema
-from siliconcompiler.schema import CommandLineSchema
-from siliconcompiler.schema import EditableSchema
-from siliconcompiler.schema import Parameter, Scope
+from siliconcompiler.schema import BaseSchema, EditableSchema, Parameter, Scope
+from siliconcompiler.cmdlineschema import CommandLineSchema
 
 
-SCHEMA_VERSION = '0.0.2'
+SCHEMA_VERSION = '0.0.3'
 
 
-class ServerSchema(BaseSchema, CommandLineSchema):
+class ServerSchema(CommandLineSchema, BaseSchema):
     def __init__(self):
         super().__init__()
 
@@ -57,7 +55,7 @@ class ServerSchema(BaseSchema, CommandLineSchema):
             Parameter(
                 'dir',
                 scope=Scope.GLOBAL,
-                defvalue='/nfs/sc_compute',
+                defvalue='./sc_compute',
                 require='all',
                 shorthelp="Directory of mounted shared NFS storage.",
                 switch="-nfsmount <dir>",
@@ -78,22 +76,6 @@ class ServerSchema(BaseSchema, CommandLineSchema):
                          "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(

siliconcompiler/remote/server.py

@@ -1,31 +1,35 @@
 # Copyright 2020 Silicon Compiler Authors. All Rights Reserved.
 
-from aiohttp import web
 import copy
-import threading
+import fastjsonschema
 import json
-import logging as log
+import logging
 import os
 import shutil
-import uuid
-import tarfile
 import sys
-import fastjsonschema
+import tarfile
+import threading
+import uuid
+
+from aiohttp import web
 from pathlib import Path
 from fastjsonschema import JsonSchemaException
 
 import os.path
 
 from siliconcompiler import Chip, Schema
-from siliconcompiler.schema import utils as schema_utils
+from siliconcompiler import NodeStatus as SCNodeStatus
 from siliconcompiler._metadata import version as sc_version
+
+from siliconcompiler.schema import utils as schema_utils
 from siliconcompiler.schema import SCHEMA_VERSION as sc_schema_version
-from siliconcompiler.remote.schema import ServerSchema
-from siliconcompiler.remote import banner, JobStatus
-from siliconcompiler import NodeStatus as SCNodeStatus
-from siliconcompiler.remote import NodeStatus
+
 from siliconcompiler.flowgraph import RuntimeFlowgraph
-from siliconcompiler.scheduler.taskscheduler import TaskScheduler
+from siliconcompiler.scheduler import SchedulerNode
+from siliconcompiler.scheduler import TaskScheduler
+
+from siliconcompiler.remote import JobStatus, NodeStatus
+from siliconcompiler.remote.schema import ServerSchema
 
 
 # Compile validation code for API request bodies.
@@ -57,7 +61,7 @@ with open(api_dir / 'get_results.json') as schema:
     validate_get_results = fastjsonschema.compile(json.loads(schema.read()))
 
 
-class Server:
+class Server(ServerSchema):
     """
     The core class for the siliconcompiler 'gateway' server, which can run
     locally or on a remote host. Its job is to process requests for
@@ -74,26 +78,21 @@ class Server:
         Init method for Server object
         '''
 
+        super().__init__()
+
         # Initialize logger
-        self.logger = log.getLogger(f'sc_server_{id(self)}')
-        handler = log.StreamHandler(stream=sys.stdout)
-        formatter = log.Formatter('%(asctime)s | %(levelname)-8s | %(message)s')
+        self.logger = logging.getLogger(f'sc_server_{uuid.uuid4().hex}')
+        handler = logging.StreamHandler(stream=sys.stdout)
+        formatter = logging.Formatter('%(asctime)s | %(levelname)-8s | %(message)s')
         handler.setFormatter(formatter)
         self.logger.addHandler(handler)
         self.logger.setLevel(schema_utils.translate_loglevel(loglevel))
 
-        self.schema = ServerSchema()
-
         # Set up a dictionary to track running jobs.
         self.sc_jobs_lock = threading.Lock()
         self.sc_jobs = {}
         self.sc_chip_lookup = {}
 
-        # Register callbacks
-        TaskScheduler.register_callback("pre_run", self.__run_start)
-        TaskScheduler.register_callback("pre_node", self.__node_start)
-        TaskScheduler.register_callback("post_node", self.__node_end)
-
     def __run_start(self, chip):
         flow = chip.get("option", "flow")
         nodes = chip.get("flowgraph", flow, field="schema").get_nodes()
@@ -135,15 +134,19 @@ class Server:
                                        job_hash,
                                        f'{job_hash}_{step}{index}.tar.gz'),
                           mode='w:gz') as tf:
-            chip._archive_node(tf, step=step, index=index, include="*")
+            SchedulerNode(chip, step, index).archive(tf, include="*")
 
         with self.sc_jobs_lock:
             self.sc_jobs[job_name][f"{step}{index}"]["status"] = \
                 chip.get('record', 'status', step=step, index=index)
 
     def run(self):
+        if not os.path.exists(self.nfs_mount):
+            os.makedirs(self.nfs_mount, exist_ok=True)
         if not os.path.exists(self.nfs_mount):
             raise FileNotFoundError(f'{self.nfs_mount} could not be found.')
+        with open(os.path.join(self.nfs_mount, ".gitignore"), "w") as f:
+            f.write("*")
 
         self.logger.info(f"Running in: {self.nfs_mount}")
         # If authentication is enabled, try connecting to the SQLite3 database.
@@ -176,6 +179,11 @@ class Server:
                                     "file in the server's working directory. "
                                     "(User : Key) mappings were not imported.")
 
+        # Register callbacks
+        TaskScheduler.register_callback("pre_run", self.__run_start)
+        TaskScheduler.register_callback("pre_node", self.__node_start)
+        TaskScheduler.register_callback("post_node", self.__node_end)
+
         # Create a minimal web server to process the 'remote_run' API call.
         self.app = web.Application()
         self.app.add_routes([
@@ -194,21 +202,6 @@ class Server:
         # Start the async server.
         web.run_app(self.app, port=self.get('option', 'port'))
 
-    def create_cmdline(self, progname, description=None, switchlist=None, additional_args=None):
-        def print_banner():
-            print(banner)
-            print("Version:", Server.__version__, "\n")
-            print("-" * 80)
-
-        return self.schema.create_cmdline(
-            progname=progname,
-            description=description,
-            switchlist=switchlist,
-            additional_args=additional_args,
-            version=Server.__version__,
-            print_banner=print_banner,
-            logger=self.logger)
-
     ####################
     async def handle_remote_run(self, request):
         '''
@@ -284,6 +277,15 @@ class Server:
         # Remove 'remote' JSON config value to run locally on compute node.
         chip.set('option', 'remote', False)
 
+        # Mark as nodisplay since it is a remote run
+        chip.set('option', 'nodisplay', True)
+
+        # Mark as quite to make server logging easier
+        chip.set('option', 'quiet', True)
+
+        # Log job received
+        self.logger.info(f"Received job: {job_hash}")
+
         # Run the job with the configured clustering option. (Non-blocking)
         job_proc = threading.Thread(target=self.remote_sc,
                                     args=[
@@ -543,18 +545,3 @@ class Server:
     @property
     def checkinterval(self):
         return self.get('option', 'checkinterval')
-
-    def get(self, *keypath, field='value'):
-        return self.schema.get(*keypath, field=field)
-
-    def set(self, *args, field='value', clobber=True):
-        keypath = args[:-1]
-        value = args[-1]
-
-        if keypath == ['option', 'loglevel'] and field == 'value':
-            self.logger.setLevel(schema_utils.translate_loglevel(value))
-
-        self.schema.set(*keypath, value, field=field, clobber=clobber)
-
-    def write_configuration(self, filepath):
-        self.schema.write_manifest(filepath)

siliconcompiler/report/__init__.py

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

siliconcompiler/report/dashboard/__init__.py

@@ -3,6 +3,16 @@ from enum import Enum
 
 
 class DashboardType(Enum):
+    """
+    An enumeration to represent the available types of dashboards.
+
+    This allows for a standardized way to specify whether to launch a
+    web-based dashboard or a command-line interface (CLI) dashboard.
+
+    Attributes:
+        WEB: Represents a web-based dashboard.
+        CLI: Represents a command-line interface dashboard.
+    """
     WEB = 'web'
     CLI = 'cli'
 
@@ -10,72 +20,96 @@ class DashboardType(Enum):
 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.
+
+    This class establishes a contract for all concrete dashboard classes,
+    such as `CliDashboard` or a future `WebDashboard`. It ensures that any
+    dashboard implementation will have a consistent set of methods for
+    starting, stopping, and updating its state, regardless of its specific
+    rendering technology (e.g., terminal UI or web browser).
     """
 
     @abstractmethod
     def __init__(self, chip):
         """
-        Initialize the dashboard.
+        Initializes the dashboard with a reference to the chip object.
 
         Args:
-            chip: The chip object to display in the dashboard
+            chip: The SiliconCompiler chip object whose data will be displayed
+                  by the dashboard.
         """
         self._chip = chip
 
     @abstractmethod
     def open_dashboard(self):
         """
-        Open and start the dashboard service.
+        Opens and starts the dashboard service.
+
+        This method should handle all setup required to make the dashboard
+        visible and active, such as starting a rendering thread or a web server.
         """
         pass
 
     @abstractmethod
     def update_manifest(self, payload=None):
         """
-        Update the manifest file with the latest chip information.
+        Updates the dashboard with the latest information from the chip's manifest.
+
+        This method is the primary mechanism for pushing new data to the
+        dashboard as the compilation flow progresses.
 
         Args:
-            payload (dict): Dictionary of metadata to pass along to dashboard.
-                {"starttimes" {<node>: time, ...}}
+            payload (dict, optional): A dictionary of metadata to pass to the
+                dashboard. A common use is to provide node start times, e.g.,
+                `{"starttimes": {<node_tuple>: time, ...}}`. Defaults to None.
         """
         pass
 
     @abstractmethod
     def update_graph_manifests(self):
         """
-        Update the manifest files for all graph chips.
+        Updates the manifest files for all associated graph chips.
+
+        This is intended for scenarios where a dashboard might need to display
+        data from multiple, related chip objects (e.g., in a multi-job run).
         """
         pass
 
     @abstractmethod
     def is_running(self):
         """
-        Check if the dashboard is currently running.
+        Checks if the dashboard service is currently active.
 
         Returns:
-            bool: True if the dashboard is running, False otherwise
+            bool: True if the dashboard is running, False otherwise.
         """
         pass
 
     @abstractmethod
     def end_of_run(self):
         """
-        Announce that a run has completed
+        Notifies the dashboard that a compilation run has completed.
+
+        This allows the dashboard to perform any final updates or cleanup
+        actions, such as displaying a final summary.
         """
         pass
 
     @abstractmethod
     def stop(self):
         """
-        Stop the dashboard service if it's running.
+        Stops the dashboard service if it's running.
+
+        This method should gracefully shut down any background processes,
+        threads, or servers associated with the dashboard.
         """
         pass
 
     @abstractmethod
     def wait(self):
         """
-        Wait for the dashboard service to terminate.
+        Waits for the dashboard service to terminate.
+
+        This is a blocking call that should not return until the dashboard
+        has fully shut down. It is useful for ensuring a clean exit.
         """
         pass