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

siliconcompiler/scheduler/slurm.py

@@ -5,15 +5,18 @@ import shutil
 import stat
 import subprocess
 import uuid
+import time
 
 import os.path
 
-from siliconcompiler import utils
-from siliconcompiler.utils.curation import collect
-from siliconcompiler.utils.paths import collectiondir, jobdir
+from typing import List, Union, Final
+
+from siliconcompiler import utils, sc_open
+from siliconcompiler.utils.paths import jobdir
 from siliconcompiler.package import RemoteResolver
-from siliconcompiler.flowgraph import RuntimeFlowgraph
 from siliconcompiler.scheduler import SchedulerNode
+from siliconcompiler.utils.logging import SCBlankLoggerFormatter
+from siliconcompiler.utils.multiprocessing import MPManager
 
 
 class SlurmSchedulerNode(SchedulerNode):
@@ -24,6 +27,10 @@ class SlurmSchedulerNode(SchedulerNode):
     It prepares a run script, a manifest, and uses the 'srun' command
     to execute the step on a compute node.
     """
+    __OPTIONS: Final[str] = "scheduler-slurm"
+
+    _MAX_FS_DELAY = 2
+    _FS_DWELL = 0.1
 
     def __init__(self, project, step, index, replay=False):
         """Initializes a SlurmSchedulerNode.
@@ -52,34 +59,31 @@ class SlurmSchedulerNode(SchedulerNode):
         """
         A static pre-processing hook for the Slurm scheduler.
 
-        This method checks if the compilation flow starts from an entry node.
-        If so, it calls :meth:`.collect()` to gather all necessary source files
-        into a central location before any remote jobs are submitted. This
-        ensures that compute nodes have access to all required source files.
+        This method ensures that the Slurm environment is available and loads
+        any existing user configuration for the scheduler.
 
         Args:
             project (Project): The project object to perform pre-processing on.
         """
-        if os.path.exists(collectiondir(project)):
-            # nothing to do
-            return
-
-        do_collect = False
-        flow = project.get('option', 'flow')
-        entry_nodes = project.get("flowgraph", flow, field="schema").get_entry_nodes()
+        SlurmSchedulerNode.assert_slurm()
 
-        runtime = RuntimeFlowgraph(
-            project.get("flowgraph", flow, field='schema'),
-            from_steps=project.get('option', 'from'),
-            to_steps=project.get('option', 'to'),
-            prune_nodes=project.get('option', 'prune'))
+    @staticmethod
+    def _set_user_config(tag: str, value: Union[List[str], str]) -> None:
+        """
+        Sets a specific value in the user configuration map.
 
-        for (step, index) in runtime.get_nodes():
-            if (step, index) in entry_nodes:
-                do_collect = True
+        Args:
+            tag (str): The configuration key to update.
+            value (Union[List[str], str]): The value to assign to the key.
+        """
+        MPManager.get_settings().set(SlurmSchedulerNode.__OPTIONS, tag, value)
 
-        if do_collect:
-            collect(project)
+    @staticmethod
+    def _write_user_config() -> None:
+        """
+        Writes the current system configuration to the user configuration file.
+        """
+        MPManager.get_settings().save()
 
     @property
     def is_local(self):
@@ -150,6 +154,49 @@ class SlurmSchedulerNode(SchedulerNode):
         # Return the first listed partition
         return sinfo['nodes'][0]['partitions'][0]
 
