siliconcompiler 0.35.2__py3-none-any.whl → 0.35.4__py3-none-any.whl

siliconcompiler/schema/safeschema.py

@@ -7,7 +7,7 @@
 from typing import Dict, Tuple, Optional, Union, List, Set
 
 from .parameter import Parameter
-from .baseschema import BaseSchema
+from .baseschema import BaseSchema, LazyLoad
 
 
 class SafeSchema(BaseSchema):
@@ -35,7 +35,8 @@ class SafeSchema(BaseSchema):
 
     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.OFF) \
             -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
         if not isinstance(manifest, dict):
             return set(), set()
@@ -43,11 +44,13 @@ class SafeSchema(BaseSchema):
         if "__meta__" in manifest:
             del manifest["__meta__"]
 
+        lazyload = LazyLoad.OFF
+
         for key, data in manifest.items():
             obj = SafeSchema.__is_dict_leaf(data, list(keypath) + [key], version)
             if not obj:
                 obj = SafeSchema()
-                obj._from_dict(data, list(keypath) + [key], version)
+                obj._from_dict(data, list(keypath) + [key], version=version, lazyload=lazyload)
 
             if key == "default":
                 self._BaseSchema__default = obj
@@ -59,11 +62,19 @@ class SafeSchema(BaseSchema):
     @classmethod
     def from_manifest(cls,
                       filepath: Union[None, str] = None,
-                      cfg: Union[None, Dict] = None) -> "SafeSchema":
+                      cfg: Union[None, Dict] = None,
+                      lazyload: bool = False) -> "SafeSchema":
         if filepath:
             cfg = BaseSchema._read_manifest(filepath)
 
-        if cfg and "__meta__" in cfg:
-            del cfg["__meta__"]
+        def rm_meta(manifest):
+            if not isinstance(manifest, dict):
+                return
+            if manifest and "__meta__" in manifest:
+                del manifest["__meta__"]
+            for section in manifest.values():
+                rm_meta(section)
+
+        rm_meta(cfg)
 
-        return super().from_manifest(filepath=None, cfg=cfg)
+        return super().from_manifest(filepath=None, cfg=cfg, lazyload=False)

siliconcompiler/schema_support/dependencyschema.py

@@ -2,7 +2,7 @@ import os.path
 
 from typing import Dict, Union, Tuple, List, Optional, Set
 
-from siliconcompiler.schema.baseschema import BaseSchema
+from siliconcompiler.schema.baseschema import BaseSchema, LazyLoad
 from siliconcompiler.schema.editableschema import EditableSchema
 from siliconcompiler.schema.parameter import Parameter, Scope
 from siliconcompiler.schema.namedschema import NamedSchema
@@ -33,7 +33,8 @@ class DependencySchema(BaseSchema):
 
     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, ...]]]:
         '''
         Internal helper to load schema from a dictionary manifest.
@@ -50,7 +51,7 @@ class DependencySchema(BaseSchema):
             The result of the parent class's _from_dict method.
         '''
         self.set("deps", False, field="lock")
-        ret = super()._from_dict(manifest, keypath, version)
+        ret = super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
         self.set("deps", True, field="lock")
         return ret
 

siliconcompiler/schema_support/option.py

@@ -1,7 +1,8 @@
-from typing import Union, List, Tuple, Callable, Dict, Optional
+from typing import Union, List, Tuple, Callable, Dict, Optional, Final
 
 from siliconcompiler.schema import BaseSchema, EditableSchema, Parameter, Scope, PerNode
 from siliconcompiler.schema.utils import trim
+from siliconcompiler.utils.multiprocessing import MPManager
 
 
 class SchedulerSchema(BaseSchema):
