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

siliconcompiler/scheduler/schedulernode.py

@@ -30,10 +30,36 @@ if TYPE_CHECKING:
     from siliconcompiler.schema_support.metric import MetricSchema
 
 
-class SchedulerFlowReset(Exception):
+class _SchedulerReset(Exception):
+    def __init__(self, msg: str, *args: object) -> None:
+        super().__init__(msg, *args)
+        self.__msg = msg
+
+    @property
+    def msg(self) -> str:
+        return self.__msg
+
+    def log(self, logger: logging.Logger) -> None:
+        logger.debug(self.msg)
+
+
+class SchedulerFlowReset(_SchedulerReset):
     pass
 
 
+class SchedulerNodeReset(_SchedulerReset):
+    def log(self, logger: logging.Logger) -> None:
+        logger.warning(self.msg)
+
+
+class SchedulerNodeResetSilent(SchedulerNodeReset):
+    def __init__(self, msg: str, *args: object) -> None:
+        super().__init__(msg, *args)
+
+    def log(self, logger: logging.Logger) -> None:
+        _SchedulerReset.log(self, logger)
+
+
 class SchedulerNode:
     """
     A class for managing and executing a single node in the compilation flow graph.
@@ -120,10 +146,12 @@ class SchedulerNode:
         are directed to the correct task's schema.
         """
         prev_task = self.__task
-        with self.__task.runtime(self) as runtask:
-            self.__task = runtask
-            yield
-        self.__task = prev_task
+        try:
+            with self.__task.runtime(self) as runtask:
+                self.__task = runtask
+                yield
+        finally:
+            self.__task = prev_task
 
     @staticmethod
     def init(project: "Project") -> None:
@@ -382,7 +410,7 @@ class SchedulerNode:
 
             return True
 
-    def check_previous_run_status(self, previous_run: "SchedulerNode") -> bool:
+    def check_previous_run_status(self, previous_run: "SchedulerNode") -> None:
         """
         Determine whether a prior run is compatible and completed successfully for use as
         an incremental build starting point.
@@ -406,25 +434,19 @@ class SchedulerNode:
 
         # Tool name
         if self.__task.tool() != previous_run.__task.tool():
-            self.logger.debug("Tool name changed")
-            return False
+            raise SchedulerNodeResetSilent("Tool name changed")
 
         # Task name
         if self.__task.task() != previous_run.__task.task():
-            self.logger.debug("Task name changed")
-            return False
+            raise SchedulerNodeResetSilent("Task name changed")
 
         previous_status = previous_run.__project.get("record", "status",
                                                      step=self.__step, index=self.__index)
         if not NodeStatus.is_done(previous_status):
-            self.logger.debug("Previous step did not complete")
-            # Not complete
-            return False
+            raise SchedulerNodeResetSilent("Previous step did not complete")
 
         if not NodeStatus.is_success(previous_status):
-            self.logger.debug("Previous step was not successful")
-            # Not a success
-            return False
+            raise SchedulerNodeResetSilent("Previous step was not successful")
 
         # Check input nodes
         log_level = self.logger.level
@@ -433,16 +455,11 @@ class SchedulerNode:
         self.logger.setLevel(log_level)
         if set(previous_run.__project.get("record", "inputnode",
                                           step=self.__step, index=self.__index)) != set(sel_inputs):
-            self.logger.warning(f'inputs to {self.__step}/{self.__index} has been modified from '
-                                'previous run')
-            return False
-
-        # Check that all output files are present?
-
-        return True
+            raise SchedulerNodeReset(f'inputs to {self.__step}/{self.__index} has been '
+                                     'modified from previous run')
 
     def check_values_changed(self, previous_run: "SchedulerNode", keys: Set[Tuple[str, ...]]) \
-            -> bool:
+            -> None:
         """
         Checks if any specified schema parameter values have changed.
 