+    @staticmethod
+    def assert_slurm() -> None:
+        """
+        Check if slurm is installed and throw error when not installed.
+        """
+        if shutil.which('sinfo') is None:
+            raise RuntimeError('slurm is not available or installed on this machine')
+
+    def mark_copy(self) -> bool:
+        sharedprefix: List[str] = MPManager.get_settings().get(
+            SlurmSchedulerNode.__OPTIONS, "sharedpaths", default=[])
+
+        if "/" in sharedprefix:
+            # Entire filesystem is shared so no need to check
+            return False
+
+        do_collect = False
+        for key in self.get_required_path_keys():
+            mark_copy = True
+            if sharedprefix:
+                mark_copy = False
+
+                check_step, check_index = self.step, self.index
+                if self.project.get(*key, field='pernode').is_never():
+                    check_step, check_index = None, None
+
+                paths = self.project.find_files(*key, missing_ok=True,
+                                                step=check_step, index=check_index)
+                if not isinstance(paths, list):
+                    paths = [paths]
+                paths = [str(path) for path in paths if path]
+
+                for path in paths:
+                    if not any([path.startswith(shared) for shared in sharedprefix]):
+                        # File exists outside shared paths and needs to be copied
+                        mark_copy = True
+                        break
+
+            if mark_copy:
+                self.project.set(*key, True, field='copy')
+                do_collect = True
+        return do_collect
+
     def run(self):
         """
         Runs the node's task as a job on a Slurm cluster.
@@ -161,9 +208,6 @@ class SlurmSchedulerNode(SchedulerNode):
 
         self._init_run_logger()
 
-        if shutil.which('sinfo') is None:
-            raise RuntimeError('slurm is not available or installed on this machine')
-
         # Determine which cluster parititon to use.
         partition = self.project.get('option', 'scheduler', 'queue',
                                      step=self.step, index=self.index)
@@ -191,7 +235,7 @@ class SlurmSchedulerNode(SchedulerNode):
             with open(script_file, 'w') as sf:
                 sf.write(utils.get_file_template('slurm/run.sh').render(
                     cfg_file=shlex.quote(cfg_file),
-                    build_dir=shlex.quote(self.project.get("option", "builddir")),
+                    build_dir=shlex.quote(self.project.option.get_builddir()),
                     step=shlex.quote(self.step),
                     index=shlex.quote(self.index),
                     cachedir=shlex.quote(str(RemoteResolver.determine_cache_dir(self.project)))
@@ -217,9 +261,12 @@ class SlurmSchedulerNode(SchedulerNode):
 
         schedule_cmd.append(script_file)
 
+        self.logger.debug(f"Executing slurm command: {shlex.join(schedule_cmd)}")
+
         # Run the 'srun' command, and track its output.
         # TODO: output should be fed to log, and stdout if quiet = False
         step_result = subprocess.Popen(schedule_cmd,
+                                       stdin=subprocess.DEVNULL,
                                        stdout=subprocess.PIPE,
                                        stderr=subprocess.STDOUT)
 
@@ -227,3 +274,40 @@ class SlurmSchedulerNode(SchedulerNode):
         # as it has closed its output stream. But if we don't call '.wait()',
         # the '.returncode' value will not be set correctly.
         step_result.wait()
+
+        # Attempt to list dir to trigger network FS to update
+        try:
+            os.listdir(os.path.dirname(log_file))
+        except:  # noqa E722
+            pass
+
+        # Print the log to logger
+        if os.path.exists(log_file):
+            org_formatter = self.project._logger_console.formatter
+            try:
+                self.project._logger_console.setFormatter(SCBlankLoggerFormatter())
+                with sc_open(log_file) as log:
+                    for line in log.readlines():
+                        self.logger.info(line.rstrip())
+            finally:
+                self.project._logger_console.setFormatter(org_formatter)
+
+        if step_result.returncode != 0:
+            self.logger.error(f"Slurm exited with a non-zero code ({step_result.returncode}).")
+            if os.path.exists(log_file):
+                self.logger.error(f"Node log file: {log_file}")
+            self.halt()
+
+        # Wait for manifest to propagate through network filesystem
+        start = time.time()
+        elapsed = 0
+        manifest_path = self.get_manifest()
+        while not os.path.exists(manifest_path) and elapsed <= SlurmSchedulerNode._MAX_FS_DELAY:
+            os.listdir(os.path.dirname(manifest_path))
+            elapsed = time.time() - start
+            time.sleep(SlurmSchedulerNode._FS_DWELL)
+        if not os.path.exists(manifest_path):
+            self.logger.error(f"Manifest was not created on time: {manifest_path}")
+
+    def check_required_paths(self) -> bool:
+        return True

siliconcompiler/scheduler/taskscheduler.py

@@ -117,8 +117,6 @@ class TaskScheduler:
             from_steps=set([step for step, _ in self.__flow.get_entry_nodes()]),
             prune_nodes=self.__project.option.get_prune())
 
-        init_funcs = set()
-
         for step, index in self.__runtime_flow.get_nodes():
             if self.__record.get('status', step=step, index=index) != NodeStatus.PENDING:
                 continue
@@ -145,7 +143,6 @@ class TaskScheduler:
             task["node"].set_queue(pipe, self.__log_queue)
 
             task["proc"] = multiprocessing.Process(target=task["node"].run)
-            init_funcs.add(task["node"].init)
             self.__nodes[(step, index)] = task
 
         # Create ordered list of nodes
@@ -155,10 +152,6 @@ class TaskScheduler:
                 if node in self.__nodes:
                     self.__ordered_nodes.append(node)
 
-        # Call preprocessing for schedulers
-        for init_func in init_funcs:
-            init_func(self.__project)
-
     def run(self, job_log_handler: logging.Handler) -> None:
         """
         The main entry point for the task scheduling loop.

