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

siliconcompiler/tool.py

@@ -11,7 +11,6 @@ import shlex
 import shutil
 import subprocess
 import sys
-import threading
 import time
 import yaml
 
@@ -35,7 +34,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, LazyLoad
+from siliconcompiler.schema import BaseSchema, NamedSchema, DocsSchema, LazyLoad
 from siliconcompiler.schema import EditableSchema, Parameter, PerNode, Scope
 from siliconcompiler.schema.parametertype import NodeType
 from siliconcompiler.schema.utils import trim
@@ -43,6 +42,7 @@ from siliconcompiler.schema.utils import trim
 from siliconcompiler import utils, NodeStatus, Flowgraph
 from siliconcompiler import sc_open
 from siliconcompiler.utils import paths
+from siliconcompiler.utils.multiprocessing import MPManager
 
 from siliconcompiler.schema_support.pathschema import PathSchema
 from siliconcompiler.schema_support.record import RecordTool, RecordSchema
@@ -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):
@@ -389,7 +390,7 @@ class Task(NamedSchema, PathSchema, DocsSchema):
         if self.tool() in tools:
             self.logger.info(f"Missing tool can be installed via: \"sc-install {self.tool()}\"")
 
-    def get_exe_version(self) -> Optional[str]:
+    def get_exe_version(self, workdir: Optional[str] = None) -> Optional[str]:
         """
         Gets the version of the task's executable by running it with a version switch.
 
@@ -397,6 +398,10 @@ class Task(NamedSchema, PathSchema, DocsSchema):
             TaskExecutableNotFound: If the executable is not found.
             NotImplementedError: If the `parse_version` method is not implemented.
 
+        Args:
+            workdir (str): The working directory to use for the version check. If None,
+                the current working directory is used.
+
         Returns:
             str: The parsed version string.
         """
@@ -415,13 +420,14 @@ 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,
                               stdout=subprocess.PIPE,
                               stderr=subprocess.STDOUT,
-                              universal_newlines=True)
+                              universal_newlines=True,
+                              cwd=workdir)
 
         if proc.returncode != 0:
             self.logger.warning(f"Version check on '{exe_base}' ended with "
@@ -735,9 +741,7 @@ class Task(NamedSchema, PathSchema, DocsSchema):
             fout.write(template.render(manifest_dict='\n'.join(tcl_set_cmds),
                                        scroot=os.path.abspath(
                                            os.path.join(os.path.dirname(__file__))),
-                                       toolvars=self.get_tcl_variables(manifest),
-                                       record_access="get" in Journal.access(self).get_types(),
-                                       record_access_id="TODO"))
+                                       toolvars=self.get_tcl_variables(manifest)))
         else:
             for cmd in tcl_set_cmds:
                 fout.write(cmd + '\n')
@@ -900,6 +904,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,
@@ -1034,39 +1069,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)
@@ -2062,9 +2087,6 @@ class ShowTask(Task):
     Subclasses should implement `get_supported_show_extentions` to declare
     which file types they can handle.
     """
-    __TASKS_LOCK = threading.Lock()
-    __TASKS = {}
-
     def __init__(self):
         """Initializes a ShowTask, adding specific parameters for show tasks."""
         super().__init__()
@@ -2111,8 +2133,10 @@ class ShowTask(Task):
         if not cls.__check_task(task):
             raise TypeError(f"task must be a subclass of {cls.__name__}")
 
-        with cls.__TASKS_LOCK:
-            cls.__TASKS.setdefault(cls, set()).add(task)
+        MPManager.get_transient_settings().set(
+            cls.__name__,
+            f"{task.__module__}/{task.__name__}",
+            task)
 
     @classmethod
     def __populate_tasks(cls) -> None:
@@ -2124,6 +2148,9 @@ class ShowTask(Task):
         """
         cls.__check_task(None)
 
+        if MPManager.get_transient_settings().get_category(cls.__name__):
+            return  # Already populated
+
         def recurse(searchcls: Type["ShowTask"]):
             subclss = set()
             if not cls.__check_task(searchcls):
