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

siliconcompiler/schema/editableschema.py

@@ -24,9 +24,9 @@ class EditableSchema:
         self.__schema = schema
 
     def __insert(self,
-                 keypath: Tuple[str],
+                 keypath: Tuple[str, ...],
                  value: Union[BaseSchema, Parameter],
-                 fullkey: Tuple[str],
+                 fullkey: Tuple[str, ...],
                  clobber: bool) -> None:
         key = keypath[0]
         keypath = keypath[1:]
@@ -57,7 +57,7 @@ class EditableSchema:
         new_schema._BaseSchema__key = key
         EditableSchema(new_schema).__insert(keypath, value, fullkey, clobber)
 
-    def __remove(self, keypath: Tuple[str], fullkey: Tuple[str]) -> None:
+    def __remove(self, keypath: Tuple[str, ...], fullkey: Tuple[str, ...]) -> None:
         key = keypath[0]
         keypath = keypath[1:]
 
@@ -77,7 +77,7 @@ class EditableSchema:
         else:
             EditableSchema(next_param).__remove(keypath, fullkey)
 
-    def insert(self, *args, clobber: bool = False) -> None:
+    def insert(self, *args: Union[str, BaseSchema, Parameter], clobber: bool = False) -> None:
         '''
         Inserts a :class:`Parameter` or a :class:`BaseSchema` to the schema,
         based on the keypath and value provided in the ``*args``.
@@ -93,7 +93,7 @@ class EditableSchema:
         '''
 
         value = args[-1]
-        keypath = args[0:-1]
+        keypath: Tuple[str, ...] = args[0:-1]
 
         if not keypath:
             raise ValueError("A keypath is required")

siliconcompiler/schema/journal.py

@@ -1,7 +1,10 @@
 import copy
 import json
 
-from typing import Tuple, Set, Dict, List
+from typing import Tuple, Set, Dict, List, Optional, Union, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .baseschema import BaseSchema
 
 
 class Journal:
@@ -14,7 +17,7 @@ class Journal:
         keyprefix (list of str): keypath to prefix on to recorded path
     """
 
-    def __init__(self, keyprefix: Tuple[str] = None):
+    def __init__(self, keyprefix: Optional[Union[List[str], Tuple[str, ...]]] = None):
         if not keyprefix:
             self.__keyprefix = tuple()
         else:
@@ -26,14 +29,14 @@ class Journal:
         self.stop()
 
     @property
-    def keypath(self) -> Tuple[str]:
+    def keypath(self) -> Tuple[str, ...]:
         '''
         Returns the reference key path for this journal
         '''
 
         return self.__keyprefix
 
-    def get_child(self, *keypath: Tuple[str]):
+    def get_child(self, *keypath: str) -> "Journal":
         '''
         Get a child journal based on a new keypath
 
@@ -45,7 +48,7 @@ class Journal:
         child.__parent = self.__parent
         return child
 
-    def from_dict(self, manifest: Dict):
+    def from_dict(self, manifest: List[Dict]) -> None:
         '''
         Import a journal from a manifest dictionary
 
@@ -55,7 +58,7 @@ class Journal:
 
         self.__journal = manifest
 
-    def get(self) -> List[Dict]:
+    def get(self) -> Optional[List[Dict]]:
         """
         Returns a copy of the current journal
         """
@@ -109,11 +112,11 @@ class Journal:
 
     def record(self,
                record_type: str,
-               key: Tuple[str],
+               key: Union[List[str], Tuple[str, ...]],
                value=None,
-               field: str = None,
-               step: str = None,
-               index: str = None) -> None:
+               field: Optional[str] = None,
+               step: Optional[str] = None,
+               index: Optional[Union[int, str]] = None) -> None:
         '''
         Record the schema transaction
         '''
@@ -127,6 +130,9 @@ class Journal:
         if isinstance(value, set):
             value = list(value)
 
+        if index is not None and isinstance(index, int):
+            index = str(index)
+
         self.__parent.__journal.append({
             "type": record_type,
             "key": tuple([*self.__keyprefix, *key]),
@@ -154,7 +160,7 @@ class Journal:
         self.__parent.__record_types.clear()
 
     @staticmethod
-    def replay_file(schema, filepath: str) -> None:
+    def replay_file(schema: "BaseSchema", filepath: str) -> None:
         '''
         Replay a journal into a schema from a manifest
 
@@ -171,7 +177,7 @@ class Journal:
         journal.from_dict(data["__journal__"])
         journal.replay(schema)
 
-    def replay(self, schema) -> None:
+    def replay(self, schema: "BaseSchema") -> None:
         '''
         Replay journal into a schema
 
@@ -207,7 +213,7 @@ class Journal:
                 raise ValueError(f'Unknown record type {record_type}')
 
     @staticmethod
-    def access(schema) -> "Journal":
+    def access(schema: "BaseSchema") -> "Journal":
         '''
         Access a journal from a schema
 

siliconcompiler/schema/namedschema.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, Set, Union, List
 
 from .baseschema import BaseSchema
 
@@ -17,13 +17,13 @@ class NamedSchema(BaseSchema):
         name (str): name of the schema
     '''
 
-    def __init__(self, name: str = None):
+    def __init__(self, name: Optional[str] = None):
         super().__init__()
 
         self.set_name(name)
 
     @property
-    def name(self) -> str:
+    def name(self) -> Optional[str]:
         '''
         Returns the name of the schema
         '''
@@ -32,7 +32,7 @@ class NamedSchema(BaseSchema):
         except AttributeError:
             return None
 
-    def set_name(self, name: str) -> None:
+    def set_name(self, name: Optional[str]) -> None:
         """
         Set the name of this object
 
