siliconcompiler 0.35.0__py3-none-any.whl → 0.35.1__py3-none-any.whl

siliconcompiler/schema/safeschema.py

@@ -4,7 +4,7 @@
 # SC dependencies outside of its directory, since it may be used by tool drivers
 # that have isolated Python environments.
 
-from typing import Dict, Tuple
+from typing import Dict, Tuple, Optional, Union, List, Set
 
 from .parameter import Parameter
 from .baseschema import BaseSchema
@@ -17,7 +17,9 @@ class SafeSchema(BaseSchema):
     '''
 
     @staticmethod
-    def __is_dict_leaf(manifest: Dict, keypath: Tuple[str], version: str) -> Parameter:
+    def __is_dict_leaf(manifest: Dict,
+                       keypath: List[str],
+                       version: Optional[Tuple[int, ...]]) -> Optional[Parameter]:
         try:
             return Parameter.from_dict(manifest, keypath, version)
         except:  # noqa E722
@@ -31,26 +33,33 @@ class SafeSchema(BaseSchema):
 
         return "SafeSchema"
 
-    def _from_dict(self, manifest: Dict, keypath: Tuple[str], version: str = None) -> None:
+    def _from_dict(self, manifest: Dict,
+                   keypath: Union[List[str], Tuple[str, ...]],
+                   version: Optional[Tuple[int, ...]] = None) \
+            -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
         if not isinstance(manifest, dict):
-            return
+            return set(), set()
 
         if "__meta__" in manifest:
             del manifest["__meta__"]
 
         for key, data in manifest.items():
-            obj = SafeSchema.__is_dict_leaf(data, keypath + [key], version)
+            obj = SafeSchema.__is_dict_leaf(data, list(keypath) + [key], version)
             if not obj:
                 obj = SafeSchema()
-                obj._from_dict(data, keypath + [key], version)
+                obj._from_dict(data, list(keypath) + [key], version)
 
             if key == "default":
                 self._BaseSchema__default = obj
             else:
                 self._BaseSchema__manifest[key] = obj
 
+        return set(), set()
+
     @classmethod
-    def from_manifest(cls, filepath: str = None, cfg: Dict = None) -> "SafeSchema":
+    def from_manifest(cls,
+                      filepath: Union[None, str] = None,
+                      cfg: Union[None, Dict] = None) -> "SafeSchema":
         if filepath:
             cfg = BaseSchema._read_manifest(filepath)
 

siliconcompiler/schema/utils.py

@@ -6,8 +6,10 @@
 
 import sys
 
+from typing import Optional
 
-def trim(docstring: str) -> str:
+
+def trim(docstring: Optional[str]) -> str:
     '''
     Helper function for cleaning up indentation of docstring.
 

siliconcompiler/schema_support/cmdlineschema.py

@@ -4,7 +4,7 @@ import sys
 
 import os.path
 
-from typing import Set, List
+from typing import Set, List, Optional, Union
 
 from siliconcompiler.schema import BaseSchema, EditableSchema, Parameter, Scope, PerNode
 from siliconcompiler.schema.utils import trim
@@ -25,9 +25,9 @@ class CommandLineSchema(BaseSchema):
                                   name: str,
                                   type: str,
                                   help: str,
-                                  switch: List[str] = None,
+                                  switch: Optional[Union[str, List[str]]] = None,
                                   defvalue=None,
