| |
| """Verify the released videos and original-resolution frames for inference.""" |
|
|
| import argparse |
| import csv |
| import json |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
| from urllib.parse import quote, urlsplit |
|
|
| from extract_frames import relative_file, validate_frame_cache, validate_video |
|
|
|
|
| def load_rows(root): |
| rows = [json.loads(line) for line in (root / "test.jsonl").read_text(encoding="utf-8").splitlines() if line.strip()] |
| if not rows or len({row["id"] for row in rows}) != len(rows): |
| raise ValueError("Sample IDs must be unique and the dataset must be nonempty") |
| for row in rows: |
| if (not isinstance(row["id"], str) or not row["id"].isdigit() |
| or str(int(row["id"])) != row["id"]): |
| raise ValueError("Sample IDs must be canonical nonnegative integer strings") |
| if any(not isinstance(row[key], str) or not row[key].strip() for key in ("question", "answer")): |
| raise ValueError("Question and answer must be nonempty strings") |
| if row["fps"] != 1 or type(row["n_frames"]) is not int or row["n_frames"] < 1: |
| raise ValueError("Expected 1 FPS and a positive integer n_frames") |
| relative_file(root, row["video"]) |
| return rows |
|
|
|
|
| def prepare(root, rows, base_url, workers, verify_only=False): |
| inventory = { |
| row["path"]: row |
| for row in map(json.loads, (root / "media.jsonl").read_text(encoding="utf-8").splitlines()) |
| } |
| unique = {} |
| for row in rows: |
| if row["video"] in unique and unique[row["video"]]["n_frames"] != row["n_frames"]: |
| raise ValueError("Conflicting frame counts for the same video") |
| unique[row["video"]] = row |
|
|
| records = [json.loads(line) for line in (root / "frames.jsonl").read_text(encoding="utf-8").splitlines() if line.strip()] |
| cached_frames = {record["video"]: record for record in records} |
| if len(cached_frames) != len(records) or not set(unique).issubset(cached_frames): |
| raise ValueError("Frame manifest must contain unique entries covering all requested videos") |
|
|
| def process(row): |
| source = relative_file(root, row["video"]) |
| info = inventory[row["video"]] |
| if source.stat().st_size != info["bytes"]: |
| raise ValueError(f"Video byte size mismatch: {row['video']}") |
| if info["n_frames"] != row["n_frames"]: |
| raise ValueError("Media inventory and sample frame counts disagree") |
| validate_video(source, row["n_frames"]) |
| validate_frame_cache(root, cached_frames[row["video"]], info) |
|
|
| with ThreadPoolExecutor(max_workers=workers) as pool: |
| list(pool.map(process, unique.values())) |
| if verify_only: |
| return {"samples": len(rows), "videos": len(unique), "frames": sum(row["n_frames"] for row in unique.values()), "verified": True} |
|
|
| def url(relative): |
| return base_url.rstrip("/") + "/" + quote(relative, safe="/") |
|
|
| runtime = root / "runtime" |
| with (runtime / "video.csv").open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=["index", "question", "answer"]) |
| writer.writeheader() |
| writer.writerows({"index": row["id"], "question": row["question"], "answer": row["answer"]} for row in rows) |
| with (runtime / "video_manifest.jsonl").open("w", encoding="utf-8") as handle: |
| for row in rows: |
| n = row["n_frames"] |
| record = { |
| "case_id": row["id"], "ok": True, "modality": "video", |
| "video_url": url(row["video"]), "n_frames": n, "grid_fps": 1.0, |
| "duration": float(n), "frame_indices": list(range(n)), |
| "frame_urls": [url(f"runtime/frames/{Path(row['video']).stem}/frame_{i:03d}.png") for i in range(n)], |
| } |
| handle.write(json.dumps(record) + "\n") |
| return {"samples": len(rows), "videos": len(unique), "manifest": "runtime/video_manifest.jsonl"} |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--data-root", type=Path, default=Path(__file__).resolve().parent) |
| parser.add_argument("--media-base-url", help="HTTP(S) base URL serving the entire dataset directory") |
| parser.add_argument("--workers", type=int, default=4) |
| parser.add_argument("--verify-only", action="store_true", help="Verify media sizes, video layout and original-resolution PNG dimensions and order without preparing inference inputs") |
| args = parser.parse_args() |
| if args.workers < 1: |
| parser.error("--workers must be positive") |
| if not args.verify_only: |
| parsed = urlsplit(args.media_base_url or "") |
| if parsed.scheme not in ("http", "https") or not parsed.netloc or parsed.query or parsed.fragment or parsed.username: |
| parser.error("--media-base-url must be an HTTP(S) directory URL without credentials, query or fragment") |
| root = args.data_root.resolve() |
| print(json.dumps(prepare(root, load_rows(root), args.media_base_url, args.workers, args.verify_only))) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
