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

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] = {}
@@ -607,7 +622,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):
         '''

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

siliconcompiler/schema/parametervalue.py

@@ -83,11 +83,15 @@ class NodeListValue:
             field (str): name of schema field.
         """
 
-        vals = []
-        for val in self.__values:
-            value = val.get(field=field)
-            vals.append(value)
-        return vals
+        if self.__values:
+            vals = []
+            for val in self.__values:
+                vals.append(val.get(field=field))
+            return vals
+        if self.__base.get("value") is None:
+            return []
+
+        return [self.__base.get(field=field)]
 
     def set(self, value, field='value'):
         """
@@ -178,6 +182,185 @@ class NodeListValue:
         return [self.__base.type]
 
 
+class NodeSetValue:
+    '''
+    Holds the data for a set schema type.
+
+    Args:
+        base (:class:`NodeValue`): base type for this set.
+    '''
+
+    def __init__(self, base):
+        self.__base = base
+        self.__values = []
+
+    def getdict(self):
+        """
+        Returns a schema dictionary.
+
+        Examples:
+            >>> value.getdict()
+            Returns the complete dictionary for the value
+        """
+
+        manifest = {}
+        for field in self.fields:
+            if field is None:
+                continue
+
+            value = self.get(field=field, ordered=True)
+            manifest.setdefault(field, []).extend(value)
+
+            if field == "author":
+                tmplist = []
+                for a in manifest[field]:
+                    tmplist.extend(a)
+                manifest[field] = tmplist
+        return manifest
+
+    def _from_dict(self, manifest, keypath, version):
+        '''
+        Create a new value based on the provided dictionary.
+
+        Args:
+            manifest (dict): Manifest to decide.
+            keypath (list of str): Path to the current keypath.
+            version (packaging.Version): Version of the dictionary schema
+            sctype (str): schema type for this value
+        '''
+
+        self.__values.clear()
+        for n in range(len(manifest["value"])):
+            param = self.__base.copy()
+            self.__values.append(param)
+
+            for field in self.fields:
+                if field is None:
+                    continue
+
+                if len(manifest[field]) <= n:
+                    continue
+                param.set(manifest[field][n], field=field)
+
+    def get(self, field='value', ordered: bool = False):
+        """
+        Returns the value in the specified field
+
+        Args:
+            field (str): name of schema field.
+            ordered (bool): if true, returns a list instead of set for values
+        """
+
+        vals = []
+
+        if self.__values:
+            for val in self.__values:
+                vals.append(val.get(field=field))
+        elif self.__base.get("value") is None:
+            pass
+        else:
+            vals.append(self.__base.get(field=field))
+
+        if not ordered and field == "value":
+            return set(vals)
+        return vals
+
+    def set(self, value, field='value'):
+        value = NodeType.normalize(value, [self.__base.type])
+
+        if field == 'value':
+            self.__values.clear()
+        else:
+            if len(value) != len(self.__values):
+                raise ValueError(f"set on {field} field must match number of values")
+
+        current_values = []
+        if field == "value":
+            current_values = [v.get() for v in self.__values]
+
+        modified = list()
+        m = 0
+        for n in range(len(value)):
+            if field == 'value':
+                if value[n] in current_values:
+                    continue
+
+                self.__values.append(self.__base.copy())
+                current_values.append(value[n])
+            self.__values[m].set(value[n], field=field)
+            modified.append(self.__values[m])
+            m += 1
+        return tuple(modified)
+
+    def add(self, value, field='value'):
+        """
+        Adds the value in a specific field and ensures it has been normalized.
+
+        Returns:
+            tuple of modified values
+
+        Args:
+            value (any): value to set
+            field (str): field to set
+        """
+
+        current_values = []
+        if field == "value":
+            current_values = [v.get() for v in self.__values]
+
+        modified = list()
+        if field == 'value':
+            value = NodeType.normalize(value, [self.__base.type])
+
+            for n in range(len(value)):
+                if value[n] in current_values:
+                    continue
+
+                self.__values.append(self.__base.copy())
+                self.__values[-1].set(value[n], field=field)
+                current_values.append(value[n])
+                modified.append(self.__values[-1])
+        else:
+            for val in self.__values:
+                val.add(value, field=field)
+                modified.append(val)
+        return tuple(modified)
+
+    @property
+    def fields(self):
+        """
+        Returns a list of valid fields for this value
+        """
+        return self.__base.fields
+
+    @property
+    def values(self):
+        '''
+        Returns a copy of the values stored in the list
+        '''
+        return self.__values.copy()
+
+    def copy(self):
+        """
+        Returns a copy of this value.
+        """
+
+        return copy.deepcopy(self)
+
+    def _set_type(self, sctype):
+        sctype = NodeType.parse(sctype)[0]
+        self.__base._set_type(sctype)
+        for val in self.__values:
+            val._set_type(sctype)
+
+    @property
+    def type(self):
+        """
+        Returns the type for this value
+        """
+        return set([self.__base.type])
+
+
 class NodeValue:
     '''
     Holds the data for a parameter.