@@ -453,15 +470,14 @@ class SchedulerNode:
         Returns:
             bool: True if any value has changed, False otherwise.
         """
-        def print_warning(key):
-            self.logger.warning(f'[{",".join(key)}] in {self.__step}/{self.__index} has been '
-                                'modified from previous run')
+        def gen_reset(key):
+            raise SchedulerNodeReset(f'[{",".join(key)}] in {self.__step}/{self.__index} has been '
+                                     'modified from previous run')
 
         for key in sorted(keys):
             if not self.__project.valid(*key) or not previous_run.__project.valid(*key):
                 # Key is missing in either run
-                print_warning(key)
-                return True
+                gen_reset(key)
 
             param = self.__project.get(*key, field=None)
             step, index = self.__step, self.__index
@@ -472,13 +488,10 @@ class SchedulerNode:
             prev_val = previous_run.__project.get(*key, step=step, index=index)
 
             if check_val != prev_val:
-                print_warning(key)
-                return True
-
-        return False
+                gen_reset(key)
 
     def check_files_changed(self, previous_run: "SchedulerNode",
-                            previous_time: float, keys: Set[Tuple[str, ...]]) -> bool:
+                            previous_time: float, keys: Set[Tuple[str, ...]]) -> None:
         """
         Checks if any specified file-based parameters have changed.
 
@@ -494,9 +507,9 @@ class SchedulerNode:
         """
         use_hash = self.__hash and previous_run.__hash
 
-        def print_warning(key, reason):
-            self.logger.warning(f'[{",".join(key)}] ({reason}) in {self.__step}/{self.__index} has '
-                                'been modified from previous run')
+        def gen_warning(key, reason):
+            raise SchedulerNodeReset(f'[{",".join(key)}] ({reason}) in {self.__step}/'
+                                     f'{self.__index} has been modified from previous run')
 
         def get_file_time(path):
             times = [os.path.getmtime(path)]
@@ -521,8 +534,7 @@ class SchedulerNode:
                                                        step=step, index=index)
 
                 if check_hash != prev_hash:
-                    print_warning(key, "file hash")
-                    return True
+                    gen_warning(key, "file hash")
             else:
                 # check package values
                 check_val = self.__project.get(*key, field='dataroot',
@@ -531,8 +543,7 @@ class SchedulerNode:
                                                       step=step, index=index)
 
                 if check_val != prev_val:
-                    print_warning(key, "file dataroot")
-                    return True
+                    gen_warning(key, "file dataroot")
 
                 files = self.__project.find_files(*key, step=step, index=index)
                 if not isinstance(files, (list, set, tuple)):
@@ -540,10 +551,7 @@ class SchedulerNode:
 
                 for check_file in files:
                     if get_file_time(check_file) > previous_time:
-                        print_warning(key, "timestamp")
-                        return True
-
-        return False
+                        gen_warning(key, "timestamp")
 
     def get_check_changed_keys(self) -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
         """
@@ -585,7 +593,7 @@ class SchedulerNode:
 
         return value_keys, path_keys
 
