smoke-optimiser 0.1.0__py3-none-any.whl

smoke_optimiser/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

smoke_optimiser/__main__.py

@@ -0,0 +1,9 @@
+from smoke_optimiser.cli import app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

smoke_optimiser/cli.py

@@ -0,0 +1,249 @@
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from pydantic import ValidationError
+
+from smoke_optimiser.config import OperationMode, load_file_config, resolve_config
+from smoke_optimiser.optimiser.filters import apply_filters
+from smoke_optimiser.optimiser.greedy import optimise
+from smoke_optimiser.profiler.models import (
+    MachineModel,
+    ProfilingDataFile,
+    ProfilingMetaModel,
+    ProfilingOutcomeModel,
+)
+from smoke_optimiser.profiler.runner import run_profiling
+from smoke_optimiser.reports.smoke_suite import write_smoke_suite
+from smoke_optimiser.reports.summary import format_summary
+
+app = typer.Typer(pretty_exceptions_show_locals=False)
+
+
+def _split_comma_list(items: list[str] | None) -> list[str]:
+    """Split comma-separated strings in a list into individual items."""
+    if items is None:
+        return []
+    result = []
+    for item in items:
+        if "," in item:
+            result.extend([x.strip() for x in item.split(",") if x.strip()])
+        elif item.strip():
+            result.append(item.strip())
+    return result
+
+
+@app.command()
+def main(
+    profile_only: Annotated[
+        bool,
+        typer.Option("--profile-only", help="Run only the profiling phase."),
+    ] = False,
+    optimise_only: Annotated[
+        bool,
+        typer.Option("--optimise-only", help="Run only the optimisation phase."),
+    ] = False,
+    time_cap: Annotated[
+        float | None,
+        typer.Option("--time-cap", help="Maximum wall-clock runtime of the smoke suite."),
+    ] = None,
+    target_cov: Annotated[
+        float | None,
+        typer.Option(
+            "--target-cov",
+            help="Target percentage of the full suite's branch coverage to achieve.",
+        ),
+    ] = None,
+    include: Annotated[
+        list[str] | None,
+        typer.Option("--include", help="Tests or markers that MUST be in the smoke suite."),
+    ] = None,
+    exclude: Annotated[
+        list[str] | None,
+        typer.Option("--exclude", help="Tests or markers that MUST NOT be in the smoke suite."),
+    ] = None,
+    pytest_args: Annotated[
+        str | None,
+        typer.Option("--pytest-args", help="Extra arguments forwarded to pytest."),
+    ] = None,
+    output_json: Annotated[
+        Path | None,
+        typer.Option("--output-json", help="Path for the smoke suite definition file."),
+    ] = None,
+    allow_ordered: Annotated[
+        bool,
+        typer.Option(
+            "--allow-ordered",
+            help="Suppress error when pytest-randomly is not installed.",
+        ),
+    ] = False,
+    src: Annotated[
+        str | None,
+        typer.Option("--src", help="Source directory/package for coverage instrumentation."),
+    ] = None,
+    iterations: Annotated[
+        int | None,
+        typer.Option("--iterations", help="Number of times to run the suite to average timing."),
+    ] = None,
+) -> None:
+    """smoke-optimiser: Identify a minimal, high-value smoke test suite."""
+    if profile_only and optimise_only:
+        typer.secho(
+            "❌ Error: --profile-only and --optimise-only are mutually exclusive.", fg=typer.colors.RED, err=True
+        )
+        raise typer.Exit(code=1)
+
+    # Conflict check: --src and --cov in --pytest-args
+    if src and pytest_args and "--cov" in pytest_args:
+        typer.secho(
+            "❌ Error: Conflict detected. Cannot use --src and --cov in --pytest-args simultaneously.",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    # Normalize comma-separated includes/excludes
+    final_includes = _split_comma_list(include)
+    final_excludes = _split_comma_list(exclude)
+
+    # Collect CLI overrides
+    cli_overrides = {
+        "profile_only": profile_only,
+        "optimise_only": optimise_only,
+        "time_cap": time_cap,
+        "target_cov": target_cov,
+        "include_mandatory": final_includes if include is not None else None,
+        "exclude_mandatory": final_excludes if exclude is not None else None,
+        "pytest_args": pytest_args,
+        "output_json": output_json,
+        "allow_ordered": allow_ordered,
+        "cov_source": src,
+        "iterations": iterations,
+    }
+
+    project_root = Path.cwd()
+    try:
+        file_config = load_file_config(project_root)
+        config = resolve_config(file_config, cli_overrides, project_root)
+    except ValidationError as err:
+        typer.secho("❌ Error: Invalid configuration in pyproject.toml", fg=typer.colors.RED, err=True)
+        for error in err.errors():
+            loc = ".".join(str(loc) for loc in error["loc"])
+            typer.secho(f"  - {loc}: {error['msg']}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from None
+
+    # Inform user about heuristic fallback
+    # If it wasn't in CLI and isn't in pytest_args, and we are profiling
+    has_cov_in_args = pytest_args and "--cov" in pytest_args
+    if config.mode != OperationMode.OPTIMISE_ONLY and src is None and not has_cov_in_args:
+        # Check if it was in pyproject.toml
+        from_file = file_config and file_config.cov_source
+        if not from_file:
+            typer.secho(
+                f"⚠️ Warning: --src was not specified. Falling back to heuristic discovery: --src={config.cov_source}",
+                fg=typer.colors.YELLOW,
+                err=True,
+            )
+
+    profiling_data = None
+    intermediate_file = project_root / ".smoke_profiling_data.json"
+
+    # Phase 1: Profiling
+    if config.mode != OperationMode.OPTIMISE_ONLY:
+        typer.secho("🔍 Running profiling...", fg=typer.colors.CYAN, bold=True)
+        profiling_data = run_profiling(config, project_root)
+
+        if config.mode == OperationMode.PROFILE_ONLY:
+            # Save intermediate data
+            machine = profiling_data.meta.machine
+            machine_model = MachineModel(
+                os=machine.os,
+                os_version=machine.os_version,
+                platform=machine.platform,
+                architecture=machine.architecture,
+                cpu_model=machine.cpu_model,
+                cpu_cores_physical=machine.cpu_cores_physical,
+                cpu_cores_logical=machine.cpu_cores_logical,
+                ram_total_mb=machine.ram_total_mb,
+                ram_available_mb=machine.ram_available_mb,
+                hostname=machine.hostname,
+            )
+            meta_model = ProfilingMetaModel(
+                timestamp=profiling_data.meta.timestamp,
+                commit=profiling_data.meta.commit,
+                python_version=profiling_data.meta.python_version,
+                coverage_version=profiling_data.meta.coverage_version,
+                command=profiling_data.meta.command,
+                machine=machine_model,
+            )
+            test_models = {
+                tid: ProfilingOutcomeModel(
+                    test_id=po.test_id,
+                    duration_s=po.duration_s,
+                    passed=po.passed,
+                    branches_covered=list(po.branches_covered),
+                    markers=list(po.markers),
+                )
+                for tid, po in profiling_data.tests.items()
+            }
+            file_data = ProfilingDataFile(
+                meta=meta_model,
+                tests=test_models,
+                total_branches=list(profiling_data.total_branches),
+            )
+            intermediate_file.unlink(missing_ok=True)
+            with open(intermediate_file, "w") as f:
+                json.dump(file_data.model_dump(mode="json"), f)
+            typer.secho(f"💾 Profiling data saved to {intermediate_file}", fg=typer.colors.GREEN)
+
+    # Phase 2: Optimisation
+    if config.mode != OperationMode.PROFILE_ONLY:
+        if profiling_data is None:
+            # Try to load from intermediate file if it exists
+            if not intermediate_file.exists():
+                typer.secho(
+                    "❌ Error: No profiling data found. Run without --optimise-only first.",
+                    fg=typer.colors.RED,
+                    err=True,
+                )
+                raise typer.Exit(code=1)
+
+            try:
+                with open(intermediate_file, "rb") as f:
+                    raw = json.load(f)
+                    profiling_data = ProfilingDataFile(**raw).to_profiling_data()
+            except (OSError, json.JSONDecodeError) as e:
+                typer.secho(
+                    f"❌ Error: Failed to parse profiling data ({intermediate_file}): {e}",
+                    fg=typer.colors.RED,
+                    err=True,
+                )
+                raise typer.Exit(code=1) from None
+
+        typer.secho("⚡ Optimising smoke suite...", fg=typer.colors.CYAN, bold=True)
+        filtered = apply_filters(profiling_data.tests, config.include_mandatory, config.exclude_mandatory)
+
+        # Warn about unmatched includes/excludes
+        for pattern in filtered.unmatched_includes:
+            typer.secho(
+                f"⚠️ Warning: Include pattern '{pattern}' matched no tests.",
+                fg=typer.colors.YELLOW,
+                err=True,
+            )
+        for pattern in filtered.unmatched_excludes:
+            typer.secho(
+                f"⚠️ Warning: Exclude pattern '{pattern}' matched no tests.",
+                fg=typer.colors.YELLOW,
+                err=True,
+            )
+
+        result = optimise(filtered, profiling_data.total_branches, config.time_cap, config.target_cov)
+
+        # Output results
+        write_smoke_suite(result, config, profiling_data.meta, config.output_json)
+        typer.echo(format_summary(result, config, profiling_data.meta))
+
+
+if __name__ == "__main__":
+    app()

smoke_optimiser/config.py

@@ -0,0 +1,152 @@
+import tomllib
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import typer
+from pydantic import BaseModel, Field, ValidationError
+
+
+class OperationMode(Enum):
+    """Execution modes for smoke-optimiser."""
+
+    FULL = "full"
+    PROFILE_ONLY = "profile-only"
+    OPTIMISE_ONLY = "optimise-only"
+
+
+class FileConfig(BaseModel):
+    """Configuration model for [tool.smoke_optimiser] in pyproject.toml."""
+
+    time_cap: float = Field(default=15.0, ge=0.0)
+    target_cov: float = Field(default=100.0, ge=0.0, le=100.0)
+    include_mandatory: list[str] = Field(default_factory=list)
+    exclude_mandatory: list[str] = Field(default_factory=list)
+    pytest_args: str = Field(default="")
+    output_json: Path = Field(default=Path("./.smoke_suite.json"))
+    allow_ordered: bool = Field(default=False)
+    smoke_file_path: Path = Field(default=Path("./.smoke_suite.json"))
+    cov_source: str | None = Field(default=None)
+    iterations: int = Field(default=1, ge=1)
+
+
+@dataclass(frozen=True)
+class ResolvedConfig:
+    """Fully resolved configuration after merging defaults, file, and CLI."""
+
+    mode: OperationMode
+    time_cap: float
+    target_cov: float
+    include_mandatory: list[str]
+    exclude_mandatory: list[str]
+    pytest_args: str
+    output_json: Path
+    allow_ordered: bool
+    cov_source: str
+    iterations: int
+
+
+def _discover_cov_target(project_root: Path) -> str:
+    """Best-effort discovery of the source directory for coverage."""
+    # 1. src/ layout is a very strong signal
+    if (project_root / "src").is_dir():
+        return "src"
+
+    # 2. Package matching project name in pyproject.toml
+    pyproject_path = project_root / "pyproject.toml"
+    if pyproject_path.exists():
+        try:
+            with open(pyproject_path, "rb") as f:
+                data = tomllib.load(f)
+                name = data.get("project", {}).get("name")
+                if name:
+                    normalized = name.replace("-", "_")
+                    # If there's a folder matching the project name, instrument it
+                    if (project_root / normalized).is_dir():
+                        return normalized
+        except (tomllib.TOMLDecodeError, OSError) as e:
+            typer.secho(
+                f"⚠️ Warning: Failed to parse project name from pyproject.toml: {e}",
+                fg=typer.colors.YELLOW,
+                err=True,
+            )
+
+    return "."
+
+
+def load_file_config(project_root: Path) -> FileConfig | None:
+    """Load configuration from pyproject.toml in project root."""
+    pyproject_path = project_root / "pyproject.toml"
+    if not pyproject_path.exists():
+        return None
+
+    try:
+        with open(pyproject_path, "rb") as f:
+            data = tomllib.load(f)
+    except (OSError, tomllib.TOMLDecodeError):
+        return None
+
+    tool_config = data.get("tool", {}).get("smoke_optimiser")
+    if tool_config is None:
+        return None
+
+    try:
+        return FileConfig(**tool_config)
+    except ValidationError as e:
+        typer.secho(
+            "❌ Error: Invalid configuration in pyproject.toml [tool.smoke_optimiser]:",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        for err in e.errors():
+            loc = ".".join(str(loc_part) for loc_part in err["loc"])
+            typer.secho(f"  - {loc}: {err['msg']}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from None
+
+
+def resolve_config(
+    file_config: FileConfig | None,
+    cli_overrides: dict[str, Any],
+    project_root: Path,
+) -> ResolvedConfig:
+    """Merge default config, file config, and CLI overrides into a final ResolvedConfig."""
+    # Start with defaults from FileConfig
+    base_config = file_config if file_config else FileConfig()
+
+    # Apply CLI overrides
+    config_dict = base_config.model_dump()
+
+    # Determine mode from CLI overrides first
+    profile_only = cli_overrides.get("profile_only", False)
+    optimise_only = cli_overrides.get("optimise_only", False)
+
+    if profile_only:
+        mode = OperationMode.PROFILE_ONLY
+    elif optimise_only:
+        mode = OperationMode.OPTIMISE_ONLY
+    else:
+        mode = OperationMode.FULL
+
+    # Only override if CLI value is not None
+    for key, value in cli_overrides.items():
+        if key in config_dict and value is not None:
+            config_dict[key] = value
+
+    # If cov_source is still None (not in file and not in CLI), discover it
+    cov_source = config_dict["cov_source"]
+    if cov_source is None:
+        cov_source = _discover_cov_target(project_root)
+
+    return ResolvedConfig(
+        mode=mode,
+        time_cap=config_dict["time_cap"],
+        target_cov=config_dict["target_cov"],
+        include_mandatory=config_dict["include_mandatory"],
+        exclude_mandatory=config_dict["exclude_mandatory"],
+        pytest_args=config_dict["pytest_args"],
+        output_json=Path(config_dict["output_json"]),
+        allow_ordered=config_dict["allow_ordered"],
+        cov_source=cov_source,
+        iterations=config_dict["iterations"],
+    )

smoke_optimiser/environment.py

@@ -0,0 +1,86 @@
+import os
+import platform
+import shutil
+import socket
+import subprocess
+from dataclasses import dataclass
+
+try:
+    import psutil
+except ImportError:
+    psutil = None  # ty: ignore[invalid-assignment] - psutil is an optional dependency
+
+
+@dataclass(frozen=True)
+class MachineEnvironment:
+    """Captured details about the machine environment."""
+
+    os: str | None
+    os_version: str | None
+    platform: str | None
+    architecture: str | None
+    cpu_model: str | None
+    cpu_cores_physical: int | None
+    cpu_cores_logical: int | None
+    ram_total_mb: int | None
+    ram_available_mb: int | None
+    hostname: str | None
+
+
+def _get_cpu_model() -> str | None:
+    """Best-effort CPU model name retrieval."""
+    if platform.system() == "Darwin":
+        # On macOS, we can use sysctl
+        sysctl_path = shutil.which("sysctl")
+        if sysctl_path:
+            try:
+                return subprocess.run(  # noqa: S603
+                    [sysctl_path, "-n", "machdep.cpu.brand_string"], capture_output=True, text=True, check=False
+                ).stdout.strip()
+            except (OSError, ValueError):
+                return None
+        return None
+    elif platform.system() == "Linux":
+        # On Linux, parse /proc/cpuinfo
+        try:
+            with open("/proc/cpuinfo") as f:
+                for line in f:
+                    if line.startswith("model name"):
+                        return line.split(":")[1].strip()
+        except (OSError, IndexError):
+            pass
+    elif platform.system() == "Windows":
+        # On Windows, use platform
+        return platform.processor()
+
+    return None
+
+
+def capture_environment() -> MachineEnvironment:
+    """Capture machine environment information."""
+    cpu_cores_logical = os.cpu_count()
+    cpu_cores_physical = None
+    ram_total_mb = None
+    ram_available_mb = None
+
+    if psutil:
+        try:
+            cpu_cores_physical = psutil.cpu_count(logical=False)
+            virtual_mem = psutil.virtual_memory()
+            ram_total_mb = virtual_mem.total // (1024 * 1024)
+            ram_available_mb = virtual_mem.available // (1024 * 1024)
+        except (OSError, AttributeError):
+            pass
+
+    return MachineEnvironment(
+        os=platform.system(),
+        os_version=platform.release(),
+        platform=platform.platform(),
+        architecture=platform.machine(),
+        cpu_model=_get_cpu_model(),
+        cpu_cores_physical=cpu_cores_physical,
+        cpu_cores_logical=cpu_cores_logical,
+        ram_total_mb=ram_total_mb,
+        ram_available_mb=ram_available_mb,
+        hostname=socket.gethostname(),
+    )

smoke_optimiser/optimiser/filters.py

@@ -0,0 +1,111 @@
+import fnmatch
+from dataclasses import dataclass
+
+from smoke_optimiser.profiler.models import ProfilingOutcome
+
+
+@dataclass(frozen=True)
+class FilteredTests:
+    """Grouped tests after applying filters."""
+
+    candidates: dict[str, ProfilingOutcome]
+    mandatory_included: dict[str, ProfilingOutcome]
+    excluded: dict[str, ProfilingOutcome]
+    failed: dict[str, ProfilingOutcome]
+    unmatched_includes: list[str]
+    unmatched_excludes: list[str]
+
+
+def _matches_pattern(test_id: str, markers: frozenset[str], pattern: str) -> bool:
+    """Check if a test matches a glob pattern or marker pattern.
+
+    Supports:
+    - @pytest.mark.name
+    - Exact test ID (nodeid)
+    - File or directory prefix (e.g. 'tests/test_file.py' matches 'tests/test_file.py::test_it')
+    - Test name match (e.g. 'test_it' matches 'tests/test_file.py::test_it')
+    - Glob patterns (e.g. 'tests/unit/*')
+    """
+    if not pattern:
+        return False
+
+    # 1. Marker match
+    if pattern.startswith("@pytest.mark."):
+        marker_name = pattern[len("@pytest.mark.") :]
+        return marker_name in markers
+
+    # 2. Exact match
+    if test_id == pattern:
+        return True
+
+    # 3. File/Directory prefix match
+    if test_id.startswith(f"{pattern}::"):
+        return True
+
+    # 4. Test name match (suffix after ::)
+    if f"::{pattern}" in test_id:
+        return True
+
+    # 5. Glob match
+    return fnmatch.fnmatch(test_id, pattern)
+
+
+def apply_filters(
+    tests: dict[str, ProfilingOutcome],
+    include_mandatory: list[str],
+    exclude_mandatory: list[str],
+) -> FilteredTests:
+    """Split tests into candidates, mandatory included, excluded, and failed.
+
+    1. Failed tests are always hard-excluded.
+    2. Exclude mandatory patterns take precedence.
+    3. Include mandatory patterns force inclusion.
+    """
+    candidates = {}
+    mandatory_included = {}
+    excluded = {}
+    failed = {}
+
+    matched_includes = set()
+    matched_excludes = set()
+
+    for test_id, outcome in tests.items():
+        if not outcome.passed:
+            failed[test_id] = outcome
+            continue
+
+        # Check exclude first (precedence)
+        is_excluded = False
+        for pattern in exclude_mandatory:
+            if _matches_pattern(test_id, outcome.markers, pattern):
+                excluded[test_id] = outcome
+                is_excluded = True
+                matched_excludes.add(pattern)
+                break
+
+        if is_excluded:
+            continue
+
+        # Check include
+        is_mandatory = False
+        for pattern in include_mandatory:
+            if _matches_pattern(test_id, outcome.markers, pattern):
+                mandatory_included[test_id] = outcome
+                is_mandatory = True
+                matched_includes.add(pattern)
+                break
+
+        if not is_mandatory:
+            candidates[test_id] = outcome
+
+    unmatched_includes = [p for p in include_mandatory if p and p not in matched_includes]
+    unmatched_excludes = [p for p in exclude_mandatory if p and p not in matched_excludes]
+
+    return FilteredTests(
+        candidates=candidates,
+        mandatory_included=mandatory_included,
+        excluded=excluded,
+        failed=failed,
+        unmatched_includes=unmatched_includes,
+        unmatched_excludes=unmatched_excludes,
+    )