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

siliconcompiler/flowgraph.py

@@ -734,7 +734,7 @@ class Flowgraph(NamedSchema, DocsSchema):
         """
         return Flowgraph.__name__
 
-    def __get_graph_information(self):
+    def __get_graph_information(self, landscape):
         '''
         Internal helper to gather all node and edge info for graphviz.
 
@@ -744,6 +744,14 @@ class Flowgraph(NamedSchema, DocsSchema):
                 - dict: Information about each node.
                 - list: Information about each edge.
         '''
+        from siliconcompiler import Project
+        if landscape:
+            out_label_suffix = ':e'
+            in_label_suffix = ':w'
+        else:
+            out_label_suffix = ':s'
+            in_label_suffix = ':n'
+
         # Setup nodes
         node_exec_order = self.get_execution_order()
 
@@ -752,13 +760,9 @@ class Flowgraph(NamedSchema, DocsSchema):
             for step, index in rank_nodes:
                 node_rank[f'{step}/{index}'] = rank
 
-        # TODO: This appears to be unused, legacy from when files were nodes
-        all_graph_inputs = set()
-
         exit_nodes = [f'{step}/{index}' for step, index in self.get_exit_nodes()]
 
         nodes = {}
-        edges = []
 
         def clean_label(label):
             return label.replace("<", "").replace(">", "")
@@ -770,19 +774,34 @@ class Flowgraph(NamedSchema, DocsSchema):
 
         runtime_flow = RuntimeFlowgraph(self)
 
+        root = self._parent()._parent()  # Brittle since this replies on location
+        if not isinstance(root, Project):
+            root = None
+            has_io = False
+        else:
+            has_io = True
+
         for step, index in all_nodes:
             graph_node = self.get_graph_node(step, index)
-            tool = graph_node.get("tool")
-            task = graph_node.get("task")
+            tool: str = graph_node.get("tool")
+            task: str = graph_node.get("task")
 
             inputs = []
             outputs = []
+            if has_io and root:
+                try:
+                    inputs = root.get('tool', tool, 'task', task, 'input', step=step, index=index)
+                    outputs = root.get('tool', tool, 'task', task, 'output', step=step, index=index)
+                except KeyError:
+                    has_io = False
+                if not inputs and not outputs:
+                    has_io = False
 
             node = f'{step}/{index}'
 
             nodes[node] = {
                 "node": (step, index),
-                "file_inputs": inputs,
+                "file_inputs": set(inputs),
                 "inputs": {clean_text(f): f'input-{clean_label(f)}' for f in sorted(inputs)},
                 "outputs": {clean_text(f): f'output-{clean_label(f)}' for f in sorted(outputs)},
                 "task": f'{tool}/{task}' if tool != 'builtin' else task,
@@ -800,23 +819,41 @@ class Flowgraph(NamedSchema, DocsSchema):
                 rank_diff[in_node_name] = node_rank[node] - node_rank[in_node_name]
             nodes[node]["rank_diff"] = rank_diff
 
+        if not has_io:
+            for info in nodes.values():
+                info["inputs"] = []
+                info["outputs"] = []
+
+        edges = []
+        edges_io = []
         for step, index in all_nodes:
             node = f'{step}/{index}'
             all_inputs = []
             for in_step, in_index in self.get_graph_node(step, index).get_input():
                 all_inputs.append(f'{in_step}/{in_index}')
             for item in all_inputs:
-                edges.append((item, node, 1 if node in exit_nodes else 2))
-
-        return all_graph_inputs, nodes, edges
+                edges.append((f"{item}{out_label_suffix}",
+                              f"{node}{in_label_suffix}",
+                              1 if node in exit_nodes else 2))
+                if has_io:
+                    for infile in nodes[node]["inputs"]:
+                        if infile in nodes[item]["outputs"]:
+                            outlabel = f"{item}:output-{clean_label(infile)}"
+                            inlabel = f"{node}:input-{clean_label(infile)}"
+                            edges_io.append((f"{outlabel}{out_label_suffix}",
+                                             f"{inlabel}{in_label_suffix}",
+                                             1 if node in exit_nodes else 2))
+
+        return nodes, edges, edges_io, has_io
 
     def write_flowgraph(self, filename: str,
-                        fillcolor: Optional[str] = '#ffffff',
-                        fontcolor: Optional[str] = '#000000',
-                        background: Optional[str] = 'transparent',
-                        fontsize: Optional[Union[int, str]] = 14,
-                        border: Optional[bool] = True,
-                        landscape: Optional[bool] = False) -> None:
+                        fillcolor: str = '#ffffff',
+                        fontcolor: str = '#000000',
+                        background: str = 'transparent',
+                        fontsize: Union[int, str] = 14,
+                        border: bool = True,
+                        landscape: bool = False,
+                        show_io: Optional[bool] = None) -> None:
         r'''
         Renders and saves the compilation flowgraph to a file.
 
@@ -837,6 +874,7 @@ class Flowgraph(NamedSchema, DocsSchema):
             fontsize (str): Node text font size
             border (bool): Enables node border if True
             landscape (bool): Renders graph in landscape layout if True
+            show_io (bool): Add file input/outputs to graph
 
         Examples:
             >>> flow.write_flowgraph('mydump.png')
@@ -858,21 +896,22 @@ class Flowgraph(NamedSchema, DocsSchema):
         # controlling graph direction
         if landscape:
             rankdir = 'LR'
-            out_label_suffix = ':e'
-            in_label_suffix = ':w'
         else:
             rankdir = 'TB'
-            out_label_suffix = ':s'
-            in_label_suffix = ':n'
 
-        all_graph_inputs, nodes, edges = self.__get_graph_information()
+        nodes, edges, edges_io, has_io = self.__get_graph_information(landscape)
 
-        out_label_suffix = ''
-        in_label_suffix = ''
+        if show_io is None:
+            show_io = has_io
+        elif not has_io:
+            show_io = False
 
         dot = graphviz.Digraph(format=fileformat)
         dot.graph_attr['rankdir'] = rankdir
         dot.attr(bgcolor=background)
+        if show_io:
+            dot.graph_attr['concentrate'] = 'true'
+            dot.graph_attr['ranksep'] = '0.75'
 
         subgraphs = {
             "graphs": {},
@@ -901,24 +940,25 @@ class Flowgraph(NamedSchema, DocsSchema):
 
             subgraph_temp["nodes"].append(node)
 
-        with dot.subgraph(name='inputs') as input_graph:
-            input_graph.graph_attr['cluster'] = 'true'
-            input_graph.graph_attr['color'] = background
-
-            # add inputs
-            for graph_input in sorted(all_graph_inputs):
-                input_graph.node(
-                    graph_input, label=graph_input, bordercolor=fontcolor, style='filled',
-                    fontcolor=fontcolor, fontsize=fontsize, ordering="in",
-                    penwidth=penwidth, fillcolor=fillcolor, shape="box")
-
         def make_node(graph, node, prefix):
             '''Helper function to create a node in the graphviz object.'''
             info = nodes[node]
 
-            shape = "oval"
+            shape = "oval" if not show_io else "Mrecord"
             task_label = f"\\n ({info['task']})" if info['task'] is not None else ""
-            labelname = f"{node.replace(prefix, '')}{task_label}"
+            if show_io:
+                input_labels = [f"<{ikey}> {ifile}" for ifile, ikey in info['inputs'].items()]
+                output_labels = [f"<{okey}> {ofile}" for ofile, okey in info['outputs'].items()]
+                center_text = f"\\n {node.replace(prefix, '')} {task_label} \\n\\n"
+                labelname = "{"
+                if input_labels:
+                    labelname += f"{{ {' | '.join(input_labels)} }} |"
+                labelname += center_text
+                if output_labels:
+                    labelname += f"| {{ {' | '.join(output_labels)} }}"
+                labelname += "}"
+            else:
+                labelname = f"{node.replace(prefix, '')}{task_label}"
 
             graph.node(node, label=labelname, bordercolor=fontcolor, style='filled',
                        fontcolor=fontcolor, fontsize=fontsize, ordering="in",
@@ -975,8 +1015,12 @@ class Flowgraph(NamedSchema, DocsSchema):
         build_graph(subgraphs, dot, "")
 
         # Add all the edges
-        for edge0, edge1, weight in edges:
-            dot.edge(f'{edge0}{out_label_suffix}', f'{edge1}{in_label_suffix}', weight=str(weight))
+        if show_io:
+            for edge0, edge1, weight in edges_io:
+                dot.edge(edge0, edge1, weight=str(weight))
+        else:
+            for edge0, edge1, weight in edges:
+                dot.edge(edge0, edge1, weight=str(weight))
 
         dot.render(filename=fileroot, cleanup=True)
 
@@ -1270,21 +1314,30 @@ class RuntimeFlowgraph:
         if (step, index) not in self.get_nodes():
             raise ValueError(f"{step}/{index} is not a valid node")
 
+        base_nodes = set(self.__base.get_nodes())
+
         if record is None:
             inputs = set()
             for in_step, in_index in self.__base.get(step, index, "input"):
-                if (in_step, in_index) not in self.get_nodes():
+                if (in_step, in_index) not in base_nodes:
+                    continue
+                if (in_step, in_index) in self.__prune:
                     continue
                 inputs.add((in_step, in_index))
             return sorted(inputs)
 
         inputs = set()
         for in_step, in_index in self.__base.get(step, index, "input"):
-            if (in_step, in_index) not in self.get_nodes():
+            if (in_step, in_index) not in base_nodes:
+                continue
+            if (in_step, in_index) in self.__prune:
                 continue
 
             if record.get("status", step=in_step, index=in_index) == NodeStatus.SKIPPED:
-                inputs.update(self.get_node_inputs(in_step, in_index, record=record))
+                if (in_step, in_index) not in self.get_nodes():
+                    inputs.update(self.__base.get(in_step, in_index, "input"))
+                else:
+                    inputs.update(self.get_node_inputs(in_step, in_index, record=record))
             else:
                 inputs.add((in_step, in_index))
         return sorted(inputs)

siliconcompiler/flows/generate_openroad_rcx.py

@@ -74,8 +74,8 @@ class GenerateOpenRCXFlow(Flowgraph):
     @classmethod
     def make_docs(cls):
         from siliconcompiler.tools.builtin.nop import NOPTask
-        return [GenerateOpenRCXFlow(NOPTask(), corners=3, serial_extraction=False),
-                GenerateOpenRCXFlow(NOPTask(), corners=3, serial_extraction=True)]
+        return [cls(NOPTask(), corners=3, serial_extraction=False),
+                cls(NOPTask(), corners=3, serial_extraction=True)]
 
 
 ##################################################

siliconcompiler/flows/highresscreenshotflow.py

@@ -0,0 +1,37 @@
+from siliconcompiler import Flowgraph
+
+from siliconcompiler.tools.builtin import importfiles
+from siliconcompiler.tools.klayout import operations
+from siliconcompiler.tools.klayout import screenshot
+from siliconcompiler.tools.montage import tile
+
+
+class HighResScreenshotFlow(Flowgraph):
+    '''A high resolution screenshot flow.
+
+    This flow is designed to generate a high resolution design image from a GDS
+    or OAS file by preparing the layout, taking tiled screenshots, and merging
+    them into a single image.
+    '''
+    def __init__(self, name: str = "screenshotflow", add_prepare: bool = True):
+        super().__init__(name)
+
+        self.node('import', importfiles.ImportFilesTask())
+        if add_prepare:
+            self.node('prepare', operations.OperationsTask())
+        self.node('screenshot', screenshot.ScreenshotTask())
+        self.node('merge', tile.TileTask())
+
+        if add_prepare:
+            self.edge('import', 'prepare')
+            self.edge('prepare', 'screenshot')
+        else:
+            self.edge('import', 'screenshot')
+        self.edge('screenshot', 'merge')
+
+    @classmethod
+    def make_docs(cls):
+        return [
+            cls(add_prepare=True),
+            cls(add_prepare=False)
+        ]

siliconcompiler/library.py

@@ -276,7 +276,8 @@ class StdCellLibrary(DependencySchema, ToolLibrarySchema):
                 'filler',
                 'tap',
                 'endcap',
-                'antenna']:
+                'antenna',
+                'physicalonly']:
             schema.insert(
                 'asic', 'cells', item,
                 Parameter(

siliconcompiler/package/__init__.py

@@ -16,20 +16,23 @@ import logging
 import os
 import random
 import re
+import shutil
 import time
 import threading
 import uuid
 
 import os.path
 
-from typing import Optional, List, Dict, Type, Union, TYPE_CHECKING, ClassVar
+from typing import Optional, List, Dict, Type, Union, TYPE_CHECKING, Final
 
 from fasteners import InterProcessLock
 from importlib.metadata import distributions, distribution
 from pathlib import Path
 from urllib import parse as url_parse
 
-from siliconcompiler.utils import get_plugins
+from siliconcompiler.utils import get_plugins, default_cache_dir
+from siliconcompiler.utils.paths import cwdirsafe
+from siliconcompiler.utils.multiprocessing import MPManager
 
 if TYPE_CHECKING:
     from siliconcompiler.project import Project
@@ -52,12 +55,7 @@ class Resolver:
         source (str): The URI or path specifying the data source.
         reference (str): A version, commit hash, or tag for remote sources.
     """
