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

siliconcompiler/schema/editableschema.py

@@ -7,6 +7,8 @@
 from .parameter import Parameter
 from .baseschema import BaseSchema
 
+from typing import Union, Tuple
+
 
 class EditableSchema:
     '''
@@ -17,11 +19,15 @@ class EditableSchema:
         schema (:class:`BaseSchema`): schema to modify
     '''
 
-    def __init__(self, schema):
+    def __init__(self, schema: BaseSchema):
         # Grab manifest from base class
         self.__schema = schema
 
-    def __insert(self, keypath, value, fullkey, clobber):
+    def __insert(self,
+                 keypath: Tuple[str],
+                 value: Union[BaseSchema, Parameter],
+                 fullkey: Tuple[str],
+                 clobber: bool) -> None:
         key = keypath[0]
         keypath = keypath[1:]
 
@@ -31,6 +37,7 @@ class EditableSchema:
 
             if isinstance(value, BaseSchema):
                 value._BaseSchema__parent = self.__schema
+                value._BaseSchema__key = key
 
             if key == "default":
                 self.__schema._BaseSchema__default = value
@@ -47,9 +54,10 @@ class EditableSchema:
                 self.__schema._BaseSchema__default = new_schema
         else:
             new_schema = self.__schema._BaseSchema__manifest.setdefault(key, new_schema)
+        new_schema._BaseSchema__key = key
         EditableSchema(new_schema).__insert(keypath, value, fullkey, clobber)
 
-    def __remove(self, keypath, fullkey):
+    def __remove(self, keypath: Tuple[str], fullkey: Tuple[str]) -> None:
         key = keypath[0]
         keypath = keypath[1:]
 
@@ -69,7 +77,7 @@ class EditableSchema:
         else:
             EditableSchema(next_param).__remove(keypath, fullkey)
 
