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

siliconcompiler/flows/showflow.py

@@ -1,6 +1,5 @@
 from siliconcompiler import Flowgraph
 from siliconcompiler import ShowTask
-from siliconcompiler.tools import get_task
 
 
 class ShowFlow(Flowgraph):
@@ -31,5 +30,5 @@ class ShowFlow(Flowgraph):
 ##################################################
 if __name__ == "__main__":
     from siliconcompiler import ShowTask
-    flow = ShowFlow(get_task(ShowTask, "gds"))
+    flow = ShowFlow(ShowTask.get_task("gds"))
     flow.write_flowgraph(f"{flow.name}.png")

siliconcompiler/library.py

@@ -7,7 +7,7 @@ from siliconcompiler.schema_support.filesetschema import FileSetSchema
 from siliconcompiler.schema_support.pathschema import PathSchema
 from siliconcompiler.schema import NamedSchema, BaseSchema
 
-from siliconcompiler.schema import EditableSchema, Parameter, Scope, PerNode
+from siliconcompiler.schema import EditableSchema, Parameter, Scope, PerNode, LazyLoad
 from siliconcompiler.schema.utils import trim
 
 
@@ -99,7 +99,8 @@ class ToolLibrarySchema(LibrarySchema):
 
     def _from_dict(self, manifest: Dict,
                    keypath: Union[List[str], Tuple[str, ...]],
-                   version: Optional[Tuple[int, ...]] = None) \
+                   version: Optional[Tuple[int, ...]] = None,
+                   lazyload: LazyLoad = LazyLoad.ON) \
             -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
         """
         Constructs a schema from a dictionary.
@@ -112,7 +113,7 @@ class ToolLibrarySchema(LibrarySchema):
         Returns:
             dict: The constructed dictionary.
         """
-        if "tool" in manifest:
+        if not lazyload.is_enforced and "tool" in manifest:
             # collect tool keys
             tool_keys = self.allkeys("tool")
 
@@ -136,7 +137,7 @@ class ToolLibrarySchema(LibrarySchema):
             if not manifest["tool"]:
                 del manifest["tool"]
 