-    _RESOLVERS_LOCK: ClassVar[threading.Lock] = threading.Lock()
-    _RESOLVERS: ClassVar[Dict[str, Type["Resolver"]]] = {}
-    __STORAGE: str = "__Resolver_cache_id"
-
-    __CACHE_LOCK: ClassVar[threading.Lock] = threading.Lock()
-    __CACHE: ClassVar[Dict[str, Dict[str, str]]] = {}
+    __STORAGE: Final[str] = "__Resolver_cache_id"
 
     def __init__(self, name: str,
                  root: Optional[Union["Project", "BaseSchema"]],
@@ -87,18 +85,19 @@ class Resolver:
         built-in resolvers (file, key, python) and any resolvers provided
         by external plugins.
         """
-        with Resolver._RESOLVERS_LOCK:
-            Resolver._RESOLVERS.clear()
+        settings = MPManager().get_transient_settings()
+        if settings.get_category("resolvers"):
+            # Already populated
+            return
 
-            Resolver._RESOLVERS.update({
-                "": FileResolver,
-                "file": FileResolver,
-                "key": KeyPathResolver,
-                "python": PythonPathResolver
-            })
+        settings.set("resolvers", "", FileResolver)
+        settings.set("resolvers", "file", FileResolver)
+        settings.set("resolvers", "key", KeyPathResolver)
+        settings.set("resolvers", "python", PythonPathResolver)
 
-            for resolver in get_plugins("path_resolver"):
-                Resolver._RESOLVERS.update(resolver())
+        for resolver in get_plugins("path_resolver"):
+            for scheme, res in resolver().items():
+                settings.set("resolvers", scheme, res)
 
     @staticmethod
     def find_resolver(source: str) -> Type["Resolver"]:
@@ -117,13 +116,13 @@ class Resolver:
         if os.path.isabs(source):
             return FileResolver
 
-        if not Resolver._RESOLVERS:
-            Resolver.populate_resolvers()
+        Resolver.populate_resolvers()
 
         url = url_parse.urlparse(source)
-        with Resolver._RESOLVERS_LOCK:
-            if url.scheme in Resolver._RESOLVERS:
-                return Resolver._RESOLVERS[url.scheme]
+        settings = MPManager().get_transient_settings()
+        resolver = settings.get("resolvers", url.scheme, None)
+        if resolver:
+            return resolver
 
         raise ValueError(f"Source URI '{source}' is not supported")
 
@@ -229,15 +228,14 @@ class Resolver:
         if root is None:
             return None
 
-        with Resolver.__CACHE_LOCK:
-            root_id = Resolver.__get_root_id(root)
-            if root_id not in Resolver.__CACHE:
-                Resolver.__CACHE[root_id] = {}
+        cache_id = f"resolver-cache-{Resolver.__get_root_id(root)}"
+
+        settings = MPManager().get_transient_settings()
 
-            if name:
-                return Resolver.__CACHE[root_id].get(name, None)
+        if name is not None:
+            return settings.get(cache_id, name, None)
 
-            return Resolver.__CACHE[root_id].copy()
+        return settings.get_category(cache_id)
 
     @staticmethod
     def set_cache(root: Optional[Union["Project", "BaseSchema"]],
@@ -254,11 +252,11 @@ class Resolver:
         if root is None:
             return
 
-        with Resolver.__CACHE_LOCK:
-            root_id = Resolver.__get_root_id(root)
-            if root_id not in Resolver.__CACHE:
-                Resolver.__CACHE[root_id] = {}
-            Resolver.__CACHE[root_id][name] = str(path)
+        cache_id = f"resolver-cache-{Resolver.__get_root_id(root)}"
+
+        settings = MPManager().get_transient_settings()
+
+        settings.set(cache_id, name, str(path))
 
     @staticmethod
     def reset_cache(root: Optional[Union["Project", "BaseSchema"]]) -> None:
@@ -270,11 +268,11 @@ class Resolver:
         """
         if root is None:
             return
+        cache_id = f"resolver-cache-{Resolver.__get_root_id(root)}"
 
-        with Resolver.__CACHE_LOCK:
-            root_id = Resolver.__get_root_id(root)
-            if root_id in Resolver.__CACHE:
-                del Resolver.__CACHE[root_id]
+        settings = MPManager().get_transient_settings()
+
+        settings.delete(cache_id)
 
     def get_path(self) -> str:
         """
@@ -332,9 +330,6 @@ class RemoteResolver(Resolver):
     both thread-safe and process-safe locking to prevent race conditions when
     multiple SC instances try to download the same resource simultaneously.
     """
-    _CACHE_LOCKS = {}
-    _CACHE_LOCK = threading.Lock()
-
     def __init__(self, name: str,
                  root: Optional[Union["Project", "BaseSchema"]],
                  source: str,
@@ -370,7 +365,7 @@ class RemoteResolver(Resolver):
         Returns:
             Path: The path to the cache directory.
         """
-        default_path = os.path.join(Path.home(), '.sc', 'cache')
+        default_path = default_cache_dir()
         if not root:
             return Path(default_path)
 
@@ -380,8 +375,7 @@ class RemoteResolver(Resolver):
             if path:
                 path = root.find_files('option', 'cachedir', missing_ok=True)
                 if not path:
-                    path = os.path.join(getattr(root, "_Project__cwd", os.getcwd()),
-                                        root.get('option', 'cachedir'))
+                    path = os.path.join(cwdirsafe(root), root.get('option', 'cachedir'))
         if not path:
             path = default_path
 
@@ -428,10 +422,11 @@ class RemoteResolver(Resolver):
 
     def thread_lock(self) -> threading.Lock:
         """Gets a threading.Lock specific to this resolver instance."""
-        with RemoteResolver._CACHE_LOCK:
-            if self.name not in RemoteResolver._CACHE_LOCKS:
-                RemoteResolver._CACHE_LOCKS[self.name] = threading.Lock()
-            return RemoteResolver._CACHE_LOCKS[self.name]
+        settings = MPManager().get_transient_settings()
+        locks = settings.get_category("resolver-remote-cache-locks")
+        if self.name not in locks:
+            settings.set("resolver-remote-cache-locks", self.name, threading.Lock(), keep=True)
+        return settings.get("resolver-remote-cache-locks", self.name)
 
     @contextlib.contextmanager
     def __thread_lock(self):
@@ -543,7 +538,17 @@ class RemoteResolver(Resolver):
             if self.check_cache():
                 return self.cache_path
 
-            self.resolve_remote()
+            try:
+                self.resolve_remote()
+            except BaseException as e:
+                # Exception occurred, so need to cleanup
+                try:
+                    shutil.rmtree(self.cache_path)
+                except BaseException as cleane:
+                    self.logger.error(f"Exception occurred during cleanup: {cleane} "
+                                      f"({cleane.__class__.__name__})")
+                raise e from None
+
             self.set_changed()
             return self.cache_path
 
@@ -560,7 +565,7 @@ class FileResolver(Resolver):
         if source.startswith("file://"):
             source = source[7:]
         if source[0] != "$" and not os.path.isabs(source):
-            source = os.path.join(getattr(root, "_Project__cwd", os.getcwd()), source)
+            source = os.path.join(cwdirsafe(root), source)
 
         super().__init__(name, root, f"file://{source}", None)
 

siliconcompiler/project.py

@@ -205,7 +205,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         Returns:
             str: The name of the top-level design.
         """
-        return self.get("option", "design")
+        return self.option.get_design()
 
     @property
     def design(self) -> Design:
@@ -373,6 +373,9 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         """
         if isinstance(obj, DependencySchema):
             for dep in obj.get_dep():
+                if isinstance(dep, (Design, LibrarySchema)):
+                    if self._has_library(dep.name):
+                        continue
                 self.add_dep(dep)
 
             # Rebuild dependencies to ensure instances are correct
@@ -394,13 +397,21 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
             return
 
         edit_schema = EditableSchema(self)
-        edit_schema.insert("flowgraph", flow.name, flow)
 
         # Instantiate tasks
         for task_cls in flow.get_all_tasks():
             task = task_cls()
             if not self.valid("tool", task.tool(), "task", task.task()):
                 edit_schema.insert("tool", task.tool(), "task", task.task(), task)
+            else:
+                existing_task: Task = self.get("tool", task.tool(), "task", task.task(),
+                                               field="schema")
+                if type(existing_task) is not type(task):
+                    raise TypeError(f"Task {task.tool()}/{task.task()} already exists with "
+                                    f"different type {type(existing_task).__name__}, "
+                                    f"imported type is {type(task).__name__}")
+
+        edit_schema.insert("flowgraph", flow.name, flow)
 
     def check_manifest(self) -> bool:
         """

siliconcompiler/scheduler/docker.py

@@ -3,6 +3,8 @@ import os
 import shlex
 import sys
 
+import docker.errors
+
 from pathlib import Path
 
 import siliconcompiler
@@ -11,10 +13,9 @@ from siliconcompiler.package import RemoteResolver
 from siliconcompiler.utils import default_email_credentials_file
 from siliconcompiler.scheduler import SchedulerNode
 from siliconcompiler.utils.logging import SCBlankLoggerFormatter
-from siliconcompiler.utils.curation import collect
 
 
-def get_image(project, step, index):
+def get_image(project, step, index) -> str:
     """Determines the Docker image to use for a given node.
 
     The image is selected based on the following priority:
@@ -32,7 +33,7 @@ def get_image(project, step, index):
     """
     from siliconcompiler import __version__
 
-    queue = project.get('option', 'scheduler', 'queue', step=step, index=index)
+    queue = project.option.scheduler.get_queue(step=step, index=index)
     if queue:
         return queue
 
@@ -161,24 +162,24 @@ class DockerSchedulerNode(SchedulerNode):
         """
         A static pre-processing hook for the Docker scheduler.
 
-        On Windows, this method forces all file/directory parameters to be
-        copied rather than linked, which avoids issues with differing
-        filesystem types between the host and the Linux-based container.
-        It then triggers :meth:`.collect()` to ensure all files are staged.
-
         Args:
             project (Project): The project object to perform pre-processing on.
         """
-        if sys.platform == 'win32':
-            # this avoids the issue of different file system types
-            project.logger.error('Setting copy field to true for docker run on Windows')
-            for key in project.allkeys():
-                if key[0] == 'history':
-                    continue
-                sc_type = project.get(*key, field='type')
-                if 'dir' in sc_type or 'file' in sc_type:
-                    project.set(*key, True, field='copy')
-            collect(project)
+        try:
+            client = docker.from_env()
+            client.version()
+        except (docker.errors.DockerException, docker.errors.APIError):
+            raise RuntimeError('docker is not available or installed on this machine')
+
+    def mark_copy(self) -> bool:
+        if sys.platform != 'win32':
+            return False
+
+        do_collect = False
+        for key in self.get_required_path_keys():
+            self.project.set(*key, True, field='copy')
+            do_collect = True
+        return do_collect
 
     def run(self):
         """
@@ -196,12 +197,7 @@ class DockerSchedulerNode(SchedulerNode):
         """
         self._init_run_logger()
 
-        try:
-            client = docker.from_env()
-            client.version()
-        except (docker.errors.DockerException, docker.errors.APIError) as e:
-            self.logger.error(f'Unable to connect to docker: {e}')
-            self.halt()
+        client = docker.from_env()
 
         is_windows = sys.platform == 'win32'
 
@@ -233,7 +229,7 @@ class DockerSchedulerNode(SchedulerNode):
         email_file = default_email_credentials_file()
         if is_windows:
             # Hack to get around manifest merging
-            self.project.set('option', 'cachedir', None)
+            self.project.option.set_cachedir(None)
             cache_dir = '/sc_cache'
             cwd = '/sc_docker'
             builddir = f'{cwd}/build'
@@ -347,3 +343,6 @@ class DockerSchedulerNode(SchedulerNode):
 
         # Restore working directory
         os.chdir(start_cwd)
+
+    def check_required_paths(self) -> bool:
+        return True