siliconcompiler/schema/editableschema.py

@@ -6,6 +6,7 @@
 
 from .parameter import Parameter
 from .baseschema import BaseSchema
+from .namedschema import NamedSchema
 
 from typing import Union, Tuple
 
@@ -38,6 +39,11 @@ class EditableSchema:
             if isinstance(value, BaseSchema):
                 value._BaseSchema__parent = self.__schema
                 value._BaseSchema__key = key
+                if isinstance(value, NamedSchema):
+                    if key == "default":
+                        value._NamedSchema__name = None
+                    else:
+                        value._NamedSchema__name = key
 
             if key == "default":
                 self.__schema._BaseSchema__default = value
@@ -146,3 +152,26 @@ class EditableSchema:
             raise ValueError("Keypath must only be strings")
 
         return self.__schema._BaseSchema__search(*keypath, require_leaf=False)
+
+    def copy(self) -> BaseSchema:
+        '''
+        Creates a copy of the schema object, disconnected from any parent schema
+        '''
+
+        new_schema = self.__schema.copy()
+        if new_schema._parent() is not new_schema:
+            new_schema._BaseSchema__parent = None
+        return new_schema
+
+    def rename(self, name: str):
+        '''
+        Renames a named schema
+        '''
+
+        if not isinstance(self.__schema, NamedSchema):
+            raise TypeError("schema must be a named schema")
+
+        if self.__schema._parent() is not self.__schema:
+            raise ValueError("object is already in a schema")
+
+        self.__schema._NamedSchema__name = name

siliconcompiler/schema/parametervalue.py

@@ -185,7 +185,13 @@ class NodeListValue:
         '''
         Returns a copy of the values stored in the list
         '''
-        return self.__values.copy()
+        if self.__values:
+            return self.__values.copy()
+        else:
+            if self.__base.has_value:
+                return [self.__base]
+            else:
+                return []
 
     def copy(self) -> "NodeListValue":
         """
@@ -385,7 +391,13 @@ class NodeSetValue:
         '''
         Returns a copy of the values stored in the list
         '''
-        return self.__values.copy()
+        if self.__values:
+            return self.__values.copy()
+        else:
+            if self.__base.has_value:
+                return [self.__base]
+            else:
+                return []
 
     def copy(self) -> "NodeSetValue":
         """

siliconcompiler/schema_support/option.py

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

siliconcompiler/schema_support/pathschema.py

