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

siliconcompiler/packageschema.py

@@ -0,0 +1,260 @@
+import os
+
+import os.path
+
+from siliconcompiler.schema import BaseSchema
+from siliconcompiler.schema import EditableSchema, Parameter, Scope
+from siliconcompiler.schema.utils import trim
+from siliconcompiler.package import Resolver
+
+
+class PackageSchema(BaseSchema):
+    def __init__(self):
+        super().__init__()
+
+        schema_package(self)
+
+        self.__cache = {}
+
+    def register(self, name, path, ref=None, clobber=True):
+        """
+        Registers a package by its name with the source path and reference
+
+        Registered package sources are stored in the package section of the schema.
+
+        Args:
+            name (str): Package name
+            path (str): Path to the sources, can be file, git url, archive url
+            ref (str): Reference of the sources, can be commitid, branch name, tag
+            clobber (bool): Overwrite existing
+
+        Examples:
+            >>> schema.register('siliconcompiler_data',
+                    'git+https://github.com/siliconcompiler/siliconcompiler',
+                    'cd328131bafd361787f9137a6ffed999d64c8c30')
+        """
+
+        # If this is a file, get the directory for this
+        if os.path.isfile(path):
+            path = os.path.dirname(os.path.abspath(path))
+        elif os.path.isdir(path):
+            path = os.path.abspath(path)
+
+        success = False
+        if self.set('source', name, 'path', path, clobber=clobber):
+            success = True
+        if success and ref:
+            success = False
+            if self.set('source', name, 'ref', ref, clobber=clobber):
+                success = True
+        return success
+
+    def get_resolver(self, package):
+        '''
+        Returns a specific resolver
+
+        Args:
+            package (str): name of package
+        '''
+        resolver_cls = Resolver.find_resolver(self.get("source", package, "path"))
+        resolver = resolver_cls(package, self._parent(root=True),
+                                self.get("source", package, "path"),
+                                self.get("source", package, "ref"))
+        resolver.set_cache(self.__cache)
+        return resolver
+
+    def get_resolvers(self):
+        '''
+        Returns a dictionary of packages with their resolver method.
+        '''
+        resolvers = {}
+        for package in self.getkeys("source"):
+            resolvers[package] = self.get_resolver(package).get_path
+
+        return resolvers
+
+    def _set_cache(self, package, path):
+        self.__cache[package] = path
+
+    def get_path_cache(self):
+        return self.__cache.copy()
+
+
+############################################
+# Package information
+############################################
+def schema_package(schema):
+    schema = EditableSchema(schema)
+
+    schema.insert(
+        'version',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="Package: version",
+            switch="-package_version <str>",
+            example=[
+                "cli: -package_version 1.0",
+                "api: chip.set('package', 'version', '1.0')"],
+            help=trim("""Package version. Can be a branch, tag, commit hash,
+            or a semver compatible version.""")))
+
+    schema.insert(
+        'description',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="Package: description",
+            switch="-package_description <str>",
+            example=[
+                "cli: -package_description 'Yet another cpu'",
+                "api: chip.set('package', 'description', 'Yet another cpu')"],
+            help=trim("""Package short one line description for package
+            managers and summary reports.""")))
+
+    schema.insert(
+        'keyword',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="Package: keyword",
+            switch="-package_keyword <str>",
+            example=[
+                "cli: -package_keyword cpu",
+                "api: chip.set('package', 'keyword', 'cpu')"],
+            help=trim("""Package keyword(s) used to characterize package.""")))
+    schema.insert(
+        'doc', 'homepage',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="Package: documentation homepage",
+            switch="-package_doc_homepage <str>",
+            example=[
+                "cli: -package_doc_homepage index.html",
+                "api: chip.set('package', 'doc', 'homepage', 'index.html')"],
+            help=trim("""
+            Package documentation homepage. Filepath to design docs homepage.
+            Complex designs can can include a long non standard list of
+            documents dependent. A single html entry point can be used to
+            present an organized documentation dashboard to the designer.""")))
+
+    doctypes = ['datasheet',
+                'reference',
+                'userguide',
+                'quickstart',
+                'releasenotes',
+                'testplan',
+                'signoff',
+                'tutorial']
+
+    for item in doctypes:
+        schema.insert(
+            'doc', item,
+            Parameter(
+                '[file]',
+                scope=Scope.GLOBAL,
+                shorthelp=f"Package: {item} document",
+                switch=f"-package_doc_{item} <file>",
+                example=[
+                    f"cli: -package_doc_{item} {item}.pdf",
+                    f"api: chip.set('package', 'doc', '{item}', '{item}.pdf')"],
+                help=trim(f"""Package list of {item} documents.""")))
+
+    schema.insert(
+        'license',
+        Parameter(
+            '[str]',
+            scope=Scope.GLOBAL,
+            shorthelp="Package: license identifiers",
+            switch="-package_license <str>",
+            example=[
+                "cli: -package_license 'Apache-2.0'",
+                "api: chip.set('package', 'license', 'Apache-2.0')"],
+            help=trim("""Package list of SPDX license identifiers.""")))
+
+    schema.insert(
+        'licensefile',
+        Parameter(
+            '[file]',
+            scope=Scope.GLOBAL,
+            shorthelp="Package: license files",
+            switch="-package_licensefile <file>",
+            example=[
+                "cli: -package_licensefile './LICENSE'",
+                "api: chip.set('package', 'licensefile', './LICENSE')"],
+            help=trim("""Package list of license files for to be
+            applied in cases when a SPDX identifier is not available.
+            (eg. proprietary licenses).""")))
+
+    schema.insert(
+        'organization',
+        Parameter(
+            '[str]',
+            scope=Scope.GLOBAL,
+            shorthelp="Package: sponsoring organization",
+            switch="-package_organization <str>",
+            example=[
+                "cli: -package_organization 'humanity'",
+                "api: chip.set('package', 'organization', 'humanity')"],
+            help=trim("""Package sponsoring organization. The field can be left
+            blank if not applicable.""")))
+
+    record = ['name',
+              'email',
+              'username',
+              'location',
+              'organization',
+              'publickey']
+
+    for item in record:
+        schema.insert(
+            'author', 'default', item,
+            Parameter(
+                'str',
+                scope=Scope.GLOBAL,
+                shorthelp=f"Package: author {item}",
+                switch=f"-package_author_{item} 'userid <str>'",
+                example=[
+                    f"cli: -package_author_{item} 'wiley wiley@acme.com'",
+                    f"api: chip.set('package', 'author', 'wiley', '{item}', 'wiley@acme.com')"],
+                help=trim(f"""Package author {item} provided with full name as key and
+                {item} as value.""")))
+
+    schema.insert(
+        'source', 'default', 'path',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="Package: data source path",
+            switch="-package_source_path 'source <str>'",
+            example=[
+                "cli: -package_source_path "
+                "'freepdk45_data ssh://git@github.com/siliconcompiler/freepdk45/'",
+                "api: chip.set('package', 'source', "
+                "'freepdk45_data', 'path', 'ssh://git@github.com/siliconcompiler/freepdk45/')"],
+            help=trim("""
+            Package data source path, allowed paths:
+
+            * /path/on/network/drive
+            * file:///path/on/network/drive
+            * git+https://github.com/xyz/xyz
+            * git://github.com/xyz/xyz
+            * git+ssh://github.com/xyz/xyz
+            * ssh://github.com/xyz/xyz
+            * https://github.com/xyz/xyz/archive
+            * https://zeroasic.com/xyz.tar.gz
+            * python://siliconcompiler
+            """)))
+
+    schema.insert(
+        'source', 'default', 'ref',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="Package: data source reference",
+            switch="-package_source_ref 'source <str>'",
+            example=[
+                "cli: -package_source_ref 'freepdk45_data 07ec4aa'",
+                "api: chip.set('package', 'source', 'freepdk45_data', 'ref', '07ec4aa')"],
+            help=trim("""Package data source reference""")))