@@ -66,13 +66,16 @@ class NamedSchema(BaseSchema):
 
         raise NotImplementedError("Must be implemented by the child classes.")
 
-    def _getdict_meta(self) -> Dict[str, str]:
+    def _getdict_meta(self) -> Dict[str, Optional[Union[str, int, float]]]:
         info = super()._getdict_meta()
         info["name"] = self.name
         return info
 
     @classmethod
-    def from_manifest(cls, filepath: str = None, cfg: Dict = None, name: str = None):
+    def from_manifest(cls,
+                      filepath: Union[None, str] = None,
+                      cfg: Union[None, Dict] = None,
+                      name: Optional[str] = None):
         '''
         Create a new schema based on the provided source files.
 
@@ -92,10 +95,13 @@ class NamedSchema(BaseSchema):
         if filepath:
             schema.read_manifest(filepath)
         if cfg:
-            schema._from_dict(cfg, [])
+            schema._from_dict(cfg, tuple())
         return schema
 
-    def _from_dict(self, manifest: Dict, keypath: Tuple[str], version: str = 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 keypath:
             self.__name = keypath[-1]
         elif not self.__name and "__meta__" in manifest and "name" in manifest["__meta__"]:
@@ -103,8 +109,8 @@ class NamedSchema(BaseSchema):
 
         return super()._from_dict(manifest, keypath, version=version)
 
-    def copy(self, key: Tuple[str] = None) -> "NamedSchema":
-        copy = super().copy(key=key)
+    def copy(self, key: Optional[Tuple[str, ...]] = None) -> "NamedSchema":
+        copy: NamedSchema = super().copy(key=key)
 
         if key and key[-1] != "default":
             copy.__name = key[-1]

siliconcompiler/schema/parameter.py

@@ -10,7 +10,7 @@ import re
 import shlex
 
 from enum import Enum
-from typing import Tuple
+from typing import Tuple, Optional, Union, List, Dict, Any, Set
 
 from .parametervalue import NodeValue, DirectoryNodeValue, FileNodeValue, NodeListValue, \
     NodeSetValue
@@ -67,20 +67,20 @@ class Parameter:
     GLOBAL_KEY = 'global'
 
     def __init__(self,
-                 type,
-                 require=False,
+                 type: str,
+                 require: bool = False,
                  defvalue=None,
-                 scope=Scope.GLOBAL,
-                 copy=False,
-                 lock=False,
-                 hashalgo='sha256',
-                 notes=None,
-                 unit=None,
-                 shorthelp=None,
-                 switch=None,
-                 example=None,
-                 help=None,
-                 pernode=PerNode.NEVER,
+                 scope: Scope = Scope.GLOBAL,
+                 copy: bool = False,
+                 lock: bool = False,
+                 hashalgo: str = 'sha256',
+                 notes: Optional[str] = None,
+                 unit: Optional[str] = None,
+                 shorthelp: Optional[str] = None,
+                 switch: Optional[Union[List[str], str]] = None,
+                 example: Optional[Union[List[str], str]] = None,
+                 help: Optional[str] = None,
+                 pernode: PerNode = PerNode.NEVER,
                  **kwargs):
 
         self.__type = NodeType.parse(type)
@@ -127,7 +127,7 @@ class Parameter:
             self.__hashalgo = str(hashalgo)
             self.__copy = bool(copy)
 
-    def __setdefvalue(self, defvalue, **kwargs):
+    def __setdefvalue(self, defvalue, **kwargs) -> None:
         if NodeType.contains(self.__type, 'file'):
             if isinstance(self.__type, list):
                 self.__defvalue = NodeListValue(FileNodeValue(defvalue, **kwargs))
@@ -155,12 +155,12 @@ class Parameter:
             else:
                 self.__defvalue = NodeValue(self.__type, value=defvalue, **kwargs)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.getvalues())
 
     def _generate_doc(self, doc,
                       ref_root: str = "",
-                      key_offset: Tuple[str] = None,
+                      key_offset: Optional[Tuple[str, ...]] = None,
                       detailed: bool = True):
         from .docs.utils import strong, para, code, build_list, build_table
         from docutils.statemachine import ViewList
@@ -228,7 +228,9 @@ class Parameter:
 
         return [body, table]
 
-    def get(self, field='value', step=None, index=None):
+    def get(self, field: Optional[str] = 'value',
+            step: Optional[str] = None,
+            index: Optional[Union[int, str]] = None):
         """
         Returns the value in a parameter field.
 
@@ -297,7 +299,9 @@ class Parameter:
 
         raise ValueError(f'"{field}" is not a valid field')
 
-    def __assert_step_index(self, field, step, index):
+    def __assert_step_index(self, field: Optional[str],
+                            step: Optional[str],
+                            index: Optional[Union[int, str]]) -> None:
         if field not in self.__defvalue.fields:
             if step is not None or index is not None:
                 raise KeyError(
@@ -321,7 +325,11 @@ class Parameter:
         if index == 'default':
             raise KeyError('illegal index name: default is reserved')
 
-    def set(self, value, field='value', step=None, index=None, clobber=True):
+    def set(self, value,
+            field: str = 'value',
+            step: Optional[str] = None,
+            index: Optional[Union[int, str]] = None,
+            clobber: bool = True) -> Union[bool, List[NodeValue], NodeValue]:
         '''
         Sets a parameter field.
 