@@ -427,6 +428,8 @@ class OptionSchema(BaseSchema):
     compiler's behavior, such as flow control, logging, build settings, and
     remote execution. It provides getter and setter methods for each parameter.
     """
+    __OPTIONS: Final[str] = "schema-options"
+
     def __init__(self):
         """Initializes the options schema and defines all its parameters."""
         super().__init__()
@@ -844,6 +847,84 @@ class OptionSchema(BaseSchema):
 
         schema.insert('scheduler', SchedulerSchema())
 
+        self.__load_defaults()
+
+    def __load_defaults(self) -> None:
+        """Loads and applies settings from the default options file.
+
+        This method reads the configuration file specified by the settings
+        manager. It iterates through the list of option
+        objects in the file.
+
+        For each object, it checks for a "key" and a "value". If the key
+        is recognized (exists in `self.allkeys()`), it attempts to apply
+        the value using `self.set()`.
+
+        Errors during value setting (`ValueError`) are silently ignored.
+        """
+        options = MPManager.get_settings().get_category(OptionSchema.__OPTIONS)
+
+        if not options:
+            return
+
+        allkeys = self.allkeys()
+        for key, value in options.items():
+            if key is None:
+                continue
+
+            key = tuple(key.split(","))
+            if key not in allkeys:
+                continue
+
+            try:
+                self.set(*key, value)
+            except ValueError:
+                pass
+
+    def write_defaults(self) -> None:
+        """Saves all non-default settings to the configuration file.
+
+        This method iterates through all parameters known to the system
+        (via `self.allkeys()`). It compares the current value of each
+        parameter against its default value.
+
+        Any parameter whose current value differs from its default is
+        collected. This list of non-default settings is then
+        serialized as a JSON array to the file specified by
+        `default_options_file()`.
+
+        If all parameters are set to their default values, the list
+        will be empty, and no file will be written.
+        """
+        transientkeys = {
+            # Flow information
+            ("flow",),
+            ("from",),
+            ("to",),
+            ("prune",),
+
+            # Design information
+            ("design",),
+            ("alias",),
+            ("fileset",),
+        }
+
+        settings = MPManager.get_settings()
+        settings.delete(OptionSchema.__OPTIONS)
+
+        for key in self.allkeys():
+            if key in transientkeys:
+                continue
+
+            param: Parameter = self.get(*key, field=None)
+
+            value = param.get()
+            if value != param.default.get():
+                settings.set(OptionSchema.__OPTIONS, ",".join(key), value)
+
+        if settings.get_category(OptionSchema.__OPTIONS):
+            settings.save()
+
     # Getters and Setters
     def get_remote(self) -> bool:
         """Gets the remote processing flag.

siliconcompiler/schema_support/pathschema.py

@@ -11,7 +11,7 @@ from siliconcompiler.schema.parameter import Parameter, Scope
 from siliconcompiler.schema.utils import trim
 
 from siliconcompiler.package import Resolver
-from siliconcompiler.utils.paths import collectiondir
+from siliconcompiler.utils.paths import collectiondir, cwdirsafe
 
 
 class PathSchemaBase(BaseSchema):
