socx-cli 0.13.5__tar.gz → 0.13.7__tar.gz

{socx_cli-0.13.5 → socx_cli-0.13.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socx-cli
-Version: 0.13.5
+Version: 0.13.7
 Summary: System on chip verification and tooling infrastructure.
 Project-URL: Issues, https://github.com/sagikimhi/socx-cli/issues
 Project-URL: Homepage, https://sagikimhi.dev/socx-cli
@@ -28,7 +28,7 @@ Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA
 Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
 Requires-Python: >=3.12
-Requires-Dist: anyio>=4.12.1
+Requires-Dist: anyio[trio]>=4.12.1
 Requires-Dist: click
 Requires-Dist: copier~=9.11
 Requires-Dist: declare

{socx_cli-0.13.5 → socx_cli-0.13.7}/pyproject.toml

@@ -29,7 +29,7 @@ socx = 'socx.__main__:main'
 [project]
 name = "socx-cli"
 readme = "README.md"
-version = "0.13.5"
+version = "0.13.7"
 license = "Apache-2.0"
 authors = [{ name = "Sagi Kimhi", email = "sagi.kim5@gmail.com" }]
 maintainers = [{ name = "Sagi Kimhi", email = "sagi.kim5@gmail.com" }]
@@ -82,7 +82,7 @@ dependencies = [
     "pydantic-extra-types>=2.11.0",
     "pydantic-settings>=2.12.0",
     "sqlmodel>=0.0.31",
-    "anyio>=4.12.1",
+    "anyio[trio]>=4.12.1",
 ]
 
 [project.urls]

{socx_cli-0.13.5 → socx_cli-0.13.7}/socx/config/_config.py

@@ -8,9 +8,7 @@ import contextvars as ctx
 from textwrap import dedent
 from typing import Any
 from pathlib import Path
-from collections import ChainMap
 
-from dynaconf.utils import ensure_a_list
 from werkzeug.local import LocalProxy
 
 from socx.config import converters
@@ -109,70 +107,27 @@ def get_settings(
     path: str | Path | None = None,
     /,
     user_overrides: bool = False,
-    local_overrides: bool = False,
+    project_overrides: bool = False,
     extra_overrides: list[str | Path] | None = None,
     **kwargs: Any,
 ) -> Settings:
     """Create a configured ``Settings`` instance, including overrides."""
-    from socx.core import paths
-    from socx.core import metadata
-    from socx.config.serializers import ModuleSerializer
-
-    if isinstance(path, str):
-        path = Path(path)
-
-    includes = []
-    settings_file = ensure_a_list(path or paths.APP_CONFIG_FILE)
-
-    if user_overrides:
-        includes.extend(get_user_config_files())
-
-    if local_overrides:
-        includes.extend(get_local_config_files())
-
-    if extra_overrides:
-        includes.extend(
-            Path(p) if isinstance(p, str) else p for p in extra_overrides
-        )
-
-    root = includes[-1].parent if includes else Path.cwd()
-    settings_kwargs = dict(
-        preload=settings_file, root_path=root, settings_file=includes
-    )
-    kwargs = dict(
-        ChainMap(
-            kwargs,
-            settings_kwargs,
-            ModuleSerializer.serialize(paths),
-            ModuleSerializer.serialize(metadata),
-        ),
+    return Settings(
+        user_overrides=user_overrides,
+        project_overrides=project_overrides,
+        **kwargs,
     )
-    rv = Settings(**kwargs)
-    return rv
 
 
 converters.init()
-
 _tokens = []
-
 _settings_cv: ctx.ContextVar[Settings] = ctx.ContextVar("settings")
-
-_default_settings: Settings = get_settings()
-
-try:
-    _user_settings: Settings = get_settings(user_overrides=True)
-except Exception:
-    _user_settings = _default_settings
-
-try:
-    _local_settings: Settings = get_settings(
-        user_overrides=True, local_overrides=True
-    )
-except Exception:
-    _local_settings = _default_settings
-    _local_settings.update(_user_settings)
-
-settings: SettingsProxy = LocalProxy(  # type: ignore[assignment]
+_default_settings: Settings = Settings(
+    project_overrides=False, user_overrides=False
+)
+_user_settings: Settings = Settings(project_overrides=False)
+_local_settings: Settings = Settings()
+settings: SettingsProxy = LocalProxy(
     _settings_cv,
     unbound_message=dedent("""
         Working outside of application context.
@@ -180,7 +135,7 @@ settings: SettingsProxy = LocalProxy(  # type: ignore[assignment]
         Attempted to use functionality that expected a current application to
         be set. To solve this, set up an app context.
     """),
-)
+)  # ty:ignore[invalid-assignment]
 
 if "--no-configure" in sys.argv or "-NC" in sys.argv:
     _tokens.append(_settings_cv.set(_default_settings))

{socx_cli-0.13.5 → socx_cli-0.13.7}/socx/config/_settings.py

@@ -9,14 +9,16 @@ from collections import ChainMap
 from collections.abc import Callable
 
 from dynaconf import LazySettings, get_history
+from dynaconf.loaders import env_loader
 from dynaconf.base import SourceMetadata, ensure_a_list
 from dynaconf.utils.boxing import DynaBox
 from dynaconf.utils.inspect import get_debug_info, _get_data_by_key
 from dynaconf.utils.parse_conf import unparse_conf_data
 from pydantic_core import to_jsonable_python
 
-from socx.config.serializers import SettingsSerializer
-
+from socx.core import paths, metadata
+from socx.core.enums import SettingsFormat
+from socx.config.serializers import SettingsSerializer, ModuleSerializer
 
 logger = logging.getLogger(__name__)
 
@@ -29,8 +31,10 @@ VT = TypeVar("VT")
 SETTINGS_DEFAULTS: dict[str, Any] = dict(
     env="default",
     envvar="SOCX_SETTINGS_PATH",
+    preload=[paths.APP_CONFIG_FILE],
     encoding="utf-8",
     auto_cast=True,
+    root_path=paths.PROJECT_ROOT_DIR,
     load_dotenv=True,
     environments=False,
     dotted_lookup=True,
@@ -46,15 +50,51 @@ SETTINGS_DEFAULTS: dict[str, Any] = dict(
 
 
 class Settings(LazySettings):
-    """Singleton settings instance of loaded `socx` configurations."""
+    """Application settings class."""
 
     def __init__(self, wrapped=None, **kwargs: Any) -> None:
-        kwargs = dict(ChainMap(kwargs, SETTINGS_DEFAULTS))
+        default_kwargs = SETTINGS_DEFAULTS
+        if kwargs.get("project_overrides", True):
+            project_files = self.get_project_config_files()
+            if project_files:
+                default_kwargs["settings_file"] = [project_files[-1]]
+        kwargs = dict(
+            ChainMap(
+                kwargs,
+                default_kwargs,
+                ModuleSerializer.serialize(paths),
+                ModuleSerializer.serialize(metadata),
+            )
+        )
         LazySettings.__init__(self, wrapped=wrapped, **kwargs)
-        if hasattr(self, "dynaconf_include"):
-            for file in self.dynaconf_include:
-                if file not in self.loaded_files:
-                    self.load_file(path=file)
+
+    def _setup(self) -> None:
+        super()._setup()
+        self._load_overrides()
+
+    def _load_overrides(self) -> None:
+        user_overrides = self.get("user_overrides", True)
+        project_overrides = self.get("project_overrides", True)
+        includes = self.get_settings_overrides(
+            user_overrides=user_overrides, project_overrides=project_overrides
+        )
+
+        if includes:
+            for file in includes:
+                logger.debug("loading settings overrides from: '%s'")
+                try:
+                    self.load_file(file)
+                except Exception:
+                    logger.exception(
+                        "Failed to load settings file: '%s'" % str(file)
+                    )
+                    continue
+                else:
+                    logger.debug("loaded settings overrides from: '%s'")
+
+            last_loader = self.loaders and self.loaders[-1]
+            if last_loader is env_loader:
+                env_loader.load(self._store)
 
     def __contains__(self, key):
         return self.exists(key) or (
@@ -77,19 +117,6 @@ class Settings(LazySettings):
         """Get the root path of the current settings instance."""
         return Path(self._root_path)
 
-    @root.setter
-    def root(self, value: str | Path) -> None:
-        if isinstance(value, str):
-            value = Path(value)
-
-        if value.is_file() and value.exists():
-            self.set(
-                "SETTINGS_FILE_FOR_DYNACONF",
-                value,
-                loader_identifier="init_settings_module",
-            )
-            self.reload()
-
     @property
     def history(self) -> tuple[dict[str, Any], ...]:
         """Get the history of this instance.
@@ -274,6 +301,107 @@ class Settings(LazySettings):
             rv = cls._transform(rv, fn, skip_values=skip_values)
         return rv
 
+    @classmethod
+    def get_settings_overrides(
+        cls, user_overrides: bool = True, project_overrides: bool = True
+    ) -> list[Path]:
+        """Get a list of project settings file overrides."""
+        overrides = []
+        if user_overrides:
+            overrides.extend(cls.get_user_config_files())
+        if project_overrides:
+            overrides.extend(cls.get_project_config_files())
+        return overrides
+
+    @classmethod
+    def get_project_config_files(cls) -> list[Path]:
+        """Get a list of local settings file paths found in parent folders.
+
+        Description:
+        ------------
+        After initialization, `socx` searches parent directories for any file
+        named '.socx.<ext>' where <ext> is any file extension supported by the
+        `socx` configuration system.
+
+        Local configuration overrides are any files named '.socx.<ext>' which
+        found in any of the parent directories of the current working
+        directory, where <ext> may be any one of: '.yaml', '.yml', '.json', or
+        '.toml'.
+
+        For reference, it works similar to git:
+
+        1.  first, default app configurations are loaded to initialize to
+            app's core functionality.
+
+        2.  second, global user configurations are loaded from the user's
+            config directory, determined according to the 'XDG Base Directory
+            Specification'
+            (https://specifications.freedesktop.org/basedir-spec).
+
+        3.  last, a search for local configuration files is done, matching
+            (and loading) any configuration files named '.socx.yaml' found in
+            any of the parent directories starting the search at the current
+            working
+            directory.
+
+        Returns:
+        --------
+        An ordered list of `Path` objects pointing at configuration files to
+        be loaded in that exact order to preserve the described overrides
+        order.
+
+        """
+        from socx.core.paths import LOCAL_CONFIG_FILE, LOCAL_CONFIG_FILENAME
+
+        rv = []
+        for parent in LOCAL_CONFIG_FILE.parents:
+            cfg_file = parent / LOCAL_CONFIG_FILENAME
+            for member in SettingsFormat:
+                rv.extend(
+                    cfg_file.with_suffix(ext)
+                    for ext in member.extensions
+                    if cfg_file.with_suffix(ext).is_file()
+                )
+        return rv
+
+    @classmethod
+    def get_user_config_files(cls) -> list[Path]:
+        """Get a list of all local config files found in parent folders.
+
+        Description:
+        ------------
+        User configuration files are any configuration files who's format is
+        supported and are located under the XDG_CONFIG_HOME directory.
+
+        Local configuration overrides are any files named '.socx.yaml' which
+        found in any of the parent directories of the current working
+        directory.
+
+        For reference, it works similar to git:
+
+        1.  first, default app configurations are loaded to initialize to
+            app's core functionality.
+
+        2.  second, global user configurations are loaded from the user's
+            config directory, determined according to the 'XDG Base Directory
+            Specification'
+            (https://specifications.freedesktop.org/basedir-spec).
+
+        3.  last, a search for local configuration files is done, matching
+            (and loading) any configuration files named '.socx.yaml' found in
+            any of the parent directories starting the search at the current
+            working directory.
+
+        Returns:
+        --------
+        An ordered list of `Path` objects pointing at configuration files to be
+        loaded in that exact order to preserve the described overrides order.
+
+        """
+        from socx.core.paths import USER_CONFIG_FILE
+
+        return [USER_CONFIG_FILE] if USER_CONFIG_FILE.exists() else []
+
     @classmethod
     def _transform(
         cls,

{socx_cli-0.13.5 → socx_cli-0.13.7}/socx/core/_paths.py

@@ -36,7 +36,7 @@ def find_project_root(start_path: Path) -> Path:
 
     if not start_path.exists():
         err = f"Path '{start_path}' does not exist."
-        raise OSError(err)
+        raise FileNotFoundError(err)
 
     if start_path.is_file():
         start_path = start_path.parent

{socx_cli-0.13.5 → socx_cli-0.13.7}/socx/core/enums.py

@@ -18,15 +18,19 @@ class AutoNumber(int, enum.ReprEnum):
 
 
 class SettingsFormat(AutoNumber):
-    Ini = ".ini"
     Json = ".json"
     Yaml = ".yaml", ".yml"
     Toml = ".toml"
+    Ini = ".ini"
     Python = ".python"
 
     def __init__(self, extension: str, *extensions: str) -> None:
-        self.extension = extension
-        self.extensions = [extension, *extensions]
+        self.extensions = {extension, *extensions}
+
+    @classmethod
+    @cache
+    def all_extensions(cls) -> set[str]:
+        return {extension for member in cls for extension in member.extensions}
 
     @classmethod
     @cache

{socx_cli-0.13.5 → socx_cli-0.13.7}/socx/patterns/singleton/singleton.py

@@ -18,7 +18,7 @@ class _SingletonMeta(type):
         return cls._instances[cls]
 
 
-class Singleton(_SingletonMeta("SingletonMeta", (object,), {})):
+class Singleton(_SingletonMeta("_SingletonMeta", (object,), {})):
     """Mixin class for creating singleton classes.
 
     Extending this class enforces the singleton pattern on the subclass.

{socx_cli-0.13.5 → socx_cli-0.13.7}/socx/regression/progress.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-import anyio
 import logging
 from typing import Any
-from collections import ChainMap
 
+import anyio
+from anyio.abc import TaskStatus
 from rich.progress import (
     Progress as BaseProgress,
     ProgressColumn,
@@ -27,7 +27,6 @@ logger = logging.getLogger(__name__)
 
 class PipelineProgress(BaseProgress):
     def __init__(self, **kwargs: Any) -> None:
-        kwargs = dict(ChainMap(kwargs, dict(speed_estimate_period=10)))
         super().__init__(*self.get_default_columns(), **kwargs)
 
     @classmethod
@@ -60,23 +59,10 @@ class RegressionProgress:
         self,
         include: set[str] | None = None,
         exclude: set[str] | None = None,
+        limiter: anyio.CapacityLimiter | None = None,
     ) -> None:
-        """Update progress tasks and flush log messages while running."""
-        with self.progress:
-            if include is None and exclude is None:
-                async with anyio.create_task_group() as tg:
-                    for obj in self.regression.tests:
-                        tg.start_soon(
-                            self.track_regression,
-                            obj,
-                            name=f"track_{obj.name}_progress",
-                        )
-                    tg.start_soon(
-                        self.regression.start,
-                        name=f"{self.regression.name}",
-                    )
-                return
-
+        self.progress.start()
+        try:
             async with anyio.create_task_group() as tg:
                 for obj in self.regression.tests:
                     if exclude is not None and obj.name in exclude:
@@ -86,54 +72,62 @@ class RegressionProgress:
                         continue
 
                     if isinstance(obj, Regression) and not obj.started:
-                        tg.start_soon(obj.start, name=obj.name)
                         tg.start_soon(
                             self.track_regression,
                             obj,
                             name=f"track_{obj.name}_progress",
                         )
+        finally:
+            self.progress.stop()
 
-    async def track_regression(self, regression: Regression) -> None:
-        finished = 0
-        status = TestStatus.Idle
-        progress = self.progress
+    async def track_regression(
+        self,
+        regression: Regression,
+        limiter: anyio.CapacityLimiter | None = None,
+        task_status: TaskStatus = anyio.TASK_STATUS_IGNORED,
+    ) -> None:
 
-        if regression.id not in self.tasks:
-            self.tasks[regression.id] = progress.add_task(
-                total=len(regression),
-                description=(
-                    f"[gray39]{self._get_task_tag(regression)}: "
-                    f"{regression.status.name}"
-                ),
-            )
+        async with anyio.create_task_group() as tg:
+            if regression.id not in self.tasks:
+                self.tasks[regression.id] = self.progress.add_task(
+                    total=len(regression),
+                    description=(
+                        f"[gray39]{self._get_task_tag(regression)}: "
+                        f"{regression.status.name}"
+                    ),
+                )
+                tg.start_soon(self._track_regression, regression)
+                await tg.start(regression.start, limiter)
+                task_status.started()
 
-        while not progress.finished:
-            if regression.finished:
-                self.update_regression(regression, len(regression))
-                break
+    async def _track_regression(self, regression: Regression) -> None:
+        task = self.progress.tasks[self.tasks[regression.id]]
 
-            prev_status = status
-            prev_finished = finished
-            status = regression.status
-            finished = self._count_statuses(
+        while True:
+            finished = await self._count_statuses(
                 regression,
                 TestStatus.Finished,
                 TestStatus.Terminated,
             )
 
-            if prev_finished != finished or prev_status != status:
-                self.update_regression(regression, finished)
+            if finished != task.completed:
+                await self.update_regression(regression, finished)
+
+            if finished == len(regression):
+                break
 
-            await anyio.sleep(0.5)
+            await anyio.sleep(0.05)
 
-    def advance_regression(self, regression: Regression, n: int) -> None:
+    async def advance_regression(
+        self, regression: Regression, n: int = 1
+    ) -> None:
         progress = self.progress
         tid = self.tasks.get(regression.id)
         if progress is not None and tid is not None:
             task = progress.tasks[tid]
-            self.update_regression(regression, task.completed + n)
+            await self.update_regression(regression, task.completed + n)
 
-    def update_regression(self, regression: Regression, n: int) -> None:
+    async def update_regression(self, regression: Regression, n: int) -> None:
         progress = self.progress
         tid = self.tasks.get(regression.id)
         if progress is not None and tid is not None:
@@ -144,32 +138,37 @@ class RegressionProgress:
                 or regression.is_pending()
                 or regression.is_suspended()
             ):
-                task.description = (
+                description = (
                     f"[gray39]{self._get_task_tag(regression)}: "
                     f"{regression.status.name}"
                 )
             elif regression.is_running():
-                task.description = (
+                description = (
                     f"[yellow]{self._get_task_tag(regression)}: "
                     f"{regression.status.name}"
                 )
             elif regression.finished:
-                task.description = (
+                description = (
                     f"[green]{self._get_task_tag(regression)}: "
                     f"{regression.status.name}"
                 )
             elif regression.terminated:
-                task.description = (
+                description = (
                     f"[red]{self._get_task_tag(regression)}: "
                     f"{regression.status.name}"
                 )
 
-            task.completed = min(n, task.total)
+            completed = min(n, task.total)
+            progress.update(
+                task.id,
+                completed=completed,
+                description=description,
+            )
 
-    def _count_statuses(
+    async def _count_statuses(
         self, regression: Regression, *statuses: TestStatus
     ) -> int:
-        with self.regression.lock:
+        async with self.regression.mutex:
             return sum(
                 1 for test in regression.tests if test.status in statuses
             )