@@ -2138,20 +2165,25 @@ class ShowTask(Task):
         classes = recurse(cls)
 
         # Support non-SC defined tasks from plugins
-        for plugin in utils.get_plugins('showtask'):  # TODO rename
+        for plugin in utils.get_plugins('showtask'):
             plugin()
 
         if not classes:
             return
 
-        with ShowTask.__TASKS_LOCK:
-            ShowTask.__TASKS.setdefault(cls, set()).update(classes)
+        for c in classes:
+            cls.register_task(c)
 
     @classmethod
     def get_task(cls, ext: Optional[str]) -> Union[Optional["ShowTask"], Set[Type["ShowTask"]]]:
         """
         Retrieves a suitable show task instance for a given file extension.
 
+        The method first checks the user's settings file (~/.sc/settings.json)
+        under the 'showtask' category for a preferred tool. If no preference
+        is found or the preferred tool is not available, it falls back to
+        automatic discovery.
+
         Args:
             ext (str): The file extension to find a viewer for.
 
@@ -2160,24 +2192,45 @@ class ShowTask(Task):
             no suitable task is found.
         """
         cls.__check_task(None)
+        cls.__populate_tasks()
 
-        if cls not in ShowTask.__TASKS:
-            cls.__populate_tasks()
-
-        with ShowTask.__TASKS_LOCK:
-            if cls not in ShowTask.__TASKS:
-                return None
-            tasks = ShowTask.__TASKS[cls].copy()
-
-        # TODO: add user preference lookup (ext -> task)
+        settings = MPManager.get_transient_settings()
+        tasks = set(settings.get_category(cls.__name__).values())
+        if not tasks:
+            return None
 
         if ext is None:
             return tasks
 
-        for task in tasks:
+        # 1. Check User Settings for Preference
+        preference = MPManager.get_settings().get("showtask", ext)
+
+        if preference:
+            # Preference format: "tool" or "tool/task"
+            pref_parts = preference.split('/')
+            pref_tool = pref_parts[0]
+            pref_task = pref_parts[1] if len(pref_parts) > 1 else None
+
+            for task_cls in tasks:
+                try:
+                    task_inst = task_cls()
+                    # Check if this task matches the preference
+                    if task_inst.tool() == pref_tool:
+                        if pref_task and task_inst.task() != pref_task:
+                            continue
+
+                        # Verify the preferred tool actually supports the extension
+                        if ext in task_inst.get_supported_show_extentions():
+                            return task_inst
+                except NotImplementedError:
+                    continue
+
+        # 2. Fallback to Automatic Discovery
+        for task_cls in tasks:
             try:
-                if ext in task().get_supported_show_extentions():
-                    return task()
+                task_inst = task_cls()
+                if ext in task_inst.get_supported_show_extentions():
+                    return task_inst
             except NotImplementedError:
                 pass
 

siliconcompiler/tools/_common/tcl/sc_schema_access.tcl