siliconcompiler/pdk.py

@@ -1,12 +1,12 @@
-from siliconcompiler.schema import NamedSchema, PackageSchema
+from siliconcompiler.schema import NamedSchema
 from siliconcompiler.schema import EditableSchema, Parameter, Scope
 from siliconcompiler.schema.utils import trim
 
 
-class PDKSchema(NamedSchema, PackageSchema):
-    def __init__(self, name=None, package=None):
-        NamedSchema.__init__(self, name=name)
-        PackageSchema.__init__(self, package=package)
+class PDKSchema(NamedSchema):
+    def __init__(self, name=None):
+        super().__init__()
+        self.set_name(name)
 
         schema_pdk(self)
 

siliconcompiler/remote/client.py

@@ -18,12 +18,25 @@ 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.schema import JournalingSchema
+from siliconcompiler.scheduler.scheduler import Scheduler
+from siliconcompiler.schema import Journal
+from siliconcompiler.utils.logging import get_console_formatter
 
 # Step name to use while logging
 remote_step_name = 'remote'
 
 
+class ClientScheduler(Scheduler):
+    def run_core(self):
+        Client(self._Scheduler__chip).run()
+
+    def configure_nodes(self):
+        return
+
+    def check_manifest(self):
+        return True
+
+
 class Client():
     # Step name to use while logging
     STEP_NAME = "remote"