@@ -401,7 +409,10 @@ class Parameter:
 
         return True
 
-    def add(self, value, field='value', step=None, index=None):
+    def add(self, value,
+            field: str = 'value',
+            step: Optional[str] = None,
+            index: Optional[Union[int, str]] = None) -> Union[bool, List[NodeValue], NodeValue]:
         '''
         Adds item(s) to a list.
 
@@ -448,7 +459,7 @@ class Parameter:
 
         return True
 
-    def unset(self, step=None, index=None):
+    def unset(self, step: Optional[str] = None, index: Optional[Union[int, str]] = None) -> bool:
         '''
         Unsets a schema parameter.
 
@@ -490,13 +501,13 @@ class Parameter:
 
         return True
 
-    def reset(self):
+    def reset(self) -> None:
         """
         Resets a parameter back to its default state
         """
         self.__node = {}
 
-    def getdict(self, include_default=True, values_only=False):
+    def getdict(self, include_default: bool = True, values_only: bool = False) -> Dict:
         """
         Returns a schema dictionary.
 
@@ -555,7 +566,10 @@ class Parameter:
         return dictvals
 
     @classmethod
-    def from_dict(cls, manifest, keypath, version):
+    def from_dict(cls,
+                  manifest: Dict,
+                  keypath: Tuple[str, ...],
+                  version: Optional[Tuple[int, ...]]) -> "Parameter":
         '''
         Create a new parameter based on the provided dictionary.
 
@@ -570,7 +584,10 @@ class Parameter:
         param._from_dict(manifest, keypath, version)
         return param
 
-    def _from_dict(self, manifest, keypath, version):
+    def _from_dict(self,
+                   manifest: Dict,
+                   keypath: Tuple[str, ...],
+                   version: Optional[Tuple[int, ...]]) -> None:
         '''
         Copies the information from the manifest into this parameter.
 
@@ -632,7 +649,8 @@ class Parameter:
                     value = param.get()
                     param.set(value)
 
-    def gettcl(self, step=None, index=None):
+    def gettcl(self, step: Optional[str] = None,
+               index: Optional[Union[str, int]] = None) -> Optional[str]:
         """
         Returns a tcl string for this parameter.
 