-                                  **kwargs):
+                                  **kwargs) -> None:
         '''
         Adds a parameter to the commandline definition.
 
@@ -69,13 +69,13 @@ class CommandLineSchema(BaseSchema):
 
     @classmethod
     def create_cmdline(cls,
-                       progname: str = None,
-                       description: str = None,
-                       switchlist: Set[str] = None,
-                       version: str = None,
+                       progname: Optional[str] = None,
+                       description: Optional[str] = None,
+                       switchlist: Optional[Union[List[str], Set[str]]] = None,
+                       version: Optional[str] = None,
                        print_banner: bool = True,
                        use_cfg: bool = False,
-                       use_sources: bool = True):
+                       use_sources: bool = True) -> BaseSchema:
         """
         Creates an SC command line interface.
 
@@ -175,7 +175,7 @@ class CommandLineSchema(BaseSchema):
             if keypath == ("option", "cfg"):  # TODO: remove this when cfg is removed from schema
                 continue
 
-            param = keyschema.get(*keypath, field=None)
+            param: Parameter = keyschema.get(*keypath, field=None)
 
             dest, switches = param.add_commandline_arguments(
                 parser,

siliconcompiler/schema_support/dependencyschema.py

@@ -1,5 +1,7 @@
 import os.path
 
+from typing import Dict, Union, Tuple, List, Optional, Set
+
 from siliconcompiler.schema.baseschema import BaseSchema
 from siliconcompiler.schema.editableschema import EditableSchema
 from siliconcompiler.schema.parameter import Parameter, Scope
@@ -27,7 +29,10 @@ class DependencySchema(BaseSchema):
                 shorthelp="List of object dependencies",
                 help="List of named object dependencies included via add_dep()."))
 
-    def _from_dict(self, manifest, keypath, version=None):
+    def _from_dict(self, manifest: Dict,
+                   keypath: Union[List[str], Tuple[str, ...]],
+                   version: Optional[Tuple[int, ...]] = None) \
+            -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
         '''
         Internal helper to load schema from a dictionary manifest.
 
@@ -152,7 +157,7 @@ class DependencySchema(BaseSchema):
         except graphviz.ExecutableNotFound as e:
             raise RuntimeError(f'Unable to save flowgraph: {e}')
 
-    def __get_all_deps(self, seen: set) -> list:
+    def __get_all_deps(self, seen: Set[str]) -> List[NamedSchema]:
         '''
         Recursively traverses the dependency tree to generate a flat list.
 
@@ -184,7 +189,7 @@ class DependencySchema(BaseSchema):
 
         return deps
 
-    def get_dep(self, name: str = None, hierarchy: bool = True) -> list:
+    def get_dep(self, name: Optional[str] = None, hierarchy: bool = True) -> List[NamedSchema]:
         '''
         Returns all dependencies associated with this object or a specific one if requested.
 
@@ -216,7 +221,7 @@ class DependencySchema(BaseSchema):
             return self.__get_all_deps(set())
         return list(self.__deps.values())
 
-    def has_dep(self, name: str) -> bool:
+    def has_dep(self, name: Union[NamedSchema, str]) -> bool:
         '''
         Checks if a specific dependency is present.
 
@@ -232,7 +237,7 @@ class DependencySchema(BaseSchema):
 
         return name in self.__deps
 
-    def remove_dep(self, name: str) -> bool:
+    def remove_dep(self, name: Union[str, NamedSchema]) -> bool:
         '''
         Removes a previously registered module.
 
@@ -260,7 +265,7 @@ class DependencySchema(BaseSchema):
 
         return True
 