-        return super()._from_dict(manifest, keypath, version)
+        return super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
 
     def _generate_doc(self, doc,
                       ref_root: str = "",
@@ -196,7 +197,7 @@ class ToolLibrarySchema(LibrarySchema):
         return None
 
 
-class StdCellLibrary(ToolLibrarySchema, DependencySchema):
+class StdCellLibrary(DependencySchema, ToolLibrarySchema):
     """
     A class for managing standard cell library schemas.
     """

siliconcompiler/package/https.py

@@ -114,11 +114,16 @@ class HTTPResolver(RemoteResolver):
         except tarfile.ReadError:
             fileobj.seek(0)
             try:
-                with zipfile.ZipFile(fileobj) as zip_ref:
-                    zip_ref.extractall(path=self.cache_path)
-            except zipfile.BadZipFile:
-                raise TypeError(f"Could not extract file from {data_url}. "
-                                "File is not a valid tar.gz or zip archive.")
+                with tarfile.open(fileobj=fileobj, mode='r:bz2') as tar_ref:
+                    tar_ref.extractall(path=self.cache_path)
+            except tarfile.ReadError:
+                fileobj.seek(0)
+                try:
+                    with zipfile.ZipFile(fileobj) as zip_ref:
+                        zip_ref.extractall(path=self.cache_path)
+                except zipfile.BadZipFile:
+                    raise TypeError(f"Could not extract file from {data_url}. "
+                                    "File is not a valid tar.gz or zip archive.")
 
         # --- GitHub-specific directory flattening ---
         # GitHub archives often have a single top-level directory like 'repo-v1.0'.

siliconcompiler/project.py

@@ -5,10 +5,11 @@ import uuid
 
 import os.path
 
-from typing import Union, List, Tuple, TextIO
+from typing import Union, List, Tuple, TextIO, Optional, Dict, Set
 
 from siliconcompiler.schema import BaseSchema, NamedSchema, EditableSchema, Parameter, Scope, \
-    __version__ as schema_version
+    __version__ as schema_version, \
+    LazyLoad
 
 from siliconcompiler import Design
 from siliconcompiler import Flowgraph
@@ -32,7 +33,6 @@ from siliconcompiler.utils import get_file_ext
 from siliconcompiler.utils.multiprocessing import MPManager
 from siliconcompiler.utils.paths import jobdir, workdir
 from siliconcompiler.flows.showflow import ShowFlow
-from siliconcompiler.tools import get_task
 
 
 class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
@@ -43,7 +43,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
     and reporting.
     """
 
-    def __init__(self, design: Union[Design, str] = None):
+    def __init__(self, design: Optional[Union[Design, str]] = None):
         """
         Initializes a new Project instance.
 
@@ -108,7 +108,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
                 is not intended for external use."""))
 
         schema.insert("checklist", "default", Checklist())
-        schema.insert("library", BaseSchema())
+        schema.insert("library", _ProjectLibrary())
         schema.insert("flowgraph", "default", Flowgraph())
         schema.insert("metric", MetricSchema())
         schema.insert("record", RecordSchema())
@@ -290,26 +290,11 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         """
         return Project.__name__
 
-    def __populate_deps(self, obj: DependencySchema = None):
-        """
-        Ensures that all loaded dependencies (like libraries) within the project
-        contain correct internal pointers back to the project's libraries.
-        This is crucial for maintaining a consistent and navigable schema graph.
-
-        Args:
-            obj (DependencySchema, optional): An optional dependency object to
-                reset and populate. If None, all existing library dependencies
-                in the project are processed. Defaults to None.
-        """
-        if obj:
-            obj._reset_deps()
-        dep_map = {name: self.get("library", name, field="schema")
-                   for name in self.getkeys("library")}
-        for obj in dep_map.values():
-            if isinstance(obj, DependencySchema):
-                obj._populate_deps(dep_map)
-
-    def _from_dict(self, manifest, keypath, version=None):
+    def _from_dict(self, manifest: Dict,
+                   keypath: Union[List[str], Tuple[str, ...]],
+                   version: Optional[Tuple[int, ...]] = None,
+                   lazyload: LazyLoad = LazyLoad.ON) \
+            -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
         """
         Populates the project's schema from a dictionary representation.
 
@@ -326,15 +311,13 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         Returns:
             Any: The result of the superclass's `_from_dict` method.
         """
-        ret = super()._from_dict(manifest, keypath, version)
-
-        # Restore dependencies
-        self.__populate_deps()
+        ret = super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
 
-        # Preserve logger in history
-        for history in self.getkeys("history"):
-            hist = self.get("history", history, field="schema")
-            hist.__logger = self.__logger
+        if not lazyload.is_enforced:
+            # Preserve logger in history
+            for history in self.getkeys("history"):
+                hist: "Project" = self.get("history", history, field="schema")
+                hist.__logger = self.__logger
 
         return ret
 
@@ -393,7 +376,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
                 self.add_dep(dep)
 
             # Rebuild dependencies to ensure instances are correct
-            self.__populate_deps(obj)
+            self.get("library", field="schema")._populate_deps(obj)
 
     def __import_flow(self, flow: Flowgraph):
         """
@@ -665,6 +648,9 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         # Pass along manager address
         state["__manager__"] = MPManager._get_manager_address()
 
+        # Pass along logger level
+        state["__loglevel__"] = self.logger.level
+
         return state
 
     def __setstate__(self, state):
@@ -677,6 +663,10 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         Args:
             state (dict): The deserialized state of the object.
         """
+        # Retrieve log level
+        loglevel = state["__loglevel__"]
+        del state["__loglevel__"]
+
         # Retrieve manager address
         MPManager._set_manager_address(state["__manager__"])
         del state["__manager__"]
@@ -685,6 +675,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
 
         # Reinitialize logger on restore
         self.__init_logger()
+        self.logger.setLevel(loglevel)
 
         # Restore callbacks
         self.__init_option_callbacks()
@@ -1155,7 +1146,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         '''
         tool_cls = ScreenshotTask if screenshot else ShowTask
 
-        sc_jobname = self.get("option", "jobname")
+        sc_jobname = self.option.get_jobname()
         sc_step, sc_index = None, None
 
         has_filename = filename is not None
@@ -1220,12 +1211,13 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
             return None
 
         # Create copy of project to avoid changing user project
-        proj = self.copy()
+        proj: Project = self.copy()
         proj.set_flow(ShowFlow(task))
 
         # Setup options:
         for option, value in [
                 ("track", False),
+                ("remote", False),
                 ("hash", False),
                 ("nodisplay", False),
                 ("continue", True),
@@ -1242,7 +1234,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         proj.set("option", "jobname", jobname)
 
         # Setup in task variables
-        task: ShowTask = get_task(proj, filter=task.__class__)
+        task: ShowTask = task.find_task(proj)
         task.set_showfilepath(filename)
         task.set_showfiletype(filetype)
         task.set_shownode(jobname=sc_jobname, step=sc_step, index=sc_index)
@@ -1277,3 +1269,61 @@ class Lint(Project):
     @classmethod
     def _getdict_type(cls) -> str:
         return Lint.__name__
+
+
+class _ProjectLibrary(BaseSchema):
+    def _from_dict(self, manifest: Dict,
+                   keypath: Union[List[str], Tuple[str, ...]],
+                   version: Optional[Tuple[int, ...]] = None,
+                   lazyload: LazyLoad = LazyLoad.ON) \
+            -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
+        """
+        Populates the project's schema from a dictionary representation.
+
+        This method is typically used during deserialization or when loading
+        a project state from a manifest. After loading the data, it ensures
+        that internal dependencies are correctly re-established.
+
+        Args:
+            manifest (dict): The dictionary containing the schema data.
+            keypath (list): The current keypath being processed (used internally
+                            for recursive loading).
+            version (str, optional): The schema version of the manifest. Defaults to None.
+
+        Returns:
+            Any: The result of the superclass's `_from_dict` method.
+        """
+        ret = super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
+
+        if not lazyload.is_enforced:
+            # Restore dependencies
+            self._populate_deps(complete=True)
+
+        return ret
+
+    def _populate_deps(self, obj: Optional[DependencySchema] = None, complete: bool = False):
+        """
+        Ensures that all loaded dependencies (like libraries) within the project
+        contain correct internal pointers back to the project's libraries.
+        This is crucial for maintaining a consistent and navigable schema graph.
+
+        Args:
+            obj (DependencySchema, optional): An optional dependency object to
+                reset and populate. If None, all existing library dependencies
+                in the project are processed. Defaults to None.
+            complete (bool, optional): If True, performs a full reset of all
+                DependencySchema objects before populating dependencies. This
+                ensures a clean state during manifest deserialization. Defaults to False.
+        """
+        if obj:
+            obj._reset_deps()
+        dep_map = {name: self.get(name, field="schema") for name in self.getkeys()}
+
+        if complete:
+            for obj in dep_map.values():
+                if isinstance(obj, DependencySchema):
+                    obj._reset_deps()
+
+        for obj in dep_map.values():
+            if isinstance(obj, DependencySchema):
+                obj._populate_deps(dep_map)

siliconcompiler/remote/client.py

@@ -18,7 +18,8 @@ from siliconcompiler import NodeStatus as SCNodeStatus
 from siliconcompiler._metadata import default_server
 from siliconcompiler.flowgraph import RuntimeFlowgraph
 from siliconcompiler.scheduler import Scheduler
-from siliconcompiler.schema import Journal
+from siliconcompiler.schema import Journal, Parameter
+from siliconcompiler.package import PythonPathResolver, FileResolver, KeyPathResolver
 
 from siliconcompiler.utils.logging import get_console_formatter
 from siliconcompiler.utils.curation import collect
@@ -573,19 +574,29 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
 
         # Ensure dataroots with python sources are copied
         for key in self.__project.allkeys():
-            key_type = self.__project.get(*key, field='type')
+            if key[0] == "history":
+                continue
+
+            param: Parameter = self.__project.get(*key, field=None)
+            key_type: str = param.get(field="type")
 
             if 'dir' in key_type or 'file' in key_type:
-                for _, step, index in self.__project.get(*key, field=None).getvalues(
-                        return_defvalue=False):
-                    dataroots = self.__project.get(*key, field='dataroot', step=step, index=index)
+                schema_obj = self.__project.get(*key[:-1], field="schema")
+                dataroot_objs = schema_obj._find_files_dataroot_resolvers(True)
+
+                for value, step, index in param.getvalues():
+                    if not value:
+                        continue
+                    dataroots = param.get(field='dataroot', step=step, index=index)
                     if not isinstance(dataroots, list):
                         dataroots = [dataroots]
                     force_copy = False
                     for dataroot in dataroots:
                         if not dataroot:
                             continue
-                        if dataroot.startswith('python://'):
+                        dataroot_resolver = dataroot_objs.get(dataroot, None)
+                        if isinstance(dataroot_resolver,
+                                      (PythonPathResolver, FileResolver, KeyPathResolver)):
                             force_copy = True
                     if force_copy:
                         self.__project.set(*key, True, field='copy', step=step, index=index)