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

{socx_cli-0.13.2 → socx_cli-0.13.3}/.gitignore

@@ -40,7 +40,6 @@
 !*.yaml
 !*.toml
 !*.json
-!*.example
 
 !LICENSE
 !Makefile
@@ -50,3 +49,5 @@
 !CHANGELOG.md
 !CONTRIBUTING.md
 !CODE_OF_CONDUCT.md
+
+workrun/

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socx-cli
-Version: 0.13.2
+Version: 0.13.3
 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

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

@@ -29,7 +29,7 @@ socx = 'socx.__main__:main'
 [project]
 name = "socx-cli"
 readme = "README.md"
-version = "0.13.2"
+version = "0.13.3"
 license = "Apache-2.0"
 authors = [{ name = "Sagi Kimhi", email = "sagi.kim5@gmail.com" }]
 maintainers = [{ name = "Sagi Kimhi", email = "sagi.kim5@gmail.com" }]

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

@@ -5,9 +5,10 @@ from __future__ import annotations
 import asyncio as aio
 import anyio
 import logging
+import re
 import time
 from collections import OrderedDict
-from collections.abc import AsyncGenerator, Iterable
+from collections.abc import AsyncGenerator, Iterable, Mapping
 from pathlib import Path
 from threading import RLock
 from typing import Self, Any, Annotated
@@ -36,6 +37,25 @@ logger = logging.getLogger(__name__)
 semaphore = anyio.Semaphore(max(1, settings.regression.max_runs_in_parallel))
 
 
+def _safe_dir_name(name: str, node_id: UUID4) -> str:
+    slug = re.sub(r"[^A-Za-z0-9._-]+", "-", name).strip("-").lower()
+    return f"{slug or 'item'}-{node_id}"
+
+
+def _coerce_status(value: TestStatus | int | str) -> TestStatus:
+    if isinstance(value, TestStatus):
+        return value
+    if isinstance(value, int):
+        return TestStatus(value)
+    return TestStatus[value.strip().lower().title()]
+
+
+def _coerce_result(value: TestResult | str) -> TestResult:
+    if isinstance(value, TestResult):
+        return value
+    return TestResult(value)
+
+
 class Regression(TestBase):
     """Manage and execute a collection of tests with concurrency control."""
 
@@ -78,7 +98,28 @@ class Regression(TestBase):
         test_cls: type[TestBase] | None = None,
         **kwargs: Any,
     ) -> Self:
-        return cls._from_file(path, test_cls=test_cls, **kwargs)
+        return cls._from_file(path, name=name, test_cls=test_cls, **kwargs)
+
+    @classmethod
+    @validate_call()
+    def load(
+        cls,
+        path: str | Path,
+        name: str | None = None,
+        test_cls: type[TestBase] | None = None,
+        **kwargs: Any,
+    ) -> Self:
+        path = TypeAdapter(FilePath).validate_python(path)
+        data = cls._read_data(path)
+
+        if cls._looks_like_state(data):
+            return cls._from_state_data(
+                data,
+                output_dir=path.parent,
+                test_cls=test_cls or Test,
+            )
+
+        return cls._from_file(path, name=name, test_cls=test_cls, **kwargs)
 
     @computed_field
     @property
@@ -187,7 +228,7 @@ class Regression(TestBase):
         self._done = aio.Queue()
         self._pending = aio.Queue()
         self.finished_time = None
-        self.started_time = time.perf_counter()
+        self.started_time = time.time()
         logger.info("regression starting...")
 
         try:
@@ -196,7 +237,7 @@ class Regression(TestBase):
                 for _ in range(self.run_limit):
                     tg.start_soon(self._runner)
         finally:
-            self.finished_time = time.perf_counter()
+            self.finished_time = time.time()
             self._pause_event.set()
             self._running.clear()
             logger.info(f"regression {self.status.name.lower()}.")
@@ -294,24 +335,146 @@ class Regression(TestBase):
                 self.pending.task_done()
                 semaphore.release()
 