-    def requires_run(self) -> bool:
+    def requires_run(self) -> None:
         """
         Determines if the node needs to be re-run.
 
@@ -601,8 +609,7 @@ class SchedulerNode:
 
         if self.__breakpoint:
             # Breakpoint is set to must run
-            self.logger.debug("Breakpoint is set")
-            return True
+            raise SchedulerNodeResetSilent(f"Breakpoint is set on {self.__step}/{self.__index}")
 
         # Load previous manifest
         previous_node = None
@@ -612,33 +619,27 @@ class SchedulerNode:
             try:
                 i_project: Project = Project.from_manifest(filepath=self.__manifests["input"])
             except:  # noqa E722
-                self.logger.debug("Input manifest failed to load")
-                return True
+                raise SchedulerNodeResetSilent("Input manifest failed to load")
             previous_node = SchedulerNode(i_project, self.__step, self.__index)
         else:
             # No manifest found so assume rerun is needed
-            self.logger.debug("Previous run did not generate input manifest")
-            return True
+            raise SchedulerNodeResetSilent("Previous run did not generate input manifest")
 
         previous_node_end = None
         if os.path.exists(self.__manifests["output"]):
             try:
                 o_project = Project.from_manifest(filepath=self.__manifests["output"])
             except:  # noqa E722
-                self.logger.debug("Output manifest failed to load")
-                return True
+                raise SchedulerNodeResetSilent("Output manifest failed to load")
             previous_node_end = SchedulerNode(o_project, self.__step, self.__index)
         else:
             # No manifest found so assume rerun is needed
-            self.logger.debug("Previous run did not generate output manifest")
-            return True
+            raise SchedulerNodeResetSilent("Previous run did not generate output manifest")
 
         with self.runtime():
             if previous_node_end:
                 with previous_node_end.runtime():
-                    if not self.check_previous_run_status(previous_node_end):
-                        self.logger.debug("Previous run state failed")
-                        return True
+                    self.check_previous_run_status(previous_node_end)
 
             if previous_node:
                 with previous_node.runtime():
@@ -650,18 +651,10 @@ class SchedulerNode:
                         value_keys.update(previous_value_keys)
                         path_keys.update(previous_path_keys)
                     except KeyError:
-                        self.logger.debug("Failed to acquire keys")
-                        return True
-
-                    if self.check_values_changed(previous_node, value_keys.union(path_keys)):
-                        self.logger.debug("Key values changed")
-                        return True
+                        raise SchedulerNodeResetSilent("Failed to acquire keys")
 
-                    if self.check_files_changed(previous_node, previous_node_time, path_keys):
-                        self.logger.debug("Files changed")
-                        return True
-
-        return False
+                    self.check_values_changed(previous_node, value_keys.union(path_keys))
+                    self.check_files_changed(previous_node, previous_node_time, path_keys)
 
     def setup_input_directory(self) -> None:
         """
@@ -869,6 +862,67 @@ class SchedulerNode:
         if self.__pipe:
             self.__pipe.send(Resolver.get_cache(self.__project))
 