-    def insert(self, *args, clobber=False):
+    def insert(self, *args, 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``.
@@ -98,7 +106,7 @@ class EditableSchema:
 
         self.__insert(keypath, value, keypath, clobber=clobber)
 
-    def remove(self, *keypath):
+    def remove(self, *keypath: str) -> None:
         '''
         Removes a keypath from the schema.
 
@@ -118,7 +126,7 @@ class EditableSchema:
 
         self.__remove(keypath, keypath)
 
-    def search(self, *keypath):
+    def search(self, *keypath: str) -> Union[BaseSchema, Parameter]:
         '''
         Finds an item in the schema. This will raise a KeyError if
         the path is not found.

siliconcompiler/schema/journal.py

@@ -1,6 +1,8 @@
 import copy
 import json
 
+from typing import Tuple, Set, Dict, List
+
 
 class Journal:
     """
@@ -12,7 +14,7 @@ class Journal:
         keyprefix (list of str): keypath to prefix on to recorded path
     """
 
-    def __init__(self, keyprefix=None):
+    def __init__(self, keyprefix: Tuple[str] = None):
         if not keyprefix:
             self.__keyprefix = tuple()
         else:
@@ -24,14 +26,14 @@ class Journal:
         self.stop()
 
     @property
-    def keypath(self):
+    def keypath(self) -> Tuple[str]:
         '''
         Returns the reference key path for this journal
         '''
 
         return self.__keyprefix
 
-    def get_child(self, *keypath):
+    def get_child(self, *keypath: Tuple[str]):
         '''
         Get a child journal based on a new keypath
 
@@ -43,7 +45,7 @@ class Journal:
         child.__parent = self.__parent
         return child
 
-    def from_dict(self, manifest):
+    def from_dict(self, manifest: Dict):
         '''
         Import a journal from a manifest dictionary
 
@@ -53,33 +55,33 @@ class Journal:
 
         self.__journal = manifest
 
-    def get(self):
+    def get(self) -> List[Dict]:
         """
         Returns a copy of the current journal
         """
 
         return copy.deepcopy(self.__parent.__journal)
 
-    def has_journaling(self):
+    def has_journaling(self) -> bool:
         """
         Returns true if the schema is currently setup and is the root of the journal and has data
         """
         return self is self.__parent and bool(self.__journal)
 
-    def is_journaling(self):
+    def is_journaling(self) -> bool:
         """
         Returns true if the schema is currently setup for journaling
         """
         return self.__parent.__journal is not None
 
-    def get_types(self):
+    def get_types(self) -> Set[str]:
         """
         Returns the current schema accesses that are being recorded
         """
 
         return self.__parent.__record_types.copy()
 
-    def add_type(self, value):
+    def add_type(self, value: str) -> None:
         """
         Adds a new access type to the journal record.
 
@@ -90,9 +92,9 @@ class Journal:
         if value not in ("set", "add", "remove", "unset", "get"):
             raise ValueError(f"{value} is not a valid type")
 
-        return self.__parent.__record_types.add(value)
+        self.__parent.__record_types.add(value)
 
-    def remove_type(self, value):
+    def remove_type(self, value: str) -> None:
         """
         Removes a new access type to the journal record.
 
@@ -105,7 +107,13 @@ class Journal:
         except KeyError:
             pass
 
-    def record(self, record_type, key, value=None, field=None, step=None, index=None):
+    def record(self,
+               record_type: str,
+               key: Tuple[str],
+               value=None,
+               field: str = None,
+               step: str = None,
+               index: str = None) -> None:
         '''
         Record the schema transaction
         '''
@@ -116,6 +124,9 @@ class Journal:
         if record_type not in self.__parent.__record_types:
             return
 
+        if isinstance(value, set):
+            value = list(value)
+
         self.__parent.__journal.append({
             "type": record_type,
             "key": tuple([*self.__keyprefix, *key]),
@@ -125,7 +136,7 @@ class Journal:
             "index": index
         })
 
-    def start(self):
+    def start(self) -> None:
         '''
         Start journaling the schema transactions
         '''
@@ -135,7 +146,7 @@ class Journal:
         self.add_type("remove")
         self.add_type("unset")
 
-    def stop(self):
+    def stop(self) -> None:
         '''
         Stop journaling the schema transactions
         '''
@@ -143,7 +154,7 @@ class Journal:
         self.__parent.__record_types.clear()
 
     @staticmethod
-    def replay_file(schema, filepath):
+    def replay_file(schema, filepath: str) -> None:
         '''
         Replay a journal into a schema from a manifest
 
@@ -160,7 +171,7 @@ class Journal:
         journal.from_dict(data["__journal__"])
         journal.replay(schema)
 
-    def replay(self, schema):
+    def replay(self, schema) -> None:
         '''
         Replay journal into a schema
 
@@ -196,7 +207,7 @@ class Journal:
                 raise ValueError(f'Unknown record type {record_type}')
 
     @staticmethod
-    def access(schema):
+    def access(schema) -> "Journal":
         '''
         Access a journal from a schema
 

siliconcompiler/schema/namedschema.py

@@ -4,6 +4,8 @@
 # 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 .baseschema import BaseSchema
 
 
@@ -15,12 +17,13 @@ class NamedSchema(BaseSchema):
         name (str): name of the schema
     '''
 
-    def __init__(self, name=None):
+    def __init__(self, name: str = None):
         super().__init__()
 
-        self.__name = name
+        self.set_name(name)
 
-    def name(self):
+    @property
+    def name(self) -> str:
         '''
         Returns the name of the schema
         '''
@@ -29,7 +32,7 @@ class NamedSchema(BaseSchema):
         except AttributeError:
             return None
 
-    def set_name(self, name):
+    def set_name(self, name: str) -> None:
         """
         Set the name of this object
 
@@ -40,24 +43,28 @@ class NamedSchema(BaseSchema):
             name (str): name for object
         """
 
-        if self.name() is not None:
+        if self.name is not None:
             raise RuntimeError("Cannot call set_name more than once.")
+        if name is not None and "." in name:
+            raise ValueError("Named schema object cannot contains: .")
         self.__name = name
 
-    def _reset(self) -> None:
+    def type(self) -> str:
         """
-        Resets the state of the object
+        Returns the type of this object
         """
-        pass
+        raise NotImplementedError("Must be implemented by the child classes.")
 
-    def type(self) -> str:
+    @classmethod
+    def _getdict_type(cls) -> str:
         """
-        Returns the type of this object
+        Returns the meta data for getdict
         """
+
         raise NotImplementedError("Must be implemented by the child classes.")
 
     @classmethod
-    def from_manifest(cls, name, filepath=None, cfg=None):
+    def from_manifest(cls, name: str, filepath: str = None, cfg: Dict = None):
         '''
         Create a new schema based on the provided source files.
 
@@ -72,20 +79,21 @@ class NamedSchema(BaseSchema):
         if not filepath and cfg is None:
             raise RuntimeError("filepath or dictionary is required")
 
-        schema = cls(name)
+        schema = cls()
+        schema.set_name(name)
         if filepath:
             schema.read_manifest(filepath)
         if cfg:
             schema._from_dict(cfg, [])
         return schema
 
-    def _from_dict(self, manifest, keypath, version=None):
+    def _from_dict(self, manifest: Dict, keypath: Tuple[str], version: str = None):
         if keypath:
             self.__name = keypath[-1]
 
         return super()._from_dict(manifest, keypath, version=version)
 
-    def copy(self, key=None):
+    def copy(self, key: Tuple[str] = None) -> "NamedSchema":
         copy = super().copy(key=key)
 
         if key and key[-1] != "default":

siliconcompiler/schema/parameter.py

@@ -11,7 +11,8 @@ import shlex
 
 from enum import Enum
 
-from .parametervalue import NodeValue, DirectoryNodeValue, FileNodeValue, NodeListValue
+from .parametervalue import NodeValue, DirectoryNodeValue, FileNodeValue, NodeListValue, \
+    NodeSetValue
 from .parametertype import NodeType, NodeEnumType
 
 
@@ -59,6 +60,7 @@ class Parameter:
         example (list of str): example field
         help (str): help field
         pernode (:class:`.PerNode`): pernode field
+        kwargs: forwarded to default value constructor
     '''
 
     GLOBAL_KEY = 'global'
@@ -77,7 +79,8 @@ class Parameter:
                  switch=None,
                  example=None,
                  help=None,
-                 pernode=PerNode.NEVER):
+                 pernode=PerNode.NEVER,
+                 **kwargs):
 
         self.__type = NodeType.parse(type)
         self.__scope = Scope(scope)