-    def dump_state(self, output_dir: Path) -> None:
-        """Write the regression command results to their respective files."""
+    def assign_output_dir(self, output_dir: Path) -> Path:
+        self.output_dir = output_dir
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        for child in self.tests:
+            child_output_dir = output_dir / _safe_dir_name(
+                child.name, child.id
+            )
+            if isinstance(child, Regression):
+                child.assign_output_dir(child_output_dir)
+            else:
+                child.output_dir = child_output_dir
+
+        return output_dir
+
+    def dump_state(self, output_dir: Path | None = None) -> Path:
+        """Write the regression state and test artifacts to disk."""
+        root_output_dir = self.output_dir
+        if output_dir is not None:
+            root_output_dir = self.assign_output_dir(output_dir / self.name)
+
+        if root_output_dir is None:
+            msg = "Regression output directory is not configured."
+            raise ValueError(msg)
+
         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"},
-        )
+        self._persist_test_outputs()
+        file = root_output_dir / "state.yaml"
+        state = self._serialize_state(root_output_dir)
         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}'.")
+        logger.info(f"state and results saved to: '{file}'.")
+        return file
 
     def _active_tests(self) -> list[TestBase]:
         return [test for test in self.tests if test.id in self._running]
 
+    def iter_leaf_tests(self) -> Iterable[TestBase]:
+        for test in self.tests:
+            if isinstance(test, Regression):
+                yield from test.iter_leaf_tests()
+            else:
+                yield test
+
+    @property
+    def leaf_tests(self) -> list[TestBase]:
+        return list(self.iter_leaf_tests())
+
+    @property
+    def total_test_count(self) -> int:
+        return len(self.leaf_tests)
+
+    @property
+    def completed_test_count(self) -> int:
+        return sum(
+            1
+            for test in self.iter_leaf_tests()
+            if test.status in (TestStatus.Finished, TestStatus.Terminated)
+        )
+
+    @property
+    def progress_ratio(self) -> float:
+        total = self.total_test_count
+        if total == 0:
+            return 0.0
+        return min(1.0, self.completed_test_count / total)
+
+    @property
+    def estimated_remaining_time(self) -> float | None:
+        total = self.total_test_count
+        completed = self.completed_test_count
+        elapsed = self.elapsed_time
+
+        if total == 0 or elapsed is None:
+            return None
+        if completed >= total:
+            return 0.0
+        if completed == 0 or elapsed <= 0:
+            return None
+
+        rate = completed / elapsed
+        if rate <= 0:
+            return None
+
+        return max(0.0, (total - completed) / rate)
+
+    def _persist_test_outputs(self) -> None:
+        for child in self.tests:
+            if isinstance(child, Regression):
+                child._persist_test_outputs()
+                continue
+
+            if (
+                isinstance(child, Test)
+                and child.started_time is not None
+                and child.output_dir is not None
+            ):
+                child._prepare_output_files()
+                child._write_output_files()
+
+    def _serialize_state(self, root_output_dir: Path) -> dict[str, Any]:
+        return self._serialize_node(self, root_output_dir)
+
+    @classmethod
+    def _serialize_node(
+        cls, node: TestBase, root_output_dir: Path
+    ) -> dict[str, Any]:
+        state = {
+            "kind": "regression" if isinstance(node, Regression) else "test",
+            "id": str(node.id),
+            "name": node.name,
+            "started_time": node.started_time,
+            "finished_time": node.finished_time,
+            "status": node.status.name.lower(),
+            "result": node.result.value,
+        }
+
+        if node.output_dir is not None and node.output_dir != root_output_dir:
+            state["output_dir"] = str(
+                node.output_dir.relative_to(root_output_dir)
+            )
+
+        if isinstance(node, Regression):
+            state["tests"] = [
+                cls._serialize_node(child, root_output_dir)
+                for child in node.tests
+            ]
+            return state
+
+        state["exec"] = str(node.exec) if node.exec is not None else None
+        if node.stdout_path is not None and node.stdout_path.exists():
+            state["stdout_path"] = str(
+                node.stdout_path.relative_to(root_output_dir)
+            )
+        if node.stderr_path is not None and node.stderr_path.exists():
+            state["stderr_path"] = str(
+                node.stderr_path.relative_to(root_output_dir)
+            )
+        return state
+
     @classmethod
     @validate_call()
     def _from_file(
@@ -326,20 +489,29 @@ class Regression(TestBase):
         path = TypeAdapter(FilePath).validate_python(path)
         name = name or path.stem
         test_cls = test_cls or Test
+        data = cls._read_data(path)
+
+        settings.update(Box({name: data}), merge=False)
+        return cls._from_data(name, settings[name], test_cls)
+
+    @staticmethod
+    def _read_data(path: Path) -> Mapping[str, Any]:
+        from box import Box
 
         match path.suffix.lower():
             case ".yml" | ".yaml":
-                data = Box.from_yaml(filename=str(path))
+                return Box.from_yaml(filename=str(path))
             case ".toml":
-                data = Box.from_toml(filename=str(path))
+                return Box.from_toml(filename=str(path))
             case ".json":
-                data = Box.from_json(filename=str(path))
+                return Box.from_json(filename=str(path))
             case _:
                 msg = f"Unsupported file format: '{path.suffix}'"
                 raise ValueError(msg)
 
-        settings.update(Box({name: data}), merge=False)
-        return cls._from_data(name, settings[name], test_cls)
+    @staticmethod
+    def _looks_like_state(data: Mapping[str, Any]) -> bool:
+        return data.get("kind") == "regression" and "tests" in data
 
     @classmethod
     def _from_data(
@@ -366,6 +538,97 @@ class Regression(TestBase):
             regressions.append(regression)
         return cls(name=name, tests=regressions)
 
+    @classmethod
+    def _from_state_data(
+        cls,
+        data: Mapping[str, Any],
+        output_dir: Path,
+        test_cls: type[TestBase],
+    ) -> Self:
+        node = cls._deserialize_node(
+            data,
+            root_output_dir=output_dir,
+            test_cls=test_cls,
+            parent_output_dir=None,
+        )
+        if not isinstance(node, Regression):
+            msg = "State file must contain a root regression."
+            raise ValueError(msg)
+        return node
+
+    @classmethod
+    def _deserialize_node(
+        cls,
+        data: Mapping[str, Any],
+        root_output_dir: Path,
+        test_cls: type[TestBase],
+        parent_output_dir: Path | None,
+    ) -> TestBase:
+        kind = str(data.get("kind", "")).strip().lower()
+        output_dir = cls._resolve_output_dir(
+            data,
+            root_output_dir=root_output_dir,
+            parent_output_dir=parent_output_dir,
+        )
+
+        if kind == "regression":
+            regression = cls(
+                id=data["id"],
+                name=data["name"],
+                started_time=data.get("started_time"),
+                finished_time=data.get("finished_time"),
+                tests=[],
+            )
+            regression.output_dir = output_dir
+            regression.tests = [
+                cls._deserialize_node(
+                    child,
+                    root_output_dir=root_output_dir,
+                    test_cls=test_cls,
+                    parent_output_dir=regression.output_dir,
+                )
+                for child in data.get("tests", [])
+            ]
+            return regression
+
+        test = test_cls(
+            id=data["id"],
+            name=data["name"],
+            exec=data.get("exec"),
+            started_time=data.get("started_time"),
+            finished_time=data.get("finished_time"),
+        )
+        test.output_dir = output_dir
+        test.status = _coerce_status(data.get("status", TestStatus.Idle))
+        test.result = _coerce_result(data.get("result", TestResult.NA))
+
+        if isinstance(test, Test):
+            for attr, relpath in (
+                ("stdout", data.get("stdout_path")),
+                ("stderr", data.get("stderr_path")),
+            ):
+                if relpath:
+                    file = root_output_dir / str(relpath)
+                    if file.exists():
+                        setattr(test, attr, file.read_text(encoding="utf-8"))
+
+        return test
+
+    @classmethod
+    def _resolve_output_dir(
+        cls,
+        data: Mapping[str, Any],
+        *,
+        root_output_dir: Path,
+        parent_output_dir: Path | None,
+    ) -> Path:
+        relative_output_dir = data.get("output_dir")
+        if relative_output_dir:
+            return root_output_dir / str(relative_output_dir)
+        if parent_output_dir is None:
+            return root_output_dir
+        return parent_output_dir / _safe_dir_name(data["name"], data["id"])
+
 
 TreeNode = Annotated[
     TestBase,

{socx_cli-0.13.2 → socx_cli-0.13.3}/socx/regression/test.py

@@ -8,6 +8,7 @@ import signal
 import time
 import uuid
 from enum import StrEnum, IntEnum, auto
+from pathlib import Path
 
 from pydantic import (
     BaseModel,
@@ -59,6 +60,7 @@ class TestBase(BaseModel):
     _status: TestStatus = PrivateAttr(TestStatus.Idle)
     _process: aio.subprocess.Process | None = PrivateAttr(default=None)
     _termination_requested: bool = PrivateAttr(default=False)
+    _output_dir: Path | None = PrivateAttr(default=None)
 
     @computed_field
     @property
@@ -84,12 +86,41 @@ class TestBase(BaseModel):
             return None
         return Process(self._process.pid)
 
+    @property
+    def output_dir(self) -> Path | None:
+        return self._output_dir
+
+    @output_dir.setter
+    def output_dir(self, value: Path | None) -> None:
+        self._output_dir = value
+
+    @property
+    def stdout_path(self) -> Path | None:
+        if self.output_dir is None:
+            return None
+        return self.output_dir / "stdout.txt"
+
+    @property
+    def stderr_path(self) -> Path | None:
+        if self.output_dir is None:
+            return None
+        return self.output_dir / "stderr.txt"
+
     @computed_field
     @property
     def started(self) -> bool:
         """Return ``True`` once ``start`` has spawned the subprocess."""
         return self.status > TestStatus.Pending
 
+    @property
+    def elapsed_time(self) -> float | None:
+        """Return the elapsed runtime derived from wall-clock timestamps."""
+        if self.started_time is None:
+            return None
+
+        end_time = self.finished_time or time.time()
+        return max(0.0, end_time - self.started_time)
+
     @property
     def finished(self) -> bool:
         """Return ``True`` if the test completed and recorded a result."""
@@ -188,6 +219,15 @@ class TestBase(BaseModel):
         self.reset()
         await self.start()
 
+    def _prepare_output_files(self) -> None:
+        if self.output_dir is None:
+            return
+
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        for path in (self.stdout_path, self.stderr_path):
+            if path is not None:
+                path.write_text("", encoding="utf-8")
+
 
 class Test(TestBase):
     """Concrete test model with subprocess execution support."""
@@ -237,14 +277,16 @@ class Test(TestBase):
         self.result = TestResult.NA
         self.stdout = ""
         self.stderr = ""
-        self.started_time = time.perf_counter()
+        self.started_time = time.time()
         self.finished_time = None
         self.status = TestStatus.Pending
+        self._prepare_output_files()
 
         if not self.exec:
             self.status = TestStatus.Terminated
             self.result = TestResult.Failed
-            self.finished_time = time.perf_counter()
+            self.finished_time = time.time()
+            self._write_output_files()
             return
 
         process = await aio.create_subprocess_exec(
@@ -263,9 +305,10 @@ class Test(TestBase):
         try:
             stdout, stderr = await process.communicate()
         finally:
-            self.finished_time = time.perf_counter()
+            self.finished_time = time.time()
             self.stderr = stderr.decode() if stderr else ""
             self.stdout = stdout.decode() if stdout else ""
+            self._write_output_files()
             returncode = process.returncode or 0
 
             if self._termination_requested or returncode < 0:
@@ -279,3 +322,11 @@ class Test(TestBase):
                 self.result = TestResult.Failed
 
             self._process = None
+
+    def _write_output_files(self) -> None:
+        for path, content in (
+            (self.stdout_path, self.stdout),
+            (self.stderr_path, self.stderr),
+        ):
+            if path is not None:
+                path.write_text(content, encoding="utf-8")

{socx_cli-0.13.2 → socx_cli-0.13.3}/socx_plugins/regression/_run.py

@@ -219,6 +219,7 @@ async def run_regression(
     path_in = file or _get_input_path()
     regression = populate_regression(path_in)
     output_dir = _get_output_path(regression)
+    regression.assign_output_dir(output_dir / regression.name)
     names_set = _get_names_to_run()
     progress = RegressionProgress(regression)
 

{socx_cli-0.13.2 → socx_cli-0.13.3}/socx_tui/regression/app.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from contextlib import suppress
 from typing import Any, ClassVar
 from collections import ChainMap
 from collections.abc import Iterable
@@ -38,6 +39,16 @@ class SoCX(App[int]):
         kwargs = dict(ChainMap(kwargs, dict(inline=True)))
         return super().run(*args, **kwargs)
 
+    def exit(
+        self,
+        result: int | None = None,
+        return_code: int = 0,
+        message: Any | None = None,
+    ) -> None:
+        with suppress(Exception):
+            self.regression.persist_loaded_regression_state()
+        super().exit(result=result, return_code=return_code, message=message)
+
     def compose(self) -> ComposeResult:
         """Lay out the application chrome shared between all screens."""
         yield Header(

{socx_cli-0.13.2 → socx_cli-0.13.3}/socx_tui/regression/details.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime
 from textwrap import wrap
 from typing import ClassVar
 
@@ -79,9 +80,11 @@ class RegressionDetails(Widget, can_focus=True, inherit_bindings=True):
                     f"**✅ Passed:** {self.count_results(model, TestResult.Passed)}",  # noqa: E501
                     f"**💡 Status:** {self.format_status(model.status)}",
                     f"**🚩 Result:** {self.format_result(model.result)}",
-                    # f"**⌛ Elapsed Time:** {self.format_timedelta(model.time_elapsed)}",  # noqa: E501, W505
+                    f"**⌛ Elapsed Time:** {self.format_timedelta(model.elapsed_time)}",  # noqa: E501
                     f"**⌛ Started Time:** {self.format_time(model.started_time)}",  # noqa: E501
                     f"**⌛ Finished Time:** {self.format_time(model.finished_time)}",  # noqa: E501
+                    f"**📊 Progress:** `{self.format_progress(model)}`",
+                    f"**⏳ ETA:** {self.format_timedelta(model.estimated_remaining_time)}",  # noqa: E501
                 ]
             )
         else:
@@ -89,7 +92,7 @@ class RegressionDetails(Widget, can_focus=True, inherit_bindings=True):
                 [
                     f"**💡 Status:** {self.format_status(model.status)}",
                     f"**🚩 Result:** {self.format_result(model.result)}",
-                    # f"**⌛ Elapsed Time:** {self.format_timedelta(model.time_elapsed)}",  # noqa: E501, W505
+                    f"**⌛ Elapsed Time:** {self.format_timedelta(model.elapsed_time)}",  # noqa: E501
                     f"**⌛ Started Time:** {self.format_time(model.started_time)}",  # noqa: E501
                     f"**⌛ Finished Time:** {self.format_time(model.finished_time)}",  # noqa: E501
                     "",
@@ -123,7 +126,20 @@ class RegressionDetails(Widget, can_focus=True, inherit_bindings=True):
         return status.name.lower()
 
     def format_time(self, value: float | None) -> str:
-        return "n/a" if value is None else f"{value:.3f}"
+        if value is None:
+            return "n/a"
+
+        try:
+            if value >= 946684800:
+                return (
+                    datetime.fromtimestamp(value)
+                    .astimezone()
+                    .strftime("%Y-%m-%d %H:%M:%S %Z")
+                )
+        except (OverflowError, OSError, ValueError):
+            pass
+
+        return f"{value:.3f}s"
 
     def format_timedelta(self, value: int | float | None) -> str:
         if value is None:
@@ -135,4 +151,15 @@ class RegressionDetails(Widget, can_focus=True, inherit_bindings=True):
         return f"{hours:02}h:{minutes:02}m:{seconds:02}s"
 
     def count_results(self, regression: Regression, result: TestResult) -> int:
-        return sum(1 for test in regression.tests if test.result is result)
+        return sum(
+            1 for test in regression.iter_leaf_tests() if test.result is result
+        )
+
+    def format_progress(self, regression: Regression, width: int = 24) -> str:
+        total = regression.total_test_count
+        completed = regression.completed_test_count
+        ratio = regression.progress_ratio
+        filled = min(width, round(ratio * width))
+        bar = "#" * filled + "-" * (width - filled)
+        percent = int(ratio * 100)
+        return f"[{bar}] {completed}/{total} ({percent}%)"