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

siliconcompiler/package/__init__.py

@@ -22,6 +22,8 @@ import uuid
 
 import os.path
 
+from typing import Optional, List, Dict, Type, Union, TYPE_CHECKING, ClassVar
+
 from fasteners import InterProcessLock
 from importlib.metadata import distributions, distribution
 from pathlib import Path
@@ -29,6 +31,11 @@ from urllib import parse as url_parse
 
 from siliconcompiler.utils import get_plugins
 
+if TYPE_CHECKING:
+    from siliconcompiler.project import Project
+    from siliconcompiler.schema_support.pathschema import PathSchema
+    from siliconcompiler.schema import BaseSchema
+
 
 class Resolver:
     """
@@ -45,13 +52,17 @@ class Resolver:
         source (str): The URI or path specifying the data source.
         reference (str): A version, commit hash, or tag for remote sources.
     """
-    _RESOLVERS_LOCK = threading.Lock()
-    _RESOLVERS = {}
+    _RESOLVERS_LOCK: ClassVar[threading.Lock] = threading.Lock()
+    _RESOLVERS: ClassVar[Dict[str, Type["Resolver"]]] = {}
+    __STORAGE: str = "__Resolver_cache_id"
 
-    __CACHE_LOCK = threading.Lock()
-    __CACHE = {}
+    __CACHE_LOCK: ClassVar[threading.Lock] = threading.Lock()
+    __CACHE: ClassVar[Dict[str, Dict[str, str]]] = {}
 
-    def __init__(self, name, root, source, reference=None):
+    def __init__(self, name: str,
+                 root: Optional[Union["Project", "BaseSchema"]],
+                 source: str,
+                 reference: Optional[str] = None):
         """
         Initializes the Resolver.
         """
@@ -68,7 +79,7 @@ class Resolver:
             self.__logger = logging.getLogger(f"resolver-{self.name}")
 
     @staticmethod
-    def populate_resolvers():
+    def populate_resolvers() -> None:
         """
         Scans for and registers all available resolver plugins.
 
@@ -90,7 +101,7 @@ class Resolver:
                 Resolver._RESOLVERS.update(resolver())
 
     @staticmethod
-    def find_resolver(source):
+    def find_resolver(source: str) -> Type["Resolver"]:
         """
         Finds the appropriate resolver class for a given source URI.
 
@@ -122,7 +133,7 @@ class Resolver:
         return self.__name
 
     @property
-    def root(self):
+    def root(self) -> Optional[Union["Project", "BaseSchema"]]:
         """The root object (e.g., Project) providing context."""
         return self.__root
 
@@ -137,7 +148,7 @@ class Resolver:
         return self.__source
 
     @property
-    def reference(self) -> str:
+    def reference(self) -> Union[None, str]:
         """A version, commit hash, or tag for the source."""
         return self.__reference
 
@@ -185,7 +196,7 @@ class Resolver:
         """Marks the resolved data as having been changed."""
         self.__changed = True
 
-    def resolve(self):
+    def resolve(self) -> Union[Path, str]:
         """
         Abstract method to perform the actual data resolution.
 
@@ -195,15 +206,15 @@ class Resolver:
         raise NotImplementedError("child class must implement this")
 
     @staticmethod
-    def __get_root_id(root):
+    def __get_root_id(root: Union["Project", "BaseSchema"]) -> str:
         """Generates or retrieves a unique ID for a root object."""
-        STORAGE = "__Resolver_cache_id"
-        if not getattr(root, STORAGE, None):
-            setattr(root, STORAGE, uuid.uuid4().hex)
-        return getattr(root, STORAGE)
+        if not getattr(root, Resolver.__STORAGE, None):
+            setattr(root, Resolver.__STORAGE, uuid.uuid4().hex)
+        return getattr(root, Resolver.__STORAGE)
 
     @staticmethod
-    def get_cache(root, name: str = None):
+    def get_cache(root: Optional[Union["Project", "BaseSchema"]], name: Optional[str] = None) \
+            -> Union[None, str, Dict[str, str]]:
         """
         Gets a cached path for a given root object and resolver name.
 