@@ -108,7 +111,7 @@ class Parameter:
 
         self.__pernode = PerNode(pernode)
 
-        self.__setdefvalue(defvalue)
+        self.__setdefvalue(defvalue, **kwargs)
 
         self.__node = {}
 
@@ -123,26 +126,33 @@ class Parameter:
             self.__hashalgo = str(hashalgo)
             self.__copy = bool(copy)
 
-    def __setdefvalue(self, defvalue):
+    def __setdefvalue(self, defvalue, **kwargs):
         if NodeType.contains(self.__type, 'file'):
-            base = FileNodeValue(defvalue)
             if isinstance(self.__type, list):
-                self.__defvalue = NodeListValue(base)
+                self.__defvalue = NodeListValue(FileNodeValue(defvalue, **kwargs))
+            elif isinstance(self.__type, set):
+                self.__defvalue = NodeSetValue(FileNodeValue(defvalue, **kwargs))
             else:
-                self.__defvalue = base
+                self.__defvalue = FileNodeValue(defvalue, **kwargs)
         elif NodeType.contains(self.__type, 'dir'):
-            base = DirectoryNodeValue(defvalue)
             if isinstance(self.__type, list):
-                self.__defvalue = NodeListValue(base)
+                self.__defvalue = NodeListValue(DirectoryNodeValue(defvalue, **kwargs))
+            elif isinstance(self.__type, set):
+                self.__defvalue = NodeSetValue(DirectoryNodeValue(defvalue, **kwargs))
             else:
-                self.__defvalue = base
+                self.__defvalue = DirectoryNodeValue(defvalue, **kwargs)
         else:
+            kwargs = {}
             if isinstance(self.__type, list):
-                self.__defvalue = NodeListValue(NodeValue(self.__type[0]))
+                self.__defvalue = NodeListValue(NodeValue(self.__type[0], **kwargs))
+                if defvalue:
+                    self.__defvalue.set(defvalue)
+            elif isinstance(self.__type, set):
+                self.__defvalue = NodeSetValue(NodeValue(list(self.__type)[0], **kwargs))
                 if defvalue:
                     self.__defvalue.set(defvalue)
             else:
-                self.__defvalue = NodeValue(self.__type, value=defvalue)
+                self.__defvalue = NodeValue(self.__type, value=defvalue, **kwargs)
 
     def __str__(self):
         return str(self.getvalues())
@@ -344,7 +354,7 @@ class Parameter:
 
         if field in self.__defvalue.fields:
             if not self.is_list() and field == 'value':
-                raise ValueError("add can only be used on lists")
+                raise ValueError("add can only be used on lists or sets")
 
             if isinstance(index, int):
                 index = str(index)
@@ -409,6 +419,12 @@ class Parameter:
 
         return True
 