@@ -286,14 +299,15 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
             nodes_log = f'  {status.title()} ({num_nodes}): '
             log_nodes = []
             for node, _ in nodes:
-                node_len = len(node)
+                node_name = self.__node_information[node]['print']
+                node_len = len(node_name)
 
                 if node_len + line_len + 2 < self.__maxlinelength:
-                    log_nodes.append(node)
+                    log_nodes.append(node_name)
                     line_len += node_len + 2
                 else:
                     if len(log_nodes) == num_nodes - 1:
-                        log_nodes.append(node)
+                        log_nodes.append(node_name)
                     else:
                         log_nodes.append('...')
                     break
@@ -363,7 +377,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
             if SCNodeStatus.is_running(stat):
                 self.__logger.info(f'  {stat.title()} ({len(nodes)}):')
                 for node, node_info in nodes:
-                    running_log = f"    {node}"
+                    running_log = f"    {self.__node_information[node]['print']}"
                     if 'elapsed_time' in node_info:
                         running_log += f" ({node_info['elapsed_time']})"
                     self.__logger.info(running_log)
@@ -471,7 +485,8 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
 
         # Run the job on the remote server, and wait for it to finish.
         # Set logger to indicate remote run
-        self.__chip._init_logger(step=self.STEP_NAME, index=None, in_run=True)
+        self.__chip._logger_console.setFormatter(
+            get_console_formatter(self.__chip, True, self.STEP_NAME, None))
 
         # Ask the remote server to start processing the requested step.
         self.__request_run()
@@ -482,7 +497,8 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
         finally:
             # Restore logger
             self.__chip._dash.end_of_run()