@@ -215,6 +226,9 @@ class Resolver:
         Returns:
             str or dict or None: The cached path, a copy of the cache, or None.
         """
+        if root is None:
+            return None
+
         with Resolver.__CACHE_LOCK:
             root_id = Resolver.__get_root_id(root)
             if root_id not in Resolver.__CACHE:
@@ -226,7 +240,9 @@ class Resolver:
             return Resolver.__CACHE[root_id].copy()
 
     @staticmethod
-    def set_cache(root, name: str, path: str):
+    def set_cache(root: Optional[Union["Project", "BaseSchema"]],
+                  name: str,
+                  path: Union[Path, str]) -> None:
         """
         Sets a cached path for a given root object and resolver name.
 
@@ -235,26 +251,32 @@ class Resolver:
             name (str): The name of the resolver cache to set.
             path (str): The path to cache.
         """
+        if root is None:
+            return
+
         with Resolver.__CACHE_LOCK:
             root_id = Resolver.__get_root_id(root)
             if root_id not in Resolver.__CACHE:
                 Resolver.__CACHE[root_id] = {}
-            Resolver.__CACHE[root_id][name] = path
+            Resolver.__CACHE[root_id][name] = str(path)
 
     @staticmethod
-    def reset_cache(root):
+    def reset_cache(root: Optional[Union["Project", "BaseSchema"]]) -> None:
         """
         Resets the entire cache for a given root object.
 
         Args:
             root: The root object whose cache will be cleared.
         """
+        if root is None:
+            return
+
         with Resolver.__CACHE_LOCK:
             root_id = Resolver.__get_root_id(root)
             if root_id in Resolver.__CACHE:
                 del Resolver.__CACHE[root_id]
 
-    def get_path(self):
+    def get_path(self) -> str:
         """
         Resolves the data source and returns its local path.
 
@@ -267,7 +289,7 @@ class Resolver:
         Raises:
             FileNotFoundError: If the resolved path does not exist.
         """
-        cache_path = Resolver.get_cache(self.__root, self.cache_id)
+        cache_path: Optional[str] = Resolver.get_cache(self.__root, self.cache_id)
         if cache_path:
             return cache_path
 
@@ -281,9 +303,9 @@ class Resolver:
             self.logger.info(f'Found {self.name} data at {path}')
 
         Resolver.set_cache(self.__root, self.cache_id, path)
-        return path
+        return str(path)
 
-    def __resolve_env(self, path):
+    def __resolve_env(self, path: str) -> str:
         """Expands environment variables and user home directory in a path."""
         env_save = os.environ.copy()
 
@@ -313,26 +335,29 @@ class RemoteResolver(Resolver):
     _CACHE_LOCKS = {}
     _CACHE_LOCK = threading.Lock()
 
-    def __init__(self, name, root, source, reference=None):
+    def __init__(self, name: str,
+                 root: Optional[Union["Project", "BaseSchema"]],
+                 source: str,
+                 reference: Optional[str] = None):
         if reference is None:
             raise ValueError(f'A reference (e.g., version, commit) is required for {name}')
 
         super().__init__(name, root, source, reference)
 
         # Wait a maximum of 10 minutes for other processes to finish
-        self.__max_lock_wait = 60 * 10
+        self.__max_lock_wait: int = 60 * 10
 
     @property
-    def timeout(self):
+    def timeout(self) -> int:
         """The maximum time in seconds to wait for a lock."""
         return self.__max_lock_wait
 
-    def set_timeout(self, value):
+    def set_timeout(self, value: int) -> None:
         """Sets the maximum time in seconds to wait for a lock."""
         self.__max_lock_wait = value
 
     @staticmethod
-    def determine_cache_dir(root) -> Path:
+    def determine_cache_dir(root: Optional[Union["Project", "BaseSchema"]]) -> Path:
         """
         Determines the directory for the on-disk cache.
 
@@ -401,7 +426,7 @@ class RemoteResolver(Resolver):
 
         return self.cache_dir / f"{self.cache_name}.sc_lock"
 
