| """Measure SVG frames and run trusted benchmark verifiers without OS sandboxing.""" |
|
|
| from __future__ import annotations |
|
|
| import ast |
| import hashlib |
| import json |
| import os |
| import re |
| import shutil |
| import subprocess |
| import sys |
| import tempfile |
| import time |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| _BASE64_BLOB = re.compile(r"(;base64,)([A-Za-z0-9+/=]{64,})") |
|
|
|
|
| def strip_base64(svg: str) -> str: |
| def replace(match: re.Match[str]) -> str: |
| blob = match.group(2) |
| digest = hashlib.sha1(blob.encode()).hexdigest()[:12] |
| return f";base64,STRIPPED[{len(blob)}B,sha1:{digest}]" |
| return _BASE64_BLOB.sub(replace, svg) |
|
|
|
|
| def run_verifiers(program: str, matrix: dict[str, Any], *, timeout: float = 900) -> dict[str, Any]: |
| module_error = "" |
| try: |
| tree = ast.parse(program) |
| except SyntaxError as error: |
| module_error = str(error) |
| checks = [] |
| else: |
| checks = sorted({ |
| node.name for node in tree.body |
| if isinstance(node, ast.FunctionDef) and node.name.startswith("ver_") |
| }) |
| if not checks: |
| module_error = "no top-level ver_*(matrix) functions found" |
| results = [] |
| with tempfile.TemporaryDirectory(prefix="mgb-verifiers-") as temporary: |
| root = Path(temporary) |
| shutil.copyfile(__file__, root / "verify_animations.py") |
| shutil.copyfile(Path(__file__).with_name("verifier_helper_library.py"), root / "verifier_helper_library.py") |
| (root / "matrix.json").write_text(json.dumps(matrix, allow_nan=False), encoding="utf-8") |
| (root / "verifier.py").write_text(program, encoding="utf-8") |
| deadline = time.monotonic() + timeout |
| for name in checks: |
| result = {"name": name, "passed": False, "detail": "", "measured": {}, "logs": "", "error": ""} |
| remaining = deadline - time.monotonic() |
| if remaining <= 0: |
| result["error"] = "verification deadline expired before this check" |
| else: |
| output = root / f"{name}.json" |
| try: |
| process = subprocess.run( |
| [sys.executable, "-I", "-S", "-B", str(root / "verify_animations.py"), |
| str(root / "matrix.json"), str(root / "verifier.py"), name, str(output)], |
| cwd=root, env={"TMPDIR": str(root), "LANG": "C.UTF-8"}, |
| stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=remaining, |
| ) |
| except subprocess.TimeoutExpired: |
| result["error"] = f"verification timed out after {timeout:g} seconds" |
| else: |
| result["logs"] = process.stdout |
| if process.returncode or not output.is_file(): |
| result["error"] = process.stderr or f"verifier exited {process.returncode} without a result" |
| else: |
| result.update(json.loads(output.read_text(encoding="utf-8"))) |
| results.append(result) |
| return { |
| "passed_checks": [result["name"] for result in results if result["passed"]], |
| "failed_checks": [result["name"] for result in results if not result["passed"]], |
| "verification_decision": not module_error and bool(results) and all(result["passed"] for result in results), |
| "module_error": module_error, |
| "verification_errors": {result["name"]: result["error"] for result in results if result["error"]}, |
| "results": results, |
| } |
|
|
|
|
| def verify_animations( |
| program: str, frames: list[str], *, fps: float, timeout: float = 900, |
| ) -> dict[str, Any]: |
| from frames_to_matrix import measure |
|
|
| matrix = measure([strip_base64(frame) for frame in frames], fps=fps, timeout=timeout) |
| return { |
| "frame_count": len(frames), |
| "measurement": matrix["info"], |
| **run_verifiers(program, matrix, timeout=timeout), |
| } |
|
|
|
|
| def _run_check(matrix_path: str, program_path: str, name: str, output_path: str) -> None: |
| sys.path.insert(0, os.getcwd()) |
| matrix = json.loads(Path(matrix_path).read_text(encoding="utf-8")) |
| namespace: dict[str, Any] = {} |
| exec(compile(Path(program_path).read_text(encoding="utf-8"), "<verifier_module>", "exec"), namespace) |
| result = namespace[name](matrix) |
| if isinstance(result, bool): |
| result = {"passed": result, "detail": "", "measured": {}} |
| if not isinstance(result, dict) or not isinstance(result.get("passed"), bool): |
| raise TypeError(f"{name} must return a bool or a dictionary with a boolean 'passed' field") |
| detail, measured = result.get("detail", ""), result.get("measured", {}) |
| if not isinstance(detail, str) or not isinstance(measured, dict): |
| raise TypeError(f"{name} must return a string detail and a dictionary of measurements") |
| Path(output_path).write_text(json.dumps({ |
| "name": name, "passed": result["passed"], "detail": detail, "measured": measured, |
| }, allow_nan=False), encoding="utf-8") |
|
|
|
|
| if __name__ == "__main__": |
| _run_check(*sys.argv[1:]) |
|
|
