#!/usr/bin/env python3 """Pin the extracted New Generation clips to one reproducible evaluation selection.""" from __future__ import annotations import argparse import csv import hashlib import json import sys from collections import Counter from pathlib import Path, PurePosixPath import cv2 import pandas as pd ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) from stateplay.constants import SF3_BUTTON_COLS # noqa: E402 from stateplay_eval import normalized_label # noqa: E402 def sha256_file(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 dataset_file(root: Path, relative: str) -> Path: name = PurePosixPath(relative) if name.is_absolute() or ".." in name.parts: raise ValueError(f"Unsafe dataset path: {relative}") path = (root / name).resolve() if not path.is_file() or not path.is_relative_to(root): raise FileNotFoundError(f"Missing dataset file: {relative}") return path def verify_packaged_files(root: Path) -> None: manifest = root / "qa/file_manifest.sha256" lines = manifest.read_text(encoding="utf-8").splitlines() if len(lines) < 200: raise ValueError(f"Unexpectedly short dataset checksum manifest: {manifest}") for line in lines: parts = line.split(maxsplit=2) if len(parts) == 3: expected_hash, expected_size, relative = parts elif len(parts) == 2: expected_hash, relative = parts expected_size = None else: raise ValueError(f"Malformed dataset checksum entry: {line}") path = dataset_file(root, relative) if (expected_size is not None and path.stat().st_size != int(expected_size)) or sha256_file(path) != expected_hash: raise ValueError(f"Dataset checksum mismatch: {relative}") def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--dataset", type=Path, required=True) parser.add_argument("--archive", type=Path, required=True) parser.add_argument("--output", type=Path, required=True) args = parser.parse_args() dataset = args.dataset.resolve() archive = args.archive.resolve() if not dataset.is_dir() or not archive.is_file(): raise FileNotFoundError("Dataset directory and source ZIP must both exist") verify_packaged_files(dataset) build = json.loads((dataset / "build_info.json").read_text(encoding="utf-8")) if (build.get("clip_count"), build.get("game"), build.get("stage")) != ( 100, "sfiii_new_generation", "Ibuki (Round 1)" ): raise ValueError("This is not the expected 100-clip Ibuki Round 1 release") with (dataset / "metadata_state_polish.csv").open(newline="", encoding="utf-8-sig") as handle: metadata = list(csv.DictReader(handle)) with (dataset / "selection_manifest.csv").open(newline="", encoding="utf-8-sig") as handle: source_rows = list(csv.DictReader(handle)) source_by_video = {row["video"]: row for row in source_rows} if len(metadata) != 100 or len(source_by_video) != 100: raise ValueError("Expected 100 unique metadata and source rows") samples = [] for index, row in enumerate(metadata, start=1): source = source_by_video.get(row["video"]) if source is None or row["action"] != source["action"]: raise ValueError(f"Missing matching source identity for {row['video']}") label = normalized_label(row["distribution"]) if label != normalized_label(source["category"]): raise ValueError(f"Mechanics label mismatch for {row['video']}") video = dataset_file(dataset, row["video"]) actions = dataset_file(dataset, row["action"]) frame_actions = pd.read_parquet(actions) required = {"timer", "p1_hp", "p2_hp", "p1_meter", "p2_meter", *SF3_BUTTON_COLS} if len(frame_actions) != 100 or required - set(frame_actions.columns): raise ValueError(f"Invalid action/state table: {actions}") cap = cv2.VideoCapture(str(video)) try: frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) fps = cap.get(cv2.CAP_PROP_FPS) valid_first_frame = cap.read()[0] finally: cap.release() if frames != 100 or abs(fps - 20) > 0.1 or not valid_first_frame: raise ValueError(f"Invalid reference video: {video} ({frames} frames, {fps} FPS)") clip_id = source["clip_id"] if video.parent.name != clip_id: raise ValueError(f"Clip identity mismatch: {video} versus {clip_id}") prompt = row["prompt"].strip() if not prompt: raise ValueError(f"Empty prompt for {clip_id}") samples.append({ "id": f"ng_{index:03d}", "source_kind": "independent_new_generation_selftest", "source_id": clip_id, "label": label, "input_image": None, "source_video": str(video), "reference_video": str(video), "actions": str(actions), "prompt": prompt, "output_name": f"ng_{index:03d}_{label}_{clip_id}.mp4", "identity": { "video_sha256": sha256_file(video), "actions_file_sha256": sha256_file(actions), "source_action_fingerprint": source["action_sha256"], "episode_id": source["episode_id"], }, }) counts = Counter(sample["label"] for sample in samples) if set(counts.values()) != {20} or len(counts) != 5: raise ValueError(f"Expected 20 clips in each of five classes, got {dict(counts)}") result = { "benchmark_name": "stateplay_ibuki_round1_new_generation_100_v1", "warning": "Independent self-test, not the paper authors' unpublished test set.", "source_archive": str(archive), "source_archive_sha256": sha256_file(archive), "dataset_root": str(dataset), "class_counts": dict(sorted(counts.items())), "samples": samples, } output = args.output.resolve() output.parent.mkdir(parents=True, exist_ok=True) temporary = output.with_suffix(".tmp") temporary.write_text(json.dumps(result, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") if output.exists() and output.read_bytes() != temporary.read_bytes(): temporary.unlink() raise ValueError(f"Existing selection differs; refusing to remap prior outputs: {output}") temporary.replace(output) print(f"Prepared {len(samples)} verified clips in {output}") if __name__ == "__main__": main()