#!/usr/bin/env python3 """Build the loader-free PixCell L0–L4 Hugging Face release. This is a maintainer tool. It consumes the five audited source banks and materializes canonical Parquet files with embedded PNG bytes. Downloaders do not need the source repository or this builder to load the dataset. """ from __future__ import annotations import argparse import io import math import os import shutil import tempfile from collections import Counter, defaultdict from pathlib import Path from typing import Any from datasets import Dataset, Features, Image as HFImage, List as HFList, Value from datasets.utils.logging import disable_progress_bar from PIL import Image from _shared import ( LEVELS, SCHEMA_VERSION, SAFE_PUBLIC_ID, ReleaseError, canonical_json, canonical_sha256, flatten_strings, forbidden_release_imports, no_absolute_path, normalized_d4_sha256, primitive_calls, purity_violations, read_json, scan_text, scan_value_strings, sha256_bytes, top_level_parameters, write_checksums, write_json, ) from render_galleries import render_release_galleries BANK_NAMES = { "l0": "pool_v8_l0_bank", "l1": "pool_v8_l1_bank", "l2": "pool_v8_l2_bank", "l3": "pool_v8_l3_full120", "l4": "pool_v8_l4_core108", } PORT_EDGES = ("left", "right", "bottom", "top") ROW_COLUMNS = ( "schema_version", "id", "level", "curriculum_order", "image", "target_image", "code", "code_language", "instruction", "label", "family", "concept_id", "representation_id", "grammar_id", "leakage_group_id", "variation_role", "primitive_calls", "prerequisite_ids", "port_signature_json", "footprint_um", "parameters_json", "topology_json", "metadata_json", "image_sha256", "target_image_sha256", "code_sha256", "normalized_d4_sha256", "view_policy", "source_dataset_digest_sha256", "source_generator_version", ) NON_DIGEST_PAYLOAD_COLUMNS = frozenset({"image", "target_image", "code"}) L0_PRIMITIVE_PREREQUISITES = { "L": "l0_08_l_shape", "bend_circular": "l0_11_bend_circular", "bend_euler": "l0_10_bend_euler", "bend_s": "l0_12_bend_s", "bezier": "l0_13_bezier", "circle": "l0_02_circle", "coupler_straight": "l0_15_coupler_straight", "cross": "l0_04_cross", "ellipse": "l0_06_ellipse", "rectangle": "l0_01_rectangle", "regular_polygon": "l0_07_regular_polygon", "ring": "l0_03_ring", "straight": "l0_09_straight", "taper": "l0_14_taper", "triangle": "l0_05_triangle", "path.Path": "l0_16_path_polyline", "path.arc": "l0_18_path_arc", "path.euler": "l0_19_path_euler", "path.smooth": "l0_20_path_smooth", "path.spiral_archimedean": "l0_21_path_spiral", "path.straight": "l0_17_path_straight", "path.transition": "l0_22_path_transition", "extrude_transition": "l0_22_path_transition", } DROP_METADATA_KEYS = frozenset( { "admission_status", "manual_visual_approval_status", "proposal_workspace", "artifact_hashes", "path", "model_view_path", "program_path", "selection_path", } ) def release_features() -> Features: return Features( { "schema_version": Value("string"), "id": Value("string"), "level": Value("string"), "curriculum_order": Value("int32"), "image": HFImage(), "target_image": HFImage(), "code": Value("string"), "code_language": Value("string"), "instruction": Value("string"), "label": Value("string"), "family": Value("string"), "concept_id": Value("string"), "representation_id": Value("string"), "grammar_id": Value("string"), "leakage_group_id": Value("string"), "variation_role": Value("string"), "primitive_calls": HFList(Value("string")), "prerequisite_ids": HFList(Value("string")), "port_signature_json": Value("string"), "footprint_um": HFList(Value("float64")), "parameters_json": Value("string"), "topology_json": Value("string"), "metadata_json": Value("string"), "image_sha256": Value("string"), "target_image_sha256": Value("string"), "code_sha256": Value("string"), "normalized_d4_sha256": Value("string"), "view_policy": Value("string"), "source_dataset_digest_sha256": Value("string"), "source_generator_version": Value("string"), } ) def release_digest_record(row: dict[str, Any]) -> dict[str, Any]: """Return the complete logical row, replacing large payloads by hashes.""" return { key: row[key] for key in ROW_COLUMNS if key not in NON_DIGEST_PAYLOAD_COLUMNS } def _safe_generated_root(path: Path) -> Path: resolved = path.expanduser().resolve() forbidden = { Path("/").resolve(), Path.home().resolve(), resolved.parent.resolve(), } if resolved in forbidden or len(resolved.parts) < 4: raise ReleaseError(f"refusing unsafe release output root: {resolved}") return resolved def _resolve_inside(root: Path, relative: str, *, label: str) -> Path: candidate = (root / relative).resolve() try: candidate.relative_to(root.resolve()) except ValueError as exc: raise ReleaseError(f"{label} escapes its source bank: {relative}") from exc if not candidate.is_file(): raise ReleaseError(f"{label} does not exist: {relative}") return candidate def _clean_metadata(value: Any) -> Any: """Strip internal path/status bookkeeping while retaining gate evidence.""" if isinstance(value, dict): cleaned: dict[str, Any] = {} for key, child in value.items(): key_string = str(key) if key_string in DROP_METADATA_KEYS: continue if "quarantine" in key_string.lower() or "admission" in key_string.lower(): continue candidate = _clean_metadata(child) if any(scan_text(key_string, text) for text in flatten_strings(candidate)): continue cleaned[key_string] = candidate return cleaned if isinstance(value, list): return [_clean_metadata(item) for item in value] if isinstance(value, tuple): return [_clean_metadata(item) for item in value] return value def _label(level: str, record: dict[str, Any]) -> str: if record.get("label"): return str(record["label"]) prefix_keys = { "l0": ("concept_label", "mode_label"), "l1": ("operation_label", "mode_label"), "l2": ("composition_label", "mode_label"), "l3": ("identity_label", "mode_label"), "l4": ("identity_label", "mode_label"), } pieces: list[str] = [] for key in prefix_keys[level]: value = record.get(key) if value and str(value) not in pieces: pieces.append(str(value)) return ": ".join(pieces) if pieces else str(record.get("candidate_id", "")) def _family(level: str, record: dict[str, Any]) -> str: return str( record.get("family") or record.get("composition_family") or { "l0": "Primitive catalog", "l1": "Primitive operations", "l2": "Composed operations", "l3": "Hierarchical representations", "l4": "Photonic components", }[level] ) def _concept_id(level: str, record: dict[str, Any]) -> str: for key in ( "concept_id", "operation_id", "composition_id", "identity_id", "motif_id", "card_id", "candidate_id", ): if record.get(key): return str(record[key]) raise ReleaseError(f"{level}: record has no concept identifier") def _prerequisites(record: dict[str, Any]) -> list[str]: values: list[str] = [] for key, raw in record.items(): if key.startswith("prerequisite") or key in { "constituent_motifs", "ordered_operation_graph", }: if isinstance(raw, str): values.append(raw) elif isinstance(raw, list): values.extend(str(item) for item in raw if isinstance(item, str)) return list(dict.fromkeys(values)) def _public_variation_role(record: dict[str, Any]) -> str: role = str(record.get("variation_role") or record.get("public_role") or "semantic") return "semantic" if role == "semantic_base" else role def _sidecar(card_dir: Path, name: str) -> Any | None: path = card_dir / name return read_json(path) if path.is_file() else None def _parameters(card_dir: Path, code: str) -> dict[str, Any]: sidecar = _sidecar(card_dir, "parameters.json") if isinstance(sidecar, dict): selected = { key: sidecar[key] for key in ("parameters", "fixed_context") if key in sidecar } if selected: return selected return top_level_parameters(code) def _topology(record: dict[str, Any], card_dir: Path) -> Any: sidecar = _sidecar(card_dir, "topology_contract.json") if sidecar is not None: return _clean_metadata(sidecar) keys = ( "topology", "port_evidence", "structural_emission_evidence", "terminal_witness_evidence", "analytic_witness_evidence", ) return {key: record[key] for key in keys if key in record} def _l4_edge_counts( example_id: str, label: str, value: Any, ) -> dict[str, int]: if not isinstance(value, dict) or any(key not in PORT_EDGES for key in value): raise ReleaseError(f"{example_id}: malformed {label}") counts: dict[str, int] = {} for edge in PORT_EDGES: count = value.get(edge, 0) if not isinstance(count, int) or isinstance(count, bool) or count < 0: raise ReleaseError(f"{example_id}: malformed {label}") counts[edge] = count return counts def _validate_l4_source_port_evidence( example_id: str, topology: Any, ) -> None: """Reject L4 rows whose port contract was not actually executed.""" if not isinstance(topology, dict): raise ReleaseError(f"{example_id}: L4 topology sidecar is missing") expected = _l4_edge_counts( example_id, "expected optical edge-port counts", topology.get("expected_optical_edge_ports"), ) evidence = topology.get("runtime_port_evidence") if not isinstance(evidence, dict): raise ReleaseError(f"{example_id}: L4 runtime port evidence is missing") if evidence.get("runtime_inspected") is not True: raise ReleaseError(f"{example_id}: L4 ports were not runtime-inspected") if evidence.get("source_admission_bound") is not False: raise ReleaseError( f"{example_id}: L4 port evidence is still source-admission-bound" ) if evidence.get("machine_checks_passed") is not True: raise ReleaseError(f"{example_id}: L4 runtime port gate did not pass") expected_count = evidence.get("expected_count") if ( not isinstance(expected_count, int) or isinstance(expected_count, bool) or expected_count != sum(expected.values()) ): raise ReleaseError(f"{example_id}: L4 runtime port count evidence drifted") evidence_expected = _l4_edge_counts( example_id, "runtime expected edge-port counts", evidence.get("expected_edge_counts"), ) evidence_observed = _l4_edge_counts( example_id, "runtime observed edge-port counts", evidence.get("observed_edge_counts"), ) if evidence_expected != expected or evidence_observed != expected: raise ReleaseError( f"{example_id}: L4 runtime edge-port evidence differs from topology" ) def _row_metadata(record: dict[str, Any], card_dir: Path) -> dict[str, Any]: result: dict[str, Any] = {"source_record": _clean_metadata(record)} for filename, key in ( ("factor_assignment.json", "factor_assignment"), ("candidate_evidence.json", "candidate_evidence"), ("calibration.json", "calibration"), ): value = _sidecar(card_dir, filename) if value is not None: result[key] = _clean_metadata(value) return result def _instruction(card_dir: Path, footprint: list[float]) -> str: calibration = _sidecar(card_dir, "calibration.json") if not isinstance(calibration, dict): raise ReleaseError(f"{card_dir.name}: calibration sidecar is missing") scale = calibration.get("scale_px_per_um") if not isinstance(scale, list) or len(scale) != 2: raise ReleaseError(f"{card_dir.name}: invalid display scale evidence") sx, sy = (float(value) for value in scale) if any(not math.isfinite(value) or value <= 0 for value in (sx, sy)): raise ReleaseError(f"{card_dir.name}: invalid display scale evidence") reference = min(sx, sy) x_magnification = sx / reference y_magnification = sy / reference length_um, width_um = footprint return ( "The image is a device-only black-and-white silhouette: BLACK is " "material on layer (1,0), WHITE is background. " f"Footprint (bounding box): {length_um} x {width_um} micrometers. " "DISPLAY NOTE: the overview is normalized for maximum shape visibility; " "it is not guaranteed to use physical aspect ratio and has no fixed " "absolute pixel scale. Relative overview magnification x:y = " f"{x_magnification:.3f}:{y_magnification:.3f}. Use the silhouette for " "topology and within-axis proportions, then the stated footprint for " "absolute dimensions. Recreate the shown geometry as a primitives-only, " "parametric GDSFactory 9.20.7 Python program using the permitted PixCell " "catalog. Do not use device-level stencils, raw polygons, raster tracing, " "or runtime image reads. Keep function-defining tunables top-level, define " "an @gf.cell device, and write device.gds. Output only the Python program." ) def _image_bytes(path: Path, *, label: str) -> bytes: payload = path.read_bytes() try: with Image.open(io.BytesIO(payload)) as opened: opened.verify() with Image.open(io.BytesIO(payload)) as opened: grayscale = opened.convert("L") extrema = grayscale.getextrema() if extrema[0] == extrema[1]: raise ReleaseError(f"{label} is visually blank: {path.name}") except OSError as exc: raise ReleaseError(f"{label} is not a valid image: {path}") from exc return payload def _record_paths(bank: Path, record: dict[str, Any]) -> tuple[Path, Path, Path, Path]: card_relative = record.get("path") if not isinstance(card_relative, str): raise ReleaseError(f"{record.get('candidate_id')}: missing card path") card_dir = (bank / card_relative).resolve() try: card_dir.relative_to(bank.resolve()) except ValueError as exc: raise ReleaseError(f"card path escapes bank: {card_relative}") from exc if not card_dir.is_dir(): raise ReleaseError(f"missing card directory: {card_relative}") code_path = _resolve_inside( bank, str(record.get("program_path") or f"{card_relative}/ground_truth.py"), label="program", ) image_path = _resolve_inside( bank, str(record.get("model_view_path") or f"{card_relative}/model_view.png"), label="model view", ) target_path = _resolve_inside( bank, f"{card_relative}/device_bw.png", label="target image", ) return card_dir, code_path, image_path, target_path def _build_row( *, level: str, order: int, bank: Path, manifest: dict[str, Any], record: dict[str, Any], ) -> dict[str, Any]: example_id = str( record.get("card_id") or record.get("candidate_id") or record.get("task_id") or "" ) if not example_id: raise ReleaseError(f"{level}[{order}]: missing example id") if SAFE_PUBLIC_ID.fullmatch(example_id) is None: raise ReleaseError(f"{level}[{order}]: unsafe public id: {example_id!r}") if record.get("compiled") is not True: raise ReleaseError(f"{example_id}: source record is not compiled") if record.get("purity_clean") is not True: raise ReleaseError(f"{example_id}: source record is not purity-clean") if "admission_status" in record and record["admission_status"] not in { "accepted", "approved", "manual_visual_approved", }: raise ReleaseError( f"{example_id}: source admission status is not approved: " f"{record['admission_status']}" ) if ( "manual_visual_approval_status" in record and record["manual_visual_approval_status"] != "approved" ): raise ReleaseError(f"{example_id}: manual visual approval is not approved") if any( "quarantine" in str(key).lower() and bool(value) for key, value in record.items() ): raise ReleaseError(f"{example_id}: source record is quarantined") card_dir, code_path, image_path, target_path = _record_paths(bank, record) code = code_path.read_text(encoding="utf-8") try: compile(code, f"{example_id}/ground_truth.py", "exec") except SyntaxError as exc: raise ReleaseError(f"{example_id}: program 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}") text_hits = scan_text(f"{example_id}/code", code) if text_hits: raise ReleaseError("; ".join(text_hits)) image_bytes = _image_bytes(image_path, label=f"{example_id}/image") target_bytes = _image_bytes(target_path, label=f"{example_id}/target_image") with Image.open(io.BytesIO(image_bytes)) as opened: d4_hash = normalized_d4_sha256(opened) source_d4 = record.get("normalized_d4_mask_sha256") if source_d4 and d4_hash != source_d4: raise ReleaseError( f"{example_id}: normalized D4 witness changed ({source_d4} != {d4_hash})" ) grammar_id = str(record.get("grammar_id") or example_id) leakage_group_id = str(record.get("leakage_group_id") or grammar_id) footprint_raw = record.get("footprint_um") if not isinstance(footprint_raw, list): footprint_sidecar = _sidecar(card_dir, "footprint.json") or {} footprint_raw = footprint_sidecar.get("footprint_um", []) footprint = [float(value) for value in footprint_raw] if len(footprint) != 2 or any(value <= 0 for value in footprint): raise ReleaseError(f"{example_id}: invalid footprint {footprint}") metadata = _row_metadata(record, card_dir) parameters = _parameters(card_dir, code) if level == "l4": _validate_l4_source_port_evidence( example_id, _sidecar(card_dir, "topology_contract.json"), ) topology = _topology(record, card_dir) observed_primitives = primitive_calls(code) prerequisites = _prerequisites(record) if level == "l1": prerequisites.extend( L0_PRIMITIVE_PREREQUISITES[primitive] for primitive in observed_primitives if primitive in L0_PRIMITIVE_PREREQUISITES ) prerequisites = list(dict.fromkeys(prerequisites)) for label, value in ( ("metadata", metadata), ("parameters", parameters), ("topology", topology), ): no_absolute_path(value, label=f"{example_id}/{label}") label = _label(level, record) family = _family(level, record) instruction = _instruction(card_dir, footprint) row = { "schema_version": SCHEMA_VERSION, "id": example_id, "level": level.upper(), "curriculum_order": order, "image": {"bytes": image_bytes, "path": f"{example_id}.png"}, "target_image": { "bytes": target_bytes, "path": f"{example_id}.target.png", }, "code": code, "code_language": "python", "instruction": instruction, "label": label, "family": family, "concept_id": _concept_id(level, record), "representation_id": grammar_id, "grammar_id": grammar_id, "leakage_group_id": leakage_group_id, "variation_role": _public_variation_role(record), "primitive_calls": observed_primitives, "prerequisite_ids": prerequisites, "port_signature_json": canonical_json( record.get("port_evidence") or record.get("port_signature") or {} ), "footprint_um": footprint, "parameters_json": canonical_json(parameters), "topology_json": canonical_json(topology), "metadata_json": canonical_json(metadata), "image_sha256": sha256_bytes(image_bytes), "target_image_sha256": sha256_bytes(target_bytes), "code_sha256": sha256_bytes(code.encode("utf-8")), "normalized_d4_sha256": d4_hash, "view_policy": str(record.get("view_policy") or "max_visible_v1"), "source_dataset_digest_sha256": str( manifest.get("dataset_digest_sha256") or "" ), "source_generator_version": str( manifest.get("generator_version") or record.get("generator_version") or "" ), } if tuple(row) != ROW_COLUMNS: raise AssertionError("release row column order drifted") row_hits = scan_value_strings(example_id, row) if row_hits: raise ReleaseError("; ".join(row_hits)) return row def _source_summary( level: str, manifest: dict[str, Any], audit: dict[str, Any], row_count: int, ) -> dict[str, Any]: safe_manifest_keys = ( "schema_version", "level", "status", "dataset_id", "dataset_schema", "dataset_digest_sha256", "generator_source_sha256", "generator_version", "selection_policy", "view_policy", "candidate_count", "public_task_count", "public_card_count", "identity_count", "primitive_count", "operation_count", "composition_count", "semantic_grammar_count", "family_counts", "role_counts", "public_role_counts", "duplicate_telemetry", "duplicate_gate", "lower_level_collision_gate", ) summary = { "level": level.upper(), "exported_row_count": row_count, "manifest": _clean_metadata( {key: manifest[key] for key in safe_manifest_keys if key in manifest} ), "audit": _clean_metadata(audit), } no_absolute_path(summary, label=f"{level}/source_summary") return summary def _extract_level( source_root: Path, output_root: Path, level: str, bank_name: str, ) -> tuple[list[dict[str, Any]], dict[str, Any]]: bank = source_root / "rl" / "tasks" / bank_name manifest_path = bank / "manifest.json" audit_path = bank / "audit_report.json" if not manifest_path.is_file() or not audit_path.is_file(): raise ReleaseError(f"{level}: incomplete source bank at {bank}") manifest = read_json(manifest_path) audit = read_json(audit_path) records = manifest.get("records") if not isinstance(records, list) or not records: raise ReleaseError(f"{level}: manifest has no records") if "accepted_only" not in str(manifest.get("status", "")): raise ReleaseError(f"{level}: source manifest is not accepted-only") if audit.get("accepted_only") is False or manifest.get("accepted_only") is False: raise ReleaseError(f"{level}: source bank contains non-accepted rows") if audit.get("passed") is False: raise ReleaseError(f"{level}: source audit did not pass") if audit.get("dataset_digest_sha256") != manifest.get("dataset_digest_sha256"): raise ReleaseError(f"{level}: source manifest/audit digest mismatch") for key in ( "all_tasks_compiled", "all_tasks_pure", "all_tasks_conductor_verified", "all_views_deterministic", ): if key in manifest and manifest[key] is not True: raise ReleaseError(f"{level}: source gate is false: {key}") for key in ( "compiled", "purity_clean", "conductor_reexecuted", "exact_views_verified", "reexecuted_card_count", ): if key in audit and audit[key] != len(records): raise ReleaseError( f"{level}: source audit count {key}={audit[key]} " f"does not match {len(records)} rows" ) rows = [ _build_row( level=level, order=order, bank=bank, manifest=manifest, record=record, ) for order, record in enumerate(records) ] ids = [row["id"] for row in rows] if len(ids) != len(set(ids)): duplicates = [item for item, count in Counter(ids).items() if count > 1] raise ReleaseError(f"{level}: duplicate ids: {duplicates}") source_summary = _source_summary(level, manifest, audit, len(rows)) write_json( output_root / "metadata" / "source_reports" / f"{level}.json", source_summary, ) return rows, source_summary def _normalize_leakage_groups(rows: list[dict[str, Any]]) -> None: """Close source leakage groups over exact image aliases. Some deliberately retained L0 cross-API aliases have different source grammar IDs despite identical rasters. A public split boundary must keep those aliases together. """ parent = list(range(len(rows))) def find(index: int) -> int: while parent[index] != index: parent[index] = parent[parent[index]] index = parent[index] return index def union(left: int, right: int) -> None: left_root = find(left) right_root = find(right) if left_root != right_root: parent[max(left_root, right_root)] = min(left_root, right_root) by_source_group: dict[str, int] = {} by_exact_image: dict[str, int] = {} for index, row in enumerate(rows): for mapping, key in ( (by_source_group, row["leakage_group_id"]), (by_exact_image, row["image_sha256"]), ): previous = mapping.setdefault(key, index) union(index, previous) groups: dict[int, list[int]] = defaultdict(list) for index in range(len(rows)): groups[find(index)].append(index) for members in groups.values(): ids = sorted(rows[index]["id"] for index in members) public_id = f"lg_{canonical_sha256(ids)[:20]}" for index in members: rows[index]["leakage_group_id"] = public_id def _write_parquet(output_root: Path, level: str, rows: list[dict[str, Any]]) -> None: dataset = Dataset.from_list(rows, features=release_features()) shard = output_root / "data" / level / "train-00000-of-00001.parquet" shard.parent.mkdir(parents=True, exist_ok=True) dataset.to_parquet( str(shard), batch_size=100, ) def _collision_report(rows: list[dict[str, Any]]) -> dict[str, Any]: exact_groups: dict[str, list[str]] = defaultdict(list) d4_groups: dict[str, list[str]] = defaultdict(list) for row in rows: exact_groups[row["image_sha256"]].append(row["id"]) d4_groups[row["normalized_d4_sha256"]].append(row["id"]) exact = sorted(sorted(group) for group in exact_groups.values() if len(group) > 1) d4 = sorted(sorted(group) for group in d4_groups.values() if len(group) > 1) return { "exact_duplicate_group_count": len(exact), "exact_duplicate_groups": exact, "d4_equivalent_group_count": len(d4), "d4_equivalent_groups": d4, "policy": ( "Exact and D4-equivalent groups are reported rather than silently " "removed; leakage_group_id is the split boundary. L0 retains " "explicitly declared cross-API aliases and pose/calibration examples." ), } def _promote_generated_release(stage_root: Path, output_root: Path) -> None: """Replace generated directories transactionally, restoring on failure.""" generated_names = ("data", "metadata", "galleries") for name in generated_names: if not (stage_root / name).is_dir(): raise ReleaseError(f"staged release is missing {name}/") backup_root = Path( tempfile.mkdtemp( prefix=f".{output_root.name}.backup.", dir=output_root.parent, ) ) moved_old: list[str] = [] moved_new: list[str] = [] try: for name in generated_names: destination = output_root / name if destination.exists(): if not destination.is_dir(): raise ReleaseError( f"generated destination is not a directory: {destination}" ) os.replace(destination, backup_root / name) moved_old.append(name) for name in generated_names: os.replace(stage_root / name, output_root / name) moved_new.append(name) write_checksums(output_root) except Exception: for name in reversed(moved_new): destination = output_root / name if destination.is_dir(): shutil.rmtree(destination) for name in reversed(moved_old): os.replace(backup_root / name, output_root / name) raise finally: shutil.rmtree(backup_root, ignore_errors=True) def build_release( source_root: Path, output_root: Path, *, bank_names: dict[str, str] | None = None, expected_release_digest: str | None = None, expected_row_count: int | None = None, ) -> dict[str, Any]: source_root = source_root.expanduser().resolve() output_root = _safe_generated_root(output_root) names = {**BANK_NAMES, **(bank_names or {})} if not (source_root / "rl" / "tasks").is_dir(): raise ReleaseError(f"source root has no rl/tasks: {source_root}") output_root.mkdir(parents=True, exist_ok=True) stage_root = Path( tempfile.mkdtemp( prefix=f".{output_root.name}.stage.", dir=output_root.parent, ) ) try: disable_progress_bar() all_rows: list[dict[str, Any]] = [] rows_by_level: dict[str, list[dict[str, Any]]] = {} level_summaries: dict[str, Any] = {} for level in LEVELS: rows, source_summary = _extract_level( source_root, stage_root, level, names[level], ) all_rows.extend(rows) rows_by_level[level] = rows level_summaries[level] = { "row_count": len(rows), "family_counts": dict( sorted(Counter(row["family"] for row in rows).items()) ), "variation_role_counts": dict( sorted(Counter(row["variation_role"] for row in rows).items()) ), "source_dataset_digest_sha256": rows[0]["source_dataset_digest_sha256"], "source_generator_version": rows[0]["source_generator_version"], "source_report_sha256": canonical_sha256(source_summary), } all_ids = [row["id"] for row in all_rows] if len(all_ids) != len(set(all_ids)): raise ReleaseError("example ids collide across curriculum levels") for curriculum_order, row in enumerate(all_rows): row["curriculum_order"] = curriculum_order _normalize_leakage_groups(all_rows) for level in LEVELS: _write_parquet(stage_root, level, rows_by_level[level]) collision_report = _collision_report(all_rows) release_digest_records = [release_digest_record(row) for row in all_rows] release_digest = canonical_sha256(release_digest_records) catalog = { "schema_version": SCHEMA_VERSION, "release_digest_sha256": release_digest, "accepted_only": True, "canonical_format": "Parquet with embedded PNG bytes", "columns": list(ROW_COLUMNS), "configurations": ["all", "core-v1", *LEVELS], "levels": level_summaries, "total_rows": len(all_rows), "total_representation_ids": len( {row["representation_id"] for row in all_rows} ), "collision_report": collision_report, } write_json(stage_root / "metadata" / "catalog.json", catalog) gallery_records = render_release_galleries(stage_root) audit = { "schema_version": SCHEMA_VERSION, "release_digest_sha256": release_digest, "accepted_only": True, "level_count": len(LEVELS), "row_count": len(all_rows), "unique_id_count": len(set(all_ids)), "compiled_program_count": len(all_rows), "purity_clean_program_count": len(all_rows), "embedded_model_image_count": len(all_rows), "embedded_target_image_count": len(all_rows), "source_d4_witness_match_count": len(all_rows), "absolute_path_or_secret_hits": [], "collision_report": collision_report, "galleries": gallery_records, "gates": { "all_rows_from_accepted_source_records": True, "all_programs_compile": True, "all_programs_pass_purity": True, "all_images_decode_and_are_nonblank": True, "all_images_are_embedded": True, "all_source_d4_witnesses_match": True, "all_paths_are_release_relative": True, }, } write_json(stage_root / "metadata" / "audit_report.json", audit) if ( expected_release_digest is not None and release_digest != expected_release_digest ): raise ReleaseError( "staged release digest differs from the required freeze: " f"{release_digest} != {expected_release_digest}" ) if expected_row_count is not None and len(all_rows) != expected_row_count: raise ReleaseError( "staged release row count differs from the required freeze: " f"{len(all_rows)} != {expected_row_count}" ) _promote_generated_release(stage_root, output_root) return catalog finally: shutil.rmtree(stage_root, ignore_errors=True) def _parse_bank_override(values: list[str]) -> dict[str, str]: overrides: dict[str, str] = {} for value in values: if "=" not in value: raise ReleaseError(f"bank override must be LEVEL=NAME: {value}") level, name = value.split("=", 1) level = level.lower() if level not in LEVELS or not name or "/" in name: raise ReleaseError(f"invalid bank override: {value}") overrides[level] = name return overrides def _parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "--source", type=Path, required=True, help="PixCell working tree containing audited rl/tasks banks.", ) parser.add_argument( "--output", type=Path, default=Path(__file__).resolve().parents[1], help="Release package root (default: parent of scripts/).", ) parser.add_argument( "--bank", action="append", default=[], metavar="LEVEL=NAME", help="Override one source bank directory name.", ) return parser def main() -> None: args = _parser().parse_args() catalog = build_release( args.source, args.output, bank_names=_parse_bank_override(args.bank), ) print( f"built {catalog['total_rows']} rows; " f"release digest {catalog['release_digest_sha256']}" ) if __name__ == "__main__": main()