@@ -11,7 +11,7 @@ from siliconcompiler.schema.parameter import Parameter, Scope
 from siliconcompiler.schema.utils import trim
 
 from siliconcompiler.package import Resolver
-from siliconcompiler.utils.paths import collectiondir
+from siliconcompiler.utils.paths import collectiondir, cwdirsafe
 
 
 class PathSchemaBase(BaseSchema):
@@ -51,14 +51,12 @@ class PathSchemaBase(BaseSchema):
             the schema.
         """
         schema_root = self._parent(root=True)
-        cwd = getattr(schema_root, "_Project__cwd", os.getcwd())
-        collection_dir = collectiondir(schema_root)
 
         return super()._find_files(*keypath,
                                    missing_ok=missing_ok,
                                    step=step, index=index,
-                                   collection_dir=collection_dir,
-                                   cwd=cwd)
+                                   collection_dir=collectiondir(schema_root),
+                                   cwd=cwdirsafe(schema_root))
 
     def check_filepaths(self, ignore_keys: Optional[List[Tuple[str, ...]]] = None) -> bool:
         '''
@@ -71,17 +69,15 @@ class PathSchemaBase(BaseSchema):
             True if all file paths are valid, otherwise False.
         '''
         schema_root = self._parent(root=True)
-        cwd = getattr(schema_root, "_Project__cwd", os.getcwd())
         logger = getattr(schema_root,
                          "logger",
                          logging.getLogger("siliconcompiler.check_filepaths"))
-        collection_dir = collectiondir(schema_root)
 
         return super()._check_filepaths(
             ignore_keys=ignore_keys,
             logger=logger,
-            collection_dir=collection_dir,
-            cwd=cwd)
+            collection_dir=collectiondir(schema_root),
+            cwd=cwdirsafe(schema_root))
 
     def hash_files(self, *keypath: str,
                    update: bool = True,
@@ -126,11 +122,9 @@ class PathSchemaBase(BaseSchema):
             Computes, stores, and returns hashes of files in :keypath:`input, rtl, verilog`.
         '''
         schema_root = self._parent(root=True)
-        cwd = getattr(schema_root, "_Project__cwd", os.getcwd())
         logger = getattr(schema_root,
                          "logger",
                          logging.getLogger("siliconcompiler.hash_files"))
-        collection_dir = collectiondir(schema_root)
 
         if verbose:
             logger.info(f"Computing hash value for [{','.join([*self._keypath, *keypath])}]")
@@ -138,8 +132,8 @@ class PathSchemaBase(BaseSchema):
         hashes = super()._hash_files(*keypath,
                                      missing_ok=missing_ok,
                                      step=step, index=index,
-                                     collection_dir=collection_dir,
-                                     cwd=cwd)
+                                     collection_dir=collectiondir(schema_root),
+                                     cwd=cwdirsafe(schema_root))
 
         if check:
             check_hashes = self.get(*keypath, field="filehash", step=step, index=index)

siliconcompiler/tool.py

@@ -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):
@@ -415,7 +416,7 @@ class Task(NamedSchema, PathSchema, DocsSchema):
         cmdlist.extend(veropt)
 
         self.logger.debug(f'Running {self.tool()}/{self.task()} version check: '
-                          f'{" ".join(cmdlist)}')
+                          f'{shlex.join(cmdlist)}')
 
         proc = subprocess.run(cmdlist,
                               stdin=subprocess.DEVNULL,
@@ -900,6 +901,37 @@ class Task(NamedSchema, PathSchema, DocsSchema):
                                     f'{timeout} seconds. Terminating...')
                 terminate_process(proc.pid, timeout=timeout)
 
+    def __collect_memory(self, pid) -> Optional[int]:
+        try:
+            pproc = psutil.Process(pid)
+            proc_mem_bytes = pproc.memory_full_info().uss
+            for child in pproc.children(recursive=True):
+                proc_mem_bytes += child.memory_full_info().uss
+            return proc_mem_bytes
+        except psutil.Error:
+            # Process may have already terminated or been killed.
+            # Retain existing memory usage statistics in this case.
+            pass
+        except PermissionError:
+            # OS is preventing access to this information so it cannot
+            # be collected
+            pass
+        return None
+
+    def __check_memory_limit(self, warn_limit: int) -> int:
+        try:
+            memory_usage = psutil.virtual_memory()
+            if memory_usage.percent > warn_limit:
+                self.logger.warning(
+                    'Current system memory usage is '
+                    f'{memory_usage.percent:.1f}%')
+                return int(memory_usage.percent + 1)
+        except psutil.Error:
+            pass
+        except PermissionError:
+            pass
+        return warn_limit
+
     def run_task(self,
                  workdir: str,
                  quiet: bool,
@@ -1034,39 +1066,29 @@ class Task(NamedSchema, PathSchema, DocsSchema):
                         raise TaskError(f"Unable to start {exe}: {str(e)}")
 
                     memory_warn_limit = Task.__MEMORY_WARN_LIMIT
+                    next_collection = None
                     try:
                         while proc.poll() is None:
+                            curr_time = time.time()
+
                             # Monitor subprocess memory usage
-                            try:
-                                pproc = psutil.Process(proc.pid)
-                                proc_mem_bytes = pproc.memory_full_info().uss
-                                for child in pproc.children(recursive=True):
-                                    proc_mem_bytes += child.memory_full_info().uss
-                                max_mem_bytes = max(max_mem_bytes, proc_mem_bytes)
-
-                                memory_usage = psutil.virtual_memory()
-                                if memory_usage.percent > memory_warn_limit:
-                                    self.logger.warning(
-                                        'Current system memory usage is '
-                                        f'{memory_usage.percent:.1f}%')
-                                    memory_warn_limit = int(memory_usage.percent + 1)
-                            except psutil.Error:
-                                # Process may have already terminated or been killed.
-                                # Retain existing memory usage statistics in this case.
-                                pass
-                            except PermissionError:
-                                # OS is preventing access to this information so it cannot
-                                # be collected
-                                pass
+                            if next_collection is None or \
+                                    next_collection <= curr_time:
+                                proc_mem_bytes = self.__collect_memory(proc.pid)
+                                if proc_mem_bytes is not None:
+                                    max_mem_bytes = max(max_mem_bytes, proc_mem_bytes)
+                                next_collection = curr_time + Task.__MEM_POLL_INTERVAL
+
+                                memory_warn_limit = self.__check_memory_limit(memory_warn_limit)
 
                             read_stdio(stdout_reader, stderr_reader)
 
                             # Check for timeout
-                            duration = time.time() - cpu_start
+                            duration = curr_time - cpu_start
                             if timeout is not None and duration > timeout:
                                 raise TaskTimeout(timeout=duration)
 
-                            time.sleep(Task.__POLL_INTERVAL)
+                            time.sleep(Task.__IO_POLL_INTERVAL)
                     except KeyboardInterrupt:
                         self.logger.info("Received ctrl-c.")
                         self.__terminate_exe(proc)

siliconcompiler/tools/klayout/__init__.py

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

siliconcompiler/tools/klayout/scripts/klayout_convert_drc_db.py

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

siliconcompiler/tools/klayout/scripts/klayout_export.py

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

siliconcompiler/tools/klayout/scripts/klayout_operations.py

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

siliconcompiler/tools/klayout/scripts/klayout_show.py

@@ -193,6 +193,7 @@ def main():
     # SC_ROOT provided by CLI, and is only accessible when this is main module
     sys.path.append(SC_KLAYOUT_ROOT)  # noqa: F821
     sys.path.append(SC_TOOLS_ROOT)  # noqa: F821
+    sys.path.append(SC_ROOT)  # noqa: F821
 
     from klayout_utils import (
         technology,

siliconcompiler/tools/klayout/scripts/klayout_utils.py

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