symtest-cli 1.3.0__py3-none-any.whl

symtest/runners/json_runner.py

@@ -0,0 +1,21 @@
+"""JSONRunner – thin backward-compatible wrapper around ConfigRunner."""
+import json
+import logging
+from typing import Optional
+
+from .config_runner import ConfigRunner
+
+logger = logging.getLogger("symtest.runners.json_runner")
+
+
+class JSONRunner(ConfigRunner):
+    """Sequential JSON test runner (backward-compatible thin wrapper)."""
+
+    def __init__(self, config_file="test_cases.json",
+                 workspace: Optional[str] = None, **kwargs):
+        super().__init__(
+            config_file=config_file,
+            workspace=workspace,
+            config_loader=json.load,
+            **kwargs,
+        )

symtest/runners/parallel_config_runner.py

@@ -0,0 +1,278 @@
+"""Generic parallel config-driven test runner with injectable config loader.
+
+The only difference between ParallelJSONRunner and ParallelYAMLRunner was the
+``load`` call.  This module extracts the common scheduling / resource-management
+logic into ``ParallelConfigRunner``, accepting a ``config_loader`` callable.
+"""
+import sys
+import os
+import logging
+from typing import Optional, Dict, Any, Callable, BinaryIO
+
+from ..core.parallel_runner import ParallelRunner, AtomicSemaphore
+from ..core.config_loader import parse_test_cases, execute_sequence
+from ..config.inheritance_expander import resolve_inheritance, apply_variables
+from ..core.test_case import TestCase
+from ..core.execution import execute_single_test_case
+from ..core.types import TestCaseData
+from ..utils.path_resolver import PathResolver
+from ..config.import_expander import expand_imports
+
+logger = logging.getLogger("symtest.runners.parallel_config_runner")
+
+
+class ParallelConfigRunner(ParallelRunner):
+    """Generic parallel test runner with injectable config loader.
+
+    Subclasses inject a ``config_loader`` instead of hardcoding
+    ``json.load`` / ``yaml.safe_load``.  All scheduling (CPU-aware semaphore,
+    heuristic ordering, proportional core assignment) lives here.
+    """
+
+    def __init__(self, config_file: str = "test_cases.json",
+                 workspace: Optional[str] = None,
+                 max_workers: Optional[int] = None,
+                 execution_mode: str = "thread",
+                 config_loader: Optional[Callable[[BinaryIO], Dict[str, Any]]] = None,
+                 variables: Optional[Dict[str, Any]] = None,
+                 **kwargs):
+        # Auto-detect physical CPU cores (reserve 2 for OS)
+        self.total_physical = os.cpu_count() or 4
+        self.safe_capacity = max(1, self.total_physical - 2)
+
+        if max_workers is None:
+            max_workers = self.total_physical
+
+        super().__init__(config_file, workspace, max_workers,
+                         execution_mode, **kwargs)
+        self._config_loader = config_loader
+        self._variables = variables or {}
+        # Backward-compatible attribute for tests that patch path_resolver
+        self.path_resolver = PathResolver(self.workspace)
+
+        # Resource pool – only meaningful in thread mode
+        self.cpu_semaphore = (
+            AtomicSemaphore(self.safe_capacity)
+            if execution_mode == "thread" else None
+        )
+
+        logger.info(
+            "✅ [Resource Manager] Detected %d CPUs. Pool size set to %d.",
+            self.total_physical, self.safe_capacity,
+        )
+
+    # ------------------------------------------------------------------
+    #  CPU allocation helpers
+    # ------------------------------------------------------------------
+
+    def _assign_relative_cpu_cores(self) -> None:
+        """Assign ``cpu_cores`` proportionally based on *estimated_time*
+        and *min_memory_mb* for cases without an explicit ``cpu_cores``.
+
+        Weight = estimated_time (s) + min_memory_mb / 100.
+        """
+        candidates = [
+            c for c in self.test_cases
+            if not (c.resources and "cpu_cores" in c.resources)
+        ]
+        if not candidates:
+            return
+
+        def weight(case: TestCase) -> float:
+            res = case.resources or {}
+            est = float(res.get("estimated_time") or 0)
+            mem = float(res.get("min_memory_mb") or 0)
+            return est + mem / 100.0
+
+        weights = [weight(c) for c in candidates]
+        total_weight = sum(weights)
+
+        if total_weight <= 0:
+            for case in candidates:
+                if not case.resources:
+                    case.resources = {}
+                case.resources["cpu_cores"] = 1
+            return
+
+        allocated = 0
+        indexed = sorted(
+            enumerate(zip(candidates, weights)),
+            key=lambda x: x[1][1], reverse=True,
+        )
+        for rank, (_idx, (case, w)) in enumerate(indexed):
+            if rank == len(indexed) - 1:
+                share = max(1, self.safe_capacity - allocated)
+            else:
+                share = max(
+                    1, int(round(self.safe_capacity * w / total_weight)),
+                )
+            if not case.resources:
+                case.resources = {}
+            case.resources["cpu_cores"] = share
+            allocated += share
+
+    # ------------------------------------------------------------------
+    #  Test loading (format-agnostic)
+    # ------------------------------------------------------------------
+
+    def load_test_cases(self) -> None:
+        """Load test cases from config file using the injected loader."""
+        if self._config_loader is None:
+            raise RuntimeError(
+                "config_loader must be set before loading test cases"
+            )
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config = self._config_loader(f)
+
+            # Expand import references (no-op if none present)
+            config = expand_imports(config, self.config_path)
+            # Resolve extends inheritance (no-op if none present)
+            config = resolve_inheritance(config)
+            # Per-case + global variable substitution
+            config = apply_variables(config, self._variables)
+
+            self.load_setup_from_config(config)
+            self.test_cases = parse_test_cases(
+                config, self.workspace, self.path_resolver,
+            )
+
+            logger.info("Successfully loaded %d test cases",
+                        len(self.test_cases))
+
+            # Heuristic scheduling: longest-estimated first
+            if self.test_cases:
+                history_cases: Dict[str, Any] = {}
+                if self.history_dir:
+                    from ..core.history_store import load_history
+                    hist = load_history(self.history_dir)
+                    history_cases = hist.get("cases", {})
+
+                def get_estimated_time(case: TestCase) -> float:
+                    if case.name in history_cases:
+                        return float(
+                            history_cases[case.name]["avg_duration"],
+                        )
+                    return float(
+                        (case.resources or {}).get("estimated_time", 0),
+                    )
+
+                logger.info(
+                    "Optimizing execution order based on estimated duration...",
+                )
+                self.test_cases.sort(key=get_estimated_time, reverse=True)
+                top_case = self.test_cases[0]
+                top_est = get_estimated_time(top_case)
+                source = (
+                    "history" if top_case.name in history_cases else "config"
+                )
+                logger.info(
+                    "Heaviest task: %s (Est: %.2fs, source: %s)",
+                    top_case.name, top_est, source,
+                )
+
+            self._assign_relative_cpu_cores()
+        except Exception as e:
+            sys.exit(f"Failed to load configuration file: {str(e)}")
+
+    # ------------------------------------------------------------------
+    #  Execution
+    # ------------------------------------------------------------------
+
+    def _run_sequence(self, case: TestCase) -> Dict[str, Any]:
+        """Run a sequence test case with fail-fast semantics."""
+        return execute_sequence(
+            case_name=case.name,
+            steps=case.steps,
+            workspace=str(self.workspace) if self.workspace else None,
+            print_prefix="[Worker]",
+            case_expected=case.expected if case.expected else None,
+            update_baseline=self.update_baseline,
+            error_analysis=self.error_analysis,
+            resume=self.resume,
+        )
+
+    def run_single_test(self, case: TestCase) -> Dict[str, Any]:
+        """Thread-safe, resource-aware execution of a single test case.
+
+        In *thread* mode this uses an ``AtomicSemaphore`` to cap concurrent
+        CPU core usage and sets ``OMP_NUM_THREADS`` / ``MKL_NUM_THREADS``
+        environment variables accordingly.
+        """
+        # 1. Determine required core count
+        required_cores = 1
+        if case.resources and "cpu_cores" in case.resources:
+            required_cores = case.resources["cpu_cores"]
+
+        if required_cores > self.safe_capacity:
+            required_cores = self.safe_capacity
+
+        tokens_acquired = 0
+        task_env = None
+
+        # 2. Acquire resource tokens (thread mode only)
+        if self.execution_mode == "thread" and self.cpu_semaphore is not None:
+            if not self.cpu_semaphore.acquire(required_cores, timeout=10.0):
+                required_cores = 1
+                self.cpu_semaphore.acquire(1)
+                tokens_acquired = 1
+            else:
+                tokens_acquired = required_cores
+
+            task_env = {
+                "OMP_NUM_THREADS": str(required_cores),
+                "MKL_NUM_THREADS": str(required_cores),
+                "NPROC": str(required_cores),
+            }
+
+            logger.info(
+                "  [Scheduler] Task '%s' acquired %d cores. Running...",
+                case.name, tokens_acquired,
+            )
+
+        # 3. Execute
+        if case.steps:
+            result = self._run_sequence(case)
+        else:
+            case_data = case.to_execution_dict()
+
+            command_preview = (
+                f"{case_data['command']} {' '.join(case_data['args'])}".strip()
+            )
+            if self.execution_mode != "thread" or self.cpu_semaphore is None:
+                logger.info(
+                    "  [Worker] Executing command: %s", command_preview,
+                )
+
+            result = execute_single_test_case(
+                case_data,
+                str(self.workspace) if self.workspace else None,
+                env=task_env,
+                update_baseline=self.update_baseline,
+                error_analysis=self.error_analysis,
+            )
+
+            if result["output"].strip():
+                logger.debug(
+                    "  [Worker] Command output for %s:", case.name,
+                )
+                for line in result["output"].splitlines():
+                    logger.debug("    %s", line)
+
+            if result["status"] != "passed" and result.get("message"):
+                logger.error(
+                    "  [Worker] Error for %s: %s",
+                    case.name, result["message"],
+                )
+
+        # 4. Release tokens
+        if (self.execution_mode == "thread"
+                and self.cpu_semaphore is not None
+                and tokens_acquired > 0):
+            self.cpu_semaphore.release(tokens_acquired)
+            logger.info(
+                "  [Scheduler] Task '%s' released %d cores.",
+                case.name, tokens_acquired,
+            )
+
+        return result

