siliconcompiler 0.36.1__py3-none-any.whl → 0.36.3__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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,

siliconcompiler/tool.py

@@ -53,7 +53,8 @@ if TYPE_CHECKING:
     from siliconcompiler.scheduler import SchedulerNode
     from siliconcompiler import Project
 
-TTask = TypeVar('TTask')
+TTask = TypeVar('TTask', bound='Task')
+TShowTask = TypeVar('TShowTask', bound='ShowTask')
 
 
 class TaskError(Exception):
@@ -997,7 +998,7 @@ class Task(NamedSchema, PathSchema, DocsSchema):
                      open(stderr_file, 'w') as stderr_writer:
                     if stderr_file == stdout_file:
                         stderr_writer.close()
-                        stderr_writer = sys.stdout
+                        stderr_writer = stdout_writer
 
                     with contextlib.redirect_stderr(stderr_writer), \
                          contextlib.redirect_stdout(stdout_writer):
@@ -1009,6 +1010,8 @@ class Task(NamedSchema, PathSchema, DocsSchema):
             finally:
                 with sc_open(stdout_file) as stdout_reader, \
                      sc_open(stderr_file) as stderr_reader:
+                    if stdout_file == stderr_file:
+                        stderr_reader = None
                     read_stdio(stdout_reader, stderr_reader)
 
                 if resource:
@@ -2175,7 +2178,8 @@ class ShowTask(Task):
             cls.register_task(c)
 
     @classmethod
-    def get_task(cls, ext: Optional[str]) -> Union[Optional["ShowTask"], Set[Type["ShowTask"]]]:
+    def get_task(cls: Type[TShowTask], ext: Optional[str]) -> \
+            Union[Optional[TShowTask], Set[Type[TShowTask]]]:
         """
         Retrieves a suitable show task instance for a given file extension.
 

siliconcompiler/tools/builtin/wait.py

@@ -0,0 +1,16 @@
+from siliconcompiler.tools.builtin import BuiltinTask
+
+
+class Wait(BuiltinTask):
+    '''
+    A wait task that stalls the flow until all inputs are available.
+    '''
+    def __init__(self):
+        super().__init__()
+
+    def _set_io_files(self):
+        # No file IO needed for wait task
+        return
+
+    def task(self):
+        return "wait"

siliconcompiler/tools/keplerformal/lec.py

@@ -37,7 +37,7 @@ class LECTask(Task):
         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")
+            lib = self.project.get_library(asiclib)
             for corner in libcorners:
                 if not lib.valid("asic", "libcornerfileset", corner, delay_model):
                     continue
@@ -64,7 +64,7 @@ class LECTask(Task):
             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")
+                lib = self.project.get_library(asiclib)
                 for corner in libcorners:
                     if not lib.valid("asic", "libcornerfileset", corner, delay_model):
                         continue

siliconcompiler/tools/klayout/export.py

@@ -79,8 +79,6 @@ class ExportTask(KLayoutTask, ScreenshotParams):
         self.add_output_file(ext="lyt")
         self.add_output_file(ext="lyp")
 
-        self.add_required_key("var", "stream")
-
         sc_stream_order = [default_stream, *[s for s in ("gds", "oas") if s != default_stream]]
         req_set = False
         for s in sc_stream_order:
@@ -98,7 +96,7 @@ class ExportTask(KLayoutTask, ScreenshotParams):
                 lib_requires_stream = False
 
             req_set = False
-            libobj = self.project.get("library", lib, field="schema")
+            libobj = self.project.get_library(lib)
             for s in sc_stream_order:
                 for fileset in libobj.get("asic", "aprfileset"):
                     if libobj.valid("fileset", fileset, "file", s):

siliconcompiler/tools/klayout/merge.py

@@ -0,0 +1,95 @@
+from typing import Optional, Union
+
+from siliconcompiler.tools.klayout import KLayoutTask
+
+
+class Merge(KLayoutTask):
+    """
+    Klayout task to merge multiple GDS files and provide prefixing for cell names.
+    """
+    def __init__(self):
+        super().__init__()
+
+        self.add_parameter("reference", "(<fs,input>,str,str)",
+                           "Reference fileset or input node for merge operation, structured as "
+                           "(fs, library name, fileset) or (input, step, index)")
+        self.add_parameter("merge", "[(<fs,input>,str,str,str)]",
+                           "Fileset or input node to be merge with prefix, structured as "
+                           "(fs, library name, fileset) or (input, step, index) along with prefix "
+                           "string")
+
+    def __fix_type(self, type: str) -> str:
+        if type == "fileset":
+            return "fs"
+        return type
+
+    def set_klayout_reference(self, type: str, source0: str, source1: str,
+                              step: Optional[str] = None,
+                              index: Optional[Union[str, int]] = None):
+        """
+        Sets the reference file for the merge operation.
+        Args:
+            type (str): The reference fileset or input node.
+            source0 (str): The first part of the source (library name or step).
+            source1 (str): The second part of the source (fileset name or index).
+            step (Optional[str]): The specific step to apply this configuration to.
+            index (Optional[Union[str, int]]): The specific index to apply this configuration to.
+        """
+        self.set("var", "reference", (self.__fix_type(type), source0, source1),
+                 step=step, index=index)
+
+    def add_klayout_merge(self, type: str, source0: str, source1: str, prefix: str,
+                          step: Optional[str] = None,
+                          index: Optional[Union[str, int]] = None, clobber: bool = False):
+        """
+        Adds a file to be merged with the reference file.
+        Args:
+            type (str): The fileset or input node to be merged.
+            prefix (str): The prefix to apply during the merge.
+            source0 (str): The first part of the source (library name or step).
+            source1 (str): The second part of the source (fileset name or index).
+            step (Optional[str]): The specific step to apply this configuration to.
+            index (Optional[Union[str, int]]): The specific index to apply this configuration to.
+            clobber (bool, optional): If True, overwrites the existing list of merge files.
+                                      If False, appends to the list. Defaults to False.
+        """
+        if clobber:
+            self.set("var", "merge", (self.__fix_type(type), source0, source1, prefix),
+                     step=step, index=index)
+        else:
+            self.add("var", "merge", (self.__fix_type(type), source0, source1, prefix),
+                     step=step, index=index)
+
+    def task(self) -> str:
+        return 'merge'
+
+    def setup(self) -> None:
+        super().setup()
+
+        self.set_script("klayout_merge.py")
+
+        self.add_required_key("var", "reference")
+        self.add_required_key("var", "merge")
+
+        if self.get("var", "reference"):
+            ref_type, ref_source0, ref_source1 = self.get("var", "reference")
+            if ref_type == 'input':
+                step, index = ref_source0, ref_source1
+                self.add_input_file(
+                    self.compute_input_file_node_name(f"{self.design_topmodule}.gds",
+                                                      step, index))
+            else:
+                lib_name, fileset = ref_source0, ref_source1
+                self.add_required_key("library", lib_name, "fileset", fileset, "file", "gds")
+        for merge_entry in self.get("var", "merge"):
+            merge_type, merge_source0, merge_source1, _ = merge_entry
+            if merge_type == 'input':
+                step, index = merge_source0, merge_source1
+                self.add_input_file(
+                    self.compute_input_file_node_name(f"{self.design_topmodule}.gds",
+                                                      step, index))
+            else:
+                lib_name, fileset = merge_source0, merge_source1
+                self.add_required_key("library", lib_name, "fileset", fileset, "file", "gds")
+
+        self.add_output_file(ext="gds")