-    def thread_lock(self):
+    def thread_lock(self) -> threading.Lock:
         """Gets a threading.Lock specific to this resolver instance."""
         with RemoteResolver._CACHE_LOCK:
             if self.name not in RemoteResolver._CACHE_LOCKS:
@@ -479,11 +504,11 @@ class RemoteResolver(Resolver):
             with self.__file_lock():
                 yield
 
-    def resolve_remote(self):
+    def resolve_remote(self) -> None:
         """Abstract method to fetch the remote data."""
         raise NotImplementedError("child class must implement this")
 
-    def check_cache(self):
+    def check_cache(self) -> bool:
         """
         Abstract method to check if the on-disk cache is valid.
 
@@ -492,7 +517,7 @@ class RemoteResolver(Resolver):
         """
         raise NotImplementedError("child class must implement this")
 
-    def resolve(self) -> Path:
+    def resolve(self) -> Union[str, Path]:
         """
         Resolves the remote data, using the on-disk cache if possible.
 
@@ -531,7 +556,7 @@ class FileResolver(Resolver):
     It normalizes the source string to a `file://` URI.
     """
 
-    def __init__(self, name, root, source, reference=None):
+    def __init__(self, name: str, root: "Project", source: str, reference: Optional[str] = None):
         if source.startswith("file://"):
             source = source[7:]
         if source[0] != "$" and not os.path.isabs(source):
@@ -540,14 +565,17 @@ class FileResolver(Resolver):
         super().__init__(name, root, f"file://{source}", None)
 
     @property
-    def urlpath(self):
+    def urlpath(self) -> str:
         """The absolute file path, stripped of the 'file://' prefix."""
         # Rebuild URL and remove scheme prefix
         return self.urlparse.geturl()[7:]
 
-    def resolve(self):
+    def resolve(self) -> str:
         """Returns the absolute path to the file."""
-        return os.path.abspath(self.urlpath)
+        path = self.urlpath
+        if path and path[0] == "$":
+            return path
+        return os.path.abspath(path)
 
 
 class PythonPathResolver(Resolver):
@@ -559,12 +587,12 @@ class PythonPathResolver(Resolver):
     determine if a package is installed in "editable" mode.
     """
 
-    def __init__(self, name, root, source, reference=None):
+    def __init__(self, name: str, root: "Project", source: str, reference: Optional[str] = None):
         super().__init__(name, root, source, None)
 
     @staticmethod
     @functools.lru_cache(maxsize=1)
-    def get_python_module_mapping():
+    def get_python_module_mapping() -> Dict[str, List[str]]:
         """
         Creates a mapping from importable module names to their distribution names.
 
@@ -592,13 +620,13 @@ class PythonPathResolver(Resolver):
 
             provides = dist.read_text('top_level.txt')
             if provides:
-                for module in dist.read_text('top_level.txt').split():
+                for module in provides.split():
                     mapping.setdefault(module, []).append(dist_name)
 
         return mapping
 
     @staticmethod
-    def is_python_module_editable(module_name):
+    def is_python_module_editable(module_name: str) -> bool:
         """
         Checks if a Python module is installed in "editable" mode.
 
@@ -630,12 +658,12 @@ class PythonPathResolver(Resolver):
         return is_editable
 
     @staticmethod
-    def set_dataroot(root,
-                     package_name,
-                     python_module,
-                     alternative_path,
-                     alternative_ref=None,
-                     python_module_path_append=None):
+    def set_dataroot(root: "PathSchema",
+                     package_name: str,
+                     python_module: str,
+                     alternative_path: str,
+                     alternative_ref: Optional[str] = None,
+                     python_module_path_append: Optional[str] = None):
         """
         Helper to conditionally set a dataroot to a Python module or a fallback path.
         """
@@ -652,7 +680,7 @@ class PythonPathResolver(Resolver):
 
         root.set_dataroot(package_name, path=path, tag=ref)
 
-    def resolve(self):
+    def resolve(self) -> str:
         """
         Resolves the path to the specified Python module.
 
