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

siliconcompiler/tool.py

@@ -32,10 +32,10 @@ import os.path
 from packaging.version import Version, InvalidVersion
 from packaging.specifiers import SpecifierSet, InvalidSpecifier
 
-from typing import List, Dict, Tuple, Union, Optional, Set, TextIO, Type, TYPE_CHECKING
+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
@@ -53,6 +53,8 @@ if TYPE_CHECKING:
     from siliconcompiler.scheduler import SchedulerNode
     from siliconcompiler import Project
 
+TTask = TypeVar('TTask')
+
 
 class TaskError(Exception):
     '''Error indicating that task execution cannot continue and should be terminated.'''
@@ -76,6 +78,15 @@ class TaskExecutableNotFound(TaskError):
     pass
 
 
+class TaskExecutableNotReceived(TaskExecutableNotFound):
+    '''Error indicating that the tool executable was not received from a previous step.
+
+    This exception is raised specifically when a task expects to receive an executable
+    from an upstream task but no executable file was provided.
+    '''
+    pass
+
+
 class TaskSkip(TaskError):
     """
     Error raised to indicate that the current task should be skipped.
@@ -136,13 +147,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())
@@ -160,7 +172,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",
@@ -802,6 +814,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
@@ -1404,7 +1420,7 @@ class Task(NamedSchema, PathSchema, DocsSchema):
             return True
         return False
 
-    def set_refdir(self, dir: str, dataroot: Optional[str] = None,
+    def set_refdir(self, dir: Union[Path, str], dataroot: Optional[str] = None,
                    step: Optional[str] = None, index: Optional[Union[str, int]] = None,
                    clobber: bool = False):
         '''Sets the reference directory for tool scripts and auxiliary files.
@@ -1428,7 +1444,7 @@ class Task(NamedSchema, PathSchema, DocsSchema):
         with self.active_dataroot(self._get_active_dataroot(dataroot)):
             return self.set("refdir", dir, step=step, index=index, clobber=clobber)
 
-    def set_script(self, script: str, dataroot: Optional[str] = ...,
+    def set_script(self, script: Union[Path, str], dataroot: Optional[str] = ...,
                    step: Optional[str] = None, index: Optional[Union[str, int]] = None,
                    clobber: bool = False):
         '''Sets the main entry script for a script-based tool (e.g., a TCL script).
@@ -1691,7 +1707,8 @@ class Task(NamedSchema, PathSchema, DocsSchema):
                 return self.add("sbom", version, sbom, step=step, index=index)
 
     def record_metric(self, metric: str, value: Union[int, float],
-                      source_file: Optional[str] = None, source_unit: Optional[str] = None,
+                      source_file: Optional[Union[List[Union[Path, str]], Path, str]] = None,
+                      source_unit: Optional[str] = None,
                       quiet: bool = False):
         '''
         Records a metric and associates the source file with it.
@@ -1783,6 +1800,81 @@ class Task(NamedSchema, PathSchema, DocsSchema):
         return super().find_files(*keypath, missing_ok=missing_ok,
                                   step=step, index=index)
 
+    @classmethod
+    def find_task(cls: Type[TTask], project: "Project") -> Union[Set[TTask], TTask]:
+        """Finds registered task(s) in a project that match the calling class.
+
+        This method searches through all tasks configured in the provided `project`
+        and returns those that meet specific criteria derived from the class on
+        which this method is called. The filtering is based on three levels:
+
+        1.  **Class Type**: The primary filter ensures that any found task object
+            is an instance of the calling class (`cls`).
+        2.  **Tool Name**: If the calling class (`cls`) implements the `tool()`
+            method, the search is narrowed to tasks with that specific tool name.
+        3.  **Task Name**: If the calling class (`cls`) implements the `task()`
+            method, the search is further narrowed to tasks with that name.
+
+        The method conveniently returns a single object if only one match is
+        found, or a set of objects if multiple matches are found.
+
+        Args:
+            project (Project): The project instance to search within.
+
+        Returns:
+            Union[Task, Set[Task]]: A single Task instance if exactly one
+            match is found, otherwise a set of matching Task instances.
+
+        Raises:
+            TypeError: If the `project` argument is not a valid `Project` object.
+            ValueError: If no tasks matching the specified criteria are found in
+                the project.
+        """
+
+        from siliconcompiler import Project
+        if not isinstance(project, Project):
+            raise TypeError("project must be a Project")
+
+        task_obj: "Task" = cls()
+        tool, task = None, None
+        try:
+            tool = task_obj.tool()
+        except NotImplementedError:
+            pass
+        try:
+            task = task_obj.task()
+        except NotImplementedError:
+            pass
+
+        all_tasks: Set[Task] = set()
+        for tool_name in project.getkeys("tool"):
+            if tool and tool != tool_name:
+                continue
+            for task_name in project.getkeys("tool", tool_name, "task"):
+                if task and task != task_name:
+                    continue
+                all_tasks.add(project.get("tool", tool_name, "task", task_name, field="schema"))
+
+        tasks: Set[Task] = set()
+        for task_obj in all_tasks:
+            if not isinstance(task_obj, cls):
+                continue
+            tasks.add(task_obj)
+
+        if not tasks:
+            parts = []
+            if tool:
+                parts.append(f"tool='{tool}'")
+            if task:
+                parts.append(f"task='{task}'")
+            parts.append(f"class={cls.__name__}")
+            criteria = ", ".join(parts) if parts else "any criteria"
+            raise ValueError(f"No tasks found matching {criteria}")
+
+        if len(tasks) == 1:
+            return next(iter(tasks))
+        return tasks
+
     def _find_files_search_paths(self, key: str,
                                  step: Optional[str],
                                  index: Optional[Union[int, str]]) -> List[str]:

siliconcompiler/tools/__init__.py

@@ -36,6 +36,14 @@ def get_task(
         ValueError: If no tasks match the specified criteria.
         TypeError: If project is not a Project instance.
     """
