| |
| """Verify OneSearch-MI images and prepare ordered inference inputs.""" |
|
|
| import argparse |
| import csv |
| import json |
| import struct |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
| from urllib.parse import quote, urlsplit |
|
|
|
|
| def relative_file(root, value): |
| path = Path(value) |
| if path.is_absolute() or ".." in path.parts or "\\" in value: |
| raise ValueError(f"Expected a relative image path: {value}") |
| resolved = (root / path).resolve() |
| if not resolved.is_relative_to(root.resolve()) or not resolved.is_file(): |
| raise ValueError(f"Missing image or path outside the dataset: {value}") |
| return resolved |
|
|
|
|
| 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") |
| images = row["images"] |
| if not isinstance(images, list) or len(images) < 2: |
| raise ValueError("Each MI sample must contain at least two ordered image paths") |
| if type(row["n_images"]) is not int or row["n_images"] != len(images): |
| raise ValueError("n_images must equal the length of images") |
| for image in images: |
| relative_file(root, image) |
| return rows |
|
|
|
|
| def prepare(root, rows, base_url, workers, verify_only=False): |
| media = [json.loads(line) for line in (root / "media.jsonl").read_text(encoding="utf-8").splitlines() if line.strip()] |
| inventory = {row["path"]: row for row in media} |
| if len(inventory) != len(media): |
| raise ValueError("Media inventory paths must be unique") |
| referenced = {path for row in rows for path in row["images"]} |
| if referenced != set(inventory): |
| raise ValueError("Media inventory must match the referenced image set") |
|
|
| def check(relative): |
| path = relative_file(root, relative) |
| info = inventory[relative] |
| if path.stat().st_size != info["bytes"]: |
| raise ValueError(f"Image byte size mismatch: {relative}") |
| with path.open("rb") as handle: |
| header = handle.read(24) |
| if (len(header) != 24 or header[:8] != b"\x89PNG\r\n\x1a\n" |
| or header[12:16] != b"IHDR" |
| or struct.unpack(">II", header[16:24]) != (info["width"], info["height"])): |
| raise ValueError(f"PNG dimensions differ from media.jsonl: {relative}") |
|
|
| with ThreadPoolExecutor(max_workers=workers) as pool: |
| list(pool.map(check, sorted(referenced))) |
| result = {"samples": len(rows), "images": len(referenced), "verified": True} |
| if verify_only: |
| return result |
|
|
| runtime = root / "runtime" |
| runtime.mkdir(parents=True, exist_ok=True) |
| with (runtime / "mi.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 / "mi_manifest.jsonl").open("w", encoding="utf-8") as handle: |
| for row in rows: |
| record = { |
| "case_id": row["id"], "ok": True, "modality": "multi_image", |
| "n_images": len(row["images"]), |
| "image_urls": [base_url.rstrip("/") + "/" + quote(path, safe="/") for path in row["images"]], |
| } |
| handle.write(json.dumps(record) + "\n") |
| result["manifest"] = "runtime/mi_manifest.jsonl" |
| return result |
|
|
|
|
| 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 this MI dataset directory") |
| parser.add_argument("--workers", type=int, default=4) |
| parser.add_argument("--verify-only", action="store_true") |
| 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() |
|
|
