#!/usr/bin/env python3 """Build the standalone ESI-Bench passive-single Hugging Face dataset repo.""" from __future__ import annotations import argparse import json import os import shutil from collections import Counter from pathlib import Path from typing import Any PROJECT_ROOT = Path(__file__).resolve().parents[2] DEFAULT_SOURCE_ROOT = PROJECT_ROOT / "outputs/passive_single" DEFAULT_MANIFEST = DEFAULT_SOURCE_ROOT / "all_manifest.jsonl" DEFAULT_QUESTIONS = PROJECT_ROOT / "hf_dataset/data/questions.jsonl" DEFAULT_OUTPUT_ROOT = PROJECT_ROOT / "hf_passive_single_dataset" def read_jsonl(path: Path) -> list[dict[str, Any]]: rows: list[dict[str, Any]] = [] with path.open(encoding="utf-8") as handle: for line_number, line in enumerate(handle, start=1): line = line.strip() if not line: continue try: value = json.loads(line) except json.JSONDecodeError as exc: raise SystemExit(f"Invalid JSON in {path}:{line_number}: {exc}") from exc if not isinstance(value, dict): raise SystemExit(f"Expected an object in {path}:{line_number}") rows.append(value) return rows def json_text(value: Any) -> str: return json.dumps(value, ensure_ascii=False, separators=(",", ":")) def relative_image_path(raw_path: str) -> Path: prefix = "outputs/passive_single/" normalized = raw_path.replace("\\", "/") if normalized.startswith(prefix): normalized = normalized[len(prefix) :] relative = Path(normalized) if relative.is_absolute() or ".." in relative.parts: raise SystemExit(f"Unsafe output_image path: {raw_path}") return relative def action_qa(row: dict[str, Any]) -> tuple[str | None, str | None, str | None, str | None]: result = row.get("result") if not isinstance(result, dict): return None, None, None, None camera_info = result.get("camera_info") if not isinstance(camera_info, dict): return None, None, None, None qa = camera_info.get("qa") if not isinstance(qa, dict) or not qa.get("question"): return None, None, None, None answers = { key: qa[key] for key in ("answer_A", "answer_C") if key in qa } options: dict[str, Any] = {} if "choices_A" in qa: options["A"] = qa["choices_A"] if "choices_C" in qa: options["C"] = qa["choices_C"] return ( str(qa["question"]), json_text(answers) if answers else None, "choice" if answers else None, json_text(options) if options else None, ) def public_metadata( manifest_row: dict[str, Any], question_row: dict[str, Any], file_name: str, item_id: str, ) -> dict[str, Any]: result = manifest_row.get("result") if not isinstance(result, dict): result = {} rendered_question, rendered_answer, rendered_answer_type, rendered_options = action_qa(manifest_row) return { "file_name": file_name, "id": item_id, "big_task": manifest_row.get("big_task") or result.get("big_task"), "small_task": manifest_row.get("small_task") or result.get("small_task"), "runner_task": question_row.get("runner_task") or result.get("runner_task"), "scene": manifest_row.get("scene") or result.get("scene"), "room": manifest_row.get("room") or result.get("room"), "question": rendered_question or question_row.get("question"), "answer": rendered_answer or question_row.get("answer"), "answer_type": rendered_answer_type or question_row.get("answer_type"), "options_json": rendered_options or question_row.get("options_json") or "{}", } def place_image(source: Path, destination: Path, mode: str) -> str: destination.parent.mkdir(parents=True, exist_ok=True) if mode == "copy": shutil.copy2(source, destination) return "copied" try: os.link(source, destination) return "linked" except OSError: shutil.copy2(source, destination) return "copied" def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: path.parent.mkdir(parents=True, exist_ok=True) with path.open("w", encoding="utf-8") as handle: for row in rows: handle.write(json_text(row)) handle.write("\n") def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--source-root", type=Path, default=DEFAULT_SOURCE_ROOT) parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST) parser.add_argument("--questions", type=Path, default=DEFAULT_QUESTIONS) parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT) parser.add_argument("--copy", action="store_true", help="Copy images instead of using hard links when possible.") parser.add_argument("--overwrite", action="store_true", help="Replace an existing generated data directory.") args = parser.parse_args() source_root = args.source_root.resolve() manifest_path = args.manifest.resolve() questions_path = args.questions.resolve() output_root = args.output_root.resolve() data_root = output_root / "data" if output_root == PROJECT_ROOT or output_root == source_root: raise SystemExit(f"Refusing unsafe output root: {output_root}") if data_root.exists(): if not args.overwrite: raise SystemExit("Generated data already exists. Pass --overwrite to rebuild it.") shutil.rmtree(data_root) manifest_rows = read_jsonl(manifest_path) question_rows = read_jsonl(questions_path) questions_by_id = {str(row["id"]): row for row in question_rows} if len(questions_by_id) != len(question_rows): raise SystemExit("Question IDs are not unique") manifest_by_index = {int(row["index"]): row for row in manifest_rows} metadata: list[dict[str, Any]] = [] referenced_images: set[Path] = set() placement_counts: Counter[str] = Counter() for row in manifest_rows: status = row.get("status") result = row.get("result") if status not in {"rendered", "rendered_warning"} or not isinstance(result, dict): continue item_id = str(result.get("id") or "") if not item_id or item_id not in questions_by_id: raise SystemExit(f"Missing standardized question metadata for rendered ID {item_id!r}") raw_image_path = result.get("output_image") if not isinstance(raw_image_path, str): raise SystemExit(f"Rendered ID {item_id} has no output_image") relative = relative_image_path(raw_image_path) source = source_root / relative if not source.is_file(): raise SystemExit(f"Missing rendered image for ID {item_id}: {source}") referenced_images.add(relative) destination = data_root / relative placement_counts[place_image(source, destination, "copy" if args.copy else "link")] += 1 metadata.append( public_metadata(row, questions_by_id[item_id], relative.as_posix(), item_id) ) all_pngs = { path.relative_to(source_root) for path in source_root.rglob("*.png") if path.is_file() } recovered_images: list[str] = [] for relative in sorted(all_pngs - referenced_images): prefix = relative.name.split("_", 1)[0] if not prefix.isdigit(): raise SystemExit(f"Cannot recover an ID from image name: {relative}") item_id = f"{int(prefix):04d}" manifest_row = manifest_by_index.get(int(prefix)) question_row = questions_by_id.get(item_id) if manifest_row is None or question_row is None: raise SystemExit(f"Cannot recover metadata for image: {relative}") placement_counts[ place_image(source_root / relative, data_root / relative, "copy" if args.copy else "link") ] += 1 metadata.append(public_metadata(manifest_row, question_row, relative.as_posix(), item_id)) recovered_images.append(relative.as_posix()) metadata.sort(key=lambda row: row["id"]) if len({row["id"] for row in metadata}) != len(metadata): raise SystemExit("Published image IDs are not unique") write_jsonl(data_root / "metadata.jsonl", metadata) summary = { "manifest_rows": len(manifest_rows), "question_rows": len(question_rows), "published_images": len(metadata), "recovered_images": recovered_images, "image_placement": dict(sorted(placement_counts.items())), } print(json.dumps(summary, ensure_ascii=False, indent=2)) return 0 if __name__ == "__main__": raise SystemExit(main())