@@ -1,11 +1,5 @@
-proc _sc_cfg_get_debug { args } {
-
-}
-
 # Shortcut to get values from configuration
 proc sc_cfg_get { args } {
-    _sc_cfg_get_debug $args
-
     # Refer to global sc_cfg dictionary
     global sc_cfg
 

siliconcompiler/tools/keplerformal/__init__.py

@@ -0,0 +1,7 @@
+'''
+Kepler-Formal is a logic equivalence checking (LEC) tool that operates on verilog
+and the naja interchange format (https://github.com/najaeda/naja-if) and focuses
+today on combinational equivalence checking only.
+
+Sources: https://github.com/keplertech/kepler-formal
+'''

siliconcompiler/tools/keplerformal/lec.py

@@ -0,0 +1,112 @@
+import os.path
+
+from siliconcompiler import Task
+from siliconcompiler.utils import sc_open
+
+
+class LECTask(Task):
+    """LEC task using Kepler-formal for logical equivalence checking."""
+    def tool(self) -> str:
+        return "kepler-formal"
+
+    def task(self) -> str:
+        return "lec"
+
+    def setup(self) -> None:
+        super().setup()
+
+        self.set_exe("kepler-formal")
+
+        # Log file handled by kepler-formal config
+        self.set_logdestination("stdout", "none")
+        self.set_logdestination("stderr", "none")
+
+        if f"{self.design_topmodule}.lec.vg" in self.get_files_from_input_nodes():
+            inputnodes = self.get_files_from_input_nodes()[f"{self.design_topmodule}.lec.vg"]
+            if len(inputnodes) != 2:
+                raise ValueError("LEC requires exactly two input netlists for comparison.")
+            for node in inputnodes:
+                self.add_input_file(
+                    self.compute_input_file_node_name(f"{self.design_topmodule}.lec.vg", *node))
+
+        scenarios = self.project.constraint.timing.get_scenario()
+        if not scenarios:
+            raise ValueError("LEC requires at least one timing scenario to determine "
+                             "library corners.")
+        scenario = list(scenarios.values())[0]
+        libcorners = scenario.get_libcorner(self.step, self.index)
+        delay_model = self.project.get("asic", "delaymodel")
+        for asiclib in self.project.get("asic", "asiclib"):
+            lib = self.project.get("library", asiclib, field="schema")
+            for corner in libcorners:
+                if not lib.valid("asic", "libcornerfileset", corner, delay_model):
+                    continue
+                self.add_required_key(lib, "asic", "libcornerfileset", corner, delay_model)
+                for fileset in lib.get("asic", "libcornerfileset", corner, delay_model):
+                    self.add_required_key(lib, "fileset", fileset, "file", "liberty")
+
+    def __config_file(self) -> str:
+        return "lec.yaml"
+
+    def pre_process(self):
+        super().pre_process()
+
+        with open(self.__config_file(), "w") as f:
+            f.write("format: verilog\n")
+            f.write("input_paths:\n")
+            for node in self.get_files_from_input_nodes()[f"{self.design_topmodule}.lec.vg"]:
+                filename = self.compute_input_file_node_name(f"{self.design_topmodule}.lec.vg",
+                                                             *node)
+                f.write(f"  - inputs/{filename}\n")
+            f.write("liberty_files:\n")
+
+            scenario = list(self.project.constraint.timing.get_scenario().values())[0]
+            libcorners = scenario.get_libcorner(self.step, self.index)
+            delay_model = self.project.get("asic", "delaymodel")
+            for asiclib in self.project.get("asic", "asiclib"):
+                lib = self.project.get("library", asiclib, field="schema")
+                for corner in libcorners:
+                    if not lib.valid("asic", "libcornerfileset", corner, delay_model):
+                        continue
+                    for fileset in lib.get("asic", "libcornerfileset", corner, delay_model):
+                        for file in lib.get_file(fileset=fileset, filetype="liberty"):
+                            f.write(f"  - {file}\n")
+            f.write(f"log_file: {self.get_logpath('exe')}\n")
+
+    def runtime_options(self):
+        options = super().runtime_options()
+        options.append("--config")
+        options.append(self.__config_file())
+        return options
+
+    def post_process(self):
+        super().post_process()
+        # Kepler-formal writes its own log file; nothing to do here.
+        errors = 0
+        log = self.get_logpath('exe')
+        if os.path.exists(log):
+            with sc_open(log, 'r') as f:
+                for logline in f:
+                    if "Found difference " in logline:
+                        errors += 1
+
+            self.record_metric("drvs", errors, source_file=log)
+
+    @classmethod
+    def make_docs(cls):
+        from siliconcompiler import Flowgraph, Design, ASIC
+        from siliconcompiler.scheduler import SchedulerNode
+        from siliconcompiler.targets import freepdk45_demo
+        design = Design("<design>")
+        with design.active_fileset("docs"):
+            design.set_topmodule("top")
+        proj = ASIC(design)
+        proj.add_fileset("docs")
+        freepdk45_demo(proj)
+        flow = Flowgraph("docsflow")
+        flow.node("<step>", cls(), index="<index>")
+        proj.set_flow(flow)
+
+        node = SchedulerNode(proj, "<step>", "<index>")
+        node.setup()
+        return node.task

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/screenshot.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from siliconcompiler import ScreenshotTask, Task
 from siliconcompiler.tools.klayout.show import ShowTask
 
@@ -20,7 +22,70 @@ class ScreenshotParams(Task):
         self.add_parameter("show_linewidth", "int",
                            "Width of lines in detailed screenshots", defvalue=0, unit="px")
         self.add_parameter("show_oversampling", "int",
-                           "Image oversampling used in detailed screenshots'", defvalue=2)
+                           "Image oversampling used in detailed screenshots", defvalue=2)
+
+    def set_klayout_bins(self, xbins: int, ybins: int,
+                         step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Set the number of bins for KLayout screenshotting.
+
+        Args:
+            xbins (int): Number of bins along the x-axis.
+            ybins (int): Number of bins along the y-axis.
+            step (Optional[str]): Flow step to set the parameter for. Defaults to None.
+            index (Optional[Union[str, int]]): Index to set the parameter for. Defaults to None.
+        """
+        self.set("var", "show_bins", (xbins, ybins), step=step, index=index)
+
+    def set_klayout_margin(self, margin: float,
+                           step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Set the margin for KLayout screenshotting.
+
+        Args:
+            margin (float): Margin around the design in microns.
+            step (Optional[str]): Flow step to set the parameter for. Defaults to None.
+            index (Optional[Union[str, int]]): Index to set the parameter for. Defaults to None.
+        """
+        self.set("var", "show_margin", margin, step=step, index=index)
+
+    def set_klayout_resolution(self, xres: int, yres: int,
+                               step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Set the resolution for KLayout screenshotting.
+
+        Args:
+            xres (int): Horizontal resolution in pixels.
+            yres (int): Vertical resolution in pixels.
+            step (Optional[str]): Flow step to set the parameter for. Defaults to None.
+            index (Optional[Union[str, int]]): Index to set the parameter for. Defaults to None.
+        """
+        self.set("var", "show_resolution", (xres, yres), step=step, index=index)
+
+    def set_klayout_linewidth(self, linewidth: int,
+                              step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Set the linewidth for KLayout screenshotting.
+
+        Args:
+            linewidth (int): Width of lines in detailed screenshots.
+            step (Optional[str]): Flow step to set the parameter for. Defaults to None.
+            index (Optional[Union[str, int]]): Index to set the parameter for. Defaults to None.
+        """
+        self.set("var", "show_linewidth", linewidth, step=step, index=index)
+
+    def set_klayout_oversampling(self, oversampling: int,
+                                 step: Optional[str] = None,
+                                 index: Optional[Union[str, int]] = None):
+        """
+        Set the oversampling for KLayout screenshotting.
+
+        Args:
+            oversampling (int): Image oversampling used in detailed screenshots.
+            step (Optional[str]): Flow step to set the parameter for. Defaults to None.
+            index (Optional[Union[str, int]]): Index to set the parameter for. Defaults to None.
+        """
+        self.set("var", "show_oversampling", oversampling, step=step, index=index)
 
     def setup(self):
         super().setup()

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

@@ -39,24 +39,23 @@ import sys
 import fnmatch
 
 
-def gds_export(design_name, in_def, in_files, out_file, tech, allow_missing, config_file='',
-               seal_file='',
-               timestamps=True):
+def gds_export(design_name, in_def, out_file, tech, allow_missing, timestamps=True):
     from klayout_utils import get_write_options  # noqa E402
 
     # Load def file
     main_layout = pya.Layout()
     main_layout.technology_name = tech.name
-    main_layout.read(in_def, tech.load_layout_options)
+    layout_options = tech.load_layout_options
+    main_layout.read(in_def, layout_options)
 
     # List cells
     def_cells = []
-    for def_cell in main_layout.each_cell():
-        def_cells.append(def_cell.name)
+    for cell_idx in main_layout.cell(design_name).each_child_cell():
+        def_cells.append(main_layout.cell_name(cell_idx))
 
-    def_cells.remove(design_name)
     # Remove vias
-    def_cells = sorted([cell for cell in def_cells if not cell.startswith("VIA_")])
+    via_prefix = layout_options.lefdef_config.via_cellname_prefix
+    def_cells = sorted([cell for cell in def_cells if not cell.startswith(via_prefix)])
     print(f"[INFO] Read in {len(def_cells)} cells from DEF file")
     for cell in def_cells:
         print(f"  [INFO] DEF cell: {cell}")
@@ -65,16 +64,11 @@ def gds_export(design_name, in_def, in_files, out_file, tech, allow_missing, con
         def_cells.remove(f"{design_name}_DEF_FILL")
 
     # Load in the gds to merge
-    print("[INFO] Merging GDS/OAS files...")
-    for fil in in_files:
+    for fil in layout_options.lefdef_config.macro_layout_files:
         macro_layout = pya.Layout()
         macro_layout.read(fil)
-        print(f"[INFO] Read in {fil}")
         for cell in list(def_cells):
             if macro_layout.has_cell(cell):
-                subcell = main_layout.cell(cell)
-                print(f"  [INFO] Merging in {cell}")
-                subcell.copy_tree(macro_layout.cell(cell))
                 def_cells.remove(cell)
 
     # Copy the top level only to a new layout
@@ -100,18 +94,6 @@ def gds_export(design_name, in_def, in_files, out_file, tech, allow_missing, con
         if i.name != design_name and i.parent_cells() == 0:
             print("[ERROR] Found orphan cell '{0}'".format(i.name))
 
-    if seal_file:
-        top_cell = top_only_layout.top_cell()
-
-        print("[INFO] Reading seal GDS/OAS file...")
-        print("\t{0}".format(seal_file))
-        top_only_layout.read(seal_file)
-
-        for cell in top_only_layout.top_cells():
-            if cell != top_cell:
-                print("[INFO] Merging '{0}' as child of '{1}'".format(cell.name, top_cell.name))
-                top.insert(pya.CellInstArray(cell.cell_index(), pya.Trans()))
-
     # Write out the GDS
     print("[INFO] Writing out GDS/OAS '{0}'".format(out_file))
     top_only_layout.write(out_file, get_write_options(out_file, timestamps))
@@ -121,10 +103,10 @@ 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,
-        get_streams,
         save_technology,
         get_schema,
         generate_metrics
@@ -154,18 +136,8 @@ def main():
 
     out_file = os.path.join('outputs', f'{design}.{sc_stream}')
 
-    in_files = []
-    libs = schema.get("asic", "asiclib")
-    for lib in libs:
-        libobj = schema.get("library", lib, field="schema")
-        for s in get_streams(schema):
-            for fileset in libobj.get("asic", "aprfileset"):
-                if libobj.valid("fileset", fileset, "file", s):
-                    in_files.extend(libobj.get("fileset", fileset, "file", s))
-                    break
-
     allow_missing = []
-    for lib in libs:
+    for lib in schema.get("asic", "asiclib"):
         if schema.valid('library', lib, 'tool', 'klayout', 'allow_missing_cell'):
             patterns = [pattern for pattern in schema.get('library', lib, 'tool', 'klayout',
                                                           'allow_missing_cell') if pattern]
@@ -178,8 +150,7 @@ def main():
 
     sc_tech = technology(design, schema)
 
-    gds_export(design, in_def, in_files, out_file, sc_tech, allow_missing,
-               config_file='', seal_file='', timestamps=sc_timestamps)
+    gds_export(design, in_def, out_file, sc_tech, allow_missing, timestamps=sc_timestamps)
 
     if sc_screenshot:
         show(schema, sc_tech, out_file, f'outputs/{design}.png', screenshot=True)

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,