-            self.__chip._init_logger(in_run=True)
+            self.__chip._logger_console.setFormatter(
+                get_console_formatter(self.__chip, False, None, None))
 
     def __request_run(self):
         '''
@@ -517,7 +533,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
         # Redirected POST requests are translated to GETs. This is actually
         # part of the HTTP spec, so we need to manually follow the trail.
         post_params = {
-            'chip_cfg': self.__chip.schema.getdict(),
+            'chip_cfg': self.__chip.getdict(),
             'params': self.__get_post_params(include_job_id=True)
         }
 
@@ -559,7 +575,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
             key_type = self.__chip.get(*key, field='type')
 
             if 'dir' in key_type or 'file' in key_type:
-                for _, step, index in self.__chip.schema.get(*key, field=None).getvalues(
+                for _, step, index in self.__chip.get(*key, field=None).getvalues(
                         return_defvalue=False):
                     packages = self.__chip.get(*key, field='package', step=step, index=index)
                     if not isinstance(packages, list):
@@ -597,7 +613,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
                 manifest = os.path.join(self.__chip.getworkdir(), f'{self.__chip.design}.pkg.json')
                 if os.path.exists(manifest):
                     try:
-                        JournalingSchema(self.__chip.schema).read_journal(manifest)
+                        Journal.replay_file(self.__chip.schema, manifest)
                         self.__setup_information_loaded = True
                         changed = True
                     except:  # noqa E722
@@ -619,7 +635,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
                 f'{self.__chip.design}.pkg.json')
             if os.path.exists(manifest):
                 try:
-                    JournalingSchema(self.__chip.schema).read_journal(manifest)
+                    Journal.replay_file(self.__chip.schema, manifest)
                     node_info["imported"] = True
                     changed = True
                 except:  # noqa E722
@@ -638,7 +654,8 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
         return changed
 
     def __ensure_run_loop_information(self):
-        self.__chip._init_logger(step=self.STEP_NAME, index='0', in_run=True)
+        self.__chip._logger_console.setFormatter(
+            get_console_formatter(self.__chip, True, self.STEP_NAME, None))
         if not self.__download_pool:
             self.__download_pool = multiprocessing.Pool()
 
@@ -651,7 +668,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
 
         self.__node_information = {}
         runtime = RuntimeFlowgraph(
-            self.__chip.schema.get("flowgraph", self.__chip.get('option', 'flow'), field='schema'),
+            self.__chip.get("flowgraph", self.__chip.get('option', 'flow'), field='schema'),
             from_steps=self.__chip.get('option', 'from'),
             to_steps=self.__chip.get('option', 'to'),
             prune_nodes=self.__chip.get('option', 'prune'))
@@ -662,7 +679,8 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
                 "step": step,
                 "index": index,
                 "imported": done,
-                "fetched": done
+                "fetched": done,
+                "print": f"{step}/{index}"
             }
             self.__node_information[f'{step}{index}'] = node_info
 
@@ -737,7 +755,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
     def __schedule_fetch_result(self, node):
         if node:
             self.__node_information[node]["fetched"] = True
-            self.__logger.info(f'    {node}')
+            self.__logger.info(f'    {self.__node_information[node]["print"]}')
         else:
             self.__setup_information_fetched = True
         self.__download_pool.apply_async(Client._fetch_result, (self, node))

siliconcompiler/remote/server.py

@@ -96,7 +96,7 @@ class Server:
 
     def __run_start(self, chip):
         flow = chip.get("option", "flow")
-        nodes = chip.schema.get("flowgraph", flow, field="schema").get_nodes()
+        nodes = chip.get("flowgraph", flow, field="schema").get_nodes()
 
         with self.sc_jobs_lock:
             job_hash = self.sc_chip_lookup[chip]["jobhash"]
@@ -442,7 +442,7 @@ class Server:
         job_hash = chip.get('record', 'remoteid')
 
         runtime = RuntimeFlowgraph(
-            chip.schema.get("flowgraph", chip.get('option', 'flow'), field='schema'),
+            chip.get("flowgraph", chip.get('option', 'flow'), field='schema'),
             from_steps=chip.get('option', 'from'),
             to_steps=chip.get('option', 'to'),
             prune_nodes=chip.get('option', 'prune'))

siliconcompiler/report/dashboard/cli/__init__.py

@@ -23,11 +23,11 @@ class CliDashboard(AbstractDashboard):
         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.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()
+            self._dashboard._log_handler.setFormatter(self.__logger_console.formatter)
 
     def open_dashboard(self):
         """Starts the dashboard rendering thread if it is not already running."""
@@ -71,9 +71,9 @@ class CliDashboard(AbstractDashboard):
         # Restore logger
         if self.__logger_console:
             self._logger.removeHandler(self._dashboard._log_handler)
-            self._chip.logger._console = self.__logger_console
+            self._chip._logger_console = self.__logger_console
             self._logger.addHandler(self.__logger_console)
-            self._chip._init_logger_formats()
+            self.__logger_console.setFormatter(self._dashboard._log_handler.formatter)
             self.__logger_console = None
 
     def wait(self):

siliconcompiler/report/dashboard/cli/board.py

@@ -414,7 +414,7 @@ class Board(metaclass=BoardSingleton):
         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}[/]")
+            table.add_row(f"[white]{line}[/]")
         while table.row_count < layout.log_height:
             table.add_row("")
 
@@ -750,10 +750,10 @@ class Board(metaclass=BoardSingleton):
                 raise SiliconCompilerError("dummy error")
 
             runtime_flow = RuntimeFlowgraph(
-                chip.schema.get("flowgraph", flow, field='schema'),
+                chip.get("flowgraph", flow, field='schema'),
                 to_steps=chip.get('option', 'to'),
                 prune_nodes=chip.get('option', 'prune'))
-            record = chip.schema.get("record", field='schema')
+            record = chip.get("record", field='schema')
 
             execnodes = runtime_flow.get_nodes()
             lowest_priority = 3 * len(execnodes)  # 2x + 1 is lowest computed, so 3x will be lower
@@ -776,7 +776,7 @@ class Board(metaclass=BoardSingleton):
                         node_outputs.setdefault(in_node, set()).add(node)
 
             flow_entry_nodes = set(
-                chip.schema.get("flowgraph", flow, field="schema").get_entry_nodes())
+                chip.get("flowgraph", flow, field="schema").get_entry_nodes())
 
             running_nodes = set([node for node in nodes if NodeStatus.is_running(nodestatus[node])])
             done_nodes = set([node for node in nodes if NodeStatus.is_done(nodestatus[node])])

siliconcompiler/report/dashboard/web/components/__init__.py

@@ -301,7 +301,7 @@ def manifest_viewer(
             if streamlit.checkbox(
                     'Raw manifest',
                     help='Click here to see the manifest before it was made more readable'):
-                manifest_to_show = chip.schema.getdict()
+                manifest_to_show = chip.getdict()
             else:
                 manifest_to_show = report.make_manifest(chip)
 
@@ -326,7 +326,7 @@ def manifest_viewer(
         streamlit.download_button(
             label='Download',
             file_name='manifest.json',
-            data=json.dumps(chip.schema.getdict(), indent=2),
+            data=json.dumps(chip.getdict(), indent=2),
             mime="application/json",
             use_container_width=True)
 
@@ -494,7 +494,7 @@ def node_viewer(chip, step, index, metric_dataframe, height=None):
 
     metrics_col, records_col, logs_and_reports_col = streamlit.columns(3, gap='small')
 
-    node_name = f'{step}{index}'
+    node_name = f'{step}/{index}'
 
     with metrics_col:
         streamlit.subheader(f'{node_name} metrics')
@@ -504,7 +504,7 @@ def node_viewer(chip, step, index, metric_dataframe, height=None):
                 use_container_width=True,
                 height=height)
     with records_col:
-        streamlit.subheader(f'{step}{index} details')
+        streamlit.subheader(f'{step}/{index} details')
         nodes = {}
         nodes[step + index] = report.get_flowgraph_nodes(chip, step, index)
         streamlit.dataframe(
@@ -512,7 +512,7 @@ def node_viewer(chip, step, index, metric_dataframe, height=None):
             use_container_width=True,
             height=height)
     with logs_and_reports_col:
-        streamlit.subheader(f'{step}{index} files')
+        streamlit.subheader(f'{step}/{index} files')
         node_file_tree_viewer(chip, step, index)
 
 

siliconcompiler/report/dashboard/web/components/flowgraph.py

@@ -45,8 +45,8 @@ def get_nodes_and_edges(chip):
     successful_path = report.get_flowgraph_path(chip)
 
     flow = chip.get('option', 'flow')
-    entry_exit_nodes = chip.schema.get("flowgraph", flow, field="schema").get_entry_nodes() + \
-        chip.schema.get("flowgraph", flow, field="schema").get_exit_nodes()
+    entry_exit_nodes = chip.get("flowgraph", flow, field="schema").get_entry_nodes() + \
+        chip.get("flowgraph", flow, field="schema").get_exit_nodes()
 
     for step, index in node_dependencies:
         # Build node
@@ -60,7 +60,7 @@ def get_nodes_and_edges(chip):
         node_color = NODE_COLORS[node_status]
 
         tool, task = get_tool_task(chip, step, index)
-        node_name = f'{step}{index}'
+        node_name = f'{step}/{index}'
         label = node_name + "\n" + tool + "/" + task
         if tool == 'builtin':
             label = node_name + "\n" + tool
@@ -95,7 +95,7 @@ def get_nodes_and_edges(chip):
                 dashes = True
 
             edges.append(Edge(
-                source=f'{source_step}{source_index}',
+                source=f'{source_step}/{source_index}',
                 target=node_name,
                 dir='up',
                 width=edge_width,

siliconcompiler/report/dashboard/web/components/graph.py

@@ -67,7 +67,7 @@ def settings(metrics, nodes, graph_number):
 
     Args:
         metrics (list) : A list of metrics that are set for all chips given in chips.
-        nodes (list) : A list of nodes given in the form f'{step}{index}'
+        nodes (list) : A list of nodes given in the form f'{step}/{index}'
         graph_number (int) : The number of graphs there are. Used to create
             keys to distinguish selectboxes from each other.
     """
@@ -147,7 +147,7 @@ def graph(metrics, nodes, node_to_step_index_map, graph_number):
 
     labels = {
         "runs": state.get_key(state.GRAPH_JOBS),
-        "nodes": [f'{step}{index}' for step, index in data]
+        "nodes": [f'{step}/{index}' for step, index in data]
     }
 
     if nodes:

siliconcompiler/report/dashboard/web/state.py

@@ -125,7 +125,7 @@ def init():
         chip_index = chip.get('arg', 'index')
 
         if chip_step and chip_index:
-            set_key(SELECTED_NODE, f'{chip_step}{chip_index}')
+            set_key(SELECTED_NODE, f'{chip_step}/{chip_index}')
 
     chip = get_chip("default")
     chip.unset('arg', 'step')

siliconcompiler/report/dashboard/web/utils/__init__.py

@@ -24,9 +24,9 @@ def make_node_to_step_index_map(chip, metric_dataframe):
     '''
     node_to_step_index_map = {}
     if chip.get('option', 'flow'):