@@ -51,14 +51,12 @@ class PathSchemaBase(BaseSchema):
             the schema.
         """
         schema_root = self._parent(root=True)
-        cwd = getattr(schema_root, "_Project__cwd", os.getcwd())
-        collection_dir = collectiondir(schema_root)
 
         return super()._find_files(*keypath,
                                    missing_ok=missing_ok,
                                    step=step, index=index,
-                                   collection_dir=collection_dir,
-                                   cwd=cwd)
+                                   collection_dir=collectiondir(schema_root),
+                                   cwd=cwdirsafe(schema_root))
 
     def check_filepaths(self, ignore_keys: Optional[List[Tuple[str, ...]]] = None) -> bool:
         '''
@@ -71,17 +69,15 @@ class PathSchemaBase(BaseSchema):
             True if all file paths are valid, otherwise False.
         '''
         schema_root = self._parent(root=True)
-        cwd = getattr(schema_root, "_Project__cwd", os.getcwd())
         logger = getattr(schema_root,
                          "logger",
                          logging.getLogger("siliconcompiler.check_filepaths"))
-        collection_dir = collectiondir(schema_root)
 
         return super()._check_filepaths(
             ignore_keys=ignore_keys,
             logger=logger,
-            collection_dir=collection_dir,
-            cwd=cwd)
+            collection_dir=collectiondir(schema_root),
+            cwd=cwdirsafe(schema_root))
 
     def hash_files(self, *keypath: str,
                    update: bool = True,
@@ -126,11 +122,9 @@ class PathSchemaBase(BaseSchema):
             Computes, stores, and returns hashes of files in :keypath:`input, rtl, verilog`.
         '''
         schema_root = self._parent(root=True)
-        cwd = getattr(schema_root, "_Project__cwd", os.getcwd())
         logger = getattr(schema_root,
                          "logger",
                          logging.getLogger("siliconcompiler.hash_files"))
-        collection_dir = collectiondir(schema_root)
 
         if verbose:
             logger.info(f"Computing hash value for [{','.join([*self._keypath, *keypath])}]")
@@ -138,8 +132,8 @@ class PathSchemaBase(BaseSchema):
         hashes = super()._hash_files(*keypath,
                                      missing_ok=missing_ok,
                                      step=step, index=index,
-                                     collection_dir=collection_dir,
-                                     cwd=cwd)
+                                     collection_dir=collectiondir(schema_root),
+                                     cwd=cwdirsafe(schema_root))
 
         if check:
             check_hashes = self.get(*keypath, field="filehash", step=step, index=index)
@@ -392,7 +386,8 @@ class PathSchema(PathSchemaBase):
         resolver = Resolver.find_resolver(path)
         return resolver(name, schema._parent(root=True), path, tag).get_path()
 
-    def _find_files_dataroot_resolvers(self) -> Dict[str, Union[str, Callable]]:
+    def _find_files_dataroot_resolvers(self, resolvers: bool = False) \
+            -> Dict[str, Union[str, Callable]]:
         """
         Returns a dictionary of path resolvers data directory handling for find_files
 
@@ -410,7 +405,11 @@ class PathSchema(PathSchemaBase):
             path = BaseSchema.get(schema, "dataroot", dataroot, "path")
             tag = BaseSchema.get(schema, "dataroot", dataroot, "tag")
             resolver = Resolver.find_resolver(path)
-            resolver_map[dataroot] = resolver(dataroot, schema_root, path, tag).get_path
+            resolver_obj = resolver(dataroot, schema_root, path, tag)
+            if resolvers:
+                resolver_map[dataroot] = resolver_obj
+            else:
+                resolver_map[dataroot] = resolver_obj.get_path
         return resolver_map
 
     @contextlib.contextmanager

siliconcompiler/schema_support/record.py

@@ -12,7 +12,7 @@ from typing import Dict, Union, List, Optional, Set, Tuple
 from datetime import datetime, timezone
 from enum import Enum
 
-from siliconcompiler.schema import BaseSchema
+from siliconcompiler.schema import BaseSchema, LazyLoad
 from siliconcompiler.schema import EditableSchema, Parameter, PerNode, Scope
 from siliconcompiler.schema.utils import trim
 
@@ -53,7 +53,8 @@ class RecordSchema(BaseSchema):
 
     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.
