File size: 6,363 Bytes
f340984 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | #!/usr/bin/env python3
from __future__ import annotations
import argparse
import copy
import hashlib
import json
from pathlib import Path
from unlimited_ocr_rdna4.constants import MODEL_REVISION, VERIFIED_HIP_VERSION, VERIFIED_PACKAGE_VERSIONS
def _load_json(path: Path) -> dict:
value = json.loads(path.read_text(encoding="utf-8"))
if not isinstance(value, dict):
raise AssertionError(f"expected a JSON object: {path}")
return value
def _sha256(path: Path) -> str:
return hashlib.sha256(path.read_bytes()).hexdigest()
def _check_output(path: Path) -> None:
text = path.read_text(encoding="utf-8")
ordered = (
"Unlimited OCR RDNA4 Smoke Test",
"Items",
"Document scan",
"Table extraction",
"Total",
"Verification notes",
"RDNA4-OCR-PASS",
)
positions = [text.index(marker) for marker in ordered]
assert positions == sorted(positions), f"reading order mismatch in {path}"
assert "€48.50" in text, f"euro table total missing from {path}"
assert "mc}^2" in text or "mc^2" in text, f"formula missing from {path}"
assert "<table" in text or "| Item" in text, f"structured table missing from {path}"
def _check_run(payload: dict, *, expected_pages: int) -> None:
assert payload["schema_version"] == 1
assert payload["status"] == "ok"
assert payload["model_revision"] == MODEL_REVISION
assert payload["architecture"] == "gfx1201"
assert payload["hardware_verified"] is True
assert payload["software_verified"] is True
assert payload["pages_processed"] == expected_pages
assert payload["pages_total"] == expected_pages
assert 0 < payload["peak_allocated_gib"] < 16
def main() -> None:
parser = argparse.ArgumentParser(description="Validate machine-readable RDNA 4 smoke evidence")
parser.add_argument("--doctor", type=Path, required=True)
parser.add_argument("--image-run", type=Path, action="append", required=True)
parser.add_argument("--pdf-run", type=Path, required=True)
parser.add_argument("--image-output", type=Path, action="append", required=True)
parser.add_argument("--pdf-output", type=Path, required=True)
parser.add_argument("--expected-image-sha256")
parser.add_argument("--expected-pdf-sha256")
parser.add_argument("--network-isolated", action="store_true")
parser.add_argument("--gpu-processes", type=Path)
parser.add_argument("--evidence-output", type=Path)
args = parser.parse_args()
assert len(args.image_run) == 2, "exactly two image-run JSON files are required"
assert len(args.image_output) == 2, "exactly two image outputs are required"
doctor = _load_json(args.doctor)
assert doctor["schema_version"] == 1
assert doctor["status"] == "ok"
assert doctor["runtime_issues"] == []
runtime = doctor["runtime"]
assert runtime["visible_devices"] == 1
assert runtime["accepted_architecture"] is True
assert runtime["hardware_verified"] is True
assert runtime["software_verified"] is True
assert runtime["hip_version"] == VERIFIED_HIP_VERSION
assert runtime["package_versions"] == VERIFIED_PACKAGE_VERSIONS
assert doctor["model"]["prepared"] is True
assert doctor["model"]["revision"] == MODEL_REVISION
image_runs = [_load_json(run_path) for run_path in args.image_run]
pdf_run = _load_json(args.pdf_run)
for image_run in image_runs:
_check_run(image_run, expected_pages=1)
_check_run(pdf_run, expected_pages=1)
for output_path in (*args.image_output, args.pdf_output):
_check_output(output_path)
image_hashes = [_sha256(path) for path in args.image_output]
assert image_hashes[0] == image_hashes[1], "fresh-process image outputs are not byte-identical"
pdf_hash = _sha256(args.pdf_output)
if args.expected_image_sha256:
assert image_hashes[0] == args.expected_image_sha256
if args.expected_pdf_sha256:
assert pdf_hash == args.expected_pdf_sha256
if args.network_isolated:
assert args.network_isolated is True
processes = _load_json_array(args.gpu_processes) if args.gpu_processes else None
if processes is not None:
names = []
for gpu in processes:
for process in gpu.get("process_list", []):
process_info = process.get("process_info")
if isinstance(process_info, dict) and isinstance(process_info.get("name"), str):
names.append(process_info["name"])
assert not any("python" in name.lower() for name in names), f"OCR Python process still owns VRAM: {names}"
summary = {
"schema_version": 1,
"validation": "PASS",
"network_isolated": args.network_isolated,
"image_sha256": image_hashes[0],
"pdf_sha256": pdf_hash,
}
if args.evidence_output:
doctor_evidence = copy.deepcopy(doctor)
doctor_evidence["model"]["model_dir"] = "<prepared-model>"
image_evidence = copy.deepcopy(image_runs)
for index, image_run in enumerate(image_evidence, start=1):
image_run["input"] = "tests/fixtures/rdna4-smoke.png"
image_run["output"] = f"<temporary-output>/smoke-image-{index}.md"
pdf_evidence = copy.deepcopy(pdf_run)
pdf_evidence["input"] = "tests/fixtures/rdna4-smoke.pdf"
pdf_evidence["output"] = "<temporary-output>/smoke-pdf.md"
evidence = {
**summary,
"fixtures": {
"image_sha256": "f5099e17be868abfb4213dbdab220deac82a2db93ba87ab22f03219178246972",
"pdf_sha256": "cdd2b484d0ac90bd98b489dd97565a65eb17246f713359524cddd41d78cc10cb",
},
"doctor": doctor_evidence,
"image_runs": image_evidence,
"pdf_run": pdf_evidence,
"gpu_processes_after": processes,
}
args.evidence_output.parent.mkdir(parents=True, exist_ok=True)
args.evidence_output.write_text(json.dumps(evidence, indent=2, sort_keys=True) + "\n", encoding="utf-8")
print(json.dumps(summary, sort_keys=True))
def _load_json_array(path: Path) -> list[dict]:
value = json.loads(path.read_text(encoding="utf-8"))
if not isinstance(value, list):
raise AssertionError(f"expected a JSON array: {path}")
return value
if __name__ == "__main__":
main()
|