+    def reset(self):
+        """
+        Resets a parameter back to its default state
+        """
+        self.__node = {}
+
     def getdict(self, include_default=True, values_only=False):
         """
         Returns a schema dictionary.
@@ -523,15 +539,14 @@ class Parameter:
         requires_set = NodeType.contains(self.__type, tuple) or NodeType.contains(self.__type, set)
 
         try:
-            defvalue = manifest["node"]["default"]["default"]["value"]
+            defvalue = manifest["node"]["default"]["default"]
             del manifest["node"]["default"]
         except KeyError:
             defvalue = None
 
-        if requires_set:
-            self.__setdefvalue(NodeType.normalize(defvalue, self.__type))
-        else:
-            self.__setdefvalue(defvalue)
+        self.__setdefvalue(None)
+        if defvalue:
+            self.__defvalue._from_dict(defvalue, keypath, version)
 
         for step, indexdata in manifest["node"].items():
             self.__node[step] = {}
@@ -559,14 +574,27 @@ class Parameter:
 
         if self.__pernode == PerNode.REQUIRED and (step is None or index is None):
             return None
-        if not self.__pernode.is_never():
-            value = self.get(step=step, index=index)
-        else:
-            value = self.get()
 
-        return NodeType.to_tcl(value, self.__type)
+        if isinstance(index, int):
+            index = str(index)
+
+        try:
+            return self.__node[step][index].gettcl()
+        except KeyError:
+            if self.__pernode == PerNode.REQUIRED:
+                return self.__defvalue.gettcl()
+
+        try:
+            return self.__node[step][Parameter.GLOBAL_KEY].gettcl()
+        except KeyError:
+            pass
+
+        try:
+            return self.__node[Parameter.GLOBAL_KEY][Parameter.GLOBAL_KEY].gettcl()
+        except KeyError:
+            return self.__defvalue.gettcl()
 
-    def getvalues(self, return_defvalue=True):
+    def getvalues(self, return_defvalue=True, return_values=True):
         """
         Returns all values (global and pernode) associated with a particular parameter.
 
@@ -584,10 +612,16 @@ class Parameter:
                 index_arg = None if index == Parameter.GLOBAL_KEY else index
                 if step_arg is None and index_arg is None:
                     has_global = True
-                vals.append((self.__node[step][index].get(), step_arg, index_arg))
+                if return_values:
+                    vals.append((self.__node[step][index].get(), step_arg, index_arg))
+                else:
+                    vals.append((self.__node[step][index], step_arg, index_arg))
 
-        if (self.__pernode != PerNode.REQUIRED) and not has_global and return_defvalue:
-            vals.append((self.__defvalue.get(), None, None))
+        if self.__pernode != PerNode.REQUIRED and not has_global and return_defvalue:
+            if return_values:
+                vals.append((self.__defvalue.get(), None, None))
+            else:
+                vals.append((self.__defvalue, None, None))
 
         return vals
 
@@ -607,7 +641,7 @@ class Parameter:
         Returns true is this parameter is a list type
         """
 
-        return isinstance(self.__type, list)
+        return isinstance(self.__type, (list, set))
 
     def is_empty(self):
         '''
@@ -641,6 +675,33 @@ class Parameter:
             index in self.__node[step] and \
             self.__node[step][index]
 
+    def has_value(self, step=None, index=None) -> bool:
+        '''
+        Returns whether the parameter as a value.
+
+        A value counts as set if a user has set a global value OR a value for
+        the provided step/index.
+        '''
+
+        if isinstance(index, int):
+            index = str(index)
+
+        try:
+            return self.__node[step][index].has_value
+        except KeyError:
+            if self.__pernode == PerNode.REQUIRED:
+                return self.__defvalue.has_value
+
+        try:
+            return self.__node[step][Parameter.GLOBAL_KEY].has_value
+        except KeyError:
+            pass
+
+        try:
+            return self.__node[Parameter.GLOBAL_KEY][Parameter.GLOBAL_KEY].has_value
+        except KeyError:
+            return self.__defvalue.has_value
+
     @property
     def default(self):
         """

siliconcompiler/schema/parametertype.py

@@ -100,6 +100,8 @@ class NodeType:
                 return True
         if isinstance(value, list):
             return NodeType.contains(value[0], check)
+        if isinstance(value, set):
+            return NodeType.contains(list(value)[0], check)
         if isinstance(value, tuple):
             return any([NodeType.contains(v, check) for v in value])
         return value == check