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

siliconcompiler/dependencyschema.py

@@ -4,9 +4,6 @@ from siliconcompiler.schema.baseschema import BaseSchema
 from siliconcompiler.schema.editableschema import EditableSchema
 from siliconcompiler.schema.parameter import Parameter, Scope
 from siliconcompiler.schema.namedschema import NamedSchema
-from siliconcompiler.schema.utils import trim
-
-from siliconcompiler.package import Resolver
 
 
 class DependencySchema(BaseSchema):
@@ -15,9 +12,10 @@ class DependencySchema(BaseSchema):
     '''
 
     def __init__(self):
+        '''Initializes the DependencySchema.'''
         super().__init__()
 
-        self.__deps = {}
+        self._reset_deps()
 
         schema = EditableSchema(self)
         schema.insert(
@@ -26,51 +24,24 @@ class DependencySchema(BaseSchema):
                 '[str]',
                 scope=Scope.GLOBAL,
                 lock=True,
-                shorthelp="List of dependencies",
+                shorthelp="List of object dependencies",
                 help="List of named object dependencies included via add_dep()."))
 
-        schema.insert(
-            'package', 'default', 'root',
-            Parameter(
-                'str',
-                scope=Scope.GLOBAL,
-                shorthelp="Package: package root",
-                example=[
-                    "api: chip.set('source', "
-                    "'freepdk45_data', 'path', 'ssh://git@github.com/siliconcompiler/freepdk45/')"],
-                help=trim("""
-                    Package root path, this points the location where the package data can be
-                    retrieved or accessed.
-                    Allowed roots:
-
-                    * /path/on/network/drive
-                    * file:///path/on/network/drive
-                    * git+https://github.com/xyz/xyz
-                    * git://github.com/xyz/xyz
-                    * git+ssh://github.com/xyz/xyz
-                    * ssh://github.com/xyz/xyz
-                    * https://github.com/xyz/xyz/archive
-                    * https://zeroasic.com/xyz.tar.gz
-                    * github://siliconcompiler/lambdapdk/v1.0/asap7.tar.gz
-                    * python://siliconcompiler
-                    """)))
+    def _from_dict(self, manifest, keypath, version=None):
+        '''
+        Internal helper to load schema from a dictionary manifest.
 
-        schema.insert(
-            'package', 'default', 'tag',
-            Parameter(
-                'str',
-                scope=Scope.GLOBAL,
-                shorthelp="Package: package tag/version",
-                example=[
-                    "api: chip.set('source', 'freepdk45_data', 'ref', '07ec4aa')"],
-                help=trim("""
-                    Package reference tag. The meaning of the this tag depends on the context of
-                    the root.
-                    For git, this can be a tag, branch, or commit id. For https this is the version
-                    of the file that will be downloaded.
-                    """)))
+        This method temporarily unlocks the 'deps' parameter to allow it to be
+        populated from the manifest data.
 
-    def _from_dict(self, manifest, keypath, version=None):
+        Args:
+            manifest (dict): The dictionary to load data from.
+            keypath (list): The list of keys representing the path to the data.
+            version (str, optional): The schema version. Defaults to None.
+
+        Returns:
+            The result of the parent class's _from_dict method.
+        '''
         self.set("deps", False, field="lock")
         ret = super()._from_dict(manifest, keypath, version)
         self.set("deps", True, field="lock")
@@ -81,9 +52,9 @@ class DependencySchema(BaseSchema):
         Adds a module to this object.
 
         Args:
-            obj (:class:`NamedSchema`): Module to add
+            obj (:class:`NamedSchema`): Module to add.
             clobber (bool): If true will insert the object and overwrite any
-                existing with the same name
+                existing with the same name.
 
         Returns:
             True if object was imported, otherwise false.
@@ -92,16 +63,18 @@ class DependencySchema(BaseSchema):
         if not isinstance(obj, NamedSchema):
             raise TypeError(f"Cannot add an object of type: {type(obj)}")
 
-        if not clobber and obj.name() in self.__deps:
+        if not clobber and obj.name in self.__deps:
             return False
 
-        if obj.name() not in self.__deps:
+        if obj.name is None:
+            raise ValueError("Cannot add an unnamed dependency")
+
+        if not self.has_dep(obj):
             self.set("deps", False, field="lock")
-            self.add("deps", obj.name())
+            self.add("deps", obj.name)
             self.set("deps", True, field="lock")
 
-        self.__deps[obj.name()] = obj
-        obj._reset()
+        self.__deps[obj.name] = obj
 
         return True
 
@@ -114,12 +87,12 @@ class DependencySchema(BaseSchema):
         Renders and saves the dependency graph to a file.
 
         Args:
-            filename (filepath): Output filepath
-            fontcolor (str): Node font RGB color hex value
-            background (str): Background color
-            fontsize (str): Node text font size
-            border (bool): Enables node border if True
-            landscape (bool): Renders graph in landscape layout if True
+            filename (filepath): Output filepath.
+            fontcolor (str): Node font RGB color hex value.
+            background (str): Background color.
+            fontsize (str): Node text font size.
+            border (bool): Enables node border if True.
+            landscape (bool): Renders graph in landscape layout if True.
 
         Examples:
             >>> schema.write_depgraph('mydump.png')
@@ -148,11 +121,11 @@ class DependencySchema(BaseSchema):
         dot.attr(bgcolor=background)
 
         def make_label(dep):
-            return f"lib-{dep.name()}"
+            return f"lib-{dep.name}"
 
         nodes = {
-            self.name(): {
-                "text": self.name(),
+            self.name: {
+                "text": self.name,
                 "shape": "box",
                 "color": background,
                 "connects_to": set([make_label(subdep) for subdep in self.__deps.values()])
@@ -160,7 +133,7 @@ class DependencySchema(BaseSchema):
         }
         for dep in self.get_dep():
             nodes[make_label(dep)] = {
-                "text": dep.name(),
+                "text": dep.name,
                 "shape": "oval",
                 "color": background,
                 "connects_to": set([make_label(subdep) for subdep in dep.__deps.values()])
@@ -181,16 +154,25 @@ class DependencySchema(BaseSchema):
 
     def __get_all_deps(self, seen: set) -> list:
         '''
