| """Helpers for invoking public commands and locating external test fixtures.""" |
|
|
| from __future__ import annotations |
|
|
| import atexit |
| import json |
| import os |
| import subprocess |
| import sys |
| import tempfile |
| from functools import cache |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| _WORKSPACE = tempfile.TemporaryDirectory(prefix="yolo26n-tests-") |
| atexit.register(_WORKSPACE.cleanup) |
| WORKSPACE = Path(_WORKSPACE.name) |
|
|
|
|
| def run_module(module: str, *arguments: object) -> subprocess.CompletedProcess[str]: |
| """Run a Python command exactly as a user invokes it from the repository.""" |
| return subprocess.run( |
| [sys.executable, "-m", module, *(str(argument) for argument in arguments)], |
| cwd=ROOT, |
| text=True, |
| capture_output=True, |
| check=False, |
| ) |
|
|
|
|
| @cache |
| def checkpoint() -> Path: |
| """Return the checkpoint supplied to the converter functional-test target.""" |
| |
| |
| configured = os.environ.get("YOLO26N_CHECKPOINT") |
| if configured: |
| return Path(configured).resolve() |
| raise RuntimeError("YOLO26N_CHECKPOINT is required for converter functional tests") |
|
|
|
|
| def exported_model(resolution: int = 320) -> Path: |
| """Convert the shared checkpoint through the supported command.""" |
| return _exported_model(resolution) |
|
|
|
|
| @cache |
| def _exported_model(resolution: int) -> Path: |
| output = WORKSPACE / f"export-{resolution}" |
| completed = run_module( |
| "converter.export_yolo26n", |
| "--checkpoint", |
| checkpoint(), |
| "--resolution", |
| resolution, |
| "--output-dir", |
| output, |
| ) |
| if completed.returncode != 0: |
| raise RuntimeError(completed.stderr) |
| return output |
|
|
|
|
| def read_json(path: Path) -> dict[str, object]: |
| """Read a JSON object emitted by a public command.""" |
| value = json.loads(path.read_text(encoding="utf-8")) |
| if not isinstance(value, dict): |
| raise AssertionError(f"expected JSON object: {path}") |
| return value |
|
|
|
|
| @cache |
| def configured_runtime() -> Path: |
| """Return the native library supplied to the end-to-end tests.""" |
| value = os.environ.get("YOLO26N_E2E_RUNTIME") |
| if not value: |
| raise RuntimeError("YOLO26N_E2E_RUNTIME is required for end-to-end tests") |
| runtime = Path(value).resolve() |
| if not runtime.is_file(): |
| raise RuntimeError(f"YOLO26N_E2E_RUNTIME is not a file: {runtime}") |
| return runtime |
|
|
|
|
| def configured_model() -> Path: |
| """Return one converted model for example behavior tests.""" |
| return configured_models()[0] |
|
|
|
|
| @cache |
| def configured_models() -> tuple[Path, ...]: |
| """Return the six converted models required by the end-to-end tests.""" |
| value = os.environ.get("YOLO26N_E2E_MODELS") |
| if not value: |
| raise RuntimeError("YOLO26N_E2E_MODELS is required for end-to-end tests") |
|
|
| models_by_resolution: dict[int, Path] = {} |
| for item in value.split(os.pathsep): |
| model_directory = Path(item).resolve() |
| if not model_directory.is_dir(): |
| raise RuntimeError(f"YOLO26N_E2E_MODELS contains a non-directory: {model_directory}") |
| manifest = read_json(model_directory / "manifest.json") |
| model = manifest.get("model") |
| if not isinstance(model, dict): |
| raise RuntimeError(f"converted model has no model record: {model_directory}") |
| shape = model.get("input_shape") |
| if not isinstance(shape, list) or len(shape) != 4 or type(shape[2]) is not int: |
| raise RuntimeError(f"converted model has no supported input shape: {model_directory}") |
| models_by_resolution[shape[2]] = model_directory |
|
|
| expected = {320, 480, 640, 800, 960, 1280} |
| if set(models_by_resolution) != expected: |
| raise RuntimeError( |
| "YOLO26N_E2E_MODELS must contain exactly one model for each supported " |
| f"resolution; received {sorted(models_by_resolution)}" |
| ) |
| return tuple(models_by_resolution[resolution] for resolution in sorted(models_by_resolution)) |
|
|