+    import warnings
+    warnings.warn("This function is deprecated and will be removed in a future version, "
+                  "use cls.find_task instead", DeprecationWarning, stacklevel=2)
+
+    if filter:
+        if inspect.isclass(filter):
+            return filter.find_task(project)
+
     from siliconcompiler import Project
     if not isinstance(project, Project):
         raise TypeError("project must be a Project")
@@ -52,10 +60,7 @@ def get_task(
         if task and task_obj.task() != task:
             continue
         if filter:
-            if inspect.isclass(filter):
-                if not isinstance(task_obj, filter):
-                    continue
-            elif callable(filter):
+            if callable(filter):
                 if not filter(task_obj):
                     continue
             else:
@@ -69,9 +74,7 @@ def get_task(
         if task:
             parts.append(f"task='{task}'")
         if filter:
-            if inspect.isclass(filter):
-                parts.append(f"filter={filter.__name__}")
-            elif callable(filter):
+            if callable(filter):
                 filter_name = getattr(filter, '__name__', repr(filter))
                 parts.append(f"filter={filter_name}")
         criteria = ", ".join(parts) if parts else "any criteria"

siliconcompiler/tools/bambu/convert.py

@@ -4,6 +4,8 @@ import shutil
 
 import os.path
 
+from typing import Optional
+
 from siliconcompiler.utils import sc_open
 
 from siliconcompiler import Task
@@ -17,6 +19,23 @@ class ConvertTask(ASICTask, Task):
         self.add_parameter("memorychannels", "int", "Number of memory channels available",
                            defvalue=1)
 
+    def set_bambu_memorychannels(self, channels: int,
+                                 step: Optional[str] = None, index: Optional[str] = None) -> None:
+        """Sets the number of memory channels for the Bambu synthesizer.
+
+        This method configures the 'memorychannels' variable within the Bambu
+        tool flow. It's used to specify the number of independent memory
+        channels the synthesized hardware should have.
+
+        Args:
+            channels: The number of memory channels to configure.
+            step: The specific synthesis step to which this setting applies.
+                  If None, it applies globally. Defaults to None.
+            index: The index for the step, used if a step can have multiple
+                   configurations. Defaults to None.
+        """
+        self.set("var", "memorychannels", channels, step=step, index=index)
+
     def tool(self):
         return "bambu"
 

siliconcompiler/tools/builtin/__init__.py

@@ -7,7 +7,6 @@ from siliconcompiler import NodeStatus
 
 from siliconcompiler import Task
 from siliconcompiler import utils
-from siliconcompiler.tools import get_task
 
 
 class BuiltinTask(Task):
@@ -22,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)
@@ -58,7 +59,7 @@ class BuiltinTask(Task):
         flow.set("<step>", "<index>", "args", "errors==0")
         proj.set_flow(flow)
 
-        get_task(proj, filter=NOPTask).add_output_file("<top>.v", step="<in>", index="0")
+        NOPTask.find_task(proj).add_output_file("<top>.v", step="<in>", index="0")
         node = SchedulerNode(proj, "<step>", "<index>")
         node.setup()
         return node.task

siliconcompiler/tools/builtin/filter.py

@@ -0,0 +1,108 @@
+import fnmatch
+import shutil
+
+from typing import Optional, List, Union
+
+from siliconcompiler import Task
+from siliconcompiler import utils
+
+
+class FilterTask(Task):
+    '''
+    A task for filtering files based on specified glob patterns.
+
+    This task determines which files to "keep" from a given set of inputs,
+    passing only those that match the criteria to the outputs.
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.add_parameter("keep", "[str]", "Glob of files to keep")
+
+    def add_filter_keep(self, keep: Union[List[str], str],
+                        step: Optional[str] = None, index: Optional[str] = None,
+                        clobber: bool = False) -> None:
+        '''
+        Adds one or more glob patterns for files to keep.
+
+        Args:
+            keep (Union[List[str], str]): A single glob pattern or a list of
+                glob patterns to identify which files should be kept.
+            step (Optional[str], optional): The specific workflow step to
+                apply this filter to. Defaults to None.
+            index (Optional[str], optional): The specific index within the step
+                to apply this filter to. Defaults to None.
+            clobber (bool, optional): If True, existing 'keep' patterns are
+                overwritten with the new value(s). If False, the new patterns
+                are appended to the existing list. Defaults to False.
+        '''
+        if clobber:
+            self.set("var", "keep", keep, step=step, index=index)
+        else:
+            self.add("var", "keep", keep, step=step, index=index)
+
+    def tool(self):
+        return "builtin"
+
+    def task(self):
+        return "filter"
+
+    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") or graph_node.get_args()
+        if not filters:
+            filters = ["*"]
+
+        keep_files = []
+        for keep in filters:
+            keep_files.extend(fnmatch.filter(files, keep))
+
+        if not keep_files:
+            self.logger.warning(f"Filters ({', '.join(filters)}) removed all incoming files")
+        else:
+            self.add_input_file(keep_files)
+            self.add_output_file(keep_files)
+
+    def run(self):
+        self.logger.info(f"Running builtin task '{self.task()}'")
+
+        shutil.copytree('inputs', 'outputs', dirs_exist_ok=True,
+                        copy_function=utils.link_symlink_copy)
+
+        return 0
+
+    @classmethod
+    def make_docs(cls):
+        from siliconcompiler import Flowgraph, Design, Project
+        from siliconcompiler.scheduler import SchedulerNode
+        from siliconcompiler.tools.builtin.nop import NOPTask
+        design = Design("<design>")
+        with design.active_fileset("docs"):
+            design.set_topmodule("top")
+        proj = Project(design)
+        proj.add_fileset("docs")
+        flow = Flowgraph("docsflow")
+        flow.node("<in>", NOPTask())
+        flow.node("<step>", cls(), index="<index>")
+        flow.edge("<in>", "<step>", head_index="<index>")
+        proj.set_flow(flow)
+
+        NOPTask.find_task(proj).add_output_file("<top>.v", step="<in>", index="0")
+        node = SchedulerNode(proj, "<step>", "<index>")
+        node.setup()
+        return node.task

siliconcompiler/tools/builtin/importfiles.py

@@ -0,0 +1,154 @@
+import shutil
+
+import os.path
+
+from pathlib import Path
+
+from typing import Union, List, Optional
+
+from siliconcompiler import Task
+from siliconcompiler.utils import link_copy
+
+
+class ImportFilesTask(Task):
+    '''A built-in task to import (copy) files and directories.
+
+    This task provides a mechanism to copy specified files and directories
+    from their source locations into the current task's output directory
+    (``outputs/``), making them available for subsequent steps in the tool flow.
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.add_parameter("file", "[file]", "input files to import")
+        self.add_parameter("dir", "[dir]", "input directories to import")
+
+    def add_import_file(self, file: Union[List[Union[str, Path]], str, Path],
+                        dataroot: Optional[str] = None,
+                        step: Optional[str] = None, index: Optional[str] = None,
+                        clobber: bool = False) -> None:
+        """Adds one or more files to the list of items to import.
+
+        Args:
+            file (Union[List[Union[str, Path]], str, Path]): The path(s) to the file(s)
+                to be imported.
+            dataroot (Optional[str]): The dataroot to use for resolving relative paths.
+                If None, the active dataroot is used. Defaults to None.
+            step (Optional[str]): The step to associate this file with.
+                Defaults to the current step.
+            index (Optional[str]): The index to associate this file with.
+                Defaults to the current index.
+            clobber (bool): If True, existing file entries for the specified
+                step/index will be overwritten. If False, the new file(s)
+                will be appended. Defaults to False.
+        """
+        with self.active_dataroot(self._get_active_dataroot(dataroot)):
+            if clobber:
+                self.set("var", "file", file, step=step, index=index)
+            else:
+                self.add("var", "file", file, step=step, index=index)
+
+    def add_import_dir(self, directory: Union[List[Union[str, Path]], str, Path],
+                       dataroot: Optional[str] = None,
+                       step: Optional[str] = None, index: Optional[str] = None,
+                       clobber: bool = False) -> None:
+        """Adds one or more directories to the list of items to import.
+
+        Args:
+            directory (Union[List[Union[str, Path]], str, Path]): The path(s) to the
+                directory/directories to be imported.
+            dataroot (Optional[str]): The dataroot to use for resolving relative paths.
+                If None, the active dataroot is used. Defaults to None.
+            step (Optional[str]): The step to associate this directory with.
+                Defaults to the current step.
+            index (Optional[str]): The index to associate this directory with.
+                Defaults to the current index.
+            clobber (bool): If True, existing directory entries for the specified
+                step/index will be overwritten. If False, the new directory/directories
+                will be appended. Defaults to False.
+        """
+        with self.active_dataroot(self._get_active_dataroot(dataroot)):
+            if clobber:
+                self.set("var", "dir", directory, step=step, index=index)
+            else:
+                self.add("var", "dir", directory, step=step, index=index)
+
+    def tool(self) -> str:
+        return "builtin"
+
+    def task(self) -> str:
+        return "importfiles"
+
+    def setup(self) -> None:
+        """Prepares the task for execution by setting up dependencies and requirements.
+
+        This method validates that the task is configured correctly (i.e., has files
+        or directories to import and does not have formal input nodes) and registers
+        the items to be imported as task outputs.
+
+        Raises:
+            ValueError: If the task is configured with input nodes or if no
+                files or directories are specified for import.
+        """
+        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")
+
+        if not self.get("var", "file") and not self.get("var", "dir"):
+            raise ValueError("task requires files or directories to import")
+
+        if self.get("var", "file"):
+            self.add_required_key("var", "file")
+
+        if self.get("var", "dir"):
+            self.add_required_key("var", "dir")
+
+        for file in self.get("var", "file") + self.get("var", "dir"):
+            self.add_output_file(os.path.basename(file))
+
+    def run(self) -> int:
+        """Executes the file and directory import process.
+
+        Copies all specified files and directories into the task's ``outputs/``
+        directory using a copy function that attempts to create hard links
+        as an optimization.
+
+        Returns:
+            int: A status code, where 0 indicates successful execution.
+        """
+        self.logger.info(f"Running builtin task '{self.task()}'")
+
+        for file in self.find_files("var", "file"):
+            self.logger.debug(f"Copying file {file} to outputs")
+            link_copy(file, "outputs/")
+
+        for directory in self.find_files("var", "dir"):
+            # For directories, copytree needs the destination to be the specific new directory name
+            dest_dir = os.path.join("outputs", os.path.basename(directory))
+            self.logger.debug(f"Copying directory {directory} to {dest_dir}")
+            shutil.copytree(directory, dest_dir, copy_function=link_copy)
+
+        return 0
+
+    @classmethod
+    def make_docs(cls):
+        from siliconcompiler import Flowgraph, Design, Project
+        from siliconcompiler.scheduler import SchedulerNode
+        design = Design("<design>")
+        with design.active_fileset("docs"):
+            design.set_topmodule("top")
+        proj = Project(design)
+        proj.add_fileset("docs")
+        flow = Flowgraph("docsflow")
+        flow.node("<step>", cls(), index="<index>")
+        proj.set_flow(flow)
+
+        cls.find_task(proj).add_import_file("import.txt")
+        cls.find_task(proj).add_import_dir("/directory")
+
+        node = SchedulerNode(proj, "<step>", "<index>")
+        node.setup()
+        return node.task

siliconcompiler/tools/execute/exec_input.py

@@ -4,7 +4,7 @@ import stat
 import os.path
 
 from siliconcompiler import Task
-from siliconcompiler.tools import get_task
+from siliconcompiler.tool import TaskExecutableNotReceived
 
 
 class ExecInputTask(Task):
@@ -41,7 +41,8 @@ class ExecInputTask(Task):
             break
 
         if not exec:
-            raise FileNotFoundError(f'{self.step}/{self.index} did not receive an executable file')
+            raise TaskExecutableNotReceived(f'{self.step}/{self.index} did not receive an '
+                                            'executable file')
 
         os.chmod(exec, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
 
@@ -64,7 +65,7 @@ class ExecInputTask(Task):
         flow.set("<step>", "<index>", "args", "errors==0")
         proj.set_flow(flow)
 
-        get_task(proj, filter=NOPTask).add_output_file("<top>.exe", step="<in>", index="0")
+        NOPTask.find_task(proj).add_output_file("<top>.exe", step="<in>", index="0")
         node = SchedulerNode(proj, "<step>", "<index>")
         node.setup()
         return node.task

siliconcompiler/tools/gtkwave/show.py

@@ -5,13 +5,13 @@ from siliconcompiler import ShowTask
 
 class ShowTask(ShowTask):
     '''
-    Show a VCD file.
+    Show a VCD or FST file.
     '''
     def tool(self):
         return "gtkwave"
 
     def get_supported_show_extentions(self):
-        return ["vcd"]
+        return ["vcd", "fst"]
 
     def parse_version(self, stdout):
         # First line: GTKWave Analyzer v3.3.116 (w)1999-2023 BSI
@@ -37,6 +37,8 @@ class ShowTask(ShowTask):
 
         if f"{self.design_topmodule}.vcd" in self.get_files_from_input_nodes():
             self.add_input_file(ext="vcd")
+        elif f"{self.design_topmodule}.fst" in self.get_files_from_input_nodes():
+            self.add_input_file(ext="fst")
         else:
             self.add_required_key("var", "showfilepath")
 
@@ -48,6 +50,8 @@ class ShowTask(ShowTask):
 
         if os.path.exists(f'inputs/{self.design_topmodule}.vcd'):
             dump = f'inputs/{self.design_topmodule}.vcd'
+        elif os.path.exists(f'inputs/{self.design_topmodule}.fst'):
+            dump = f'inputs/{self.design_topmodule}.fst'
         else:
             dump = self.find_files('var', 'showfilepath')
         options.append(f'--dump={dump}')

siliconcompiler/tools/icarus/compile.py

@@ -103,6 +103,7 @@ class CompileTask(Task):
             options.append('-D' + define)
 
         # add siliconcompiler specific defines
+        options.append("-DSILICONCOMPILER_TRACE_DIR=\"reports\"")
         options.append(f"-DSILICONCOMPILER_TRACE_FILE=\"reports/{self.design_topmodule}.vcd\"")
 
         #######################

siliconcompiler/tools/klayout/scripts/klayout_show.py

@@ -250,7 +250,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/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}")

siliconcompiler/tools/openroad/screenshot.py

@@ -16,7 +16,6 @@ class ScreenshotTask(ScreenshotTask, ShowTask):
     def setup(self):
         super().setup()
 
-        self.unset("input")
         self.add_output_file(ext="png", clobber=True)
 
         self.set_script("sc_show.tcl")

siliconcompiler/tools/openroad/scripts/common/screenshot.tcl

@@ -11,5 +11,5 @@ sc_save_image \
 gui::restore_display_controls
 
 if { [sc_cfg_tool_task_get var include_report_images] } {
-    source "${sc_refdir}/sc_write_images.tcl"
+    source "${sc_refdir}/common/write_images.tcl"
 }