-        Loop through the dependency tree and generate a flat list
+        Recursively traverses the dependency tree to generate a flat list.
+
+        This method avoids cycles and duplicate entries by keeping track of
+        visited nodes in the 'seen' set.
+
+        Args:
+            seen (set): A set of dependency names that have already been visited.
+
+        Returns:
+            list: A flat list of all dependency objects.
         '''
         deps = []
 
         for obj in self.__deps.values():
-            if obj.name() in seen:
+            if obj.name in seen:
                 continue
 
             deps.append(obj)
-            seen.add(obj.name())
+            seen.add(obj.name)
 
             if not isinstance(obj, DependencySchema):
                 # nothing to iterate over
@@ -198,7 +180,7 @@ class DependencySchema(BaseSchema):
 
             for obj_dep in obj.__get_all_deps(seen):
                 deps.append(obj_dep)
-                seen.add(obj_dep.name())
+                seen.add(obj_dep.name)
 
         return deps
 
@@ -207,16 +189,25 @@ class DependencySchema(BaseSchema):
         Returns all dependencies associated with this object or a specific one if requested.
 
         Raises:
-            KeyError: if the module specific module is requested but not found
+            KeyError: if the specific module is requested but not found.
 
         Args:
-            name (str): name of the module
-            hierarchy (bool): if True, will return all modules including children
-                otherwise only this objects modules are returned.
+            name (str): Name of the module.
+            hierarchy (bool): If True, will return all modules including children,
+                otherwise only this object's modules are returned.
+
+        Returns:
+            list: A list of dependency objects.
         '''
 
         if name:
-            if name not in self.__deps:
+            if not self.has_dep(name):
+                if "." in name:
+                    name0, *name1 = name.split(".")
+                    subdep = self.get_dep(name0)
+                    if isinstance(subdep, DependencySchema):
+                        return subdep.get_dep(".".join(name1))
+                    raise KeyError(f"{name} does not contain dependency information")
                 raise KeyError(f"{name} is not an imported module")
 
             return self.__deps[name]
@@ -225,19 +216,38 @@ class DependencySchema(BaseSchema):
             return self.__get_all_deps(set())
         return list(self.__deps.values())
 
+    def has_dep(self, name: str) -> bool:
+        '''
+        Checks if a specific dependency is present.
+
+        Args:
+            name (str): Name of the module.
+
+        Returns:
+            True if the module was found, False otherwise.
+        '''
+
+        if isinstance(name, NamedSchema):
+            name = name.name
+
+        return name in self.__deps
+
     def remove_dep(self, name: str) -> bool:
         '''
         Removes a previously registered module.
 
         Args:
-            name (str): name of the module
+            name (str): Name of the module.
 
         Returns:
-            True if the module was removed, False is not found.
+            True if the module was removed, False if it was not found.
         '''
-        if name not in self.__deps:
+        if not self.has_dep(name):
             return False
 
+        if isinstance(name, NamedSchema):
+            name = name.name
+
         del self.__deps[name]
 
         # Remove from dependency list
@@ -251,6 +261,15 @@ class DependencySchema(BaseSchema):
         return True
 
     def _populate_deps(self, module_map: dict):