@@ -672,10 +700,10 @@ class KeyPathResolver(Resolver):
     `find_files` method of the root project object to locate the corresponding file.
     """
 
-    def __init__(self, name, root, source, reference=None):
+    def __init__(self, name: str, root: "Project", source: str, reference: Optional[str] = None):
         super().__init__(name, root, source, None)
 
-    def resolve(self):
+    def resolve(self) -> str:
         """
         Resolves the path by looking up the keypath in the project schema.
 

siliconcompiler/package/git.py

@@ -8,11 +8,16 @@ branches, tags, or commit hashes), and managing the cached repository's state.
 import shutil
 import os.path
 
+from typing import Dict, Type, Optional, Union, TYPE_CHECKING
+
 from git import Repo, GitCommandError
 from siliconcompiler.package import RemoteResolver
 
+if TYPE_CHECKING:
+    from siliconcompiler.project import Project
+
 
-def get_resolver():
+def get_resolver() -> Dict[str, Type["GitResolver"]]:
     """
     Returns a dictionary mapping Git-related URI schemes to the GitResolver class.
 
@@ -40,13 +45,13 @@ class GitResolver(RemoteResolver):
     for SSH-based URLs.
     """
 
-    def __init__(self, name, root, source, reference=None):
+    def __init__(self, name: str, root: "Project", source: str, reference: Optional[str] = None):
         """
         Initializes the GitResolver.
         """
         super().__init__(name, root, source, reference)
 
-    def check_cache(self):
+    def check_cache(self) -> bool:
         """
         Checks if a valid, clean Git repository exists at the cache path.
 
@@ -69,7 +74,7 @@ class GitResolver(RemoteResolver):
                 return False
         return False
 
-    def __get_token_env(self):
+    def __get_token_env(self) -> Union[None, str]:
         """
         Searches for a Git authentication token in predefined environment variables.
 
@@ -99,7 +104,7 @@ class GitResolver(RemoteResolver):
         return None
 
     @property
-    def git_path(self):
+    def git_path(self) -> str:
         """
         Constructs the final Git URL for cloning.
 
@@ -123,7 +128,7 @@ class GitResolver(RemoteResolver):
         url = url._replace(scheme='https')
         return url.geturl()
 
-    def resolve_remote(self):
+    def resolve_remote(self) -> None:
         """
         Fetches the remote repository and checks out the specified reference.
 

siliconcompiler/package/github.py

@@ -6,13 +6,18 @@ release assets from public or private GitHub repositories.
 """
 import os
 
+from typing import Dict, Type, Optional, Tuple, TYPE_CHECKING
+
 from github import Github, Auth
 from github.GithubException import UnknownObjectException
 
 from siliconcompiler.package.https import HTTPResolver
 
+if TYPE_CHECKING:
+    from siliconcompiler.project import Project
+
 
-def get_resolver():
+def get_resolver() -> Dict[str, Type["GithubResolver"]]:
     """
     Returns a dictionary mapping GitHub URI schemes to the GithubResolver class.
 
@@ -43,7 +48,7 @@ class GithubResolver(HTTPResolver):
     a GitHub token must be provided via environment variables.
     """
 
-    def __init__(self, name, root, source, reference=None):
+    def __init__(self, name: str, root: "Project", source: str, reference: Optional[str] = None):
         """
         Initializes the GithubResolver.
         """
@@ -55,7 +60,7 @@ class GithubResolver(HTTPResolver):
                 "github://<owner>/<repository>/<version>/<artifact>")
 
     @property
-    def gh_path(self):
+    def gh_path(self) -> Tuple[str, ...]:
         """
         Parses the source URL into its constituent GitHub parts.
 
@@ -65,7 +70,7 @@ class GithubResolver(HTTPResolver):
         return self.urlpath, *self.urlparse.path.split("/")[1:]
 
     @property
-    def download_url(self):
+    def download_url(self) -> str:
         """
         Determines the direct download URL for the GitHub release asset.
 
@@ -93,7 +98,7 @@ class GithubResolver(HTTPResolver):
             self.logger.info("Could not find public release, trying private.")
             return self.__get_release_url(repository, release, artifact, private=True)
 
-    def __get_release_url(self, repository, release, artifact, private: bool):
+    def __get_release_url(self, repository: str, release: str, artifact: str, private: bool) -> str:
         """
         Uses the GitHub API to find the download URL for a specific release asset.
 