@@ -66,10 +67,10 @@ class RecordSchema(BaseSchema):
         Returns:
             dict: The constructed dictionary.
         """
-        ret = super()._from_dict(manifest, keypath, version)
+        ret = super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
 
         # Correct for change specification
-        if version and version < (0, 50, 4):
+        if not lazyload.is_enforced and version and version < (0, 50, 4):
             for timekey in RecordTime:
                 start_param = self.get(timekey.value, field=None)
                 for value, step, index in start_param.getvalues():

siliconcompiler/targets/asap7_demo.py

@@ -3,7 +3,9 @@ from siliconcompiler import ASIC
 from siliconcompiler.flows import asicflow, synflow
 
 from lambdapdk.asap7.libs.asap7sc7p5t import ASAP7SC7p5RVT, ASAP7SC7p5SLVT, ASAP7SC7p5LVT
-from lambdapdk.asap7.libs.fakeram7 import FakeRAM7Lambdalib_SinglePort, FakeRAM7Lambdalib_DoublePort
+from lambdapdk.asap7.libs.fakeram7 import FakeRAM7Lambdalib_SinglePort, \
+    FakeRAM7Lambdalib_DoublePort, \
+    FakeRAM7Lambdalib_TrueDoublePort
 from lambdapdk.asap7.libs.fakeio7 import FakeIO7Lambdalib_IO
 
 
@@ -101,4 +103,5 @@ def asap7_demo(
     # for demonstration and academic purposes.
     FakeRAM7Lambdalib_SinglePort.alias(project)
     FakeRAM7Lambdalib_DoublePort.alias(project)
+    FakeRAM7Lambdalib_TrueDoublePort.alias(project)
     FakeIO7Lambdalib_IO.alias(project)

siliconcompiler/tool.py

@@ -35,7 +35,7 @@ from packaging.specifiers import SpecifierSet, InvalidSpecifier
 from typing import List, Dict, Tuple, Union, Optional, Set, TextIO, Type, TypeVar, TYPE_CHECKING
 from pathlib import Path
 
-from siliconcompiler.schema import BaseSchema, NamedSchema, Journal, DocsSchema
+from siliconcompiler.schema import BaseSchema, NamedSchema, Journal, DocsSchema, LazyLoad
 from siliconcompiler.schema import EditableSchema, Parameter, PerNode, Scope
 from siliconcompiler.schema.parametertype import NodeType
 from siliconcompiler.schema.utils import trim
@@ -130,7 +130,8 @@ class Task(NamedSchema, PathSchema, DocsSchema):
         r"^\s*" + __parse_version_check_str + r"\s*$",
         re.VERBOSE | re.IGNORECASE)
 
-    __POLL_INTERVAL: float = 0.1
+    __IO_POLL_INTERVAL: float = 0.1
+    __MEM_POLL_INTERVAL: float = 0.5
     __MEMORY_WARN_LIMIT: int = 90
 
     def __init__(self):
@@ -147,13 +148,14 @@ class Task(NamedSchema, PathSchema, DocsSchema):
 
     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, ...]]]:
         """
         Populates the schema from a dictionary, dynamically adding 'var'
         parameters found in the manifest that are not already defined.
         """
-        if "var" in manifest:
+        if not lazyload.is_enforced and "var" in manifest:
             # Collect existing and manifest var keys
             var_keys = [k[0] for k in self.allkeys("var")]
             manifest_keys = set(manifest["var"].keys())
@@ -171,7 +173,7 @@ class Task(NamedSchema, PathSchema, DocsSchema):
             if not manifest["var"]:
                 del manifest["var"]
 
-        return super()._from_dict(manifest, keypath, version)
+        return super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
 
     @contextlib.contextmanager
     def runtime(self, node: "SchedulerNode",
@@ -414,7 +416,7 @@ class Task(NamedSchema, PathSchema, DocsSchema):
         cmdlist.extend(veropt)
 
         self.logger.debug(f'Running {self.tool()}/{self.task()} version check: '
-                          f'{" ".join(cmdlist)}')
+                          f'{shlex.join(cmdlist)}')
 
         proc = subprocess.run(cmdlist,
                               stdin=subprocess.DEVNULL,
@@ -813,6 +815,10 @@ class Task(NamedSchema, PathSchema, DocsSchema):
         schema = root.copy()
 
         for keypath in root.allkeys():
+            if keypath[0] == "history":
+                # Ignore history as this is not relevant to the task
+                continue
+
             paramtype: str = schema.get(*keypath, field='type')
             if 'file' not in paramtype and 'dir' not in paramtype:
                 continue
@@ -895,6 +901,37 @@ class Task(NamedSchema, PathSchema, DocsSchema):
                                     f'{timeout} seconds. Terminating...')
                 terminate_process(proc.pid, timeout=timeout)
 
+    def __collect_memory(self, pid) -> Optional[int]:
+        try:
+            pproc = psutil.Process(pid)
+            proc_mem_bytes = pproc.memory_full_info().uss
+            for child in pproc.children(recursive=True):
+                proc_mem_bytes += child.memory_full_info().uss
+            return proc_mem_bytes
+        except psutil.Error:
+            # Process may have already terminated or been killed.
+            # Retain existing memory usage statistics in this case.
+            pass
+        except PermissionError:
+            # OS is preventing access to this information so it cannot
+            # be collected
+            pass
+        return None
+
+    def __check_memory_limit(self, warn_limit: int) -> int:
+        try:
+            memory_usage = psutil.virtual_memory()
+            if memory_usage.percent > warn_limit:
+                self.logger.warning(
+                    'Current system memory usage is '
+                    f'{memory_usage.percent:.1f}%')
+                return int(memory_usage.percent + 1)
+        except psutil.Error:
+            pass
+        except PermissionError:
+            pass
+        return warn_limit
+
     def run_task(self,
                  workdir: str,
                  quiet: bool,
@@ -1029,39 +1066,29 @@ class Task(NamedSchema, PathSchema, DocsSchema):
                         raise TaskError(f"Unable to start {exe}: {str(e)}")
 
                     memory_warn_limit = Task.__MEMORY_WARN_LIMIT
+                    next_collection = None
                     try:
                         while proc.poll() is None:
+                            curr_time = time.time()
+
                             # Monitor subprocess memory usage
-                            try:
-                                pproc = psutil.Process(proc.pid)
-                                proc_mem_bytes = pproc.memory_full_info().uss
-                                for child in pproc.children(recursive=True):
-                                    proc_mem_bytes += child.memory_full_info().uss
-                                max_mem_bytes = max(max_mem_bytes, proc_mem_bytes)
-
-                                memory_usage = psutil.virtual_memory()
-                                if memory_usage.percent > memory_warn_limit:
-                                    self.logger.warning(
-                                        'Current system memory usage is '
-                                        f'{memory_usage.percent:.1f}%')
-                                    memory_warn_limit = int(memory_usage.percent + 1)
-                            except psutil.Error:
-                                # Process may have already terminated or been killed.
-                                # Retain existing memory usage statistics in this case.
-                                pass
-                            except PermissionError:
-                                # OS is preventing access to this information so it cannot
-                                # be collected
-                                pass
+                            if next_collection is None or \
+                                    next_collection <= curr_time:
+                                proc_mem_bytes = self.__collect_memory(proc.pid)
+                                if proc_mem_bytes is not None:
+                                    max_mem_bytes = max(max_mem_bytes, proc_mem_bytes)
+                                next_collection = curr_time + Task.__MEM_POLL_INTERVAL
+
+                                memory_warn_limit = self.__check_memory_limit(memory_warn_limit)
 
                             read_stdio(stdout_reader, stderr_reader)
 
                             # Check for timeout
-                            duration = time.time() - cpu_start
+                            duration = curr_time - cpu_start
                             if timeout is not None and duration > timeout:
                                 raise TaskTimeout(timeout=duration)
 
-                            time.sleep(Task.__POLL_INTERVAL)
+                            time.sleep(Task.__IO_POLL_INTERVAL)
                     except KeyboardInterrupt:
                         self.logger.info("Received ctrl-c.")
                         self.__terminate_exe(proc)

siliconcompiler/tools/builtin/__init__.py

@@ -21,6 +21,8 @@ class BuiltinTask(Task):
 
         self._set_io_files()
 
+        self.set_threads(1)
+
     def _set_io_files(self):
         files = sorted(list(self.get_files_from_input_nodes().keys()))
         self.add_input_file(files)

siliconcompiler/tools/builtin/filter.py

@@ -50,14 +50,21 @@ class FilterTask(Task):
     def setup(self):
         super().setup()
 
+        self.set_threads(1)
+
+        flow = self.project.get("flowgraph", self.project.option.get_flow(), field="schema")
+        graph_node = flow.get_graph_node(self.step, self.index)
+
         if self.get("var", "keep"):
             self.add_required_key("var", "keep")
+        elif graph_node.get_args():
+            self.add_required_key(graph_node, "args")
 
         files = sorted(list(self.get_files_from_input_nodes().keys()))
         if not files:
             raise ValueError("task receives no files")
 
-        filters: List[str] = self.get("var", "keep")
+        filters: List[str] = self.get("var", "keep") or graph_node.get_args()
         if not filters:
             filters = ["*"]
 

siliconcompiler/tools/builtin/importfiles.py

@@ -92,6 +92,8 @@ class ImportFilesTask(Task):
         """
         super().setup()
 