-    def _populate_deps(self, module_map: dict):
+    def _populate_deps(self, module_map: Dict[str, NamedSchema]) -> None:
         '''
         Internal method to populate the internal dependency dictionary.
 
@@ -281,6 +286,6 @@ class DependencySchema(BaseSchema):
             if isinstance(self.__deps[module], DependencySchema):
                 self.__deps[module]._populate_deps(module_map)
 
-    def _reset_deps(self):
+    def _reset_deps(self) -> None:
         '''Resets the internal dependency dictionary.'''
         self.__deps = {}

siliconcompiler/schema_support/filesetschema.py

@@ -1,6 +1,6 @@
 import contextlib
 
-from typing import List, Tuple
+from typing import List, Tuple, Optional, Union, Iterable
 
 from siliconcompiler import utils
 
@@ -44,10 +44,10 @@ class FileSetSchema(PathSchema):
     ###############################################
     def add_file(self,
                  filename: str,
-                 fileset: str = None,
-                 filetype: str = None,
+                 fileset: Optional[str] = None,
+                 filetype: Optional[str] = None,
                  clobber: bool = False,
-                 dataroot: str = None) -> List[str]:
+                 dataroot: Optional[str] = None) -> List[str]:
         """
         Adds files to a fileset.
 
@@ -121,8 +121,8 @@ class FileSetSchema(PathSchema):
 
     ###############################################
     def get_file(self,
-                 fileset: str = None,
-                 filetype: str = None):
+                 fileset: Optional[str] = None,
+                 filetype: Optional[str] = None) -> List[str]:
         """Returns a list of files from one or more filesets.
 
         Args:
@@ -159,7 +159,7 @@ class FileSetSchema(PathSchema):
         return filelist
 
     ###############################################
-    def has_file(self, fileset: str = None, filetype: str = None) -> bool:
+    def has_file(self, fileset: Optional[str] = None, filetype: Optional[str] = None) -> bool:
         """Returns true if the fileset contains files.
 
         Args:
@@ -225,7 +225,7 @@ class FileSetSchema(PathSchema):
         with self._active(fileset=fileset):
             yield
 
-    def copy_fileset(self, src_fileset: str, dst_fileset: str, clobber: bool = False):
+    def copy_fileset(self, src_fileset: str, dst_fileset: str, clobber: bool = False) -> None:
         """
         Creates a new copy of a source fileset.
 
@@ -248,7 +248,7 @@ class FileSetSchema(PathSchema):
         new_fs = self.get("fileset", src_fileset, field="schema").copy()
         EditableSchema(self).insert("fileset", dst_fileset, new_fs, clobber=True)
 
-    def _assert_fileset(self, fileset: str) -> None:
+    def _assert_fileset(self, fileset: Union[None, Iterable[str], str]) -> None:
         """
         Raises an error if the specified fileset does not exist.
 
@@ -257,6 +257,11 @@ class FileSetSchema(PathSchema):
             LookupError: If the fileset is not found.
         """
 
+        if isinstance(fileset, (list, set, tuple)):
+            for fs in fileset:
+                self._assert_fileset(fs)
+            return
+
         if not isinstance(fileset, str):
             raise TypeError("fileset must be a string")
 
@@ -282,7 +287,7 @@ class FileSetSchema(PathSchema):
 
     def _generate_doc(self, doc,
                       ref_root: str = "",
-                      key_offset: Tuple[str] = None,
+                      key_offset: Optional[Tuple[str, ...]] = None,
                       detailed: bool = True):
         from ..schema.docs.utils import build_section
 

siliconcompiler/schema_support/metric.py

@@ -1,14 +1,19 @@
 import shutil
 import sys
 
-from typing import List, Tuple, TextIO
+from typing import List, Tuple, TextIO, Union, Optional, TYPE_CHECKING
 
 from siliconcompiler.schema import BaseSchema
 from siliconcompiler.schema import EditableSchema, Parameter, PerNode, Scope
 from siliconcompiler.schema.utils import trim
 
 from siliconcompiler.utils import truncate_text, units
-from siliconcompiler.schema_support.record import RecordTime
+from siliconcompiler.schema_support.record import RecordTime, RecordSchema
+
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+    from siliconcompiler import Flowgraph
 
 
 class MetricSchema(BaseSchema):
@@ -111,7 +116,7 @@ class MetricSchema(BaseSchema):
                 Metric tracking the total amount of time spent from the beginning
                 of the run up to and including the current step and index.""")))
 
-    def clear(self, step, index):
+    def clear(self, step: str, index: Union[int, str]) -> None:
         '''
         Clears all saved metrics for a given step and index.
 
@@ -122,7 +127,11 @@ class MetricSchema(BaseSchema):
         for metric in self.getkeys():
             self.unset(metric, step=step, index=str(index))
 
-    def record(self, step, index, metric, value, unit=None):
+    def record(self,
+               step: str, index: Union[str, int],
+               metric: str,
+               value: Union[float, int],
+               unit: Optional[str] = None):
         """
         Records a metric value for a specific step and index.
 
@@ -141,7 +150,7 @@ class MetricSchema(BaseSchema):
         Returns:
             The recorded value after any unit conversion.
         """
-        metric_unit = self.get(metric, field='unit')
+        metric_unit: Optional[str] = self.get(metric, field='unit')
 
         if not metric_unit and unit:
             raise ValueError(f"{metric} does not have a unit, but {unit} was supplied")
@@ -151,7 +160,7 @@ class MetricSchema(BaseSchema):
 
         return self.set(metric, value, step=step, index=str(index))
 
-    def record_tasktime(self, step, index, record):
+    def record_tasktime(self, step: str, index: Union[str, int], record: RecordSchema):
         """
         Records the task time for a given node based on start and end times.
 
@@ -173,7 +182,10 @@ class MetricSchema(BaseSchema):
 
         return self.record(step, index, "tasktime", end_time-start_time, unit="s")
 
-    def record_totaltime(self, step, index, flow, record):
+    def record_totaltime(self,
+                         step: str, index: Union[str, int],
+                         flow: "Flowgraph",
+                         record: RecordSchema):
         """
         Records the cumulative total time up to the end of a given node.
 