symtest/runners/parallel_json_runner.py

@@ -0,0 +1,26 @@
+"""ParallelJSONRunner – thin backward-compatible wrapper around ParallelConfigRunner."""
+import json
+import logging
+from typing import Optional
+
+from .parallel_config_runner import ParallelConfigRunner
+
+logger = logging.getLogger("symtest.runners.parallel_json_runner")
+
+
+class ParallelJSONRunner(ParallelConfigRunner):
+    """Parallel JSON test runner (backward-compatible thin wrapper)."""
+
+    def __init__(self, config_file="test_cases.json",
+                 workspace: Optional[str] = None,
+                 max_workers: Optional[int] = None,
+                 execution_mode: str = "thread",
+                 **kwargs):
+        super().__init__(
+            config_file=config_file,
+            workspace=workspace,
+            max_workers=max_workers,
+            execution_mode=execution_mode,
+            config_loader=json.load,
+            **kwargs,
+        )

symtest/runners/parallel_yaml_runner.py

@@ -0,0 +1,31 @@
+"""ParallelYAMLRunner – thin backward-compatible wrapper around ParallelConfigRunner."""
+import logging
+from typing import Optional
+
+from .parallel_config_runner import ParallelConfigRunner
+
+logger = logging.getLogger("symtest.runners.parallel_yaml_runner")
+
+
+def _yaml_load(f):
+    """Lazy-load yaml.safe_load so the package is importable without PyYAML."""
+    import yaml
+    return yaml.safe_load(f)
+
+
+class ParallelYAMLRunner(ParallelConfigRunner):
+    """Parallel YAML test runner (backward-compatible thin wrapper)."""
+
+    def __init__(self, config_file="test_cases.yaml",
+                 workspace: Optional[str] = None,
+                 max_workers: Optional[int] = None,
+                 execution_mode: str = "thread",
+                 **kwargs):
+        super().__init__(
+            config_file=config_file,
+            workspace=workspace,
+            max_workers=max_workers,
+            execution_mode=execution_mode,
+            config_loader=_yaml_load,
+            **kwargs,
+        )