@@ -375,10 +558,10 @@ class PathNodeValue(NodeValue):
         value (any): default value for this parameter
     '''
 
-    def __init__(self, type, value=None):
+    def __init__(self, type, value=None, package=None):
         super().__init__(type, value=value)
         self.__filehash = None
-        self.__package = None
+        self.__package = package
 
     def getdict(self):
         return {
@@ -439,7 +622,7 @@ class PathNodeValue(NodeValue):
 
         return None
 
-    def resolve_path(self, search=None, collection_dir=None):
+    def resolve_path(self, search=None, collection_dir=None) -> str:
         """
         Resolve the path of this value.
 
@@ -457,10 +640,10 @@ class PathNodeValue(NodeValue):
         if collection_dir:
             collect_path = self.__resolve_collection_path(value, collection_dir)
             if collect_path:
-                return collect_path
+                return str(pathlib.Path(collect_path))
 
         if os.path.isabs(value) and os.path.exists(value):
-            return value
+            return str(pathlib.Path(value))
 
         # Search for file
         if search is None:
@@ -469,7 +652,7 @@ class PathNodeValue(NodeValue):
         for searchdir in search:
             abspath = os.path.abspath(os.path.join(searchdir, value))
             if os.path.exists(abspath):
-                return abspath
+                return str(pathlib.Path(abspath))
 
         # File not found
         raise FileNotFoundError(value)
@@ -603,8 +786,8 @@ class DirectoryNodeValue(PathNodeValue):
         value (any): default value for this parameter
     '''
 
-    def __init__(self, value=None):
-        super().__init__("dir", value=value)
+    def __init__(self, value=None, package=None):
+        super().__init__("dir", value=value, package=package)
 
     def hash(self, function, **kwargs):
         """
@@ -631,8 +814,8 @@ class FileNodeValue(PathNodeValue):
         value (any): default value for this parameter
     '''
 
-    def __init__(self, value=None):
-        super().__init__("file", value=value)
+    def __init__(self, value=None, package=None):
+        super().__init__("file", value=value, package=package)
         self.__date = None
         self.__author = []
 

siliconcompiler/schema/schema_cfg.py

@@ -59,16 +59,7 @@ def schema_cfg(schema):
     # Basic schema setup
     cfg = EditableSchema(schema)
 
-    scparam(cfg, ['schemaversion'],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            defvalue=SCHEMA_VERSION,
-            require=True,
-            shorthelp="Schema version number",
-            lock=True,
-            switch="-schemaversion <str>",
-            example=["api: chip.get('schemaversion')"],
-            schelp="""SiliconCompiler schema version number.""")
+    schema_version(cfg)
 
     # Design topmodule/entrypoint
     scparam(cfg, ['design'],
@@ -139,6 +130,19 @@ def schema_cfg(schema):
     cfg = schema_schematic(cfg)
 
 
+def schema_version(cfg):
+    scparam(cfg, ['schemaversion'],
+            sctype='str',
+            scope=Scope.GLOBAL,
+            defvalue=SCHEMA_VERSION,
+            require=True,
+            shorthelp="Schema version number",
+            lock=True,
+            switch="-schemaversion <str>",
+            example=["api: chip.get('schemaversion')"],
+            schelp="""SiliconCompiler schema version number.""")
+
+
 ###############################################################################
 # SCHEMATIC
 ###############################################################################
@@ -1071,8 +1075,8 @@ def schema_arg(cfg):
 # Metrics to Track
 ###########################################################################
 def schema_metric(cfg):
-    from siliconcompiler.metric import MetricSchema
-    cfg.insert("metric", MetricSchema())
+    from siliconcompiler.metric import MetricSchemaTmp
+    cfg.insert("metric", MetricSchemaTmp())
     return cfg
 
 
@@ -1773,8 +1777,8 @@ def schema_option_frontend(cfg):
 # Package information
 ############################################
 def schema_package(cfg):
-    from siliconcompiler.packageschema import PackageSchema
-    cfg.insert("package", PackageSchema())
+    from siliconcompiler.packageschema import PackageSchemaTmp
+    cfg.insert("package", PackageSchemaTmp())
     return cfg
 
 

siliconcompiler/schema_obj.py

@@ -9,7 +9,6 @@ from siliconcompiler.schema import SafeSchema
 from siliconcompiler.schema import EditableSchema
 from siliconcompiler.schema import CommandLineSchema
 from siliconcompiler.schema import Parameter
-from siliconcompiler.schema.baseschema import json
 
 from siliconcompiler.schema.schema_cfg import schema_cfg
 
@@ -85,6 +84,9 @@ class SchemaTmp(Schema, CommandLineSchema):
 
         super()._from_dict(manifest, keypath, version=version)
 
+    def _find_files_dataroot_resolvers(self):
+        return self.get("package", field="schema").get_resolvers()
+
     def record_history(self):
         '''
         Copies all non-empty parameters from current job into the history
@@ -115,5 +117,5 @@ class SchemaTmp(Schema, CommandLineSchema):
 ##############################################################################
 # Main routine
 if __name__ == "__main__":
-    import json as main_json
-    print(main_json.dumps(SchemaTmp().getdict(), indent=4, sort_keys=True))
+    import json
+    print(json.dumps(SchemaTmp().getdict(), indent=4, sort_keys=True))