+        '''
+        Internal method to populate the internal dependency dictionary.
+
+        This is used to reconstruct object references from a serialized format
+        by looking up dependency names in the provided map.
+
+        Args:
+            module_map (dict): A dictionary mapping module names to module objects.
+        '''
         if self.__deps:
             return
 
@@ -262,131 +281,6 @@ class DependencySchema(BaseSchema):
             if isinstance(self.__deps[module], DependencySchema):
                 self.__deps[module]._populate_deps(module_map)
 
-    def register_package(self, name: str, root: str, tag: str = None):
-        """
-        Registers a package by its name with the root and associated tag.
-
-        Args:
-            name (str): Package name
-            root (str): Path to the root, can be directory, git url, or archive url
-            tag (str): Reference of the sources, can be commitid, branch name, tag
-
-        Examples:
-            >>> schema.register_package('siliconcompiler_data',
-                    'git+https://github.com/siliconcompiler/siliconcompiler',
-                    'v1.0.0')
-        """
-
-        if os.path.isfile(root):
-            root = os.path.dirname(os.path.abspath(root))
-
-        self.set("package", name, "root", root)
-        if tag:
-            self.set("package", name, "tag", tag)
-
-    def find_package(self, name: str):
-        """
-        Returns absolute path to the package root.
-
-        Raises:
-            ValueError: is package is not found
-
-        Args:
-            name (str): name of the package to find.
-
-        Returns:
-            Path to the package directory root.
-
-        Examples:
-            >>> schema.find_package('siliconcompiler')
-            Returns the path to the root of the siliconcompiler package.
-        """
-
-        if not self.valid("package", name):
-            raise ValueError(f"{name} is not a recognized source")
-
-        root = self.get("package", name, "root")
-        tag = self.get("package", name, "tag")
-
-        resolver = Resolver.find_resolver(root)
-        return resolver(name, self._parent(root=True), root, tag).get_path()
-
-    def __get_resolver_map(self):
-        """
-        Generate the resolver map got package handling for find_files and check_filepaths
-        """
-        schema_root = self._parent(root=True)
-        resolver_map = {}
-        for package in self.getkeys("package"):
-            root = self.get("package", package, "root")
-            tag = self.get("package", package, "tag")
-            resolver = Resolver.find_resolver(root)
-            resolver_map[package] = resolver(package, schema_root, root, tag).get_path
-        return resolver_map
-
-    def find_files(self, *keypath,
-                   missing_ok=False,
-                   step=None, index=None):
-        """
-        Returns absolute paths to files or directories based on the keypath
-        provided.
-
-        The keypath provided must point to a schema parameter of type file, dir,
-        or lists of either. Otherwise, it will trigger an error.
-
-        Args:
-            keypath (list of str): Variable length schema key list.
-            missing_ok (bool): If True, silently return None when files aren't
-                found. If False, print an error and set the error flag.
-            step (str): Step name to access for parameters that may be specified
-                on a per-node basis.
-            index (str): Index name to access for parameters that may be specified
-                on a per-node basis.
-
-        Returns:
-            If keys points to a scalar entry, returns an absolute path to that
-            file/directory, or None if not found. It keys points to a list
-            entry, returns a list of either the absolute paths or None for each
-            entry, depending on whether it is found.
-
-        Examples:
-            >>> schema.find_files('input', 'verilog')
-            Returns a list of absolute paths to source files, as specified in
-            the schema.
-        """
-        schema_root = self._parent(root=True)
-        cwd = getattr(schema_root, "cwd", os.getcwd())
-        collection_dir = getattr(schema_root, "collection_dir", None)
-        if collection_dir:
-            collection_dir = collection_dir()
-
-        return super().find_files(*keypath,
-                                  missing_ok=missing_ok,
-                                  step=step, index=index,
-                                  packages=self.__get_resolver_map(),
-                                  collection_dir=collection_dir,
-                                  cwd=cwd)
-
-    def check_filepaths(self, ignore_keys=None):
-        '''
-        Verifies that paths to all files in manifest are valid.
-
-        Args:
-            ignore_keys (list of keypaths): list of keypaths to ignore while checking
-
-        Returns:
-            True if all file paths are valid, otherwise False.
-        '''
-        schema_root = self._parent(root=True)
-        cwd = getattr(schema_root, "cwd", os.getcwd())
-        logger = getattr(schema_root, "logger", None)
-        collection_dir = getattr(schema_root, "collection_dir", None)
-        if collection_dir:
-            collection_dir = collection_dir()
-
-        return super().check_filepaths(
-            ignore_keys=ignore_keys,
-            logger=logger,
-            packages=self.__get_resolver_map(),
-            collection_dir=collection_dir,
-            cwd=cwd)
+    def _reset_deps(self):
+        '''Resets the internal dependency dictionary.'''
+        self.__deps = {}