siliconcompiler 0.36.1__tar.gz → 0.36.3__tar.gz

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/Changes

@@ -8,6 +8,32 @@ The changes in each SiliconCompiler release version are described below. Commit
 version shown in (). Where applicable, the contributors that suggested a given
 feature are shown in [].
 
+SiliconCompiler 0.36.3 (2026-01-21)
+=========================================
+
+**Minor:**
+
+ * Tools:
+
+  * builtin: added wait task to better handle stalling flow progress
+  * klayout: added merge task to provide a simple interface for merging multiple GDSs
+  * pyslang: updated to v10.0.0
+
+
+SiliconCompiler 0.36.2 (2026-01-16)
+=========================================
+
+**Minor:**
+
+ * Corrected auto dataroot behavior when setting abs paths.
+ * Corrected logging during check_filepaths on design objects to ensure errors are printed.
+ * Added `.get_library` to Project to allow access to imported libraries.
+
+ * Tools:
+
+  * openroad: added option to bypass SDC loading.
+
+
 SiliconCompiler 0.36.1 (2026-01-10)
 =========================================
 

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: siliconcompiler
-Version: 0.36.1
+Version: 0.36.3
 Summary: A compiler framework that automates translation from source code to silicon.
 Author: Zero ASIC
 License: Apache License 2.0
@@ -38,12 +38,12 @@ Requires-Dist: PyYAML<7.0.0,>=6.0.0
 Requires-Dist: GitPython<3.2,>=3.1.44
 Requires-Dist: PyGithub<2.9.0,>=2.8.0
 Requires-Dist: urllib3>=1.26.0
-Requires-Dist: lambdapdk>=0.2.6
+Requires-Dist: lambdapdk>=0.2.7
 Requires-Dist: fasteners>=0.20
 Requires-Dist: pandas>=1.1.5
 Requires-Dist: psutil>=5.8.0
 Requires-Dist: Jinja2>=2.11.3
-Requires-Dist: pyslang==9.1.0
+Requires-Dist: pyslang==10.0.0
 Requires-Dist: importlib_metadata; python_version < "3.10"
 Requires-Dist: streamlit==1.46.1; python_full_version != "3.9.7"
 Requires-Dist: streamlit_agraph==0.0.45; python_full_version != "3.9.7"

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/pyproject.toml