@@ -237,7 +249,7 @@ class MetricSchema(BaseSchema):
 
         return self.record(step, index, "totaltime", total_time, unit="s")
 
-    def get_formatted_metric(self, metric: str, step: str, index: str) -> str:
+    def get_formatted_metric(self, metric: str, step: str, index: Union[int, str]) -> str:
         '''
         Retrieves and formats a metric for display.
 
@@ -264,10 +276,10 @@ class MetricSchema(BaseSchema):
                                    self.get(metric, field="unit"))
 
     def summary_table(self,
-                      nodes: List[Tuple[str, str]] = None,
+                      nodes: Optional[List[Tuple[str, str]]] = None,
                       column_width: int = 15,
                       formatted: bool = True,
-                      trim_empty_metrics: bool = True):
+                      trim_empty_metrics: bool = True) -> "DataFrame":
         '''
         Generates a summary of metrics as a pandas DataFrame.
 
@@ -289,11 +301,11 @@ class MetricSchema(BaseSchema):
         from pandas import DataFrame
 
         if not nodes:
-            nodes = set()
+            unique_nodes = set()
             for metric in self.getkeys():
-                for value, step, index in self.get(metric, field=None).getvalues():
-                    nodes.add((step, index))
-            nodes = list(sorted(nodes))
+                for _, step, index in self.get(metric, field=None).getvalues():
+                    unique_nodes.add((step, index))
+            nodes = list(sorted(unique_nodes))
 
         row_labels = list(self.getkeys())
         sort_map = {metric: 0 for metric in row_labels}
@@ -352,10 +364,10 @@ class MetricSchema(BaseSchema):
         return DataFrame(data, row_labels, column_labels)
 
     def summary(self,
-                headers: List[Tuple[str, str]],
-                nodes: List[Tuple[str, str]] = None,
+                headers: List[Tuple[str, Optional[str]]],
+                nodes: Optional[List[Tuple[str, str]]] = None,
                 column_width: int = 15,
-                fd: TextIO = None) -> None:
+                fd: Optional[TextIO] = None) -> None:
         '''
         Prints a formatted summary of metrics to a file descriptor.
 

siliconcompiler/schema_support/packageschema.py

@@ -1,4 +1,4 @@
-from typing import Union, Dict, List, Tuple
+from typing import Union, Dict, List, Tuple, Optional
 
 from siliconcompiler.schema_support.pathschema import PathSchema
 from siliconcompiler.schema import EditableSchema, Parameter, Scope, BaseSchema
@@ -196,7 +196,7 @@ class PackageSchema(PathSchema):
 
     def _generate_doc(self, doc,
                       ref_root: str = "",
-                      key_offset: Tuple[str] = None,
+                      key_offset: Optional[Tuple[str, ...]] = None,
                       detailed: bool = True):
         from ..schema.docs.utils import build_section
         section = build_section("Package", f"{ref_root}-package")

siliconcompiler/schema_support/pathschema.py

@@ -3,7 +3,7 @@ import logging
 
 import os.path
 
-from typing import Tuple
+from typing import Tuple, Union, List, Optional, Dict, Callable
 
 from siliconcompiler.schema.baseschema import BaseSchema
 from siliconcompiler.schema.editableschema import EditableSchema
@@ -19,9 +19,10 @@ class PathSchemaBase(BaseSchema):
     Schema extension to add simpler find_files and check_filepaths
     '''
 
