| |
| """Build indexes and verify the physical Full-2554 benchmark package.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import os |
| import re |
| from collections import Counter, defaultdict |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| VIEW_ROOT = Path(__file__).resolve().parent |
| |
| SOURCE_MANIFEST = VIEW_ROOT / "manifests/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, |
| } |
| HAN_RE = re.compile( |
| "[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\U00020000-\U000323af]" |
| ) |
|
|
|
|
| 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 = ( |
| VIEW_ROOT / "episodes" / FAMILY_DIRS[family] / episode_id |
| / Path(relative_path).name |
| ) |
| 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) |
| if episode_json.parent.is_symlink(): |
| raise ValueError(f"Episode directory must be physical: {episode_json.parent}") |
| 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 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] |
| 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) |
| 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)) |
| metadata_path = VIEW_ROOT / "metadata.json" |
| existing_metadata = ( |
| json.loads(metadata_path.read_text(encoding="utf-8")) |
| if metadata_path.is_file() else {} |
| ) |
| write_json( |
| metadata_path, |
| { |
| **existing_metadata, |
| "schema": "embodied_memorizer_benchmark_full2554_organized_view_v1", |
| "organization": "physical_episode_directories", |
| "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": existing_metadata.get("source_data_modified", False), |
| }, |
| ) |
|
|
|
|
| def verify_view(rows: list[dict[str, Any]]) -> dict[str, Any]: |
| counts = Counter() |
| failures = [] |
| chinese_text_issues = [] |
| symlinks = [] |
| for directory, subdirectories, filenames in os.walk(VIEW_ROOT, followlinks=False): |
| for name in subdirectories + filenames: |
| path = Path(directory) / name |
| if path.is_symlink(): |
| symlinks.append(str(path.relative_to(VIEW_ROOT))) |
| failures.extend(f"unexpected symlink: {path}" for path in symlinks) |
| for row in rows: |
| family, episode_id, episode_json = source_for(row) |
| episode_dir = VIEW_ROOT / "episodes" / FAMILY_DIRS[family] / episode_id |
| local_json = episode_dir / episode_json.name |
| if episode_dir.is_symlink() or not episode_dir.is_dir(): |
| failures.append(f"not a physical episode directory: {episode_dir}") |
| 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 |
| |
| |
| payload = json.loads(local_json.read_text(encoding="utf-8")) |
| if HAN_RE.search(json.dumps(payload, ensure_ascii=False)): |
| chinese_text_issues.append(str(local_json.relative_to(VIEW_ROOT))) |
| failures.append(f"Chinese JSON text: {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), |
| "storage": "physical_episode_directories", |
| "symlink_count": len(symlinks), |
| "language": "en", |
| "chinese_text_issues": len(chinese_text_issues), |
| "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 physical package without rebuilding indexes.", |
| ) |
| 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()) |
|
|
