socx-cli 0.13.0__tar.gz → 0.13.2__tar.gz

{socx_cli-0.13.0 → socx_cli-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socx-cli
-Version: 0.13.0
+Version: 0.13.2
 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,9 +28,10 @@ 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: click
 Requires-Dist: copier~=9.11
-Requires-Dist: dynaconf
+Requires-Dist: dynaconf<3.2.12
 Requires-Dist: gitpython
 Requires-Dist: hoptex
 Requires-Dist: jinja2

{socx_cli-0.13.0 → socx_cli-0.13.2}/pyproject.toml

@@ -29,7 +29,7 @@ socx = 'socx.__main__:main'
 [project]
 name = "socx-cli"
 readme = "README.md"
-version = "0.13.0"
+version = "0.13.2"
 license = "Apache-2.0"
 authors = [{ name = "Sagi Kimhi", email = "sagi.kim5@gmail.com" }]
 maintainers = [{ name = "Sagi Kimhi", email = "sagi.kim5@gmail.com" }]
@@ -67,7 +67,7 @@ dependencies = [
     "textual",
     "plumbum",
     "pydantic",
-    "dynaconf",
+    "dynaconf<3.2.12",
     "paramiko",
     "werkzeug>=3.1.4",
     "gitpython",
@@ -81,6 +81,7 @@ dependencies = [
     "pydantic-extra-types>=2.11.0",
     "pydantic-settings>=2.12.0",
     "sqlmodel>=0.0.31",
+    "anyio>=4.12.1",
 ]
 
 [project.urls]
@@ -164,6 +165,9 @@ packages = ["src/socx", "src/socx_tui", "src/socx_plugins"]
 [tool.hatch.build.targets.wheel]
 packages = ["src/socx", "src/socx_tui", "src/socx_plugins"]
 
+[tool.hatch.build.targets.binary]
+packages = ["src/socx", "src/socx_tui", "src/socx_plugins"]
+
 # -----------------------------------------------------------------------------
 # Tool Configurations - pytest
 # -----------------------------------------------------------------------------

{socx_cli-0.13.0 → socx_cli-0.13.2}/socx/__init__.py

@@ -123,9 +123,9 @@ __all__ = (
     # Patterns
     "Node",
     "Visitor",
-    "Structure",
     "Traversal",
     "Singleton",
+    "StructureProxy",
     "ByLevelTraversal",
     "TopDownTraversal",
     "BottomUpTraversal",
@@ -135,6 +135,7 @@ __all__ = (
     "Regression",
     "TestStatus",
     "TestResult",
+    "RegressionTree",
     "RegressionProgress",
 )
 
@@ -248,21 +249,22 @@ from socx.config import validate_all as validate_all
 
 from socx.patterns import Node as Node
 from socx.patterns import Visitor as Visitor
-from socx.patterns import Structure as Structure
 from socx.patterns import Traversal as Traversal
-from socx.patterns import UIDMixin as UIDMixin
-from socx.patterns import PtrMixin as PtrMixin
-from socx.patterns import ProxyMixin as ProxyMixin
-from socx.patterns import Singleton as Singleton
+from socx.patterns import StructureProxy as StructureProxy
 from socx.patterns import TopDownTraversal as TopDownTraversal
 from socx.patterns import BottomUpTraversal as BottomUpTraversal
 from socx.patterns import ByLevelTraversal as ByLevelTraversal
+from socx.patterns import UIDMixin as UIDMixin
+from socx.patterns import PtrMixin as PtrMixin
+from socx.patterns import Singleton as Singleton
+from socx.patterns import ProxyMixin as ProxyMixin
 
 from socx.regression import Test as Test
 from socx.regression import TestBase as TestBase
 from socx.regression import Regression as Regression
 from socx.regression import TestStatus as TestStatus
 from socx.regression import TestResult as TestResult
+from socx.regression import RegressionTree as RegressionTree
 from socx.regression import RegressionProgress as RegressionProgress
 
 from socx.cli import FuncType as FuncType

{socx_cli-0.13.0 → socx_cli-0.13.2}/socx/core/_paths.py

@@ -55,7 +55,7 @@ def find_project_root(start_path: Path) -> Path:
 # Application Paths
 # -----------------------------------------------------------------------------
 
-APP_ROOT_DIR: Path = Path(getfile(lambda: None)).parents[3].resolve()
+APP_ROOT_DIR: Path = Path(getfile(lambda: None)).parents[1].resolve()
 """Absolute path to directory where application is installed."""
 
 APP_STATIC_DIR: Path = __directory__ / "static"

{socx_cli-0.13.0 → socx_cli-0.13.2}/socx/patterns/__init__.py

@@ -6,7 +6,7 @@ __all__ = (
     "PtrMixin",
     "UIDMixin",
     "ProxyMixin",
-    "Structure",
+    "StructureProxy",
     "Traversal",
     "Singleton",
     "ByLevelTraversal",
@@ -21,8 +21,8 @@ from socx.patterns.mixins import ProxyMixin as ProxyMixin
 
 from socx.patterns.visitor import Node as Node
 from socx.patterns.visitor import Visitor as Visitor
-from socx.patterns.visitor import Structure as Structure
 from socx.patterns.visitor import Traversal as Traversal
+from socx.patterns.visitor import StructureProxy as StructureProxy
 from socx.patterns.visitor import ByLevelTraversal as ByLevelTraversal
 from socx.patterns.visitor import TopDownTraversal as TopDownTraversal
 from socx.patterns.visitor import BottomUpTraversal as BottomUpTraversal

{socx_cli-0.13.0 → socx_cli-0.13.2}/socx/patterns/visitor/__init__.py

@@ -3,7 +3,7 @@
 __all__ = (
     "Node",
     "Visitor",
-    "Structure",
+    "StructureProxy",
     "Traversal",
     "ByLevelTraversal",
     "TopDownTraversal",
@@ -13,8 +13,8 @@ __all__ = (
 
 from socx.patterns.visitor.protocol import Node as Node
 from socx.patterns.visitor.protocol import Visitor as Visitor
-from socx.patterns.visitor.protocol import Structure as Structure
 from socx.patterns.visitor.protocol import Traversal as Traversal
+from socx.patterns.visitor.protocol import StructureProxy as StructureProxy
 
 from socx.patterns.visitor.traversal import (
     ByLevelTraversal as ByLevelTraversal,

{socx_cli-0.13.0 → socx_cli-0.13.2}/socx/patterns/visitor/protocol.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from typing import Protocol
-from collections.abc import Iterable
+from collections.abc import Generator
 
 
 class Visitor[NODE](Protocol):
@@ -11,7 +11,7 @@ class Visitor[NODE](Protocol):
 
     __slots__ = ()
 
-    def visit(self, n: NODE) -> None:
+    def visit(self, node: NODE) -> None:
         """Visit a node of a structure."""
         ...
 
@@ -21,19 +21,19 @@ class Node[NODE](Protocol):
 
     __slots__ = ()
 
-    def accept(self, v: Visitor[NODE]) -> None:
+    def accept(self, visitor: Visitor[NODE]) -> None:
         """Accept a visit from a `Visitor`."""
         ...
 
 
-class Structure[NODE](Protocol):
+class StructureProxy[STRUCTURE](Protocol):
     """Protocol for structures exposing child relationships."""
 
     __slots__ = ()
 
     @classmethod
-    def children(cls, s: NODE) -> Iterable[NODE]:
-        """Return the immediate children of ``s``."""
+    def children(cls, structure: STRUCTURE) -> Generator[STRUCTURE]:
+        """Return the immediate children of ``structure``."""
         ...
 
 
@@ -43,6 +43,11 @@ class Traversal[NODE](Protocol):
     __slots__ = ()
 
     @classmethod
-    def accept(cls, n: NODE, v: Visitor[NODE], p: Structure[NODE]) -> None:
-        """Accept visits of a `NODE` n from a `Visitor` v."""
+    def accept(
+        cls,
+        structure: NODE,
+        visitor: Visitor[NODE],
+        proxy: StructureProxy[NODE],
+    ) -> None:
+        """Accept visits of a `NODE` node from a `Visitor` visitor."""
         ...

socx_cli-0.13.2/socx/patterns/visitor/traversal.py

@@ -0,0 +1,64 @@
+"""Traversal strategies compatible with the visitor protocol."""
+
+from __future__ import annotations
+
+from socx.patterns.visitor.protocol import Visitor
+from socx.patterns.visitor.protocol import StructureProxy
+from socx.patterns.visitor.protocol import Traversal
+
+
+class TopDownTraversal[NODE](Traversal[NODE]):
+    """Pre-order traversal that visits parents before descendants."""
+
+    @classmethod
+    def accept(
+        cls,
+        structure: NODE,
+        visitor: Visitor[NODE],
+        proxy: StructureProxy[NODE],
+    ) -> None:
+        """Visit ``structure`` before recursively traversing its children."""
+        visitor.visit(structure)
+
+        for c in proxy.children(structure):
+            cls.accept(c, visitor, proxy)
+
+
+class BottomUpTraversal[NODE](Traversal[NODE]):
+    """Post-order traversal that visits descendants before parents."""
+
+    @classmethod
+    def accept(
+        cls,
+        structure: NODE,
+        visitor: Visitor[NODE],
+        proxy: StructureProxy[NODE],
+    ) -> None:
+        """Traverse child subtrees prior to visiting ``structure``."""
+        for c in proxy.children(structure):
+            cls.accept(c, visitor, proxy)
+
+        visitor.visit(structure)
+
+
+class ByLevelTraversal[NODE](Traversal[NODE]):
+    """Breadth-first traversal that visits nodes one level at a time."""
+
+    @classmethod
+    def accept(
+        cls,
+        structure: NODE,
+        visitor: Visitor[NODE],
+        proxy: StructureProxy[NODE],
+    ) -> None:
+        """Walk the structure level-by-level starting from ``structure``."""
+        q: list[NODE] = [structure]
+
+        while q:
+            t: list[NODE] = []
+
+            for n_ in q:
+                visitor.visit(n_)
+                t.extend(proxy.children(n_))
+
+            q = t

{socx_cli-0.13.0 → socx_cli-0.13.2}/socx/regression/__init__.py

@@ -6,6 +6,7 @@ __all__ = (
     "TestStatus",
     "TestResult",
     "Regression",
+    "RegressionTree",
     "RegressionProgress",
 )
 
@@ -14,4 +15,5 @@ from socx.regression.test import TestBase as TestBase
 from socx.regression.test import TestStatus as TestStatus
 from socx.regression.test import TestResult as TestResult
 from socx.regression.regression import Regression as Regression
+from socx.regression.regression import RegressionTree as RegressionTree
 from socx.regression.progress import RegressionProgress as RegressionProgress

{socx_cli-0.13.0 → socx_cli-0.13.2}/socx/regression/progress.py

@@ -126,7 +126,7 @@ class RegressionProgress:
             prev_status = status
             prev_finished = finished
             status = regression.status
-            finished = await self._count_statuses(
+            finished = self._count_statuses(
                 regression,
                 TestStatus.Finished,
                 TestStatus.Terminated,
@@ -167,7 +167,7 @@ class RegressionProgress:
                 description=description,
             )
 
-    async def _count_statuses(
+    def _count_statuses(
         self, regression: Regression, *statuses: TestStatus
     ) -> int:
         with self.regression.lock:

{socx_cli-0.13.0 → socx_cli-0.13.2}/socx/regression/regression.py

@@ -10,15 +10,20 @@ from collections import OrderedDict
 from collections.abc import AsyncGenerator, Iterable
 from pathlib import Path
 from threading import RLock
-from typing import Self, Any
+from typing import Self, Any, Annotated
 
+import box
 from pydantic import (
+    Field,
     ConfigDict,
+    BaseModel,
     PrivateAttr,
     TypeAdapter,
     UUID4,
     computed_field,
     validate_call,
+    SerializeAsAny,
+    PlainValidator,
 )
 
 from socx.config import settings
@@ -28,26 +33,28 @@ from socx.regression.test import Test, TestBase, TestResult, TestStatus
 
 logger = logging.getLogger(__name__)
 
+semaphore = anyio.Semaphore(max(1, settings.regression.max_runs_in_parallel))
+
 
 class Regression(TestBase):
     """Manage and execute a collection of tests with concurrency control."""
 
+    test_map: OrderedDict[UUID4, SerializeAsAny[TestBase]] = Field(
+        default_factory=OrderedDict, repr=True, title="Test Map"
+    )
     model_config = ConfigDict(
+        title="Regression",
         from_attributes=True,
         arbitrary_types_allowed=True,
     )
-
     _lock: RLock = PrivateAttr(default_factory=RLock)
     _done: aio.Queue[TestBase] = PrivateAttr(default_factory=aio.Queue)
-    _pending: aio.Queue[TestBase | Regression | None] = PrivateAttr(
+    _pending: aio.Queue[TestBase | None] = PrivateAttr(
         default_factory=aio.Queue
     )
     _running: set[UUID4] = PrivateAttr(default_factory=set)
-    _test_map: OrderedDict[UUID4, TestBase] = PrivateAttr(
-        default_factory=OrderedDict
-    )
-    _stop_requested: bool = PrivateAttr(default=False)
     _pause_event: aio.Event = PrivateAttr(default_factory=aio.Event)
+    _stop_requested: bool = PrivateAttr(default=False)
 
     def __init__(
         self,
@@ -58,10 +65,9 @@ class Regression(TestBase):
         **kwargs: Any,
     ) -> None:
         super().__init__(*args, name=name, **kwargs)
-        tests = tests or []
         test_map = test_map or {}
-        self._test_map = OrderedDict()
-        self.tests = [*tests, *list(test_map.values())]
+        tests = [*list(test_map.values()), *(tests or [])]
+        self.test_map = OrderedDict({test.id: test for test in tests})
 
     @classmethod
     @validate_call()
@@ -74,7 +80,7 @@ class Regression(TestBase):
     ) -> Self:
         return cls._from_file(path, test_cls=test_cls, **kwargs)
 
-    @computed_field(repr=True)
+    @computed_field
     @property
     def result(self) -> TestResult:
         with self.lock:
@@ -94,7 +100,7 @@ class Regression(TestBase):
             else:
                 return super().result
 
-    @computed_field(repr=True)
+    @computed_field
     @property
     def status(self) -> TestStatus:
         terminated_statuses = [
@@ -102,50 +108,36 @@ class Regression(TestBase):
             TestStatus.Terminated,
             TestStatus.Finished,
         ]
-        running_statuses = [TestStatus.Pending, TestStatus.Running]
+        running_statuses = [TestStatus.Running]
         tests = self.tests
         if all(test.status is TestStatus.Idle for test in tests):
             return TestStatus.Idle
         if all(test.status is TestStatus.Finished for test in tests):
             return TestStatus.Finished
-        if all(test.status in terminated_statuses for test in tests):
-            return TestStatus.Terminated
         if any(test.status in running_statuses for test in tests):
             return TestStatus.Running
-        return TestStatus.Paused
+        if any(test.status is TestStatus.Paused for test in tests):
+            return TestStatus.Paused
+        if all(test.status in terminated_statuses for test in tests):
+            return TestStatus.Terminated
+        return TestStatus.Pending
 
     @computed_field
     @property
     def tests(self) -> list[TestBase]:
         with self.lock:
-            return list(self._test_map.values())
+            return list(self.test_map.values())
 
     @tests.setter
     def tests(self, other: list[TestBase]) -> None:
         with self.lock:
-            self._test_map = OrderedDict({test.id: test for test in other})
-
-    @computed_field(repr=True)
-    @property
-    def test_map(self) -> dict[UUID4, TestBase]:
-        with self.lock:
-            return self._test_map
-
-    @test_map.setter
-    def test_map(self, other: dict[UUID4, TestBase]) -> None:
-        with self.lock:
-            if isinstance(other, OrderedDict):
-                self._test_map = other
-            else:
-                self._test_map = OrderedDict(other)
+            self.test_map = OrderedDict({test.id: test for test in other})
 
-    @computed_field(repr=True)
+    @computed_field
     @property
     def run_limit(self) -> int:
         """Return the maximum number of tests that may run concurrently."""
-        with self.lock:
-            run_limit = settings.regression.max_runs_in_parallel
-        return max(1, min(run_limit, len(self) or 1))
+        return int(max(1, int(settings.regression.max_runs_in_parallel)))
 
     @property
     def lock(self) -> RLock:
@@ -275,13 +267,13 @@ class Regression(TestBase):
             if test.status in (TestStatus.Finished, TestStatus.Terminated):
                 test.reset()
             await self.pending.put(test)
-
         for _ in range(self.run_limit):
             await self.pending.put(None)
 
     async def _runner(self) -> None:
         """Consume queued tests and execute them sequentially."""
         while True:
+            await semaphore.acquire()
             test = await self.pending.get()
             try:
                 if test is None:
@@ -294,13 +286,28 @@ class Regression(TestBase):
                     return
 
                 self._running.add(test.id)
-                if test is not None:
-                    await test.start()
+                await test.start()
                 await self.done.put(test)
             finally:
                 if test is not None:
                     self._running.discard(test.id)
                 self.pending.task_done()
+                semaphore.release()
+
+    def dump_state(self, output_dir: Path) -> None:
+        """Write the regression command results to their respective files."""
+        logger.info("saving regression state and results to disk...")
+        file = output_dir / self.name / "state.yaml"
+        state = self.model_dump(
+            mode="json",
+            round_trip=True,
+            serialize_as_any=True,
+            include={"result", "status"},
+        )
+        file.parent.mkdir(parents=True, exist_ok=True)
+        file.touch(exist_ok=False)
+        box.DDBox(state).to_yaml(str(file))
+        logger.info(f"state and results saved to: '{output_dir}'.")
 
     def _active_tests(self) -> list[TestBase]:
         return [test for test in self.tests if test.id in self._running]
@@ -359,26 +366,42 @@ class Regression(TestBase):
             regressions.append(regression)
         return cls(name=name, tests=regressions)
 
-    # @field_validator("test_map", mode="before")
-    # @classmethod
-    # def _test_map_validator(
-    #     cls,
-    #     tests: set[TestBase]
-    #     | list[TestBase]
-    #     | tuple[TestBase, ...]
-    #     | dict[str, TestBase],
-    # ) -> OrderedDict[UUID4, TestBase]:
-    #     if tests is None:
-    #         err = "must not be none"
-    #         raise ValueError(err)
-
-    #     rv = OrderedDict()
-    #     it: Iterator[TestBase] = (
-    #         iter(list(tests.values()))
-    #         if isinstance(tests, dict)
-    #         else iter(tests)
-    #     )
-
-    #     for test in it:
-    #         rv[test.id] = test
-    #     return rv
+
+TreeNode = Annotated[
+    TestBase,
+    PlainValidator(lambda x: x, TestBase),
+    SerializeAsAny[Test | Regression],
+]
+
+
+class RegressionTree(BaseModel):
+    root_node: TreeNode = Field(..., title="Root Node", repr=True)
+    model_config = ConfigDict(
+        from_attributes=True,
+        arbitrary_types_allowed=True,
+    )
+
+
+# @field_validator("test_map", mode="before")
+# @classmethod
+# def _test_map_validator(
+#     cls,
+#     tests: set[TestBase]
+#     | list[TestBase]
+#     | tuple[TestBase, ...]
+#     | dict[str, TestBase],
+# ) -> OrderedDict[UUID4, TestBase]:
+#     if tests is None:
+#         err = "must not be none"
+#         raise ValueError(err)
+
+#     rv = OrderedDict()
+#     it: Iterator[TestBase] = (
+#         iter(list(tests.values()))
+#         if isinstance(tests, dict)
+#         else iter(tests)
+#     )
+
+#     for test in it:
+#         rv[test.id] = test
+#     return rv