@@ -665,7 +683,10 @@ class Parameter:
         except KeyError:
             return self.__defvalue.gettcl()
 
-    def getvalues(self, return_defvalue=True, return_values=True):
+    def getvalues(self, return_defvalue: bool = True, return_values: bool = True) \
+            -> List[Tuple[Union[Any, NodeValue, NodeSetValue, NodeListValue],
+                          Optional[str],
+                          Optional[str]]]:
         """
         Returns all values (global and pernode) associated with a particular parameter.
 
@@ -696,7 +717,7 @@ class Parameter:
 
         return vals
 
-    def copy(self, key=None):
+    def copy(self, key: Optional[Tuple[str, ...]] = None) -> "Parameter":
         """
         Returns a copy of this parameter.
 
@@ -707,14 +728,14 @@ class Parameter:
         return copy.deepcopy(self)
 
     # Utility functions
-    def is_list(self):
+    def is_list(self) -> bool:
         """
         Returns true is this parameter is a list type
         """
 
         return isinstance(self.__type, (list, set))
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         '''
         Utility function to check key for an empty value.
         '''
@@ -724,7 +745,7 @@ class Parameter:
         values = self.getvalues()
         return all([value in empty for value, _, _ in values])
 
-    def is_set(self, step=None, index=None):
+    def is_set(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) -> bool:
         '''
         Returns whether a user has set a value for this parameter.
 
@@ -746,7 +767,8 @@ class Parameter:
             index in self.__node[step] and \
             self.__node[step][index]
 
-    def has_value(self, step=None, index=None) -> bool:
+    def has_value(self, step: Optional[str] = None,
+                  index: Optional[Union[str, int]] = None) -> bool:
         '''
         Returns whether the parameter as a value.
 
@@ -774,13 +796,17 @@ class Parameter:
             return self.__defvalue.has_value
 
     @property
-    def default(self):
+    def default(self) -> Union[NodeValue, NodeSetValue, NodeListValue]:
         """
         Gets a copy of the default value.
         """
         return self.__defvalue.copy()
 
-    def add_commandline_arguments(self, argparser, *keypath, switchlist=None):
+    def add_commandline_arguments(self,
+                                  argparser: argparse.ArgumentParser,
+                                  *keypath: str,
+                                  switchlist: Optional[Union[Set[str], List[str], str]] = None) \
+            -> Tuple[Optional[str], Optional[List[str]]]:
         '''
         Adds commandline arguments for this parameter.
 
@@ -874,13 +900,14 @@ class Parameter:
 
         return dest, switches
 
-    def parse_commandline_arguments(self, value, *keypath):
+    def parse_commandline_arguments(self, value: str, *keypath: str) -> \
+            Tuple[Tuple[str, ...], Optional[str], Optional[str], str]:
         """
         Parse and set the values provided form the commandline parser.
 
         Args:
             value (str): string from commandline
-            keypath (list of str): leypath to this parameter
+            keypath (list of str): keypath to this parameter
         """
         num_free_keys = keypath.count('default')