| |
| """Validate a downloaded or locally built PixCell dataset release.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import concurrent.futures |
| import io |
| import json |
| import math |
| import os |
| import subprocess |
| import sys |
| import tempfile |
| from collections import Counter, defaultdict |
| from pathlib import Path |
| from typing import Any |
|
|
| import pyarrow.parquet as pq |
| from huggingface_hub import DatasetCard |
| from PIL import Image |
|
|
| from _shared import ( |
| LEVELS, |
| SAFE_PUBLIC_ID, |
| SCHEMA_VERSION, |
| ReleaseError, |
| canonical_sha256, |
| forbidden_release_imports, |
| iter_release_files, |
| normalized_d4_sha256, |
| purity_violations, |
| read_json, |
| scan_text, |
| scan_value_strings, |
| sha256_bytes, |
| sha256_file, |
| verify_checksums, |
| ) |
| from build_release import ROW_COLUMNS, release_digest_record |
|
|
|
|
| EXECUTION_RUNNER = r""" |
| import importlib.util |
| import json |
| import sys |
| from pathlib import Path |
| |
| import numpy as np |
| |
| program_path = Path(sys.argv[1]).resolve() |
| output_path = Path(sys.argv[2]).resolve() |
| spec = importlib.util.spec_from_file_location("pixcell_release_program", program_path) |
| if spec is None or spec.loader is None: |
| raise RuntimeError("could not load program") |
| module = importlib.util.module_from_spec(spec) |
| spec.loader.exec_module(module) |
| device = getattr(module, "device", None) |
| if not callable(device): |
| raise RuntimeError("program has no callable device()") |
| component = device() |
| bbox = np.asarray(component.bbox_np(), dtype=float) |
| if bbox.shape != (2, 2): |
| raise RuntimeError(f"unexpected bbox shape: {bbox.shape}") |
| polygons = component.get_polygons(by="tuple") |
| polygon_count = sum(len(items) for items in polygons.values()) |
| gds_path = output_path.with_suffix(".gds") |
| component.write_gds(gds_path, with_metadata=False) |
| record = { |
| "bbox_span_um": (bbox[1] - bbox[0]).tolist(), |
| "bbox_um": bbox.tolist(), |
| "gds_bytes": gds_path.stat().st_size, |
| "polygon_count": polygon_count, |
| "port_count": len(component.ports), |
| "ports": [ |
| { |
| "center": [float(value) for value in port.dcenter], |
| "name": str(port.name), |
| "orientation": float(port.orientation), |
| "port_type": str(port.port_type), |
| "width": float(port.dwidth), |
| } |
| for port in component.ports |
| ], |
| } |
| output_path.write_text(json.dumps(record, sort_keys=True), encoding="utf-8") |
| """ |
|
|
|
|
| def _parquet_path(root: Path, level: str) -> Path: |
| matches = sorted((root / "data" / level).glob("train-*.parquet")) |
| if len(matches) != 1: |
| raise ReleaseError( |
| f"{level}: expected exactly one Parquet shard, found {len(matches)}" |
| ) |
| return matches[0] |
|
|
|
|
| def _embedded_image( |
| example_id: str, |
| field: str, |
| value: Any, |
| ) -> tuple[bytes, Image.Image]: |
| if not isinstance(value, dict) or not value.get("bytes"): |
| raise ReleaseError(f"{example_id}: {field} is not embedded") |
| payload = bytes(value["bytes"]) |
| try: |
| with Image.open(io.BytesIO(payload)) as opened: |
| opened.verify() |
| opened = Image.open(io.BytesIO(payload)).convert("L") |
| except OSError as exc: |
| raise ReleaseError(f"{example_id}: invalid {field}") from exc |
| extrema = opened.getextrema() |
| if extrema[0] == extrema[1]: |
| raise ReleaseError(f"{example_id}: blank {field}") |
| return payload, opened |
|
|
|
|
| def _parse_json_field(example_id: str, field: str, value: str) -> Any: |
| try: |
| return json.loads(value) |
| except (TypeError, json.JSONDecodeError) as exc: |
| raise ReleaseError(f"{example_id}: malformed {field}") from exc |
|
|
|
|
| def _validate_row( |
| row: dict[str, Any], |
| *, |
| expected_level: str, |
| expected_order: int, |
| ) -> dict[str, Any]: |
| example_id = str(row.get("id", "")) |
| if not example_id: |
| raise ReleaseError(f"{expected_level}[{expected_order}]: missing id") |
| if SAFE_PUBLIC_ID.fullmatch(example_id) is None: |
| raise ReleaseError(f"{example_id!r}: unsafe public id") |
| row_hits = scan_value_strings(example_id, row) |
| if row_hits: |
| raise ReleaseError("; ".join(row_hits)) |
| if row["schema_version"] != SCHEMA_VERSION: |
| raise ReleaseError(f"{example_id}: schema version drift") |
| if row["level"] != expected_level.upper(): |
| raise ReleaseError(f"{example_id}: wrong level {row['level']}") |
| if row["curriculum_order"] != expected_order: |
| raise ReleaseError(f"{example_id}: non-contiguous curriculum order") |
| if row["code_language"] != "python": |
| raise ReleaseError(f"{example_id}: unsupported code language") |
| lowered_instruction = row["instruction"].lower() |
| for field in ("label", "family"): |
| value = str(row[field]).strip().lower() |
| if value and value in lowered_instruction: |
| raise ReleaseError( |
| f"{example_id}: class metadata leaked into instruction via {field}" |
| ) |
| code = row["code"] |
| try: |
| compile(code, f"{example_id}/ground_truth.py", "exec") |
| except SyntaxError as exc: |
| raise ReleaseError(f"{example_id}: code does not compile: {exc}") from exc |
| violations = purity_violations(code) |
| if violations: |
| raise ReleaseError(f"{example_id}: purity violations: {violations}") |
| forbidden = forbidden_release_imports(code) |
| if forbidden: |
| raise ReleaseError(f"{example_id}: non-standalone imports: {forbidden}") |
| if sha256_bytes(code.encode("utf-8")) != row["code_sha256"]: |
| raise ReleaseError(f"{example_id}: code hash mismatch") |
| for label, text in ( |
| ("code", code), |
| ("instruction", row["instruction"]), |
| ("label", row["label"]), |
| ("family", row["family"]), |
| ("parameters", row["parameters_json"]), |
| ("topology", row["topology_json"]), |
| ("metadata", row["metadata_json"]), |
| ): |
| hits = scan_text(f"{example_id}/{label}", text) |
| if hits: |
| raise ReleaseError("; ".join(hits)) |
| if ( |
| "admission_status" in row["metadata_json"] |
| or "quarantine" in row["metadata_json"].lower() |
| ): |
| raise ReleaseError(f"{example_id}: internal admission state leaked") |
| for field in ( |
| "port_signature_json", |
| "parameters_json", |
| "topology_json", |
| "metadata_json", |
| ): |
| _parse_json_field(example_id, field, row[field]) |
| footprint = row["footprint_um"] |
| if len(footprint) != 2 or any(float(value) <= 0 for value in footprint): |
| raise ReleaseError(f"{example_id}: invalid footprint") |
|
|
| image_bytes, image = _embedded_image(example_id, "image", row["image"]) |
| target_bytes, _ = _embedded_image( |
| example_id, |
| "target_image", |
| row["target_image"], |
| ) |
| if sha256_bytes(image_bytes) != row["image_sha256"]: |
| raise ReleaseError(f"{example_id}: image hash mismatch") |
| if sha256_bytes(target_bytes) != row["target_image_sha256"]: |
| raise ReleaseError(f"{example_id}: target image hash mismatch") |
| d4_hash = normalized_d4_sha256(image) |
| if d4_hash != row["normalized_d4_sha256"]: |
| raise ReleaseError(f"{example_id}: D4 witness mismatch") |
| return { |
| "id": example_id, |
| "level": expected_level, |
| "image_sha256": row["image_sha256"], |
| "normalized_d4_sha256": d4_hash, |
| "leakage_group_id": row["leakage_group_id"], |
| "code": code, |
| "footprint_um": [float(value) for value in footprint], |
| "port_signature": _parse_json_field( |
| example_id, |
| "port_signature_json", |
| row["port_signature_json"], |
| ), |
| "topology": _parse_json_field( |
| example_id, |
| "topology_json", |
| row["topology_json"], |
| ), |
| } |
|
|
|
|
| def _collision_report(rows: list[dict[str, Any]]) -> dict[str, Any]: |
| exact: dict[str, list[str]] = defaultdict(list) |
| d4: dict[str, list[str]] = defaultdict(list) |
| for row in rows: |
| exact[row["image_sha256"]].append(row["id"]) |
| d4[row["normalized_d4_sha256"]].append(row["id"]) |
| return { |
| "exact_duplicate_group_count": sum(len(group) > 1 for group in exact.values()), |
| "exact_duplicate_groups": sorted( |
| sorted(group) for group in exact.values() if len(group) > 1 |
| ), |
| "d4_equivalent_group_count": sum(len(group) > 1 for group in d4.values()), |
| "d4_equivalent_groups": sorted( |
| sorted(group) for group in d4.values() if len(group) > 1 |
| ), |
| } |
|
|
|
|
| def _expected_port_count(signature: Any) -> int | None: |
| if isinstance(signature, dict): |
| count = signature.get("count") |
| if isinstance(count, int): |
| return count |
| return None |
| if not isinstance(signature, str): |
| return None |
| pieces = signature.lower().split("x") |
| if len(pieces) != 2: |
| return 0 if signature.lower() in {"none", "0"} else None |
| try: |
| return int(pieces[0]) + int(pieces[1]) |
| except ValueError: |
| return None |
|
|
|
|
| def _close(left: float, right: float, *, tolerance: float = 0.002) -> bool: |
| return math.isclose(left, right, rel_tol=0.0, abs_tol=tolerance) |
|
|
|
|
| def _orientation_delta(left: float, right: float) -> float: |
| return abs((left - right + 180.0) % 360.0 - 180.0) |
|
|
|
|
| def _runtime_ports( |
| example_id: str, |
| result: dict[str, Any], |
| ) -> list[dict[str, Any]]: |
| ports = result.get("ports") |
| if not isinstance(ports, list): |
| raise ReleaseError(f"{example_id}: execution omitted runtime port records") |
| if result.get("port_count") != len(ports): |
| raise ReleaseError(f"{example_id}: runtime port records/count disagree") |
| normalized: list[dict[str, Any]] = [] |
| for index, port in enumerate(ports): |
| if not isinstance(port, dict): |
| raise ReleaseError(f"{example_id}: runtime port {index} is malformed") |
| center = port.get("center") |
| if ( |
| not isinstance(center, list) |
| or len(center) != 2 |
| or any( |
| not isinstance(value, (int, float)) or not math.isfinite(float(value)) |
| for value in center |
| ) |
| ): |
| raise ReleaseError( |
| f"{example_id}: runtime port {index} has an invalid center" |
| ) |
| width = port.get("width") |
| if ( |
| not isinstance(width, (int, float)) |
| or not math.isfinite(float(width)) |
| or float(width) <= 0 |
| ): |
| raise ReleaseError( |
| f"{example_id}: runtime port {index} has an invalid width" |
| ) |
| orientation = port.get("orientation") |
| if not isinstance(orientation, (int, float)) or not math.isfinite( |
| float(orientation) |
| ): |
| raise ReleaseError( |
| f"{example_id}: runtime port {index} has an invalid orientation" |
| ) |
| name = port.get("name") |
| if not isinstance(name, str) or not name: |
| raise ReleaseError(f"{example_id}: runtime port {index} has no name") |
| normalized.append( |
| { |
| "center": [float(value) for value in center], |
| "name": name, |
| "orientation": float(orientation) % 360.0, |
| "port_type": str(port.get("port_type", "")), |
| "width": float(width), |
| } |
| ) |
| names = [port["name"] for port in normalized] |
| if len(names) != len(set(names)): |
| raise ReleaseError(f"{example_id}: runtime port names are not unique") |
| return normalized |
|
|
|
|
| def _validate_l3_ports( |
| example_id: str, |
| signature: Any, |
| ports: list[dict[str, Any]], |
| ) -> None: |
| if not isinstance(signature, dict) or not isinstance(signature.get("ports"), list): |
| return |
| expected_ports = signature["ports"] |
| expected_by_name = { |
| str(port.get("name")): port |
| for port in expected_ports |
| if isinstance(port, dict) and port.get("name") is not None |
| } |
| if len(expected_by_name) != len(expected_ports): |
| raise ReleaseError(f"{example_id}: malformed declared L3 port records") |
| observed_by_name = {port["name"]: port for port in ports} |
| if set(observed_by_name) != set(expected_by_name): |
| raise ReleaseError( |
| f"{example_id}: runtime L3 port names disagree with declaration" |
| ) |
| declared_names = signature.get("names") |
| if isinstance(declared_names, list) and set(map(str, declared_names)) != set( |
| observed_by_name |
| ): |
| raise ReleaseError(f"{example_id}: declared L3 port name list drifted") |
| for name, expected in expected_by_name.items(): |
| observed = observed_by_name[name] |
| center = expected.get("center") |
| if ( |
| not isinstance(center, list) |
| or len(center) != 2 |
| or any( |
| not isinstance(value, (int, float)) or not math.isfinite(float(value)) |
| for value in center |
| ) |
| ): |
| raise ReleaseError(f"{example_id}: malformed declared L3 port {name}") |
| if any( |
| not _close(observed_value, float(expected_value)) |
| for observed_value, expected_value in zip( |
| observed["center"], |
| center, |
| strict=True, |
| ) |
| ): |
| raise ReleaseError(f"{example_id}: runtime L3 port {name} center drifted") |
| width = expected.get("width") |
| orientation = expected.get("orientation") |
| if not isinstance(width, (int, float)) or not _close( |
| observed["width"], |
| float(width), |
| ): |
| raise ReleaseError(f"{example_id}: runtime L3 port {name} width drifted") |
| if ( |
| not isinstance(orientation, (int, float)) |
| or _orientation_delta( |
| observed["orientation"], |
| float(orientation), |
| ) |
| > 0.01 |
| ): |
| raise ReleaseError( |
| f"{example_id}: runtime L3 port {name} orientation drifted" |
| ) |
|
|
|
|
| def _validate_l4_ports( |
| example_id: str, |
| topology: Any, |
| result: dict[str, Any], |
| ports: list[dict[str, Any]], |
| ) -> None: |
| for index, port in enumerate(ports): |
| for other in ports[index + 1 :]: |
| if ( |
| all( |
| _close(left, right, tolerance=0.001) |
| for left, right in zip( |
| port["center"], |
| other["center"], |
| strict=True, |
| ) |
| ) |
| and _orientation_delta( |
| port["orientation"], |
| other["orientation"], |
| ) |
| <= 1e-6 |
| and _close(port["width"], other["width"], tolerance=0.001) |
| ): |
| raise ReleaseError( |
| f"{example_id}: runtime L4 ports contain a duplicated " |
| "physical terminal" |
| ) |
| if not isinstance(topology, dict): |
| raise ReleaseError(f"{example_id}: malformed L4 topology contract") |
| expected = topology.get("expected_optical_edge_ports") |
| if not isinstance(expected, dict): |
| raise ReleaseError(f"{example_id}: L4 topology lacks edge-port contract") |
| allowed_sides = {"left", "right", "top", "bottom"} |
| if any(side not in allowed_sides for side in expected) or any( |
| not isinstance(count, int) or count < 0 for count in expected.values() |
| ): |
| raise ReleaseError(f"{example_id}: malformed L4 edge-port contract") |
| bbox = result.get("bbox_um") |
| if ( |
| not isinstance(bbox, list) |
| or len(bbox) != 2 |
| or any(not isinstance(point, list) or len(point) != 2 for point in bbox) |
| ): |
| raise ReleaseError(f"{example_id}: execution omitted a valid runtime bbox") |
| xmin, ymin = (float(value) for value in bbox[0]) |
| xmax, ymax = (float(value) for value in bbox[1]) |
| if any(not math.isfinite(value) for value in (xmin, ymin, xmax, ymax)) or not ( |
| xmin < xmax and ymin < ymax |
| ): |
| raise ReleaseError(f"{example_id}: execution emitted an invalid runtime bbox") |
| side_contract = { |
| "left": (0, min, xmin, 1, ymin, ymax, (-1.0, 0.0)), |
| "right": (0, max, xmax, 1, ymin, ymax, (1.0, 0.0)), |
| "top": (1, max, ymax, 0, xmin, xmax, (0.0, 1.0)), |
| "bottom": (1, min, ymin, 0, xmin, xmax, (0.0, -1.0)), |
| } |
| strongest_side_options: list[tuple[str, list[str]]] = [] |
| for port in ports: |
| angle = math.radians(port["orientation"]) |
| direction = (math.cos(angle), math.sin(angle)) |
| tangent = (-direction[1], direction[0]) |
| endpoints = [ |
| [ |
| port["center"][axis] + sign * tangent[axis] * port["width"] / 2 |
| for axis in (0, 1) |
| ] |
| for sign in (-1.0, 1.0) |
| ] |
| matches = [] |
| for side, ( |
| axis, |
| extreme, |
| boundary, |
| span_axis, |
| span_min, |
| span_max, |
| outward_normal, |
| ) in side_contract.items(): |
| outward_component = sum( |
| value * normal |
| for value, normal in zip(direction, outward_normal, strict=True) |
| ) |
| edge_coordinate = extreme(point[axis] for point in endpoints) |
| span_coordinates = [point[span_axis] for point in endpoints] |
| if ( |
| _close(edge_coordinate, boundary) |
| and max(span_coordinates) >= span_min - 0.002 |
| and min(span_coordinates) <= span_max + 0.002 |
| and outward_component > 1e-6 |
| ): |
| matches.append((outward_component, side)) |
| if not matches: |
| raise ReleaseError( |
| f"{example_id}: runtime L4 port {port['name']} has no outward " |
| "terminal cross-section on the component boundary" |
| ) |
| strongest = max(component for component, _side in matches) |
| options = sorted( |
| side |
| for component, side in matches |
| if math.isclose(component, strongest, rel_tol=0.0, abs_tol=1e-9) |
| ) |
| strongest_side_options.append((port["name"], options)) |
|
|
| remaining = {side: int(expected.get(side, 0)) for side in sorted(allowed_sides)} |
|
|
| def assign(index: int) -> bool: |
| if index == len(strongest_side_options): |
| return all(count == 0 for count in remaining.values()) |
| _name, options = strongest_side_options[index] |
| for side in options: |
| if remaining[side] <= 0: |
| continue |
| remaining[side] -= 1 |
| if assign(index + 1): |
| return True |
| remaining[side] += 1 |
| return False |
|
|
| if not assign(0): |
| raise ReleaseError( |
| f"{example_id}: runtime L4 terminal cross-sections cannot satisfy " |
| f"the declared edge-port histogram {dict(expected)}" |
| ) |
|
|
|
|
| def _validate_runtime_port_contract( |
| row: dict[str, Any], |
| result: dict[str, Any], |
| ) -> None: |
| example_id = row["id"] |
| expected_ports = _expected_port_count(row["port_signature"]) |
| if expected_ports is not None and result["port_count"] != expected_ports: |
| raise ReleaseError( |
| f"{example_id}: port count mismatch " |
| f"expected={expected_ports} observed={result['port_count']}" |
| ) |
| ports = _runtime_ports(example_id, result) |
| level = row["level"] |
| if level == "l3": |
| _validate_l3_ports(example_id, row["port_signature"], ports) |
| elif level == "l4": |
| _validate_l4_ports(example_id, row["topology"], result, ports) |
|
|
|
|
| def _execute_one( |
| row: dict[str, Any], |
| workspace: Path, |
| timeout_seconds: float, |
| ) -> dict[str, Any]: |
| example_id = row["id"] |
| task_dir = workspace / example_id |
| task_dir.mkdir(parents=True, exist_ok=False) |
| program_path = task_dir / "ground_truth.py" |
| result_path = task_dir / "result.json" |
| program_path.write_text(row["code"], encoding="utf-8") |
| runner_path = workspace / "_runner.py" |
| environment = dict(os.environ) |
| environment.update( |
| { |
| "MPLCONFIGDIR": str(task_dir / ".mpl"), |
| "XDG_CACHE_HOME": str(task_dir / ".cache"), |
| } |
| ) |
| completed = subprocess.run( |
| [sys.executable, str(runner_path), str(program_path), str(result_path)], |
| cwd=task_dir, |
| env=environment, |
| capture_output=True, |
| text=True, |
| timeout=timeout_seconds, |
| check=False, |
| ) |
| if completed.returncode != 0: |
| tail = (completed.stderr or completed.stdout)[-2000:] |
| raise ReleaseError( |
| f"{example_id}: execution failed ({completed.returncode}): {tail}" |
| ) |
| result = read_json(result_path) |
| if result["gds_bytes"] <= 100 or result["polygon_count"] <= 0: |
| raise ReleaseError(f"{example_id}: execution emitted empty geometry") |
| observed = [float(value) for value in result["bbox_span_um"]] |
| if len(observed) != 2 or any( |
| not math.isfinite(value) or value <= 0 for value in observed |
| ): |
| raise ReleaseError(f"{example_id}: execution emitted an invalid GDS bbox") |
| _validate_runtime_port_contract(row, result) |
| return {"id": example_id, **result} |
|
|
|
|
| def execute_programs( |
| rows: list[dict[str, Any]], |
| *, |
| jobs: int, |
| timeout_seconds: float, |
| ) -> list[dict[str, Any]]: |
| with tempfile.TemporaryDirectory(prefix="pixcell-release-execution-") as raw: |
| workspace = Path(raw) |
| (workspace / "_runner.py").write_text(EXECUTION_RUNNER, encoding="utf-8") |
| with concurrent.futures.ThreadPoolExecutor(max_workers=max(1, jobs)) as pool: |
| futures = { |
| pool.submit(_execute_one, row, workspace, timeout_seconds): row["id"] |
| for row in rows |
| } |
| results: list[dict[str, Any]] = [] |
| for future in concurrent.futures.as_completed(futures): |
| example_id = futures[future] |
| try: |
| results.append(future.result()) |
| except Exception as exc: |
| for pending in futures: |
| pending.cancel() |
| if isinstance(exc, ReleaseError): |
| raise |
| raise ReleaseError(f"{example_id}: execution error: {exc}") from exc |
| return sorted(results, key=lambda item: item["id"]) |
|
|
|
|
| def validate_release( |
| root: Path, |
| *, |
| execute: bool = False, |
| jobs: int = 4, |
| timeout_seconds: float = 90.0, |
| ) -> dict[str, Any]: |
| root = root.expanduser().resolve() |
| verify_checksums(root) |
| for path in iter_release_files(root): |
| if path.suffix.lower() not in { |
| ".cff", |
| ".json", |
| ".md", |
| ".py", |
| ".txt", |
| ".yaml", |
| ".yml", |
| }: |
| continue |
| text = path.read_text(encoding="utf-8") |
| hits = scan_text(path.relative_to(root).as_posix(), text) |
| if hits: |
| raise ReleaseError("; ".join(hits)) |
| if path.suffix == ".py": |
| forbidden = forbidden_release_imports(text) |
| if forbidden: |
| raise ReleaseError( |
| f"{path.relative_to(root)}: forbidden package imports {forbidden}" |
| ) |
| card_path = root / "README.md" |
| card_text = card_path.read_text(encoding="utf-8") |
| if any(mark in card_text for mark in ("—", "–", "·")): |
| raise ReleaseError("dataset card contains decorative dash or separator marks") |
| card = DatasetCard.load(str(card_path)) |
| card_data = card.data.to_dict() |
| if card_data.get("license") != "mit": |
| raise ReleaseError("dataset card must declare the MIT license") |
| expected_card_metadata = { |
| "pretty_name": "PixCell Dataset", |
| "language": ["en", "code"], |
| "annotations_creators": ["expert-generated", "machine-generated"], |
| "source_datasets": ["original"], |
| "task_categories": ["image-text-to-text"], |
| "size_categories": ["1K<n<10K"], |
| "tags": [ |
| "image", |
| "text", |
| "code", |
| "python", |
| "code-generation", |
| "vision-language", |
| "photonics", |
| "gds", |
| "gdsfactory", |
| "image-to-code", |
| "multimodal", |
| "synthetic", |
| "curriculum-learning", |
| "datasets", |
| ], |
| } |
| for field, expected in expected_card_metadata.items(): |
| if card_data.get(field) != expected: |
| raise ReleaseError(f"dataset card metadata drift for {field}") |
| configs = card_data.get("configs") |
| if not isinstance(configs, list): |
| raise ReleaseError("dataset card has no configurations") |
| config_names = [record.get("config_name") for record in configs] |
| if config_names != ["all", "core-v1", *LEVELS, "depth-v1"]: |
| raise ReleaseError(f"dataset card configuration drift: {config_names}") |
| if configs[0].get("default") is not True: |
| raise ReleaseError("dataset card's all configuration is not default") |
| core_paths = [f"data/{level}/train-*.parquet" for level in LEVELS] |
| expected_data_files = { |
| "all": [{"split": "train", "path": core_paths}], |
| "core-v1": [{"split": "train", "path": core_paths}], |
| **{ |
| level: [ |
| { |
| "split": "train", |
| "path": f"data/{level}/train-*.parquet", |
| } |
| ] |
| for level in LEVELS |
| }, |
| "depth-v1": [ |
| {"split": "train", "path": "depth-v1/data/train-*.parquet"}, |
| { |
| "split": "validation", |
| "path": "depth-v1/data/validation-*.parquet", |
| }, |
| ], |
| } |
| for record in configs: |
| name = str(record["config_name"]) |
| if record.get("data_files") != expected_data_files[name]: |
| raise ReleaseError(f"dataset card data_files drift for {name}") |
| expected_dataset_info = [ |
| { |
| "config_name": "all", |
| "splits": [{"name": "train", "num_examples": 738}], |
| }, |
| { |
| "config_name": "core-v1", |
| "splits": [{"name": "train", "num_examples": 738}], |
| }, |
| *[ |
| { |
| "config_name": level, |
| "splits": [ |
| { |
| "name": "train", |
| "num_examples": count, |
| } |
| ], |
| } |
| for level, count in zip(LEVELS, (177, 215, 118, 120, 108), strict=True) |
| ], |
| { |
| "config_name": "depth-v1", |
| "splits": [ |
| {"name": "train", "num_examples": 3468}, |
| {"name": "validation", "num_examples": 1092}, |
| ], |
| }, |
| ] |
| if card_data.get("dataset_info") != expected_dataset_info: |
| raise ReleaseError("dataset card split metadata drift") |
| catalog = read_json(root / "metadata" / "catalog.json") |
| if catalog.get("schema_version") != SCHEMA_VERSION: |
| raise ReleaseError("catalog schema version drift") |
| if catalog.get("accepted_only") is not True: |
| raise ReleaseError("catalog is not accepted-only") |
| if catalog.get("columns") != list(ROW_COLUMNS): |
| raise ReleaseError("catalog columns drifted") |
| if catalog.get("configurations") != ["all", "core-v1", *LEVELS]: |
| raise ReleaseError("catalog configuration drift") |
| freeze = read_json(root / "factory" / "core-v1" / "freeze.json") |
| if freeze.get("core_name") != "core-v1": |
| raise ReleaseError("core-v1 freeze name drift") |
| if freeze.get("release_digest_sha256") != catalog.get("release_digest_sha256"): |
| raise ReleaseError("catalog differs from frozen core-v1 digest") |
| if freeze.get("row_count") != catalog.get("total_rows"): |
| raise ReleaseError("catalog differs from frozen core-v1 row count") |
| source_bundle = freeze.get("source_bundle") |
| if not isinstance(source_bundle, dict): |
| raise ReleaseError("core-v1 freeze has no source bundle") |
| source_archive = root / str(source_bundle.get("path", "")) |
| if not source_archive.is_file(): |
| raise ReleaseError("core-v1 source archive is missing") |
| if sha256_file(source_archive) != source_bundle.get("sha256"): |
| raise ReleaseError("core-v1 source archive digest drift") |
| grammar = freeze.get("grammar_catalog") |
| if not isinstance(grammar, dict): |
| raise ReleaseError("core-v1 freeze has no grammar catalog") |
| grammar_path = root / str(grammar.get("path", "")) |
| if not grammar_path.is_file(): |
| raise ReleaseError("core-v1 grammar catalog is missing") |
| if sha256_file(grammar_path) != grammar.get("sha256"): |
| raise ReleaseError("core-v1 grammar catalog digest drift") |
| grammar_catalog = read_json(grammar_path) |
| if grammar_catalog.get("row_count") != catalog.get( |
| "total_rows" |
| ) or grammar_catalog.get("representation_count") != catalog.get( |
| "total_representation_ids" |
| ): |
| raise ReleaseError("core-v1 grammar catalog count drift") |
| policy = freeze.get("admission_policy") |
| if not isinstance(policy, dict): |
| raise ReleaseError("core-v1 freeze has no admission policy") |
| policy_path = root / str(policy.get("path", "")) |
| if not policy_path.is_file() or sha256_file(policy_path) != policy.get("sha256"): |
| raise ReleaseError("core-v1 admission policy digest drift") |
| reproducibility = freeze.get("reproducibility_report") |
| if not isinstance(reproducibility, dict): |
| raise ReleaseError("core-v1 freeze has no reproducibility report") |
| reproducibility_path = root / str(reproducibility.get("path", "")) |
| if not reproducibility_path.is_file() or sha256_file( |
| reproducibility_path |
| ) != reproducibility.get("sha256"): |
| raise ReleaseError("core-v1 reproducibility report digest drift") |
|
|
| validated: list[dict[str, Any]] = [] |
| digest_records: list[dict[str, Any]] = [] |
| level_counts: dict[str, int] = {} |
| curriculum_order = 0 |
| for level in LEVELS: |
| path = _parquet_path(root, level) |
| table = pq.read_table(path) |
| if table.schema.names != list(ROW_COLUMNS): |
| raise ReleaseError(f"{level}: Parquet column order/schema drift") |
| if b"huggingface" not in (table.schema.metadata or {}): |
| raise ReleaseError(f"{level}: Hugging Face feature metadata is missing") |
| rows = table.to_pylist() |
| digest_records.extend(release_digest_record(row) for row in rows) |
| level_counts[level] = len(rows) |
| expected_count = catalog["levels"][level]["row_count"] |
| if len(rows) != expected_count: |
| raise ReleaseError( |
| f"{level}: row count {len(rows)} != catalog {expected_count}" |
| ) |
| validated.extend( |
| _validate_row( |
| row, |
| expected_level=level, |
| expected_order=curriculum_order + index, |
| ) |
| for index, row in enumerate(rows) |
| ) |
| curriculum_order += len(rows) |
| ids = [row["id"] for row in validated] |
| if len(ids) != len(set(ids)): |
| duplicates = [item for item, count in Counter(ids).items() if count > 1] |
| raise ReleaseError(f"duplicate release IDs: {duplicates}") |
| if len(validated) != catalog["total_rows"]: |
| raise ReleaseError("catalog total row count drift") |
| release_digest = canonical_sha256(digest_records) |
| if release_digest != catalog["release_digest_sha256"]: |
| raise ReleaseError("release digest drift") |
|
|
| recomputed = _collision_report(validated) |
| catalog_collisions = catalog["collision_report"] |
| for key in ( |
| "exact_duplicate_group_count", |
| "exact_duplicate_groups", |
| "d4_equivalent_group_count", |
| "d4_equivalent_groups", |
| ): |
| if recomputed[key] != catalog_collisions[key]: |
| raise ReleaseError(f"collision report drift: {key}") |
| for group in recomputed["exact_duplicate_groups"]: |
| leakage_ids = { |
| row["leakage_group_id"] for row in validated if row["id"] in group |
| } |
| if len(leakage_ids) != 1: |
| raise ReleaseError(f"exact image aliases cross leakage boundaries: {group}") |
|
|
| execution_results: list[dict[str, Any]] = [] |
| if execute: |
| execution_results = execute_programs( |
| validated, |
| jobs=jobs, |
| timeout_seconds=timeout_seconds, |
| ) |
| return { |
| "schema_version": SCHEMA_VERSION, |
| "release_digest_sha256": catalog["release_digest_sha256"], |
| "total_rows": len(validated), |
| "level_counts": level_counts, |
| "compiled_programs": len(validated), |
| "purity_clean_programs": len(validated), |
| "embedded_images": 2 * len(validated), |
| "executed_programs": len(execution_results), |
| "collision_report": recomputed, |
| } |
|
|
|
|
| def _parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--root", |
| type=Path, |
| default=Path(__file__).resolve().parents[1], |
| help="Dataset package root (default: parent of scripts/).", |
| ) |
| parser.add_argument( |
| "--execute-programs", |
| action="store_true", |
| help=( |
| "Execute every program and verify emitted GDS and runtime port contracts." |
| ), |
| ) |
| parser.add_argument("--jobs", type=int, default=min(8, os.cpu_count() or 4)) |
| parser.add_argument("--timeout-seconds", type=float, default=90.0) |
| return parser |
|
|
|
|
| def main() -> None: |
| args = _parser().parse_args() |
| report = validate_release( |
| args.root, |
| execute=args.execute_programs, |
| jobs=args.jobs, |
| timeout_seconds=args.timeout_seconds, |
| ) |
| print(json.dumps(report, indent=2, sort_keys=True)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