symtest/runners/yaml_runner.py

@@ -0,0 +1,26 @@
+"""YAMLRunner – thin backward-compatible wrapper around ConfigRunner."""
+import logging
+from typing import Optional
+
+from .config_runner import ConfigRunner
+
+logger = logging.getLogger("symtest.runners.yaml_runner")
+
+
+def _yaml_load(f):
+    """Lazy-load yaml.safe_load so the package is importable without PyYAML."""
+    import yaml
+    return yaml.safe_load(f)
+
+
+class YAMLRunner(ConfigRunner):
+    """Sequential YAML test runner (backward-compatible thin wrapper)."""
+
+    def __init__(self, config_file="test_cases.yaml",
+                 workspace: Optional[str] = None, **kwargs):
+        super().__init__(
+            config_file=config_file,
+            workspace=workspace,
+            config_loader=_yaml_load,
+            **kwargs,
+        )

symtest/tui/__init__.py

@@ -0,0 +1,11 @@
+"""
+TUI Manager for interactive test case CRUD.
+
+Provides a Textual-based terminal UI for browsing, editing and running
+test cases. Relies on :mod:`symtest.config.config_io` for
+configuration I/O and :mod:`symtest.core` for execution.
+
+Usage::
+
+    symtest tui test_cases.json
+"""