+        self.set_threads(1)
+
         if (self.step, self.index) not in self.schema_flow.get_entry_nodes():
             raise ValueError("task must be an entry node")
 

siliconcompiler/tools/klayout/__init__.py

@@ -172,6 +172,7 @@ class KLayoutTask(ASICTask):
         with self.active_dataroot("refdir"):
             self.set_refdir("scripts")
 
+        self.set_environmentalvariable('PYTHONUNBUFFERED', '1')
         if self.project.get('option', 'nodisplay'):
             # Tells QT to use the offscreen platform if nodisplay is used
             self.set_environmentalvariable('QT_QPA_PLATFORM', 'offscreen')
@@ -185,6 +186,8 @@ class KLayoutTask(ASICTask):
         options = super().runtime_options()
         options.extend(['-rd', f'SC_KLAYOUT_ROOT={self.find_files("refdir")[0]}'])
         options.extend(['-rd', f'SC_TOOLS_ROOT={os.path.dirname(os.path.dirname(__file__))}'])
+        options.extend(['-rd',
+                        f'SC_ROOT={os.path.dirname(os.path.dirname(os.path.dirname(__file__)))}'])
         return options
 
     def post_process(self):

siliconcompiler/tools/klayout/scripts/klayout_convert_drc_db.py

@@ -151,6 +151,7 @@ def convert_drc(view, path):
 def main():
     # SC_ROOT provided by CLI
     sys.path.append(SC_KLAYOUT_ROOT)  # noqa: F821
