| |
| """Build and verify the canonical zero-copy Full-2554 benchmark view.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import os |
| import shutil |
| from collections import Counter, defaultdict |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| VIEW_ROOT = Path(__file__).resolve().parent |
| REPO_ROOT = VIEW_ROOT.parents[1] |
| REGISTRY_ROOT = ( |
| REPO_ROOT |
| / "output/evaluation/core8_full2554_registry_v1_20260717_213712" |
| ) |
| SOURCE_MANIFEST = REGISTRY_ROOT / "full2554.jsonl" |
|
|
| FAMILY_DIRS = { |
| "l2_passive": "passive_observation", |
| "l2_dynamic": "dynamic_tracking", |
| "l2_interaction": "interaction_experience", |
| "l3_owner_habit": "experience_generalization", |
| } |
| EXPECTED_COUNTS = { |
| "l2_passive": 1036, |
| "l2_dynamic": 1052, |
| "l2_interaction": 263, |
| "l3_owner_habit": 203, |
| } |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def read_jsonl(path: Path) -> list[dict[str, Any]]: |
| rows = [] |
| with path.open("r", encoding="utf-8") as handle: |
| for line_number, line in enumerate(handle, 1): |
| if line.strip(): |
| row = json.loads(line) |
| if not isinstance(row, dict): |
| raise ValueError(f"Non-object row at {path}:{line_number}") |
| rows.append(row) |
| return rows |
|
|
|
|
| def atomic_text(path: Path, content: str) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| temporary = path.with_suffix(path.suffix + ".tmp") |
| temporary.write_text(content, encoding="utf-8") |
| temporary.replace(path) |
|
|
|
|
| def write_json(path: Path, payload: Any) -> None: |
| atomic_text(path, json.dumps(payload, ensure_ascii=False, indent=2) + "\n") |
|
|
|
|
| def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: |
| atomic_text( |
| path, |
| "".join(json.dumps(row, ensure_ascii=False) + "\n" for row in rows), |
| ) |
|
|
|
|
| def source_for(row: dict[str, Any]) -> tuple[str, str, Path]: |
| source = row.get("source") or {} |
| family = str(source.get("task_family") or "") |
| episode_id = str(source.get("episode_id") or "") |
| relative_path = str(source.get("episode_path") or "") |
| if family not in FAMILY_DIRS: |
| raise ValueError(f"Unknown task family: {family!r}") |
| if not episode_id or not relative_path: |
| raise ValueError(f"Incomplete source metadata for row {row.get('id')}") |
| episode_json = REPO_ROOT / relative_path |
| return family, episode_id, episode_json |
|
|
|
|
| def validate_source(rows: list[dict[str, Any]], *, check_hashes: bool) -> None: |
| if len(rows) != sum(EXPECTED_COUNTS.values()): |
| raise ValueError(f"Expected 2,554 rows, found {len(rows):,}") |
| counts = Counter() |
| ids: set[str] = set() |
| episode_ids: set[str] = set() |
| for row in rows: |
| row_id = str(row.get("id") or "") |
| family, episode_id, episode_json = source_for(row) |
| if not row_id or row_id in ids: |
| raise ValueError(f"Duplicate or empty manifest ID: {row_id!r}") |
| if episode_id in episode_ids: |
| raise ValueError(f"Duplicate episode ID: {episode_id}") |
| if not episode_json.is_file(): |
| raise FileNotFoundError(episode_json) |
| expected_hash = str((row.get("source") or {}).get("episode_sha256") or "") |
| if check_hashes and (not expected_hash or sha256(episode_json) != expected_hash): |
| raise ValueError(f"Episode hash mismatch: {episode_json}") |
| ids.add(row_id) |
| episode_ids.add(episode_id) |
| counts[family] += 1 |
| if dict(counts) != EXPECTED_COUNTS: |
| raise ValueError(f"Family counts differ: {dict(counts)}") |
|
|
|
|
| def ensure_link(link: Path, source_dir: Path) -> None: |
| expected_target = os.path.relpath(source_dir, link.parent) |
| if link.is_symlink(): |
| if os.readlink(link) != expected_target: |
| raise ValueError(f"Existing link has the wrong target: {link}") |
| return |
| if link.exists(): |
| raise FileExistsError(f"Refusing to replace existing path: {link}") |
| link.symlink_to(expected_target, target_is_directory=True) |
|
|
|
|
| def build_view(rows: list[dict[str, Any]]) -> None: |
| family_rows: dict[str, list[dict[str, Any]]] = defaultdict(list) |
| browse_lines = ["family\tepisode_id\tepisode_json\n"] |
| for row in rows: |
| family, episode_id, episode_json = source_for(row) |
| family_dir = FAMILY_DIRS[family] |
| link = VIEW_ROOT / "episodes" / family_dir / episode_id |
| link.parent.mkdir(parents=True, exist_ok=True) |
| ensure_link(link, episode_json.parent) |
|
|
| local_json = Path("episodes") / family_dir / episode_id / episode_json.name |
| organized_row = dict(row) |
| organized_row["organized_view"] = { |
| "family_directory": family_dir, |
| "episode_directory": str(Path("episodes") / family_dir / episode_id), |
| "episode_json": str(local_json), |
| } |
| family_rows[family].append(organized_row) |
| browse_lines.append(f"{family_dir}\t{episode_id}\t{local_json}\n") |
|
|
| manifests_dir = VIEW_ROOT / "manifests" |
| manifests_dir.mkdir(parents=True, exist_ok=True) |
| shutil.copy2(SOURCE_MANIFEST, manifests_dir / "full2554.jsonl") |
| shutil.copy2(REGISTRY_ROOT / "audit_report.json", manifests_dir / "audit_report.json") |
| shutil.copy2(REGISTRY_ROOT / "core8_registry.json", manifests_dir / "core8_registry.json") |
| for family, rows_for_family in family_rows.items(): |
| write_jsonl(manifests_dir / f"{FAMILY_DIRS[family]}.jsonl", rows_for_family) |
| atomic_text(VIEW_ROOT / "browse.tsv", "".join(browse_lines)) |
| write_json( |
| VIEW_ROOT / "metadata.json", |
| { |
| "schema": "embodied_memorizer_benchmark_full2554_organized_view_v1", |
| "organization": "relative_symlink_view", |
| "canonical_manifest": "manifests/full2554.jsonl", |
| "canonical_manifest_sha256": sha256(SOURCE_MANIFEST), |
| "episode_count": len(rows), |
| "family_counts": { |
| FAMILY_DIRS[family]: count |
| for family, count in EXPECTED_COUNTS.items() |
| }, |
| "source_data_modified": False, |
| }, |
| ) |
|
|
|
|
| def verify_view(rows: list[dict[str, Any]]) -> dict[str, Any]: |
| counts = Counter() |
| failures = [] |
| for row in rows: |
| family, episode_id, episode_json = source_for(row) |
| link = VIEW_ROOT / "episodes" / FAMILY_DIRS[family] / episode_id |
| local_json = link / episode_json.name |
| if not link.is_symlink(): |
| failures.append(f"not a symlink: {link}") |
| continue |
| if link.resolve() != episode_json.parent.resolve(): |
| failures.append(f"wrong link target: {link}") |
| continue |
| if not local_json.is_file(): |
| failures.append(f"missing local JSON: {local_json}") |
| continue |
| expected_hash = str((row.get("source") or {}).get("episode_sha256") or "") |
| if sha256(local_json) != expected_hash: |
| failures.append(f"hash mismatch: {local_json}") |
| continue |
| counts[family] += 1 |
| report = { |
| "schema": "embodied_memorizer_benchmark_full2554_view_verification_v1", |
| "status": "pass" if not failures and dict(counts) == EXPECTED_COUNTS else "fail", |
| "expected_episodes": sum(EXPECTED_COUNTS.values()), |
| "verified_episodes": sum(counts.values()), |
| "family_counts": { |
| FAMILY_DIRS[family]: counts[family] for family in FAMILY_DIRS |
| }, |
| "source_manifest_sha256": sha256(SOURCE_MANIFEST), |
| "issues": failures, |
| } |
| write_json(VIEW_ROOT / "verification_report.json", report) |
| if report["status"] != "pass": |
| raise RuntimeError(json.dumps(report, indent=2)) |
| return report |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--verify-only", |
| action="store_true", |
| help="Verify the existing organized view without creating links.", |
| ) |
| args = parser.parse_args() |
| rows = read_jsonl(SOURCE_MANIFEST) |
| validate_source(rows, check_hashes=not args.verify_only) |
| if not args.verify_only: |
| build_view(rows) |
| print(json.dumps(verify_view(rows), indent=2)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