@@ -133,7 +138,7 @@ class GithubResolver(HTTPResolver):
 
         raise ValueError(f'Unable to find release asset: {repository}/{release}/{artifact}')
 
-    def __get_gh_auth(self):
+    def __get_gh_auth(self) -> str:
         """
         Searches for a GitHub authentication token in predefined environment variables.
 

siliconcompiler/package/https.py

@@ -11,13 +11,15 @@ import zipfile
 
 import os.path
 
+from typing import Dict, Type
+
 from io import BytesIO
 from urllib.parse import urlparse
 
 from siliconcompiler.package import RemoteResolver
 
 
-def get_resolver():
+def get_resolver() -> Dict[str, Type["HTTPResolver"]]:
     """
     Returns a dictionary mapping HTTP schemes to the HTTPResolver class.
 
@@ -43,7 +45,7 @@ class HTTPResolver(RemoteResolver):
     of archives downloaded from GitHub.
     """
 
-    def check_cache(self):
+    def check_cache(self) -> bool:
         """
         Checks if the data has already been cached.
 
@@ -56,7 +58,7 @@ class HTTPResolver(RemoteResolver):
         return os.path.exists(self.cache_path)
 
     @property
-    def download_url(self):
+    def download_url(self) -> str:
         """
         Constructs the final download URL.
 
@@ -71,7 +73,7 @@ class HTTPResolver(RemoteResolver):
             data_url = f"{data_url}{self.reference}.tar.gz"
         return data_url
 
-    def resolve_remote(self):
+    def resolve_remote(self) -> None:
         """
         Fetches the remote archive, unpacks it, and stores it in the cache.
 

siliconcompiler/pdk.py

@@ -1,6 +1,6 @@
 import math
 
-from typing import Tuple
+from typing import Tuple, Optional, Union, List
 
 from siliconcompiler.schema import EditableSchema, Parameter, Scope, BaseSchema
 from siliconcompiler.schema.utils import trim
@@ -20,7 +20,7 @@ class PDK(ToolLibrarySchema):
     ToolLibrarySchema to provide a standardized way of describing and
     accessing PDK data within the SiliconCompiler framework.
     """
-    def __init__(self, name: str = None):
+    def __init__(self, name: Optional[str] = None):
         """
         Initializes a PDK object.
 
@@ -405,7 +405,7 @@ class PDK(ToolLibrarySchema):
         """
         return self.set("pdk", "edgemargin", margin)
 
-    def set_aprroutinglayers(self, min: str = None, max: str = None):
+    def set_aprroutinglayers(self, min: Optional[str] = None, max: Optional[str] = None):
         """
         Sets the minimum and maximum routing layers for the PDK.
 
@@ -418,7 +418,8 @@ class PDK(ToolLibrarySchema):
         if max:
             self.set("pdk", "maxlayer", max)
 
-    def add_aprtechfileset(self, tool: str, fileset: str = None, clobber: bool = False):
+    def add_aprtechfileset(self, tool: str, fileset: Optional[Union[List[str], str]] = None,
+                           clobber: bool = False):
         """
         Adds a fileset containing APR technology files.
 
@@ -438,7 +439,8 @@ class PDK(ToolLibrarySchema):
         else:
             return self.add("pdk", "aprtechfileset", tool, fileset)
 
-    def add_layermapfileset(self, tool: str, src: str, dst: str, fileset: str = None,
+    def add_layermapfileset(self, tool: str, src: str, dst: str,
+                            fileset: Optional[Union[List[str], str]] = None,
                             clobber: bool = False):
         """
         Adds a fileset containing layer map files.
@@ -461,7 +463,8 @@ class PDK(ToolLibrarySchema):
         else:
             return self.add("pdk", "layermapfileset", tool, src, dst, fileset)
 