+    @contextlib.contextmanager
+    def __set_env(self):
+        """Temporarily sets task-specific environment variables.
+
+        This context manager saves the current `os.environ`, updates it
+        with the task's runtime variables, yields control, and then
+        restores the original environment upon exiting the context.
+        """
+        org_env = os.environ.copy()
+        try:
+            os.environ.update(self.__task.get_runtime_environmental_variables())
+            yield
+        finally:
+            os.environ.clear()
+            os.environ.update(org_env)
+
+    def get_exe_path(self) -> Optional[str]:
+        """Gets the path to the requested executable for this task.
+
+        This method retrieves the executable path from the underlying task
+        object. It ensures that the task's specific runtime environment
+        variables are set before making the call.
+
+        Returns:
+            Optional[str]: The file path to the executable, or None if not found.
+        """
+        with self.__set_env():
+            return self.__task.get_exe()
+
+    def check_version(self, version: Optional[str] = None) -> Tuple[Optional[str], bool]:
+        """Checks the version of the tool for this task.
+
+        Compares a version string against the tool's requirements. This check
+        is performed within the task's specific runtime environment.
+
+        If no `version` is provided, this method will attempt to get the
+        version from the task itself. The check can be skipped if the
+        project option 'novercheck' is set.
+
+        Args:
+            version: The version string to check. If None, the task's
+                configured version is fetched and used.
+
+        Returns:
+            A tuple (version_str, check_passed):
+                - version_str (Optional[str]): The version string that was
+                  evaluated.
+                - check_passed (bool): True if the version is compatible or
+                  if the check was skipped, False otherwise.
+        """
+        if self.__project.get('option', 'novercheck', step=self.__step, index=self.__index):
+            return version, True
+
+        with self.__set_env():
+            if version is None:
+                version = self.__task.get_exe_version()
+
+            check = self.__task.check_exe_version(version)
+
+            return version, check
+
     def execute(self) -> None:
         """
         Handles the core tool execution logic.
@@ -918,38 +972,36 @@ class SchedulerNode:
 
             send_messages.send(self.__project, "skipped", self.__step, self.__index)
         else:
-            org_env = os.environ.copy()
-            os.environ.update(self.__task.get_runtime_environmental_variables())
-
-            toolpath = self.__task.get_exe()
-            version = self.__task.get_exe_version()
+            with self.__set_env():
+                toolpath = self.__task.get_exe()
+                version, version_pass = self.check_version()
 
-            if not self.__project.get('option', 'novercheck', step=self.__step, index=self.__index):
-                if not self.__task.check_exe_version(version):
+                if not version_pass:
                     self.halt()
 
-            if version:
-                self.__record.record_tool(self.__step, self.__index, version, RecordTool.VERSION)
-
-            if toolpath:
-                self.__record.record_tool(self.__step, self.__index, toolpath, RecordTool.PATH)
-
-            send_messages.send(self.__project, "begin", self.__step, self.__index)
-
-            try:
-                if not self.__replay:
-                    self.__task.generate_replay_script(self.__replay_script, self.__workdir)
-                ret_code = self.__task.run_task(
-                    self.__workdir,
-                    self.__project.get('option', 'quiet', step=self.__step, index=self.__index),
-                    self.__breakpoint,
-                    self.__project.get('option', 'nice', step=self.__step, index=self.__index),
-                    self.__project.get('option', 'timeout', step=self.__step, index=self.__index))
-            except Exception as e:
-                raise e
-
-            os.environ.clear()
-            os.environ.update(org_env)
+                if version:
+                    self.__record.record_tool(self.__step, self.__index, version,
+                                              RecordTool.VERSION)
+
+                if toolpath:
+                    self.__record.record_tool(self.__step, self.__index, toolpath, RecordTool.PATH)
+
+                send_messages.send(self.__project, "begin", self.__step, self.__index)
+
+                try:
+                    if not self.__replay:
+                        self.__task.generate_replay_script(self.__replay_script, self.__workdir)
+                    ret_code = self.__task.run_task(
+                        self.__workdir,
+                        self.__project.get('option', 'quiet',
+                                           step=self.__step, index=self.__index),
+                        self.__breakpoint,
+                        self.__project.get('option', 'nice',
+                                           step=self.__step, index=self.__index),
+                        self.__project.get('option', 'timeout',
+                                           step=self.__step, index=self.__index))
+                except Exception as e:
+                    raise e
 
             if ret_code != 0:
                 msg = f'Command failed with code {ret_code}.'
@@ -1037,15 +1089,15 @@ class SchedulerNode:
         from siliconcompiler.utils.issue import generate_testcase
         import lambdapdk
 
+        foss_libraries = [*lambdapdk.get_pdk_names(), *lambdapdk.get_lib_names()]
+
         generate_testcase(
             self.__project,
             self.__step,
             self.__index,
             archive_directory=self.__jobworkdir,
-            include_pdks=False,
-            include_specific_pdks=lambdapdk.get_pdk_names(),
             include_libraries=False,
-            include_specific_libraries=lambdapdk.get_lib_names(),
+            include_specific_libraries=foss_libraries,
             hash_files=self.__hash,
             verbose_collect=False)
 

siliconcompiler/schema/__init__.py

@@ -4,7 +4,7 @@ from .parameter import Parameter, Scope, PerNode
 from .journal import Journal
 from .safeschema import SafeSchema
 from .editableschema import EditableSchema
-from .baseschema import BaseSchema
+from .baseschema import BaseSchema, LazyLoad
 from .namedschema import NamedSchema
 from .docschema import DocsSchema
 
@@ -17,7 +17,8 @@ __all__ = [
     "Scope",
     "PerNode",
     "Journal",
-    "DocsSchema"
+    "DocsSchema",
+    "LazyLoad"
 ]
 
 SCHEMA_VERSION = __version__

siliconcompiler/schema/_metadata.py

@@ -1,2 +1,2 @@
 # Version number following semver standard.
-version = '0.52.0'
+version = '0.52.1'