| |
| """Build the typed CASTAIGNE25 case table from case definitions and packages.""" |
| import argparse |
| import hashlib |
| import io |
| import json |
| import tomllib |
| from pathlib import Path |
| from datetime import datetime, timezone |
|
|
| from datasets import Features, Image, List, Value |
| from PIL import Image as PILImage |
| import yaml |
|
|
|
|
| DATASET_VERSION = "0.3.0" |
|
|
| FEATURES = Features({ |
| "original_image": Image(), |
| "broken_image": Image(), |
| "case_id": Value("string"), |
| "dataset_version": Value("string"), |
| "title": Value("string"), |
| "asset_id": Value("string"), |
| "source_revision": Value("string"), |
| "source_url": Value("string"), |
| "license": Value("string"), |
| "fault_count": Value("int64"), |
| "faults": List({"defect_id": Value("string"), "description": Value("string")}), |
| "failure_story": Value("string"), |
| "required_outcome": Value("string"), |
| "scope": Value("string"), |
| "agent_evidence": Value("string"), |
| "whole_package_path": Value("string"), |
| "whole_entrypoint": Value("string"), |
| "broken_package_path": Value("string"), |
| "broken_entrypoint": Value("string"), |
| "package_path": Value("string"), |
| "package_sha256": Value("string"), |
| "episode_paths": List(Value("string")), |
| "verification_scope": List(Value("string")), |
| }) |
|
|
|
|
| def read_json(path): |
| return json.loads(path.read_text()) if path.is_file() else {} |
|
|
|
|
| def sha256(path): |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for chunk in iter(lambda: stream.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def preview_image(root, item, case_id, role, expected_asset_sha256, *, folder="previews"): |
| relative = f"{folder}/{case_id}-{role}.png" |
| if item.get("path") != relative: |
| raise ValueError(f"{case_id}: unexpected {role} preview path") |
| path = root / relative |
| if not path.is_file() or path.is_symlink(): |
| raise ValueError(f"{case_id}: missing {role} preview") |
| blob = path.read_bytes() |
| if hashlib.sha256(blob).hexdigest() != item.get("sha256"): |
| raise ValueError(f"{case_id}: {role} preview image digest mismatch") |
| if item.get("asset_sha256") != expected_asset_sha256: |
| raise ValueError(f"{case_id}: {role} preview does not match the current asset") |
| with PILImage.open(io.BytesIO(blob)) as image: |
| if image.format != "PNG" or image.width < 1 or image.height < 1: |
| raise ValueError(f"{case_id}: invalid {role} PNG") |
| if folder == "gallery" and image.size != (1280, 1280): |
| raise ValueError(f"{case_id}: gallery images must be 1280 by 1280") |
| image.verify() |
| return {"bytes": blob, "path": relative} |
|
|
|
|
| def source_entry_sha256(root, case, verification): |
| entrypoint = verification["source_entrypoint"] |
| source = root / "work/originals" / case["case_id"] / case["source"]["asset_id"] / entrypoint |
| if source.is_file(): |
| return sha256(source) |
| acquisition = read_json(root / "records" / case["case_id"] / "acquisition.json") |
| matches = [row["sha256"] for row in acquisition.get("files", []) if row["path"] == entrypoint] |
| if len(matches) != 1: |
| raise ValueError(f"{case['case_id']}: source entry digest is required") |
| return matches[0] |
|
|
|
|
| def validate_version(root, manifest): |
| project = tomllib.loads((root / "pyproject.toml").read_text())["project"] |
| if project["version"] != DATASET_VERSION or manifest.get("dataset_version") != DATASET_VERSION: |
| raise ValueError("The viewer requires dataset and software version 0.3.0") |
| if any(case.get("case_version") != DATASET_VERSION for case in manifest["cases"]): |
| raise ValueError("Every viewer case must belong to version 0.3.0") |
|
|
|
|
| def episode_paths(root, case, package_sha256): |
| index_path = case.get("artifacts", {}).get("episode_index", f"episodes/cases/{case['case_id']}.json") |
| index = read_json(root / index_path) |
| paths = index.get("episode_paths", []) |
| if not isinstance(paths, list) or not all(type(path) is str for path in paths): |
| raise ValueError(f"{case['case_id']}: episode_paths must be a native list of paths") |
| started = [] |
| for path in paths: |
| target = (root / path).resolve() |
| if not path.startswith("episodes/") or not target.is_relative_to(root.resolve()) or not target.is_file(): |
| raise ValueError(f"{case['case_id']}: episode manifest is missing or leaves the dataset") |
| episode = read_json(target) |
| if episode.get("case_id") != case["case_id"]: |
| raise ValueError(f"{case['case_id']}: episode case identity mismatch") |
| if (episode.get("dataset_version") != DATASET_VERSION |
| or episode.get("input", {}).get("package_sha256") != package_sha256): |
| continue |
| if episode.get("kind") == "repair_episode" and episode.get("state") in { |
| "running", "completed", "failed", "budget_exhausted", "interrupted", "uncertain" |
| }: |
| started.append(path) |
| return list(dict.fromkeys(started)) |
|
|
|
|
| def build_rows(root, *, allow_missing_previews=False): |
| manifest = read_json(root / "cases/castaigne25.json") |
| validate_version(root, manifest) |
| cases = manifest["cases"] |
| ids = [case["case_id"] for case in cases] |
| if len(ids) != len(set(ids)): |
| raise ValueError("Case IDs must be unique") |
| |
| preview_folder = "gallery" if (root / "gallery/manifest.json").is_file() else "previews" |
| previews = read_json(root / preview_folder / "manifest.json").get("cases", []) |
| preview_ids = [item["case_id"] for item in previews] |
| missing = set(ids) - set(preview_ids) |
| allowed_missing = {f"R{i:02}" for i in range(21, 26)} if allow_missing_previews else set() |
| if (len(preview_ids) != len(set(preview_ids)) or set(preview_ids) - set(ids) |
| or not missing.issubset(allowed_missing)): |
| raise ValueError("Preview manifest must contain exactly one entry for every case") |
| for case_id in missing: |
| if any((root / f"previews/{case_id}-{role}.png").exists() for role in ("original", "broken")) or (root / f"work/preview-{case_id}.json").exists(): |
| raise ValueError(f"{case_id}: existing preview evidence must be validated, never replaced with null") |
| by_id = {item["case_id"]: item for item in previews} |
| rows = [] |
| for case in cases: |
| case_id = case["case_id"] |
| if not case_id.startswith("R") or not case_id[1:].isdigit(): |
| raise ValueError(f"Invalid case ID: {case_id}") |
| record_dir = root / "records" / case_id |
| inventory = read_json(record_dir / "upstream-inventory.json") |
| verification = read_json(record_dir / "damage-verification.json") |
| archive = read_json(record_dir / "package-verification.json") |
| package = root / "packages" / f"{case_id}.tar.gz" |
| if verification.get("passed") is not True or verification.get("case_version") != DATASET_VERSION: |
| raise ValueError(f"{case_id}: passing authored fault checks are required") |
| checks = verification.get("verification_checks") |
| if not isinstance(checks, list) or not checks or not all(type(check) is str and check for check in checks): |
| raise ValueError(f"{case_id}: explicit verification_checks list is required") |
| if not archive.get("archive_verified") or archive.get("asset_sha256") != verification["asset_sha256"]: |
| raise ValueError(f"{case_id}: archive does not match the current damaged asset") |
| package_path, digest = archive["path"], archive["sha256"] |
| if package_path != f"packages/{case_id}.tar.gz": |
| raise ValueError(f"{case_id}: unexpected package path") |
| if package.is_file(): |
| if sha256(package) != digest: |
| raise ValueError(f"{case_id}: local archive digest mismatch") |
| preview = by_id.get(case_id) |
| revision = inventory.get("revision") or case["source"].get("revision") |
| if verification.get("source_revision") != revision or (preview is not None and ( |
| preview.get("source_revision") != revision or preview.get("asset_id") != case["source"]["asset_id"])): |
| raise ValueError(f"{case_id}: preview source identity mismatch") |
| faults = case["proposed_corruptions"] |
| if {fault["defect_id"] for fault in verification.get("defects", []) if fault.get("passed")} != {fault["defect_id"] for fault in faults}: |
| raise ValueError(f"{case_id}: verified faults do not match case definitions") |
| asset_id = case["source"]["asset_id"] |
| source_entrypoint = case["source"].get("root_entrypoint") |
| if source_entrypoint != verification["source_entrypoint"]: |
| raise ValueError(f"{case_id}: source entrypoint does not match the package records") |
| whole_package = f"assets/whole/{asset_id}" |
| broken_package = f"assets/broken/{asset_id}" |
| row = { |
| "original_image": preview_image(root, preview["original"], case_id, "original", source_entry_sha256(root, case, verification), folder=preview_folder) if preview else None, |
| "broken_image": preview_image(root, preview["broken"], case_id, "broken", verification["asset_sha256"], folder=preview_folder) if preview else None, |
| "case_id": case_id, |
| "dataset_version": DATASET_VERSION, |
| "title": case["title"], |
| "asset_id": case["source"]["asset_id"], |
| "source_revision": revision, |
| "source_url": f"https://huggingface.co/datasets/{inventory['repository']}/tree/{revision}/{asset_id}", |
| "license": case["source"]["declared_license"], |
| "fault_count": len(faults), |
| "faults": [{"defect_id": fault["defect_id"], "description": fault["description"]} for fault in faults], |
| "failure_story": case["failure_story"], |
| "required_outcome": case["acceptance"]["required_outcome"], |
| "scope": case["acceptance"]["scope"], |
| "agent_evidence": case["agent_evidence_plan"], |
| "whole_package_path": whole_package, |
| "whole_entrypoint": f"{whole_package}/{source_entrypoint}", |
| "broken_package_path": broken_package, |
| "broken_entrypoint": f"{broken_package}/asset.usdc", |
| "package_path": package_path, |
| "package_sha256": digest, |
| "episode_paths": episode_paths(root, case, digest), |
| "verification_scope": checks, |
| } |
| rows.append(row) |
| return rows |
|
|
|
|
| def jsonl_text(rows): |
| serializable = [] |
| for row in rows: |
| item = dict(row) |
| for name in ("original_image", "broken_image"): |
| item[name] = {"path": row[name]["path"], "bytes": None} if row[name] is not None else None |
| serializable.append(item) |
| return "".join(json.dumps(row, ensure_ascii=False) + "\n" for row in serializable) |
|
|
|
|
| def check_parquet(path, rows): |
| import pyarrow.parquet as pq |
| table = pq.read_table(path) |
| if Features.from_arrow_schema(table.schema) != FEATURES or table.to_pylist() != rows: |
| raise ValueError("data/cases.parquet does not match the typed case records and previews") |
| |
| for row in table.to_pylist(): |
| for name in ("original_image", "broken_image"): |
| if row[name] is None: |
| continue |
| with PILImage.open(io.BytesIO(row[name]["bytes"])) as image: |
| image.load() |
|
|
|
|
| def check_card_schema(root): |
| card = yaml.safe_load((root / "README.md").read_text().split("---", 2)[1]) |
| configs = [config for config in card["configs"] if config["config_name"] == "cases"] |
| if len(configs) != 1 or configs[0].get("data_files") != [{"split": "castaigne25", "path": "data/cases.parquet"}]: |
| raise ValueError("README cases config must select data/cases.parquet") |
| if Features._from_yaml_list(configs[0]["features"]) != FEATURES: |
| raise ValueError("README feature declarations do not match the native table schema") |
|
|
|
|
| def write_check_receipt(root, rows, allow_missing_previews): |
| import datasets |
| import pyarrow |
| files = ["data/cases.parquet", "data/cases.jsonl", "README.md", "cases/castaigne25.json", |
| "previews/manifest.json", "scripts/build_case_viewer.py"] |
| if (root / "gallery/manifest.json").is_file(): |
| files.append("gallery/manifest.json") |
| for row in rows: |
| case_id = row["case_id"] |
| files.extend(f"records/{case_id}/{name}.json" for name in ( |
| "damage-verification", "package-verification", "upstream-inventory")) |
| index = f"episodes/cases/{case_id}.json" |
| if (root / index).is_file(): |
| files.append(index) |
| files.extend(row["episode_paths"]) |
| files.extend(row[name]["path"] for name in ("original_image", "broken_image") if row[name] is not None) |
| present = sum(row[name] is not None for row in rows for name in ("original_image", "broken_image")) |
| receipt = { |
| "schema": "simrepairbench-case-viewer-check-v1", |
| "dataset_version": DATASET_VERSION, |
| "checked_at": datetime.now(timezone.utc).isoformat(), |
| "command": "scripts/build_case_viewer.py --check" + (" --allow-missing-previews" if allow_missing_previews else ""), |
| "allow_missing_previews": allow_missing_previews, |
| "counts": {"cases": len(rows), "faults": sum(row["fault_count"] for row in rows), |
| "images_present": present, "images_null": 2 * len(rows) - present, |
| "episode_paths": sum(len(row["episode_paths"]) for row in rows)}, |
| "null_image_cases": [row["case_id"] for row in rows if row["original_image"] is None], |
| "assertions": {"parquet_matches_current_inputs": True, "embedded_images_decode": True, |
| "image_and_asset_hashes_match": True, "faults_are_native_list_of_records": True, |
| "fault_counts_match_lists": all(row["fault_count"] == len(row["faults"]) for row in rows), |
| "episode_paths_are_native_lists": True, "verification_scope_is_native_string_list": True, |
| "verification_scope_is_last_column": list(FEATURES)[-1] == "verification_scope", |
| "readme_features_match_parquet": True}, |
| "native_features": FEATURES.to_dict(), |
| "runtime": {"datasets": datasets.__version__, "pyarrow": pyarrow.__version__}, |
| "files": {path: sha256(root / path) for path in sorted(set(files))}, |
| } |
| target = root / "work/case-viewer-check.json" |
| target.parent.mkdir(exist_ok=True) |
| target.write_text(json.dumps(receipt, ensure_ascii=False, indent=2) + "\n") |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1]) |
| parser.add_argument("--check", action="store_true", help="Check the table without rewriting it") |
| parser.add_argument("--allow-missing-previews", action="store_true", |
| help="Permit native null images only for absent R21–R25 previews") |
| args = parser.parse_args() |
| root = args.root.resolve() |
| check_card_schema(root) |
| rows = build_rows(root, allow_missing_previews=args.allow_missing_previews) |
| text = jsonl_text(rows) |
| output = root / "data/cases.jsonl" |
| parquet = root / "data/cases.parquet" |
| if args.check: |
| if not output.is_file() or output.read_text() != text: |
| parser.error("data/cases.jsonl does not match the case definitions and packages") |
| check_parquet(parquet, rows) |
| write_check_receipt(root, rows, args.allow_missing_previews) |
| else: |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| output.parent.mkdir(exist_ok=True) |
| |
| pq.write_table(pa.Table.from_pylist(rows, schema=FEATURES.arrow_schema), parquet) |
| check_parquet(parquet, rows) |
| output.write_text(text) |
| print(json.dumps({"cases": len(rows), "faults": sum(row["fault_count"] for row in rows)})) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
