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

siliconcompiler/utils/curation.py

@@ -5,9 +5,10 @@ import os.path
 
 from typing import List, Optional, TYPE_CHECKING
 
+from siliconcompiler.schema import BaseSchema, Parameter
 from siliconcompiler.schema.parametervalue import NodeListValue, NodeSetValue
 from siliconcompiler.utils import FilterDirectories
-from siliconcompiler.utils.paths import collectiondir
+from siliconcompiler.utils.paths import collectiondir, cwdir
 from siliconcompiler.scheduler import SchedulerNode
 from siliconcompiler.flowgraph import RuntimeFlowgraph
 
@@ -43,16 +44,42 @@ def collect(project: "Project",
 
     if not directory:
         directory = collectiondir(project)
+    if not directory:
+        raise ValueError("unable to determine collection directory")
+
     directory = os.path.abspath(directory)
 
-    # Remove existing directory
+    # Move existing directory
+    prev_dir = None
     if os.path.exists(directory):
-        shutil.rmtree(directory)
+        prev_dir = os.path.join(os.path.dirname(directory), "sc_previous_collection")
+        os.rename(directory, prev_dir)
     os.makedirs(directory)
 
     if verbose:
         project.logger.info(f'Collecting files to: {directory}')
 
+    cwd = cwdir(project)
+
+    def find_files(*key, step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Find the files in the filesystem, otherwise look in previous collection
+        """
+        e = None
+        try:
+            return BaseSchema._find_files(project, *key, step=step, index=index,
+                                          cwd=cwd,
+                                          collection_dir=directory)
+        except FileNotFoundError as err:
+            e = err
+        if prev_dir:
+            # Try previous location next
+            return BaseSchema._find_files(project, *key, step=step, index=index,
+                                          cwd=cwd,
+                                          collection_dir=prev_dir)
+        if e:
+            raise e from None
+
     dirs = {}
     files = {}
 
@@ -75,17 +102,18 @@ def collect(project: "Project",
             # skip flow files files from builds
             continue
 
-        leaftype = project.get(*key, field='type')
+        param: Parameter = project.get(*key, field=None)
+        leaftype: str = param.get(field='type')
         is_dir = "dir" in leaftype
         is_file = "file" in leaftype
 
         if not is_dir and not is_file:
             continue
 
-        if not project.get(*key, field='copy'):
+        if not param.get(field='copy'):
             continue
 
-        for values, step, index in project.get(*key, field=None).getvalues(return_values=False):
+        for values, step, index in param.getvalues(return_values=False):
             if not values.has_value:
                 continue
 
@@ -99,73 +127,78 @@ def collect(project: "Project",
             else:
                 files[(key, step, index)] = values
 
-    path_filter = FilterDirectories(project)
-    for key, step, index in sorted(dirs.keys()):
-        abs_paths = project.find_files(*key, step=step, index=index)
+    try:
+        path_filter = FilterDirectories(project)
+        for key, step, index in sorted(dirs.keys()):
+            abs_paths = find_files(*key, step=step, index=index)
 
-        new_paths = set()
+            new_paths = set()
 
-        if not isinstance(abs_paths, (list, tuple, set)):
-            abs_paths = [abs_paths]
+            if not isinstance(abs_paths, (list, tuple, set)):
+                abs_paths = [abs_paths]
 
-        abs_paths = zip(abs_paths, dirs[(key, step, index)])
-        abs_paths = sorted(abs_paths, key=lambda p: p[0])
+            abs_paths = zip(abs_paths, dirs[(key, step, index)])
+            abs_paths = sorted(abs_paths, key=lambda p: p[0])
 
-        for abs_path, value in abs_paths:
-            if not abs_path:
-                raise FileNotFoundError(f"{value.get()} could not be copied")
+            for abs_path, value in abs_paths:
+                if not abs_path:
+                    raise FileNotFoundError(f"{value.get()} could not be copied")
 
-            if abs_path.startswith(directory):
-                # File already imported in directory
-                continue
+                if abs_path.startswith(directory):
+                    # File already imported in directory
+                    continue
 
-            imported = False
-            for new_path in new_paths:
-                if abs_path.startwith(new_path):
-                    imported = True
-                    break
-            if imported:
-                continue
+                imported = False
+                for new_path in new_paths:
+                    if abs_path.startswith(new_path):
+                        imported = True
+                        break
+                if imported:
+                    continue
 
-            new_paths.add(abs_path)
+                new_paths.add(abs_path)
 
-            import_path = os.path.join(directory, value.get_hashed_filename())
-            if os.path.exists(import_path):
-                continue
+                import_path = os.path.join(directory, value.get_hashed_filename())
+                if os.path.exists(import_path):
+                    continue
 
-            if whitelist is not None and abs_path not in whitelist:
-                raise RuntimeError(f'{abs_path} is not on the approved collection list.')
+                if whitelist is not None and abs_path not in whitelist:
+                    raise RuntimeError(f'{abs_path} is not on the approved collection list.')
 
-            if verbose:
-                project.logger.info(f"  Collecting directory: {abs_path}")
-            path_filter.abspath = abs_path
-            shutil.copytree(abs_path, import_path, ignore=path_filter.filter)
-            path_filter.abspath = None
+                if verbose:
+                    project.logger.info(f"  Collecting directory: {abs_path}")
+                path_filter.abspath = abs_path
+                shutil.copytree(abs_path, import_path, ignore=path_filter.filter)
+                path_filter.abspath = None
 
-    for key, step, index in sorted(files.keys()):
-        abs_paths = project.find_files(*key, step=step, index=index)
+        for key, step, index in sorted(files.keys()):
+            abs_paths = find_files(*key, step=step, index=index)
 
-        if not isinstance(abs_paths, (list, tuple, set)):
-            abs_paths = [abs_paths]
+            if not isinstance(abs_paths, (list, tuple, set)):
+                abs_paths = [abs_paths]
 
-        abs_paths = zip(abs_paths, files[(key, step, index)])
-        abs_paths = sorted(abs_paths, key=lambda p: p[0])
+            abs_paths = zip(abs_paths, files[(key, step, index)])
+            abs_paths = sorted(abs_paths, key=lambda p: p[0])
 
-        for abs_path, value in abs_paths:
-            if not abs_path:
-                raise FileNotFoundError(f"{value.get()} could not be copied")
+            for abs_path, value in abs_paths:
+                if not abs_path:
+                    raise FileNotFoundError(f"{value.get()} could not be copied")
 
-            if abs_path.startswith(directory):
-                # File already imported in directory
-                continue
+                if abs_path.startswith(directory):
+                    # File already imported in directory
+                    continue
 
-            import_path = os.path.join(directory, value.get_hashed_filename())
-            if os.path.exists(import_path):
-                continue
+                import_path = os.path.join(directory, value.get_hashed_filename())
+                if os.path.exists(import_path):
+                    continue
 
-            if verbose:
-                project.logger.info(f"  Collecting file: {abs_path}")
-            shutil.copy2(abs_path, import_path)
+                if verbose:
+                    project.logger.info(f"  Collecting file: {abs_path}")
+                shutil.copy2(abs_path, import_path)
+    finally:
+        if prev_dir:
+            # Delete existing directory
+            shutil.rmtree(prev_dir)
 
 
 def archive(project: "Project",

siliconcompiler/utils/issue.py

@@ -237,6 +237,10 @@ def generate_testcase(project: "Project",
     with open(issue_path, 'w') as fd:
         json.dump(issue_information, fd, indent=4, sort_keys=True)
 
+    gitignore_path = os.path.join(issue_dir.name, '.gitignore')
+    with open(gitignore_path, 'w') as fd:
+        fd.write("/*\n")
+
     readme_path = os.path.join(issue_dir.name, 'README.txt')
     with open(readme_path, 'w') as f:
         f.write(get_file_template('issue/README.txt').render(
@@ -268,7 +272,8 @@ def generate_testcase(project: "Project",
         # Add individual files
         add_files = [manifest_path,
                      issue_path,
-                     readme_path]
+                     readme_path,
+                     gitignore_path]
         if not is_python_tool and run_path:
             add_files.append(run_path)
         for path in add_files:

siliconcompiler/utils/multiprocessing.py

@@ -8,7 +8,11 @@ import os.path
 from typing import Union, Optional
 
 from datetime import datetime
-from multiprocessing.managers import SyncManager
+from logging.handlers import QueueHandler
+from multiprocessing.managers import SyncManager, RemoteError
+
+from siliconcompiler.utils.settings import SettingsManager
+from siliconcompiler.utils import default_sc_path
 
 from siliconcompiler.report.dashboard.cli.board import Board
 
@@ -139,6 +143,10 @@ class MPManager(metaclass=_ManagerSingleton):
         self.__board_lock = self.__manager.Lock()
         self.__board = None
 
+        # Settings
+        self.__settings = SettingsManager(default_sc_path("settings.json"), self.__logger)
+        self.__transient_settings = SettingsManager(None, self.__logger)
+
         # Register cleanup function to run at exit
         atexit.register(MPManager.stop)
 
@@ -205,7 +213,13 @@ class MPManager(metaclass=_ManagerSingleton):
 
         # Stop the dashboard service if it's running
         if manager.__board:
-            with manager.__board_lock:
+            try:
+                with manager.__board_lock:
+                    if manager.__board:
+                        manager.__board.stop()
+                        manager.__board = None
+            except RemoteError:
+                # Try without the lock
                 if manager.__board:
                     manager.__board.stop()
                     manager.__board = None
@@ -249,6 +263,26 @@ class MPManager(metaclass=_ManagerSingleton):
         """
         return MPManager().__manager
 
+    @staticmethod
+    def get_settings() -> SettingsManager:
+        """
+        Provides access to the shared SettingsManager instance.
+
+        Returns:
+            SettingsManager: The singleton settings instance.
+        """
+        return MPManager().__settings
+
+    @staticmethod
+    def get_transient_settings() -> SettingsManager:
+        """
+        Provides access to the shared transient SettingsManager instance.
+
+        Returns:
+            SettingsManager: The singleton transient settings instance.
+        """
+        return MPManager().__transient_settings
+
     @staticmethod
     def get_dashboard() -> Board:
         """
@@ -292,3 +326,13 @@ class MPManager(metaclass=_ManagerSingleton):
         Get the address of the manager
         """
         return MPManager.__address
+
+
+class MPQueueHandler(QueueHandler):
+    def enqueue(self, record):
+        try:
+            super().enqueue(record)
+        except BrokenPipeError:
+            # The pipe is broken so fail silently as this is likely
+            # at exit
+            pass

siliconcompiler/utils/paths.py

@@ -13,6 +13,27 @@ def cwdir(project: "Project") -> str:
     return project._Project__cwd
 
 
+def cwdirsafe(project: "Project") -> str:
+    """
+    Returns the current working directory for the project, with safe fallback.
+
+    This function attempts to retrieve the project's current working directory.
+    If the provided object is not a valid Project instance, it falls back to
+    the system's current working directory.
+
+    Args:
+        project (Project): The SiliconCompiler project object.
+
+    Returns:
+        str: The absolute path to the project's working directory, or the
+        system's current working directory if the project is invalid.
+    """
+    try:
+        return cwdir(project)
+    except TypeError:
+        return os.getcwd()
+
+
 def builddir(project: "Project") -> str:
     """
     Returns the absolute path to the project's build directory.

siliconcompiler/utils/settings.py

@@ -0,0 +1,162 @@
+import json
+import os
+import logging
+import threading
+
+import os.path
+
+from typing import Optional
+
+from fasteners import InterProcessLock
+
+from siliconcompiler import sc_open
+
+
+class SettingsManager:
+    """
+    A class to manage user settings stored in a JSON file.
+    Supports categories, robust error handling for malformed files,
+    and simple get/set operations.
+    """
+
+    def __init__(self, filepath: str, logger: logging.Logger, timeout: float = 1.0):
+        """
+        Initialize the settings manager.
+
+        Args:
+            filepath (str): The path to the JSON file where settings are stored.
+                If None, settings are kept in memory only.
+            logger (logging.Logger): Logger for logging errors and information.
+            timeout (float): Timeout in seconds for acquiring the file lock.
+        """
+        self.__filepath = filepath
+        if self.__filepath is not None:
+            self.__lock = InterProcessLock(self.__filepath + ".lock")
+        self.__settings_lock = threading.Lock()
+        self.__timeout = timeout
+        self.__logger = logger.getChild("settings")
+        self.__settings = {}
+        self._load()
+
+    def _load(self):
+        """
+        Internal method to load settings from disk.
+        It handles missing files and malformed JSON gracefully.
+        """
+        if self.__filepath is None or not os.path.exists(self.__filepath):
+            self.__settings = {}
+            return
+
+        with self.__settings_lock:
+            try:
+                if self.__lock.acquire(timeout=self.__timeout):
+                    try:
+                        with sc_open(self.__filepath, encoding='utf-8') as f:
+                            data = json.load(f)
+                    finally:
+                        self.__lock.release()
+                else:
+                    self.__logger.error(f"Timeout acquiring lock for {self.__filepath}. "
+                                        "Starting with empty settings.")
+                    data = {}
+
+                # Ensure the loaded data is actually a dictionary
+                if isinstance(data, dict):
+                    self.__settings = data
+                else:
+                    # If valid JSON but not a dict (e.g. a list), reset to empty
+                    self.__logger.warning(f"File {self.__filepath} did not contain a JSON object. "
+                                          "Resetting.")
+                    self.__settings = {}
+
+            except json.JSONDecodeError:
+                self.__logger.error(f"File {self.__filepath} is malformed. "
+                                    "Starting with empty settings.")
+                self.__settings = {}
+            except Exception as e:
+                # Catch-all for permission errors, etc., to ensure __init__ doesn't crash
+                self.__logger.error(f"Unexpected error loading settings: {e}")
+                self.__settings = {}
+
+    def save(self):
+        """
+        Save the current settings to the disk in JSON format.
+        """
+        if self.__filepath is None:
+            return
+
+        try:
+            # Ensure directory exists
+            directory = os.path.dirname(self.__filepath)
+            if directory and not os.path.exists(directory):
+                os.makedirs(directory)
+
+            with self.__settings_lock:
+                with self.__lock:
+                    with open(self.__filepath, 'w', encoding='utf-8') as f:
+                        json.dump(self.__settings, f, indent=4)
+        except Exception as e:
+            self.__logger.error(f"Failed to save settings to {self.__filepath}: {e}")
+            raise e
+
+    def set(self, category: str, key: str, value, keep: bool = False):
+        """
+        Set a specific setting within a category.
+
+        Args:
+            category (str): The group name (e.g., 'showtools', 'options').
+            key (str): The specific setting name.
+            value: The value to store (must be JSON serializable).
+            keep (bool): If True, do not overwrite existing value.
+        """
+        with self.__settings_lock:
+            if category not in self.__settings:
+                self.__settings[category] = {}
+
+            if keep and key in self.__settings[category]:
+                return
+            self.__settings[category][key] = value
+
+    def get(self, category: str, key: str, default=None):
+        """
+        Retrieve a setting.
+
+        Args:
+            category (str): The group name.
+            key (str): The specific setting name.
+            default: The value to return if the category or key is missing.
+
+        Returns:
+            The stored value or the default.
+        """
+        with self.__settings_lock:
+            if category not in self.__settings:
+                return default
+
+            return self.__settings[category].get(key, default)
+
+    def get_category(self, category: str):
+        """
+        Retrieve all settings for a specific category.
+        Returns an empty dict if category does not exist.
+        """
+        with self.__settings_lock:
+            if category not in self.__settings:
+                self.__settings[category] = {}
+
+            return self.__settings.get(category).copy()
+
+    def delete(self, category: str, key: Optional[str] = None):
+        """
+        Remove a setting.
+        """
+        with self.__settings_lock:
+            if category in self.__settings:
+                if key:
+                    if key in self.__settings[category]:
+                        del self.__settings[category][key]
+                        # Clean up empty categories
+                        if not self.__settings[category]:
+                            del self.__settings[category]
+                else:
+                    del self.__settings[category]

{siliconcompiler-0.35.3.dist-info → siliconcompiler-0.36.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: siliconcompiler
-Version: 0.35.3
+Version: 0.36.0
 Summary: A compiler framework that automates translation from source code to silicon.
 Author: Zero ASIC
 License: Apache License 2.0
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: Microsoft :: Windows
@@ -37,7 +38,7 @@ Requires-Dist: PyYAML<7.0.0,>=6.0.0
 Requires-Dist: GitPython<3.2,>=3.1.44
 Requires-Dist: PyGithub<2.9.0,>=2.8.0
 Requires-Dist: urllib3>=1.26.0
-Requires-Dist: lambdapdk>=0.2.4
+Requires-Dist: lambdapdk>=0.2.6
 Requires-Dist: fasteners>=0.20
 Requires-Dist: pandas>=1.1.5
 Requires-Dist: psutil>=5.8.0
@@ -60,7 +61,7 @@ Requires-Dist: responses==0.25.8; extra == "test"
 Requires-Dist: PyVirtualDisplay==3.0; extra == "test"
 Provides-Extra: lint
 Requires-Dist: flake8==7.3.0; extra == "lint"
-Requires-Dist: tclint==0.6.1; extra == "lint"
+Requires-Dist: tclint==0.7.0; extra == "lint"
 Requires-Dist: codespell==2.4.1; extra == "lint"
 Provides-Extra: docs
 Requires-Dist: Sphinx<8.3,>=7.4; extra == "docs"
@@ -102,7 +103,7 @@ SiliconCompiler is a modular hardware build system ("make for silicon"). The pro
 # Getting Started
 
 SiliconCompiler is available as wheel packages on PyPI for macOS, Windows and
-Linux platforms. For working Python 3.9-3.13 environment, just use pip.
+Linux platforms. For working Python 3.9-3.14 environment, just use pip.
 
 ```sh
 pip install --upgrade siliconcompiler