-    def add_displayfileset(self, tool: str, fileset: str = None, clobber: bool = False):
+    def add_displayfileset(self, tool: str, fileset: Optional[Union[List[str], str]] = None,
+                           clobber: bool = False):
         """
         Adds a fileset containing display configuration files.
 
@@ -481,7 +484,8 @@ class PDK(ToolLibrarySchema):
         else:
             return self.add("pdk", "displayfileset", tool, fileset)
 
-    def add_devmodelfileset(self, tool: str, type: str, fileset: str = None,
+    def add_devmodelfileset(self, tool: str, type: str,
+                            fileset: Optional[Union[List[str], str]] = None,
                             clobber: bool = False):
         """
         Adds a fileset containing device model files.
@@ -503,7 +507,8 @@ class PDK(ToolLibrarySchema):
         else:
             return self.add("pdk", "devmodelfileset", tool, type, fileset)
 
-    def add_pexmodelfileset(self, tool: str, corner: str, fileset: str = None,
+    def add_pexmodelfileset(self, tool: str, corner: str,
+                            fileset: Optional[Union[List[str], str]] = None,
                             clobber: bool = False):
         """
         Adds a fileset containing parasitic extraction (pex) model files.
@@ -525,7 +530,8 @@ class PDK(ToolLibrarySchema):
         else:
             return self.add("pdk", "pexmodelfileset", tool, corner, fileset)
 
-    def add_runsetfileset(self, type: str, tool: str, name: str, fileset: str = None,
+    def add_runsetfileset(self, type: str, tool: str, name: str,
+                          fileset: Optional[Union[List[str], str]] = None,
                           clobber: bool = False):
         """
         Adds a fileset containing a runset for a specific verification task.
@@ -548,7 +554,8 @@ class PDK(ToolLibrarySchema):
         else:
             return self.add("pdk", type, "runsetfileset", tool, name, fileset)
 
-    def add_waiverfileset(self, type: str, tool: str, name: str, fileset: str = None,
+    def add_waiverfileset(self, type: str, tool: str, name: str,
+                          fileset: Optional[Union[List[str], str]] = None,
                           clobber: bool = False):
         """
         Adds a fileset containing waiver files for a specific verification task.
@@ -601,7 +608,7 @@ class PDK(ToolLibrarySchema):
             >>> yield = pdk.calc_yield(1500.0)
             # Calculates yield for a 1500 um^2 die.
         '''
-        d0 = self.get('pdk', 'd0')
+        d0: Optional[float] = self.get('pdk', 'd0')
         if d0 is None:
             raise ValueError(f"[{','.join([*self._keypath, 'pdk', 'd0'])}] has not been set")
 
@@ -641,16 +648,16 @@ class PDK(ToolLibrarySchema):
             # Calculates dies per wafer for a 1000x1500 um die.
         '''
         # PDK information
-        wafersize = self.get('pdk', 'wafersize')
+        wafersize: Optional[float] = self.get('pdk', 'wafersize')
 
         if wafersize is None:
             raise ValueError(f"[{','.join([*self._keypath, 'pdk', 'wafersize'])}] has not been set")
 
-        edgemargin = self.get('pdk', 'edgemargin')
+        edgemargin: Optional[float] = self.get('pdk', 'edgemargin')
         if edgemargin is None:
             edgemargin = 0.0
 
-        scribe = self.get('pdk', 'scribe')
+        scribe: Tuple[Optional[float], Optional[float]] = self.get('pdk', 'scribe')
         if scribe:
             hscribe, vscribe = scribe
         else:
@@ -709,13 +716,13 @@ class PDK(ToolLibrarySchema):
 
     def _generate_doc(self, doc,
                       ref_root: str = "",
-                      key_offset: Tuple[str] = None,
+                      key_offset: Optional[Tuple[str, ...]] = None,
                       detailed: bool = True):
         from .schema.docs.utils import build_section
         docs = []
 
         if not key_offset:
-            key_offset = ["PDK"]
+            key_offset = ("PDK",)
 
         # Show dataroot
         dataroot = PathSchema._generate_doc(self, doc, ref_root)