File size: 3,925 Bytes
eeaa10a | 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 | """Content manifest of the benchmark cases, so a copy of the benchmark can be checked byte for byte.
python scripts/case_manifest.py --write # (re)write cases/official_manifest.json
python scripts/case_manifest.py --check # fail if any hash differs from the stored manifest
Per case: sha256 of case.yaml, the rubric hash the judge records (Case.rubric_sha256), the calculator file, the actor
workspace (built by Case.write_actor_workspace, i.e. after sanitization, exactly what the actor gets) and the env-side
files (env context files, env_knowledge, env data dirs and the figures dir, under the names the env workspace uses).
A tree hash is sha256 over "<relative path>\\0<sha256 of the file>\\n" lines in sorted path order.
"""
import argparse
import hashlib
import json
import sys
import tempfile
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT)) # run from a checkout without installing
from twinlab.case import Case # noqa: E402
MANIFEST = ROOT / "cases/official_manifest.json"
def case_ids() -> list:
ids = sorted(p.parent.name for p in (ROOT / "cases").glob("*/case.yaml"))
assert ids, ROOT / "cases"
return ids
def file_sha(p: Path) -> str:
return hashlib.sha256(p.read_bytes()).hexdigest()
def tree_sha(entries: dict) -> str:
"""entries: {relative name: file path}"""
h = hashlib.sha256()
for name in sorted(entries):
h.update(f"{name}\0{file_sha(entries[name])}\n".encode())
return h.hexdigest()
def files_under(d: Path, prefix: str) -> dict:
assert d.is_dir(), d
return {f"{prefix}/{f.relative_to(d).as_posix()}": f for f in sorted(d.rglob("*")) if not f.is_dir()}
def case_entry(case_id: str) -> dict:
c = Case(ROOT / "cases" / case_id / "case.yaml", "case")
assert c.id == case_id, (c.id, case_id)
calc = c.d["harness"]["env_calculator"]
with tempfile.TemporaryDirectory() as td:
ws = Path(td) / "ws"
c.write_actor_workspace(ws)
actor = files_under(ws, "ws")
actor_sha = tree_sha(actor)
env = {}
for f in c.env_context_files():
assert f.is_file() and f.name not in env, f
env[f.name] = f
for f in c.env_knowledge_files():
env[f"env_knowledge/{f.name}"] = f
for src, dst in c.d["harness"]["env_data_dirs"].items():
env.update(files_under(c.assets_dir / src, dst))
env.update(files_under(c.figures_dir, "figures"))
return {
"case_yaml_sha256": file_sha(c.path),
"rubric_sha256": c.rubric_sha256,
"calculator": calc,
"calculator_sha256": file_sha(c.assets_dir / calc) if calc else None,
"actor_workspace_sha256": actor_sha,
"actor_workspace_files": len(actor),
"env_files_sha256": tree_sha(env),
"env_files": len(env),
}
def main():
ap = argparse.ArgumentParser()
g = ap.add_mutually_exclusive_group(required=True)
g.add_argument("--write", action="store_true")
g.add_argument("--check", action="store_true")
a = ap.parse_args()
cur = {i: case_entry(i) for i in case_ids()}
if a.write:
MANIFEST.write_text(json.dumps({"n_cases": len(cur), "cases": cur}, indent=1) + "\n")
print(f"wrote {MANIFEST} ({len(cur)} cases)")
return
stored = json.loads(MANIFEST.read_text())["cases"]
assert set(stored) == set(cur), {"only in manifest": sorted(set(stored) - set(cur)),
"only on disk": sorted(set(cur) - set(stored))}
diff = {i: {k: (stored[i][k], v) for k, v in e.items() if stored[i][k] != v} for i, e in cur.items()}
diff = {i: d for i, d in diff.items() if d}
for i, d in diff.items():
print(f"CHANGED {i}: {json.dumps(d)}")
assert not diff, f"{len(diff)} case(s) differ from {MANIFEST.name}"
print(f"manifest check: {len(cur)} cases match {MANIFEST.name}")
if __name__ == "__main__":
main()
|