@@ -45,14 +45,14 @@ dependencies = [
     "PyGithub >= 2.8.0, < 2.9.0",
     "urllib3 >= 1.26.0", # Required for PyGithub
 
-    "lambdapdk >= 0.2.6",
+    "lambdapdk >= 0.2.7",
 
     "fasteners >= 0.20",
     "pandas >= 1.1.5",
     "psutil >= 5.8.0",
     "Jinja2 >= 2.11.3",
 
-    "pyslang == 9.1.0",
+    "pyslang == 10.0.0",
 
     "importlib_metadata; python_version < '3.10'",
 

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/scripts/.gitignore

@@ -1,4 +1,5 @@
 /build
 /*.png
+/*.dot
 /*.xlsx
 /*#

siliconcompiler-0.36.3/scripts/class_hierarchy.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+import inspect
+import importlib
+from argparse import ArgumentParser
+
+try:
+    import graphviz
+    _has_graphviz = True
+except ModuleNotFoundError:
+    _has_graphviz = False
+
+
+# Import all the classes
+from siliconcompiler import (Project, ASIC, FPGA, Lint, Sim, Design, PDK,
+                             Flowgraph, Checklist, StdCellLibrary, FPGADevice,
+                             Task, ShowTask, ScreenshotTask, Schematic)
+from siliconcompiler.asic import ASICTask
+from siliconcompiler.constraints import (ASICTimingConstraintSchema, ASICAreaConstraint,
+                                         ASICComponentConstraints, ASICPinConstraints,
+                                         FPGAComponentConstraints, FPGAPinConstraints,
+                                         FPGATimingConstraintSchema)
+from siliconcompiler.schema_support import metric, record, option
+from siliconcompiler.library import ToolLibrarySchema
+
+
+def generate_class_hierarchy(classes, output_file="class_hierarchy"):
+    """
+    Generates a class inheritance graph using graphviz.
+    """
+    if not _has_graphviz:
+        raise RuntimeError("Graphviz is not installed."
+                           " Please install it to generate class hierarchy graphs.")
+
+    dot = graphviz.Digraph('SiliconCompiler Class Hierarchy',
+                           comment='SiliconCompiler Class Hierarchy')
+    dot.attr('graph', rankdir='RL', concentrate='true')
+    dot.attr('node', shape='box', style='rounded,filled')
+
+    SCHEMA_COLOR = "#fff8dc"  # cornsilk
+    SCHEMA_SUPPORT_COLOR = "#add8e6"  # lightblue
+    DEFAULT_COLOR = "#d3d3d3"  # lightgrey
+
+    # Classes exposed at the top-level of the siliconcompiler package
+    TOP_LEVEL_CLASSES = {
+        'Project', 'ASIC', 'FPGA', 'Lint', 'Sim', 'Design', 'PDK',
+        'Flowgraph', 'Checklist', 'StdCellLibrary', 'FPGADevice',
+        'Task', 'ShowTask', 'ScreenshotTask', 'Schematic'
+    }
+
+    added_nodes = set()
+
+    all_mro_classes = set()
+    for cls in classes:
+        mro = [c for c in inspect.getmro(cls) if 'siliconcompiler' in c.__module__ or c is cls]
+        all_mro_classes.update(mro)
+
+    # Create a subgraph for top-level classes to cluster them
+    with dot.subgraph(name='cluster_api') as c:
+        c.attr(label='SiliconCompiler API', style='filled', color='#f0f0f0', fontcolor='black')
+
+        for cls in all_mro_classes:
+            if cls.__name__ not in added_nodes:
+                module_name = cls.__module__
+                if module_name.startswith('siliconcompiler.schema.'):
+                    color = SCHEMA_COLOR
+                elif module_name.startswith('siliconcompiler.schema_support.'):
+                    color = SCHEMA_SUPPORT_COLOR
+                else:
+                    color = DEFAULT_COLOR
+
+                # Add node to the cluster or the main graph
+                if cls.__name__ in TOP_LEVEL_CLASSES:
+                    c.node(cls.__name__, fillcolor=color)
+                else:
+                    dot.node(cls.__name__, fillcolor=color)
+                added_nodes.add(cls.__name__)
+    edges = []
+    for cls in all_mro_classes:
+        for base in cls.__bases__:
+            if 'siliconcompiler' not in base.__module__:
+                continue
+            if (base.__name__, cls.__name__) in edges:
+                continue
+            edges.append((base.__name__, cls.__name__))
+            # Add edge
+            dot.edge(f"{base.__name__}:w", f"{cls.__name__}:e")
+    # Save the dot file and render a PNG
+    try:
+        dot.render(output_file, view=False, format='png', cleanup=True)
+        print(f"Generated class hierarchy graph at {output_file}.png")
+    except graphviz.ExecutableNotFound:
+        print("Graphviz executable not found. Please install it and add it to your PATH.")
+        print("On Debian/Ubuntu: sudo apt-get install graphviz")
+        print("On macOS (with Homebrew): brew install graphviz")
+
+    with open(f"{output_file}.dot", 'w') as f:
+        f.write(dot.source)
+    print(f"Generated dot file at {output_file}.dot")
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser(
+        description="Generate a class inheritance graph for SiliconCompiler classes.")
+    parser.add_argument("cls", nargs="?",
+                        help="A specific class to graph in module/ClassName format "
+                             "(e.g., siliconcompiler/Project).")
+    parser.add_argument("--output", default="class_hierarchy",
+                        help="Output file name without extension.")
+    args = parser.parse_args()
+
+    if args.cls:
+        module, cls_name = args.cls.split("/")
+        classes_to_graph = [getattr(importlib.import_module(module), cls_name)]
+    else:
+        # The list of classes from methods.py
+        classes_to_graph = [
+            Project, ASIC, FPGA, Lint, Sim,
+            Design, PDK, Flowgraph, Checklist, StdCellLibrary, FPGADevice, Schematic,
+            Task, ShowTask, ScreenshotTask,
+            ASICTask,
+            ASICTimingConstraintSchema, ASICAreaConstraint, ASICComponentConstraints,
+            ASICPinConstraints, FPGAComponentConstraints, FPGAPinConstraints,
+            FPGATimingConstraintSchema,
+            metric.MetricSchema, record.RecordSchema, option.OptionSchema,
+            ToolLibrarySchema
+        ]
+
+    generate_class_hierarchy(classes_to_graph, args.output)

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/_metadata.py

@@ -1,5 +1,5 @@
 # Version number following semver standard.
-version = '0.36.1'
+version = '0.36.3'
 
 # Default server address for remote runs, if unspecified.
 default_server = 'https://server.siliconcompiler.com'

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/asic.py

@@ -244,7 +244,7 @@ class ASIC(Project):
             if pdk not in self.getkeys("library"):
                 error = True
                 self.logger.error(f"{pdk} library has not been loaded")
-            elif not isinstance(self.get("library", pdk, field="schema"), PDK):
+            elif not isinstance(self.get_library(pdk), PDK):
                 error = True
                 self.logger.error(f"{pdk} must be a PDK")
 
@@ -432,7 +432,7 @@ class ASIC(Project):
         if not self.get("asic", "pdk") and self.get("asic", "mainlib"):
             mainlib = None
             if self._has_library(self.get("asic", "mainlib")):
-                mainlib = self.get("library", self.get("asic", "mainlib"), field="schema")
+                mainlib = self.get_library(self.get("asic", "mainlib"))
             if mainlib:
                 mainlib_pdk = mainlib.get("asic", "pdk")
                 if mainlib_pdk:
@@ -530,7 +530,7 @@ class ASICTask(Task):
             raise ValueError("mainlib has not been defined in [asic,mainlib]")
         if mainlib not in self.project.getkeys("library"):
             raise LookupError(f"{mainlib} has not been loaded")
-        return self.project.get("library", mainlib, field="schema")
+        return self.project.get_library(mainlib)
 
     @property
     def pdk(self) -> PDK:
@@ -540,7 +540,7 @@ class ASICTask(Task):
             raise ValueError("pdk has not been defined in [asic,pdk]")
         if pdk not in self.project.getkeys("library"):
             raise LookupError(f"{pdk} has not been loaded")
-        return self.project.get("library", pdk, field="schema")
+        return self.project.get_library(pdk)
 
     def set_asic_var(self,
                      key: str,

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/design.py

@@ -694,7 +694,12 @@ class Design(DependencySchema, LibrarySchema):
         if dataroot is ...:
             dataroot = None
         else:
-            dataroot = self._get_active_dataroot(dataroot)
+            if option in ['idir', 'libdir']:
+                try:
+                    dataroot = self._get_active_dataroot(dataroot)
+                except ValueError as e:
+                    if any(not os.path.isabs(v) for v in value):
+                        raise e
 
         with self.active_dataroot(dataroot):
             if list in typelist and not clobber:

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/package/__init__.py

@@ -72,9 +72,10 @@ class Resolver:
         self.__cacheid = None
 
         if self.__root and hasattr(self.__root, "logger"):
-            self.__logger = self.__root.logger.getChild(f"resolver-{self.name}")
+            rootlogger = self.__root.logger
         else:
-            self.__logger = logging.getLogger(f"resolver-{self.name}")
+            rootlogger = MPManager.logger()
+        self.__logger = rootlogger.getChild(f"resolver-{self.name}")
 
     @staticmethod
     def populate_resolvers() -> None:

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/project.py

@@ -1,11 +1,10 @@
 import logging
 import os
-import sys
 import uuid
 
 import os.path
 
-from typing import Union, List, Tuple, TextIO, Optional, Dict, Set
+from typing import Type, Union, List, Tuple, TextIO, Optional, Dict, Set, TypeVar
 
 from siliconcompiler.schema import BaseSchema, NamedSchema, EditableSchema, Parameter, Scope, \
     __version__ as schema_version, \
@@ -28,12 +27,14 @@ from siliconcompiler.schema_support.pathschema import PathSchemaBase
 
 from siliconcompiler.report.dashboard.cli import CliDashboard
 from siliconcompiler.scheduler import Scheduler, SCRuntimeError
-from siliconcompiler.utils.logging import SCColorLoggerFormatter, SCLoggerFormatter
+from siliconcompiler.utils.logging import get_stream_handler
 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
 
+TProject = TypeVar("TProject", bound="Project")
+
 
 class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
     """
@@ -143,12 +144,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         self.__logger = MPManager.logger().getChild(f"project_{uuid.uuid4().hex}")
         self.__logger.setLevel(logging.INFO)
 
-        self._logger_console = logging.StreamHandler(stream=sys.stdout)
-        if SCColorLoggerFormatter.supports_color(sys.stdout):
-            self._logger_console.setFormatter(SCColorLoggerFormatter(SCLoggerFormatter()))
-        else:
-            self._logger_console.setFormatter(SCLoggerFormatter())
-
+        self._logger_console = get_stream_handler(self, in_run=False, step=None, index=None)
         self.__logger.addHandler(self._logger_console)
 
     def __init_dashboard(self):
@@ -225,7 +221,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         if not self.valid("library", design_name):
             raise KeyError(f"{design_name} design has not been loaded")
 
-        return self.get("library", design_name, field="schema")
+        return self.get_library(design_name)
 
     @property
     def option(self) -> OptionSchema:
@@ -242,7 +238,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         return self.get("option", field="schema")
 
     @classmethod
-    def convert(cls, obj: "Project") -> "Project":
+    def convert(cls: Type[TProject], obj: "Project") -> TProject:
         """
         Converts a project from one type to another (e.g., Project to Sim).
 
@@ -482,7 +478,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
             if not self._has_library(src_lib):
                 continue
 
-            if not self.get("library", src_lib, field="schema").has_fileset(src_fileset):
+            if not self.get_library(src_lib).has_fileset(src_fileset):
                 self.logger.error(f"{src_fileset} is not a valid fileset in {src_lib}")
                 error = True
                 continue
@@ -496,7 +492,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
                 continue
 
             if dst_fileset and \
-                    not self.get("library", dst_lib, field="schema").has_fileset(dst_fileset):
+                    not self.get_library(dst_lib).has_fileset(dst_fileset):
                 self.logger.error(f"{dst_fileset} is not a valid fileset in {dst_lib}")
                 error = True
                 continue
@@ -532,7 +528,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
                                  f"{', '.join([f'{step}/{index}' for step, index in breakpoints])}")
                 self.__dashboard.stop()
 
-    def run(self) -> "Project":
+    def run(self) -> TProject:
         '''
         Executes the compilation flow defined in the project's flowgraph.
 
@@ -715,7 +711,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
             if dst_lib:
                 if not self._has_library(dst_lib):
                     raise KeyError(f"{dst_lib} is not a loaded library")
-                dst_obj = self.get("library", dst_lib, field="schema")
+                dst_obj = self.get_library(dst_lib)
             else:
                 dst_obj = None
             if not dst_fileset:
@@ -844,7 +840,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
 
         if isinstance(src_dep, str):
             if self._has_library(src_dep):
-                src_dep = self.get("library", src_dep, field="schema")
+                src_dep = self.get_library(src_dep)
             else:
                 src_dep_name = src_dep
                 src_dep = None
@@ -875,7 +871,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
                 if not self._has_library(alias_dep):
                     raise KeyError(f"{alias_dep} has not been loaded")
 
-                alias_dep = self.get("library", alias_dep, field="schema")
+                alias_dep = self.get_library(alias_dep)
 
         if alias_dep is not None:
             if isinstance(alias_dep, Design):
@@ -894,6 +890,28 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         else:
             return self.add("option", "alias", alias)
 
+    def get_library(self, library: str) -> NamedSchema:
+        """
+        Retrieves a library by name from the project.
+
+        Args:
+            library (str): The name of the library to retrieve.
+
+        Returns:
+            NamedSchema: The `NamedSchema` object representing the library.
+
+        Raises:
+            KeyError: If the specified library is not found in the project.
+            TypeError: If the provided `library` is not a string.
+        """
+        if not isinstance(library, str):
+            raise TypeError("library must be a string")
+
+        if not self._has_library(library):
+            raise KeyError(f"{library} is not a valid library")
+
+        return self.get("library", library, field="schema")
+
     def _has_library(self, library: Union[str, NamedSchema]) -> bool:
         """
         Checks if a library with the given name exists and is loaded in the project.
@@ -1222,7 +1240,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
             return None
 
         # Create copy of project to avoid changing user project
-        proj: Project = self.copy()
+        proj = self.copy()
         proj.set_flow(ShowFlow(task))
 
         # Setup options:

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/schema/baseschema.py

@@ -26,12 +26,15 @@ import os.path
 
 from enum import Enum, auto
 from functools import cache
-from typing import Dict, Type, Tuple, Union, Set, Callable, List, Optional, TextIO, Iterable, Any
+from typing import Dict, Type, Tuple, TypeVar, Union, Set, Callable, List, Optional, \
+    TextIO, Iterable, Any
 
 from .parameter import Parameter, NodeValue
 from .journal import Journal
 from ._metadata import version
 
+TSchema = TypeVar('TSchema', bound='BaseSchema')
+
 
 class LazyLoad(Enum):
     """
@@ -286,10 +289,10 @@ class BaseSchema:
 
     # Manifest methods
     @classmethod
-    def from_manifest(cls,
+    def from_manifest(cls: Type[TSchema],
                       filepath: Union[None, str] = None,
                       cfg: Union[None, Dict] = None,
-                      lazyload: bool = True) -> "BaseSchema":
+                      lazyload: bool = True) -> TSchema:
         '''
         Create a new schema based on the provided source files.
 
@@ -849,7 +852,7 @@ class BaseSchema:
         return manifest
 
     # Utility functions
-    def copy(self, key: Optional[Tuple[str, ...]] = None) -> "BaseSchema":
+    def copy(self: TSchema, key: Optional[Tuple[str, ...]] = None) -> TSchema:
         """
         Returns a copy of this schema.
 

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/schema/docschema.py

@@ -1,6 +1,6 @@
-from typing import Union, List
+from typing import Type, Union, List
 
-from .baseschema import BaseSchema
+from .baseschema import BaseSchema, TSchema
 
 
 class DocsSchema(BaseSchema):
@@ -11,7 +11,7 @@ class DocsSchema(BaseSchema):
     """
 
     @classmethod
-    def make_docs(cls) -> Union[BaseSchema, List[BaseSchema]]:
+    def make_docs(cls: Type[TSchema]) -> Union[TSchema, List[TSchema]]:
         """Generate the documentation representation for this schema.
 
         By default, this method returns a standard instance of the class itself.

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/schema/editableschema.py

@@ -163,7 +163,7 @@ class EditableSchema:
             new_schema._BaseSchema__parent = None
         return new_schema
 
-    def rename(self, name: str):
+    def rename(self, name: str) -> None:
         '''
         Renames a named schema
         '''

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/schema/namedschema.py

@@ -4,9 +4,9 @@
 # SC dependencies outside of its directory, since it may be used by tool drivers
 # that have isolated Python environments.
 
-from typing import Dict, Tuple, Optional, Set, Union, List
+from typing import Dict, Tuple, Optional, Set, Type, Union, List
 
-from .baseschema import BaseSchema, LazyLoad
+from .baseschema import BaseSchema, LazyLoad, TSchema
 
 
 class NamedSchema(BaseSchema):
@@ -76,11 +76,11 @@ class NamedSchema(BaseSchema):
         return cfg.get("__meta__", {}).get("name", None)
 
     @classmethod
-    def from_manifest(cls,
+    def from_manifest(cls: Type[TSchema],
                       filepath: Union[None, str] = None,
                       cfg: Union[None, Dict] = None,
                       lazyload: bool = True,
-                      name: Optional[str] = None):
+                      name: Optional[str] = None) -> TSchema:
         '''
         Create a new schema based on the provided source files.
 
@@ -115,8 +115,8 @@ class NamedSchema(BaseSchema):
 
         return super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
 
-    def copy(self, key: Optional[Tuple[str, ...]] = None) -> "NamedSchema":
-        copy: NamedSchema = super().copy(key=key)
+    def copy(self: TSchema, key: Optional[Tuple[str, ...]] = None) -> TSchema:
+        copy = super().copy(key=key)
 
         if key and key[-1] != "default":
             copy.__name = key[-1]

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/schema_support/cmdlineschema.py

@@ -4,12 +4,14 @@ import sys
 
 import os.path
 
-from typing import Set, List, Optional, Union
+from typing import Set, List, Optional, Type, Union, TypeVar
 
 from siliconcompiler.schema import BaseSchema, EditableSchema, Parameter, Scope, PerNode
 from siliconcompiler.schema.utils import trim
 from siliconcompiler import _metadata
 
+TCmdSchema = TypeVar("TCmdSchema", bound="CommandLineSchema")
+
 
 class CommandLineSchema(BaseSchema):
     '''
@@ -68,14 +70,14 @@ class CommandLineSchema(BaseSchema):
         EditableSchema(self).insert("cmdarg", name, Parameter(type, **kwargs))
 
     @classmethod
-    def create_cmdline(cls,
+    def create_cmdline(cls: Type[TCmdSchema],
                        progname: Optional[str] = None,
                        description: Optional[str] = None,
                        switchlist: Optional[Union[List[str], Set[str]]] = None,
                        version: Optional[str] = None,
                        print_banner: bool = True,
                        use_cfg: bool = False,
-                       use_sources: bool = True) -> BaseSchema:
+                       use_sources: bool = True) -> TCmdSchema:
         """
         Creates an SC command line interface.
 

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/schema_support/filesetschema.py

@@ -1,5 +1,7 @@
 import contextlib
 
+import os.path
+
 from pathlib import Path
 
 from typing import List, Tuple, Optional, Union, Iterable, Set
@@ -118,8 +120,14 @@ class FileSetSchema(PathSchema):
             ext = utils.get_file_ext(filename)
             filetype = utils.get_default_iomap().get(ext, ext)
 
+        try:
+            dataroot = self._get_active_dataroot(dataroot)
+        except ValueError as e:
+            if not os.path.isabs(filename):
+                raise e
+
         # adding files to dictionary
-        with self.active_dataroot(self._get_active_dataroot(dataroot)):
+        with self.active_dataroot(dataroot):
             if clobber:
                 return self.set('fileset', fileset, 'file', filetype, filename)
             else:

{siliconcompiler-0.36.1 → siliconcompiler-0.36.3}/siliconcompiler/schema_support/pathschema.py

@@ -11,7 +11,9 @@ from siliconcompiler.schema.parameter import Parameter, Scope
 from siliconcompiler.schema.utils import trim
 
 from siliconcompiler.package import Resolver
+from siliconcompiler.utils.logging import get_stream_handler
 from siliconcompiler.utils.paths import collectiondir, cwdirsafe
+from siliconcompiler.utils.multiprocessing import MPManager
 
 
 class PathSchemaBase(BaseSchema):
@@ -19,6 +21,15 @@ class PathSchemaBase(BaseSchema):
     Schema extension to add simpler find_files and check_filepaths
     '''
 
+    def __getlogger(self, logger_name: str) -> logging.Logger:
+        schema_root = self._parent(root=True)
+        root_logger = getattr(schema_root, "logger", MPManager.logger())
+        logger = root_logger.getChild(logger_name)
+        if not logger.handlers:
+            logger.addHandler(get_stream_handler(schema_root, in_run=False, step=None, index=None))
+            logger.setLevel(logging.INFO)
+        return logger
+
     def find_files(self, *keypath: str,
                    missing_ok: bool = False,
                    step: Optional[str] = None, index: Optional[Union[int, str]] = None) \
@@ -69,13 +80,10 @@ class PathSchemaBase(BaseSchema):
             True if all file paths are valid, otherwise False.
         '''
         schema_root = self._parent(root=True)
-        logger = getattr(schema_root,
-                         "logger",
-                         logging.getLogger("siliconcompiler.check_filepaths"))
 
         return super()._check_filepaths(
             ignore_keys=ignore_keys,
-            logger=logger,
+            logger=self.__getlogger("check_filepaths"),
             collection_dir=collectiondir(schema_root),
             cwd=cwdirsafe(schema_root))
 
@@ -121,13 +129,11 @@ class PathSchemaBase(BaseSchema):
             >>> hashlist = hash_files('input', 'rtl', 'verilog')
             Computes, stores, and returns hashes of files in :keypath:`input, rtl, verilog`.
         '''
-        schema_root = self._parent(root=True)
-        logger = getattr(schema_root,
-                         "logger",
-                         logging.getLogger("siliconcompiler.hash_files"))
-
         if verbose:
-            logger.info(f"Computing hash value for [{','.join([*self._keypath, *keypath])}]")
+            self.__getlogger("hash_files").info(
+                f"Computing hash value for [{','.join([*self._keypath, *keypath])}]")
+
+        schema_root = self._parent(root=True)
 
         hashes = super()._hash_files(*keypath,
                                      missing_ok=missing_ok,