Datasets:

lzLiang
/

EmbodiedMemoryBench

+#!/usr/bin/env python3
+"""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())

episodes/interaction_experience/ep_l2_failure_retrieval_FloorPlan11_FloorPlan211/ep_l2_failure_retrieval_FloorPlan11_FloorPlan211.json ADDED Viewed