symtest/tui/app.py

@@ -0,0 +1,90 @@
+"""Textual App entry point for the TUI manager.
+
+Usage::
+
+    from symtest.tui.app import run_tui
+    run_tui("test_cases.json", workspace="/path/to/project")
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+
+from .controllers.case_controller import CaseController
+from .screens.case_list import CaseListScreen
+
+
+class CaseManagerApp(App):
+    """Terminal UI for browsing / editing / running test cases."""
+
+    TITLE = "CLI Test Framework - Case Manager"
+
+    BINDINGS = [
+        Binding("ctrl+q", "quit", "Quit", show=True, priority=True),
+        Binding("q", "quit", "Quit", show=True, priority=True),
+    ]
+
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+    """
+
+    def __init__(self, config_file: str, workspace: Optional[str] = None,
+                 update_baseline: bool = False,
+                 history_dir: Optional[str] = None,
+                 update_history: bool = False):
+        super().__init__()
+        self._config_file = config_file
+        self._workspace = workspace
+        self._controller = CaseController()
+        self._controller.update_baseline = update_baseline
+        self._controller.history_dir = history_dir
+        self._controller.update_history = update_history
+
+    def on_mount(self) -> None:
+        try:
+            count = self._controller.load(self._config_file, self._workspace)
+            self.notify(f"Loaded {count} test cases from {Path(self._config_file).name}")
+        except Exception as e:
+            self.notify(f"Failed to load config: {e}", severity="error")
+
+        self.push_screen(CaseListScreen(self._controller))
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+
+def run_tui(config_file: str, workspace: Optional[str] = None,
+            update_baseline: bool = False,
+            history_dir: Optional[str] = None,
+            update_history: bool = False) -> None:
+    """Launch the TUI manager.
+
+    Safe to call without installing textual — raises :exc:`ImportError`
+    with a friendly message if textual is not available.
+    """
+    try:
+        import textual  # noqa: F401 — verify textual is importable
+    except ImportError:
+        import sys
+
+        print(
+            "TUI 功能需要安装 textual。请运行：\n"
+            "  pip install symtest[tui]\n"
+            "或：\n"
+            "  pip install textual"
+        )
+        sys.exit(1)
+
+    app = CaseManagerApp(config_file, workspace,
+                         update_baseline=update_baseline,
+                         history_dir=history_dir,
+                         update_history=update_history)
+    app.run()