| |
| """Run ELYSIÆN verification in a clean directory without altering bundled records. |
| |
| This orchestrator measures verification duration only. Its elapsed seconds are |
| not rendering benchmarks or evidence of optical latency/energy advantage. |
| No package or Python runtime is installed automatically. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| from datetime import datetime, timezone |
| import hashlib |
| from importlib import metadata |
| import json |
| import os |
| from pathlib import Path |
| import platform |
| import shutil |
| import subprocess |
| import sys |
| import time |
|
|
| ROOT = Path(__file__).resolve().parent |
| SUITES = ( |
| "v4_engine.py", "v4_compiled_capsule.py", "v4_passive_verify.py", |
| "v4_error_verify.py", "v4_capsule_certificate_verify.py", |
| "v4_history_verify.py", "v5_physical_verify.py", |
| "v5_compression_verify.py", "v5_dynamic_verify.py", |
| ) |
|
|
|
|
| def digest(path: Path) -> str: |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def quick_arguments(script: str) -> list[str]: |
| if script in {"v4_engine.py", "v4_compiled_capsule.py"}: |
| return ["--quick"] |
| if script == "v4_history_verify.py": |
| return ["--sequences", "6", "--steps", "20"] |
| if script.startswith("v5_"): |
| |
| return ["--quick"] |
| |
| return [] |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--quick", action="store_true", |
| help="Use smaller supported cases; this is not the full recorded run") |
| parser.add_argument("--output-dir", type=Path, |
| help="Empty destination for copied scripts, logs and generated results") |
| parser.add_argument("--suites", nargs="+", choices=SUITES, |
| help="Run selected standalone scripts; default runs all nine") |
| parser.add_argument("--list", action="store_true", help="List suites and exit") |
| parser.add_argument("--timeout", type=float, default=180.0, |
| help="Per-suite execution timeout in seconds (default: 180)") |
| args = parser.parse_args() |
| if args.list: |
| print("\n".join(SUITES)) |
| return 0 |
| if sys.version_info < (3, 10): |
| parser.error("Python 3.10 or later is required; select an installed compatible runtime") |
| if args.timeout <= 0: |
| parser.error("--timeout must be positive") |
| versions = {} |
| missing = [] |
| for package in ("numpy", "scipy", "matplotlib", "threadpoolctl"): |
| try: |
| versions[package] = metadata.version(package) |
| except metadata.PackageNotFoundError: |
| missing.append(package) |
| if missing: |
| print("Missing dependencies: " + ", ".join(missing), file=sys.stderr) |
| print("Install the supplied requirements explicitly, then run again:", file=sys.stderr) |
| print(f'"{sys.executable}" -m pip install -r "{ROOT / "requirements.txt"}"', file=sys.stderr) |
| return 2 |
| chosen = tuple(args.suites or SUITES) |
| absent = [name for name in chosen if not (ROOT / name).is_file()] |
| if absent: |
| print("Missing bundled scripts: " + ", ".join(absent), file=sys.stderr) |
| return 2 |
| stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ") |
| dest = (args.output_dir or ROOT / "verification_runs" / stamp).resolve() |
| if dest.exists() and (not dest.is_dir() or any(dest.iterdir())): |
| print(f"Refusing to overwrite a nonempty run directory: {dest}", file=sys.stderr) |
| return 2 |
| dest.mkdir(parents=True, exist_ok=True) |
| for name in chosen: |
| shutil.copy2(ROOT / name, dest / name) |
| env = os.environ.copy() |
| for key in ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS"): |
| env[key] = "1" |
| env["MPLBACKEND"] = "Agg" |
| env["PYTHONUTF8"] = "1" |
| report = { |
| "project": "ELYSIAEN standalone reproducibility run", |
| "mode": "quick smoke" if args.quick else "full", |
| "started_at_utc": datetime.now(timezone.utc).isoformat(), |
| "python": platform.python_version(), "python_executable": sys.executable, |
| "platform": platform.platform(), "dependency_versions": versions, |
| "working_directory": str(dest), "scripts_copied_without_project_modules": True, |
| "scope": "CPU verification only; ordinary floating-point assertions. Elapsed time is not a rendering or optical benchmark.", |
| "runs": [], |
| } |
| summary = dest / "verification_summary.json" |
| print(f"Running {'quick' if args.quick else 'full'} verification in {dest}", flush=True) |
| failed = False |
| for name in chosen: |
| command = [sys.executable, name] + (quick_arguments(name) if args.quick else []) |
| before = time.perf_counter() |
| status, code = "passed", 0 |
| try: |
| result = subprocess.run(command, cwd=dest, env=env, capture_output=True, |
| text=True, encoding="utf-8", errors="replace", timeout=args.timeout, check=False) |
| stdout, stderr, code = result.stdout, result.stderr, result.returncode |
| if code: |
| status = "failed" |
| except subprocess.TimeoutExpired as exc: |
| status, code = "timeout", None |
| stdout = exc.stdout or "" |
| stderr = exc.stderr or "" |
| if isinstance(stdout, bytes): stdout = stdout.decode("utf-8", errors="replace") |
| if isinstance(stderr, bytes): stderr = stderr.decode("utf-8", errors="replace") |
| stderr += f"\nPer-suite timeout exceeded: {args.timeout} seconds\n" |
| except OSError as exc: |
| status, code, stdout, stderr = "launch_error", None, "", str(exc) |
| elapsed = time.perf_counter() - before |
| (dest / f"{Path(name).stem}.stdout.log").write_text(stdout, encoding="utf-8") |
| (dest / f"{Path(name).stem}.stderr.log").write_text(stderr, encoding="utf-8") |
| report["runs"].append({"script": name, "script_sha256": digest(dest / name), |
| "arguments": command[2:], "status": status, |
| "exit_code": code, "verification_elapsed_seconds": elapsed}) |
| failed |= status != "passed" |
| report["status"] = "failed" if failed else "running" |
| summary.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8") |
| print(f"{name}: {status.upper()}", flush=True) |
| report["status"] = "failed" if failed else "all selected suites passed" |
| report["finished_at_utc"] = datetime.now(timezone.utc).isoformat() |
| report["generated_files"] = [ |
| {"path": p.name, "size_bytes": p.stat().st_size, "sha256": digest(p)} |
| for p in sorted(dest.iterdir()) if p.is_file() and p != summary |
| ] |
| summary.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8") |
| print(f"Summary: {summary}", flush=True) |
| return 1 if failed else 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