-    def find_files(self, *keypath,
-                   missing_ok=False,
-                   step=None, index=None):
+    def find_files(self, *keypath: str,
+                   missing_ok: bool = False,
+                   step: Optional[str] = None, index: Optional[Union[int, str]] = None) \
+            -> Union[List[Optional[str]], Optional[str]]:
         """
         Returns absolute paths to files or directories based on the keypath
         provided.
@@ -59,7 +60,7 @@ class PathSchemaBase(BaseSchema):
                                    collection_dir=collection_dir,
                                    cwd=cwd)
 
-    def check_filepaths(self, ignore_keys=None):
+    def check_filepaths(self, ignore_keys: Optional[List[Tuple[str, ...]]] = None) -> bool:
         '''
         Verifies that paths to all files in manifest are valid.
 
@@ -82,8 +83,13 @@ class PathSchemaBase(BaseSchema):
             collection_dir=collection_dir,
             cwd=cwd)
 
-    def hash_files(self, *keypath, update=True, check=True, verbose=True,
-                   missing_ok=False, step=None, index=None):
+    def hash_files(self, *keypath: str,
+                   update: bool = True,
+                   check: bool = True,
+                   verbose: bool = True,
+                   missing_ok: bool = False,
+                   step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> Union[Optional[str], List[Optional[str]]]:
         '''Generates hash values for a list of parameter files.
 
         Generates a hash value for each file found in the keypath. If existing
@@ -157,7 +163,8 @@ class PathSchemaBase(BaseSchema):
 
 
 class PathSchemaSimpleBase(PathSchemaBase):
-    def find_files(self, *keypath, missing_ok=False):
+    def find_files(self, *keypath: str, missing_ok: bool = False) \
+            -> Union[List[Optional[str]], Optional[str]]:
         """
         Returns absolute paths to files or directories based on the keypath
         provided.
@@ -181,7 +188,12 @@ class PathSchemaSimpleBase(PathSchemaBase):
                                   missing_ok=missing_ok,
                                   step=None, index=None)
 
-    def hash_files(self, *keypath, update=True, check=True, verbose=True, missing_ok=False):
+    def hash_files(self, *keypath: str,
+                   update: bool = True,
+                   check: bool = True,
+                   verbose: bool = True,
+                   missing_ok: bool = False) \
+            -> Union[List[Optional[str]], Optional[str]]:
         '''Generates hash values for a list of parameter files.
 
         Generates a hash value for each file found in the keypath. If existing
@@ -299,9 +311,9 @@ class PathSchema(PathSchemaBase):
         return schema
 
     def set_dataroot(self, name: str = "root",
-                     path: str = None,
-                     tag: str = None,
-                     clobber: bool = False):
+                     path: Optional[str] = None,
+                     tag: Optional[str] = None,
+                     clobber: bool = False) -> None:
         """Registers a data source by name, path, and optional version tag.
 
         This method creates a reference to a data directory, which can be a local
@@ -374,13 +386,13 @@ class PathSchema(PathSchemaBase):
         if not BaseSchema.valid(schema, "dataroot", name):
             raise ValueError(f"{name} is not a recognized source")
 
-        path = BaseSchema.get(schema, "dataroot", name, "path")
-        tag = BaseSchema.get(schema, "dataroot", name, "tag")
+        path: str = BaseSchema.get(schema, "dataroot", name, "path")
+        tag: Optional[str] = BaseSchema.get(schema, "dataroot", name, "tag")
 
         resolver = Resolver.find_resolver(path)
         return resolver(name, schema._parent(root=True), path, tag).get_path()
 
-    def _find_files_dataroot_resolvers(self):
+    def _find_files_dataroot_resolvers(self) -> Dict[str, Union[str, Callable]]:
         """
         Returns a dictionary of path resolvers data directory handling for find_files
 
@@ -402,7 +414,7 @@ class PathSchema(PathSchemaBase):
         return resolver_map
 
     @contextlib.contextmanager
-    def active_dataroot(self, dataroot: str = None):
+    def active_dataroot(self, dataroot: Optional[str] = None):
         '''
         Use this context to set the dataroot parameter on files and directory parameters.
 
@@ -426,7 +438,7 @@ class PathSchema(PathSchemaBase):
         with self._active(dataroot=dataroot):
             yield
 
-    def _get_active_dataroot(self, user_dataroot: str) -> str:
+    def _get_active_dataroot(self, user_dataroot: Optional[str]) -> Optional[str]:
         """Resolves and returns the active dataroot to use.
 
         This method determines the appropriate dataroot based on a specific
@@ -475,7 +487,7 @@ class PathSchema(PathSchemaBase):
 
     def _generate_doc(self, doc,
                       ref_root: str = "",
-                      key_offset: Tuple[str] = None,
+                      key_offset: Optional[Tuple[str, ...]] = None,
                       detailed: bool = True):
         from ..schema.docs.utils import build_section, strong, build_table, build_list, \
             code, para