Add round-trip test

test_restore_roundtrip.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+End-to-end test of the publish/restore round trip, at a size you can actually run.
+
+Builds a miniature mirror of the real dataset out of the original archive, pushes
+it to a throwaway *private* Hub repo, restores it with the plain documented
+command, and checks the result against the archive. Then deletes the temp repo.
+
+    python tools/test_restore_roundtrip.py --zip VLadapter.zip --namespace ylsung
+
+Why a temp repo rather than testing against the published dataset: the
+completeness check inside restore_datasets.py only runs when --datasets,
+--limit-shards and --only are all absent, i.e. only for the bare command, and
+running that against the real repo means restoring ~132 GB. A small mirror
+exercises the same code path in a couple of minutes.
+
+Checks, in order:
+  1. bare `restore_datasets.py --out ./datasets` succeeds and its own
+     manifest verification passes
+  2. every restored .h5 is bit-exact vs the archive, read with the same access
+     pattern as VL-T5/src/*_clip_data.py  (f[f"{img_id}/features"][...])
+  3. every restored annotation is byte-identical
+  4. directory shape matches, including the empty dirs the archive carries
+  5. a second run is idempotent (downloads and rewrites nothing)
+  6. deleting files mid-tree and rerunning restores exactly those
+  7. the download cache is left ~empty (shards deleted after expanding)
+
+Exits non-zero on the first failure. Pass --keep-repo to leave the temp repo for
+inspection.
+"""
+import argparse
+import io
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+ROOT = "vlt5_dataset/"
+TOOLS = Path(__file__).resolve().parent
+FAILURES = []
+
+
+def check(label, ok, detail=""):
+    print(f"  {'PASS' if ok else 'FAIL'}  {label}" + (f"  — {detail}" if detail else ""))
+    if not ok:
+        FAILURES.append(label)
+    return ok
+
+
+def run(cmd, **kw):
+    return subprocess.run(cmd, capture_output=True, text=True, **kw)
+
+
+def build_mini(src_zip, dest_zip, per_dataset, ann_max_bytes):
+    """A small archive shaped like the real one: features + annotations, no images."""
+    src = zipfile.ZipFile(src_zip)
+    feats, others, dirs = {}, [], []
+    for info in src.infolist():
+        name = info.filename
+        if name.endswith("/"):
+            dirs.append(info)
+            continue
+        rel = name[len(ROOT):]
+        if "/clip_features/" in rel and rel.endswith(".h5"):
+            feats.setdefault(rel.split("/")[0], []).append(info)
+        elif rel.startswith("nlvr/images/"):
+            continue  # the published dataset ships no images; mirror that
+        elif info.file_size <= ann_max_bytes:
+            others.append(info)
+    picked = list(dirs) + others
+    for group in feats.values():
+        picked += group[:per_dataset]
+    with zipfile.ZipFile(dest_zip, "w", zipfile.ZIP_DEFLATED) as out:
+        for info in picked:
+            if info.filename.endswith("/"):
+                out.writestr(zipfile.ZipInfo(info.filename), b"")
+            else:
+                out.writestr(info, src.read(info))
+    return dest_zip
+
+
+def compare_tree(mini_zip, tree):
+    """Bit-exactness of features, byte-exactness of everything else."""
+    z = zipfile.ZipFile(mini_zip)
+    n_h5 = n_other = bad = missing = 0
+    for info in z.infolist():
+        if info.filename.endswith("/"):
+            continue
+        rel = info.filename[len(ROOT):]
+        dest = tree / rel
+        if not dest.exists():
+            missing += 1
+            continue
+        orig = z.read(info)
+        if rel.endswith(".h5"):
+            stem = Path(rel).stem
+            with h5py.File(io.BytesIO(orig), "r") as fh:
+                ref = fh[f"{stem}/features"][...]
+            with h5py.File(dest, "r") as fh:          # the loaders' access pattern
+                got = fh[f"{stem}/features"][...]
+            if not (got.shape == ref.shape == (49, 2048)
+                    and got.dtype == ref.dtype == np.float16
+                    and np.array_equal(got, ref)):
+                bad += 1
+            n_h5 += 1
+        else:
+            if dest.read_bytes() != orig:
+                bad += 1
+            n_other += 1
+    return n_h5, n_other, bad, missing
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--zip", required=True, help="the original VLadapter.zip")
+    p.add_argument("--namespace", required=True, help="Hub user or org for the temp repo")
+    p.add_argument("--repo-name", default="vladapter-restore-smoketest")
+    p.add_argument("--per-dataset", type=int, default=200, help="h5 files per dataset")
+    p.add_argument("--shard-rows", type=int, default=64)
+    p.add_argument("--ann-max-bytes", type=int, default=2_500_000,
+                   help="skip annotations larger than this, to keep the test quick")
+    p.add_argument("--keep-repo", action="store_true")
+    p.add_argument("--workdir", default=None)
+    args = p.parse_args()
+
+    from huggingface_hub import HfApi
+
+    repo_id = f"{args.namespace}/{args.repo_name}"
+    work = Path(args.workdir or tempfile.mkdtemp(prefix="vladapter-test-"))
+    work.mkdir(parents=True, exist_ok=True)
+    api = HfApi()
+    py = sys.executable
+    print(f"workdir : {work}\ntemp repo: {repo_id} (private)\n")
+
+    try:
+        print("[1/7] building miniature archive")
+        mini = build_mini(args.zip, work / "mini.zip", args.per_dataset, args.ann_max_bytes)
+        print(f"       {mini.stat().st_size/1e6:.1f} MB")
+
+        print("[2/7] converting to the Hub layout")
+        staging = work / "hf"
+        r = run([py, str(TOOLS / "convert_zip_to_hf.py"), "--zip", str(mini),
+                 "--out", str(staging), "--shard-rows", str(args.shard_rows),
+                 "--only", "annotations", "--only", "features"])
+        if r.returncode:
+            print(r.stdout[-2000:], r.stderr[-2000:])
+            return check("convert", False, "see output above") or 1
+        shards = list(staging.rglob("*.parquet"))
+        print(f"       {len(shards)} shards")
+
+        print("[3/7] pushing the mirror to a private temp repo")
+        api.create_repo(repo_id, repo_type="dataset", private=True, exist_ok=True)
+        api.upload_folder(folder_path=str(staging), repo_id=repo_id, repo_type="dataset",
+                          ignore_patterns=[".convert_state*", "*.tmp"],
+                          commit_message="Miniature mirror for restore testing")
+
+        print("[4/7] bare restore: restore_datasets.py --out ./datasets")
+        tree = work / "datasets"
+        r = run([py, str(TOOLS / "restore_datasets.py"), "--out", str(tree),
+                 "--repo-id", repo_id])
+        out = r.stdout + r.stderr
+        check("bare command exits 0", r.returncode == 0)
+        check("manifest verification ran and passed",
+              "missing=0, size-mismatch=0, crc-mismatch=0" in out,
+              next((l.strip() for l in out.splitlines() if "[verify]" in l), "no [verify] line"))
+
+        print("[5/7] comparing the restored tree against the archive")
+        n_h5, n_other, bad, missing = compare_tree(mini, tree)
+        check("every .h5 bit-exact", bad == 0 and missing == 0,
+              f"{n_h5} h5 + {n_other} annotations, {bad} mismatched, {missing} missing")
+
+        for rel in ["paragraphs", "COCO/clip_features/data_clip_RN101_fc", "nlvr/images"]:
+            check(f"empty dir preserved: {rel}", (tree / rel).is_dir())
+        for ds in ["COCO", "GQA", "VG", "nlvr"]:
+            d = tree / ds / "clip_features" / "data_clip_RN101_att"
+            check(f"loader path exists: {ds}", d.is_dir() and any(d.glob("*.h5")),
+                  f"{len(list(d.glob('*.h5')))} .h5")
+
+        print("[6/7] second run must be idempotent")
+        r2 = run([py, str(TOOLS / "restore_datasets.py"), "--out", str(tree),
+                  "--repo-id", repo_id])
+        o2 = r2.stdout + r2.stderr
+        check("nothing rewritten on rerun", "h5 written" not in o2,
+              f"{o2.count('already restored')} shards skipped")
+
+        print("[7/7] resume after a simulated interruption")
+        gqa = sorted((tree / "GQA/clip_features/data_clip_RN101_att").glob("*.h5"))
+        removed = gqa[: args.shard_rows]
+        for f in removed:
+            f.unlink()
+        (tree / "nlvr/test.json").unlink(missing_ok=True)
+        r3 = run([py, str(TOOLS / "restore_datasets.py"), "--out", str(tree),
+                  "--repo-id", repo_id])
+        rewritten = sum(int(l.split(":")[-1].split("/")[0].strip())
+                        for l in (r3.stdout + r3.stderr).splitlines() if "h5 written" in l)
+        check("resume rewrote exactly the deleted files", rewritten == len(removed),
+              f"deleted {len(removed)}, rewrote {rewritten}")
+        check("deleted annotation restored", (tree / "nlvr/test.json").exists())
+
+        cache = Path.home() / ".cache/huggingface/hub"
+        size = sum(f.stat().st_size for f in cache.rglob("*") if f.is_file()) if cache.exists() else 0
+        check("download cache left ~empty", size < 50e6, f"{size/1e6:.1f} MB")
+
+    finally:
+        if not args.keep_repo:
+            try:
+                api.delete_repo(repo_id, repo_type="dataset")
+                print(f"\ncleaned up {repo_id}")
+            except Exception as exc:  # noqa: BLE001
+                print(f"\ncould not delete {repo_id}: {exc}")
+        if not args.workdir:
+            shutil.rmtree(work, ignore_errors=True)
+
+    print()
+    if FAILURES:
+        print(f"FAILED ({len(FAILURES)}): " + "; ".join(FAILURES))
+        return 1
+    print("ALL CHECKS PASSED")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())