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

siliconcompiler/schema/parametervalue.py

@@ -83,11 +83,24 @@ 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 gettcl(self):
+        """
+        Returns the tcl representation for the value
+
+        Args:
+            field (str): name of schema field.
+        """
+        return NodeType.to_tcl(self.get(), self.type)
 
     def set(self, value, field='value'):
         """
@@ -150,6 +163,16 @@ class NodeListValue:
         """
         return self.__base.fields
 
+    @property
+    def has_value(self):
+        """
+        Returns true if this node has a value.
+        """
+        if self.__values:
+            return True
+        else:
+            return False
+
     @property
     def values(self):
         '''
@@ -178,6 +201,204 @@ 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 gettcl(self):
+        """
+        Returns the tcl representation for the value
+
+        Args:
+            field (str): name of schema field.
+        """
+        return NodeType.to_tcl(self.get(ordered=True), [self.__base.type])
+
+    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 has_value(self):
+        """
+        Returns true if this node has a value.
+        """
+        if self.__values:
+            return True
+        else:
+            return False
+
+    @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.
@@ -251,6 +472,15 @@ class NodeValue:
             return self.__signature
         raise ValueError(f"{field} is not a valid field")
 
+    def gettcl(self):
+        """
+        Returns the tcl representation for the value
+
+        Args:
+            field (str): name of schema field.
+        """
+        return NodeType.to_tcl(self.get(), self.__type)
+
     def set(self, value, field='value'):
         """
         Sets the value in a specific field and ensures it has been normalized.
@@ -276,6 +506,19 @@ class NodeValue:
         """
         raise ValueError(f"cannot add to {field} field")
 
+    @property
+    def has_value(self):
+        """
+        Returns true if this node has a value.
+        """
+        if isinstance(self.__type, (set, tuple, list)):
+            return bool(self.__value)
+
+        if self.__value is not None:
+            return True
+        else:
+            return False
+
     @property
     def fields(self):
         """
@@ -375,10 +618,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 +682,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 +700,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 +712,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 +846,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 +874,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/safeschema.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 .parameter import Parameter
 from .baseschema import BaseSchema
 
@@ -15,16 +17,27 @@ class SafeSchema(BaseSchema):
     '''
 
     @staticmethod
-    def __is_dict_leaf(manifest, keypath, version):
+    def __is_dict_leaf(manifest: Dict, keypath: Tuple[str], version: str) -> Parameter:
         try:
             return Parameter.from_dict(manifest, keypath, version)
         except:  # noqa E722
             return None
 
-    def _from_dict(self, manifest, keypath, version=None):
+    @classmethod
+    def _getdict_type(cls) -> str:
+        """
+        Returns the meta data for getdict
+        """
+
+        return "SafeSchema"
+
+    def _from_dict(self, manifest: Dict, keypath: Tuple[str], version: str = None) -> None:
         if not isinstance(manifest, dict):
             return
 
+        if "__meta__" in manifest:
+            del manifest["__meta__"]
+
         for key, data in manifest.items():
             obj = SafeSchema.__is_dict_leaf(data, keypath + [key], version)
             if not obj:
@@ -35,3 +48,13 @@ class SafeSchema(BaseSchema):
                 self._BaseSchema__default = obj
             else:
                 self._BaseSchema__manifest[key] = obj
+
+    @classmethod
+    def from_manifest(cls, filepath: str = None, cfg: Dict = None) -> "SafeSchema":
+        if filepath:
+            cfg = BaseSchema._read_manifest(filepath)
+
+        if cfg and "__meta__" in cfg:
+            del cfg["__meta__"]
+
+        return super().from_manifest(filepath=None, cfg=cfg)

siliconcompiler/schema/schema_cfg.py

@@ -3,7 +3,7 @@
 from . import EditableSchema, Parameter, Scope, PerNode
 from .utils import trim
 
-SCHEMA_VERSION = '0.51.4'
+SCHEMA_VERSION = '0.51.5'
 
 
 #############################################################################
@@ -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
 ###############################################################################
@@ -204,8 +208,8 @@ def schema_schematic(cfg):
 # FPGA
 ###############################################################################
 def schema_fpga(cfg):
-    from siliconcompiler.fpga import FPGASchema
-    cfg.insert("fpga", FPGASchema())
+    from siliconcompiler.fpga import FPGASchemaTmp
+    cfg.insert("fpga", FPGASchemaTmp())
     return cfg
 
 
@@ -213,8 +217,8 @@ def schema_fpga(cfg):
 # PDK
 ###############################################################################
 def schema_pdk(cfg):
-    from siliconcompiler.pdk import PDKSchema
-    cfg.insert("pdk", "default", PDKSchema(None))
+    from siliconcompiler.pdk import PDKSchemaTmp
+    cfg.insert("pdk", "default", PDKSchemaTmp())
     return cfg
 
 
@@ -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/utils.py

@@ -7,7 +7,7 @@
 import sys
 
 
-def trim(docstring):
+def trim(docstring: str) -> str:
     '''
     Helper function for cleaning up indentation of docstring.
 
@@ -42,7 +42,7 @@ def trim(docstring):
     return '\n'.join(trimmed)
 
 
-def translate_loglevel(level):
+def translate_loglevel(level: str) -> str:
     if level == "quiet":
         level = "error"
     return level.upper()

siliconcompiler/schema_obj.py

@@ -7,9 +7,8 @@
 from siliconcompiler.schema import BaseSchema
 from siliconcompiler.schema import SafeSchema
 from siliconcompiler.schema import EditableSchema
-from siliconcompiler.schema import CommandLineSchema
+from siliconcompiler.cmdlineschema import CommandLineSchemaTmp
 from siliconcompiler.schema import Parameter
-from siliconcompiler.schema.baseschema import json
 
 from siliconcompiler.schema.schema_cfg import schema_cfg
 
@@ -39,8 +38,16 @@ class Schema(BaseSchema):
 
         return super()._from_dict(manifest, keypath, version=version)
 
+    @classmethod
+    def _getdict_type(cls) -> str:
+        """
+        Returns the meta data for getdict
+        """
 
-class SchemaTmp(Schema, CommandLineSchema):
+        return Schema.__name__
+
+
+class SchemaTmp(Schema, CommandLineSchemaTmp):
     """Object for storing and accessing configuration values corresponding to
     the SiliconCompiler schema.
 
@@ -85,6 +92,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
@@ -111,9 +121,18 @@ class SchemaTmp(Schema, CommandLineSchema):
             EditableSchema(self).insert("history", job, blank)
             return blank
 
+    @classmethod
+    def _getdict_type(cls) -> str:
+        """
+        Returns the meta data for getdict
+        """
+
+        return SchemaTmp.__name__
+
 
 ##############################################################################
 # Main routine
 if __name__ == "__main__":
-    import json as main_json
-    print(main_json.dumps(SchemaTmp().getdict(), indent=4, sort_keys=True))
+    import json
+    from siliconcompiler import Schema
+    print(json.dumps(Schema().getdict(), indent=4, sort_keys=True))