+    sys.path.append(SC_ROOT)  # noqa: F821
 
     from klayout_utils import get_schema
 

siliconcompiler/tools/klayout/scripts/klayout_export.py

@@ -121,6 +121,7 @@ def main():
     # SC_ROOT provided by CLI
     sys.path.append(SC_KLAYOUT_ROOT)  # noqa: F821
     sys.path.append(SC_TOOLS_ROOT)  # noqa: F821
+    sys.path.append(SC_ROOT)  # noqa: F821
 
     from klayout_utils import (
         technology,

siliconcompiler/tools/klayout/scripts/klayout_operations.py

@@ -326,6 +326,7 @@ if __name__ == "__main__":
     # SC_ROOT provided by CLI
     sys.path.append(SC_KLAYOUT_ROOT)  # noqa: F821
     sys.path.append(SC_TOOLS_ROOT)  # noqa: F821
+    sys.path.append(SC_ROOT)  # noqa: F821
 
     from klayout_utils import (
         technology,

siliconcompiler/tools/klayout/scripts/klayout_show.py

@@ -193,6 +193,7 @@ def main():
     # SC_ROOT provided by CLI, and is only accessible when this is main module
     sys.path.append(SC_KLAYOUT_ROOT)  # noqa: F821
     sys.path.append(SC_TOOLS_ROOT)  # noqa: F821
+    sys.path.append(SC_ROOT)  # noqa: F821
 
     from klayout_utils import (
         technology,
@@ -250,7 +251,7 @@ def main():
             sc_filename = schema.get('tool', 'klayout', 'task', task, 'var', 'showfilepath',
                                      step=step, index=index)
         else:
-            for ext in (f'{sc_fileext}.gz', sc_fileext):
+            for ext in (f'{sc_fileext}.gz', sc_fileext, 'gds.gz', "gds", 'oas.gz', 'oas'):
                 sc_filename = f"inputs/{design}.{ext}"
                 if os.path.exists(sc_filename):
                     break

siliconcompiler/tools/klayout/scripts/klayout_utils.py

@@ -1,7 +1,6 @@
 import pya
 import json
 import shutil
-import sys
 import os.path
 
 
@@ -129,8 +128,9 @@ def technology(design, schema):
             map_file = os.path.abspath(os.path.join(os.path.dirname(tech_file),
                                                     map_file))
     for s in get_streams(schema):
-        if schema.valid('library', sc_pdk, 'layermapfileset', 'klayout', 'def', s):
-            for fileset in schema.get('library', sc_pdk, 'layermapfileset', 'klayout', 'def', s):
+        if schema.valid('library', sc_pdk, 'pdk', 'layermapfileset', 'klayout', 'def', s):
+            for fileset in schema.get('library', sc_pdk, 'pdk', 'layermapfileset', 'klayout',
+                                      'def', s):
                 if schema.valid('library', sc_pdk, "fileset", fileset, "file", "layermap"):
                     map_file = schema.get('library', sc_pdk, "fileset", fileset, "file", "layermap")
                 if map_file:
@@ -170,7 +170,6 @@ def get_write_options(filename, timestamps):
 
 
 def get_schema(manifest):
-    sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
     from schema.safeschema import SafeSchema
     return SafeSchema.from_manifest(filepath=manifest)
 

siliconcompiler/tools/klayout/show.py

@@ -15,6 +15,17 @@ class ShowTask(ShowTask, KLayoutTask):
 
         self.set_script("klayout_show.py")
 
+        if f"{self.design_topmodule}.gds.gz" in self.get_files_from_input_nodes():
+            self.add_input_file(ext="gds.gz")
+        elif f"{self.design_topmodule}.gds" in self.get_files_from_input_nodes():
+            self.add_input_file(ext="gds")
+        elif f"{self.design_topmodule}.oas.gz" in self.get_files_from_input_nodes():
+            self.add_input_file(ext="oas.gz")
+        elif f"{self.design_topmodule}.oas" in self.get_files_from_input_nodes():
+            self.add_input_file(ext="oas")
+        else:
+            self.add_required_key("var", "showfilepath")
+
         self.add_commandline_option(["-nc", "-rm"], clobber=True)
 
     def get_supported_show_extentions(self):
@@ -23,8 +34,9 @@ class ShowTask(ShowTask, KLayoutTask):
     def pre_process(self):
         super().pre_process()
 
-        rel_path = os.path.dirname(self.get("var", "showfilepath"))
-        for ext in ('lyt', 'lyp'):
-            ext_file = os.path.join(rel_path, f'{self.design_topmodule}.{ext}')
-            if ext_file and os.path.exists(ext_file):
-                shutil.copy2(ext_file, f"inputs/{self.design_topmodule}.{ext}")
+        if self.get("var", "showfilepath"):
+            rel_path = os.path.dirname(self.get("var", "showfilepath"))
+            for ext in ('lyt', 'lyp'):
+                ext_file = os.path.join(rel_path, f'{self.design_topmodule}.{ext}')
+                if ext_file and os.path.exists(ext_file):
+                    shutil.copy2(ext_file, f"inputs/{self.design_topmodule}.{ext}")