scripts/render_galleries.py

#!/usr/bin/env python3
"""Render deterministic contact sheets from the canonical Parquet release.

The sheets show the exact ``image`` field presented to a model.  They do not
re-render GDS, so this command works from a downloaded Hugging Face snapshot
without the geometry toolchain.
"""

from __future__ import annotations

import argparse
import io
import math
from dataclasses import dataclass
from pathlib import Path
from typing import Any

import pyarrow.parquet as pq
from PIL import Image, ImageDraw, ImageFont, ImageOps

from _shared import LEVELS, ReleaseError


BACKGROUND = "#f4f5f7"
CARD = "#ffffff"
BORDER = "#c8ccd2"
TEXT = "#111318"
MUTED = "#5c6470"
TILE_WIDTH = 360
TILE_HEIGHT = 260
IMAGE_BOX = (320, 178)
GAP = 14
OUTER = 22
HEADER_HEIGHT = 70


@dataclass(frozen=True)
class GalleryRow:
    example_id: str
    label: str
    level: str
    image_bytes: bytes


def _font(size: int, *, bold: bool = False) -> ImageFont.ImageFont:
    """Use Pillow's bundled font so output does not depend on the host OS."""

    try:
        return ImageFont.load_default(size=size)
    except TypeError:  # Pillow < 10 compatibility.
        return ImageFont.load_default()


def _read_rows(parquet_path: Path) -> list[GalleryRow]:
    if not parquet_path.is_file():
        raise ReleaseError(f"missing Parquet shard: {parquet_path}")
    table = pq.read_table(
        parquet_path,
        columns=["id", "label", "level", "image"],
    )
    rows: list[GalleryRow] = []
    for raw in table.to_pylist():
        image_value = raw["image"]
        payload = image_value.get("bytes") if isinstance(image_value, dict) else None
        if not payload:
            raise ReleaseError(f"{raw['id']}: image bytes are not embedded")
        rows.append(
            GalleryRow(
                example_id=str(raw["id"]),
                label=str(raw["label"]),
                level=str(raw["level"]),
                image_bytes=bytes(payload),
            )
        )
    return rows


def _fit_image(payload: bytes) -> Image.Image:
    with Image.open(io.BytesIO(payload)) as opened:
        image = opened.convert("RGB")
    image = ImageOps.contain(image, IMAGE_BOX, Image.Resampling.LANCZOS)
    canvas = Image.new("RGB", IMAGE_BOX, "white")
    x = (IMAGE_BOX[0] - image.width) // 2
    y = (IMAGE_BOX[1] - image.height) // 2
    canvas.paste(image, (x, y))
    return canvas


def _ellipsize(
    draw: ImageDraw.ImageDraw,
    text: str,
    font: ImageFont.ImageFont,
    width: int,
) -> str:
    if draw.textbbox((0, 0), text, font=font)[2] <= width:
        return text
    suffix = "..."
    candidate = text
    while candidate and draw.textbbox((0, 0), candidate + suffix, font=font)[2] > width:
        candidate = candidate[:-1]
    return candidate.rstrip() + suffix


def render_gallery(
    rows: list[GalleryRow],
    output_path: Path,
    *,
    title: str,
    columns: int = 6,
) -> None:
    if not rows:
        raise ReleaseError(f"cannot render empty gallery: {title}")
    columns = max(1, columns)
    row_count = math.ceil(len(rows) / columns)
    width = 2 * OUTER + columns * TILE_WIDTH + (columns - 1) * GAP
    height = (
        2 * OUTER
        + HEADER_HEIGHT
        + row_count * TILE_HEIGHT
        + max(0, row_count - 1) * GAP
    )
    sheet = Image.new("RGB", (width, height), BACKGROUND)
    draw = ImageDraw.Draw(sheet)
    title_font = _font(25, bold=True)
    body_font = _font(14)
    small_font = _font(12)
    draw.text((OUTER, OUTER), title, fill=TEXT, font=title_font)
    draw.text(
        (OUTER, OUTER + 36),
        f"{len(rows)} accepted image-program examples · exact model input view",
        fill=MUTED,
        font=body_font,
    )

    y_origin = OUTER + HEADER_HEIGHT
    for index, row in enumerate(rows):
        grid_y, grid_x = divmod(index, columns)
        x0 = OUTER + grid_x * (TILE_WIDTH + GAP)
        y0 = y_origin + grid_y * (TILE_HEIGHT + GAP)
        x1 = x0 + TILE_WIDTH
        y1 = y0 + TILE_HEIGHT
        draw.rounded_rectangle(
            (x0, y0, x1, y1),
            radius=8,
            fill=CARD,
            outline=BORDER,
            width=1,
        )
        fitted = _fit_image(row.image_bytes)
        image_x = x0 + (TILE_WIDTH - IMAGE_BOX[0]) // 2
        image_y = y0 + 12
        sheet.paste(fitted, (image_x, image_y))
        draw.rectangle(
            (
                image_x,
                image_y,
                image_x + IMAGE_BOX[0],
                image_y + IMAGE_BOX[1],
            ),
            outline="#e1e3e7",
            width=1,
        )
        label = _ellipsize(draw, row.label, body_font, TILE_WIDTH - 28)
        identifier = _ellipsize(
            draw,
            row.example_id,
            small_font,
            TILE_WIDTH - 28,
        )
        draw.text(
            (x0 + 14, image_y + IMAGE_BOX[1] + 13), label, fill=TEXT, font=body_font
        )
        draw.text(
            (x0 + 14, image_y + IMAGE_BOX[1] + 38),
            identifier,
            fill=MUTED,
            font=small_font,
        )

    output_path.parent.mkdir(parents=True, exist_ok=True)
    sheet.save(output_path, format="PNG", compress_level=6, optimize=False)


def _level_parquet(root: Path, level: str) -> Path:
    matches = sorted((root / "data" / level).glob("train-*.parquet"))
    if len(matches) != 1:
        raise ReleaseError(f"expected one shard for {level}, found {len(matches)}")
    return matches[0]


def render_release_galleries(root: Path, *, columns: int = 6) -> dict[str, Any]:
    root = root.resolve()
    gallery_dir = root / "galleries"
    gallery_dir.mkdir(parents=True, exist_ok=True)
    all_rows: list[GalleryRow] = []
    outputs: dict[str, Any] = {}
    for level in LEVELS:
        rows = _read_rows(_level_parquet(root, level))
        output = gallery_dir / f"{level}.png"
        render_gallery(
            rows,
            output,
            title=f"PixCell curriculum {level.upper()}",
            columns=columns,
        )
        outputs[level] = {
            "path": output.relative_to(root).as_posix(),
            "rows": len(rows),
            "size_px": list(Image.open(output).size),
        }
        all_rows.extend(rows)
    combined = gallery_dir / "all.png"
    render_gallery(
        all_rows,
        combined,
        title="PixCell representation-first image-to-code curriculum · L0–L4",
        columns=max(8, columns),
    )
    outputs["all"] = {
        "path": combined.relative_to(root).as_posix(),
        "rows": len(all_rows),
        "size_px": list(Image.open(combined).size),
    }
    return outputs


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("--columns", type=int, default=6)
    return parser


def main() -> None:
    args = _parser().parse_args()
    outputs = render_release_galleries(args.root, columns=args.columns)
    for name, record in outputs.items():
        print(f"{name}: {record['rows']} rows -> {record['path']}")


if __name__ == "__main__":
    main()