-        for step, index in chip.schema.get("flowgraph", chip.get('option', 'flow'),
-                                           field="schema").get_nodes():
-            node_to_step_index_map[f'{step}{index}'] = (step, index)
+        for step, index in chip.get("flowgraph", chip.get('option', 'flow'),
+                                    field="schema").get_nodes():
+            node_to_step_index_map[f'{step}/{index}'] = (step, index)
 
     # concatenate step and index
     metric_dataframe.columns = metric_dataframe.columns.map(lambda x: f'{x[0]}{x[1]}')
@@ -57,8 +57,8 @@ def make_metric_to_metric_unit_map(metric_dataframe):
 def is_running(chip):
     if not chip.get('option', 'flow'):
         return False
-    for step, index in chip.schema.get("flowgraph", chip.get('option', 'flow'),
-                                       field="schema").get_nodes():
+    for step, index in chip.get("flowgraph", chip.get('option', 'flow'),
+                                field="schema").get_nodes():
         state = chip.get('record', 'status', step=step, index=index)
         if not NodeStatus.is_done(state):
             return True

siliconcompiler/report/html_report.py

@@ -50,7 +50,7 @@ def _generate_html_report(chip, flow, flowgraph_nodes, results_html):
             metrics=metrics,
             metrics_unit=metrics_unit,
             reports=reports,
-            manifest=chip.schema.getdict(),
+            manifest=chip.getdict(),
             pruned_cfg=pruned_cfg,
             metric_keys=metrics_to_show,
             img_data=img_data,