src/explicit_learning/renderers/__init__.py

"""Structured deterministic renderers — registry & dispatch (``docs/02`` §9, P6).

A renderer turns one structured :class:`~explicit_learning.sources.base.World`
into the four byte-addressed P6 assets (``rgba.png``, ``node_map.uint32.png``,
``render_manifest.json``, ``text_manifest.json``) by **drawing fresh from the
world**, never by editing an input raster. Each concrete renderer lives in its
own module with its train/held-out family pairs; this module is the registry.

Status (hand-off note for the next agent): the three renderer modules
(:mod:`plot`, :mod:`geometry`, :mod:`base`) are implemented and gate-clean
(byte-identical replay, node-map coverage, glyph linkage all pass on smoke
worlds), but the ``render`` CLI subcommand is **not yet wired** and there are
**no unit tests** under ``tests/unit/test_renderers.py`` yet — that, plus the
table renderer (optional), is the remaining P6 work. See
``docs/09_RENDER_VALIDATION.md`` for the non-visual verification method.
"""

from __future__ import annotations

from ..sources.base import World
from .base import (
    GlyphRecord,
    RenderedAssets,
    Renderer,
    RendererFamily,
    RendererKind,
    RenderError,
    validate_rendered_assets,
)
from .clevr import CLEVR_FAMILIES, ClevrRenderer
from .clevr_blender import (
    ClevrBlenderConfig,
    ClevrBlenderResult,
    blender_renderer_spec,
    render_clevr_blender_assets,
    render_clevr_blender_rgba,
)
from .geometry import GEOMETRY_FAMILIES, GeometryRenderer
from .node_map import coverage_verdict, decode_uint32_png, index_table, read_owners
from .plot import PLOT_FAMILIES, PlotRenderer
from .text_manifest import link_verdict

#: Train/held-out family registries, keyed by family name (``docs/02`` §9.3).
FAMILIES: dict[str, RendererFamily] = {
    **PLOT_FAMILIES,
    **GEOMETRY_FAMILIES,
    **CLEVR_FAMILIES,
}

#: Concrete renderers, keyed by world kind.
RENDERERS: dict[RendererKind, Renderer] = {
    "plot": PlotRenderer(),
    "geometry": GeometryRenderer(),
    "clevr": ClevrRenderer(),
}


def get_renderer(kind: RendererKind) -> Renderer:
    """The concrete renderer for a world ``kind`` (raises if none)."""
    try:
        return RENDERERS[kind]
    except KeyError:
        raise RenderError(f"no renderer for kind {kind!r}") from None


def family_for(renderer_id: str) -> RendererFamily:
    """Resolve a ``renderer_id`` (a family name) to its :class:`RendererFamily`."""
    try:
        return FAMILIES[renderer_id]
    except KeyError:
        raise RenderError(f"unknown renderer family: {renderer_id!r}") from None


def render(
    world: World,
    *,
    renderer_id: str,
    seed: int,
    width: int,
    height: int,
) -> RenderedAssets:
    """Render ``world`` under family ``renderer_id`` — the common §9.1 entrypoint.

    The world's ``world_schema`` selects the renderer (``plot_world_v1`` → plot,
    ``geometry_world_v1`` → geometry); ``renderer_id`` selects the train/held-out
    family. The two are independent: same world, different family ⇒ disjoint
    assets (gate: "train/held-out assets disjoint").
    """
    schema = world.get("world_schema", "")
    if schema == "plot_world_v1":
        renderer = RENDERERS["plot"]
    elif schema == "geometry_world_v1":
        renderer = RENDERERS["geometry"]
    elif schema == "clevr_world_v1":
        renderer = RENDERERS["clevr"]
    else:
        raise RenderError(f"no renderer for world_schema {schema!r}")
    family = family_for(renderer_id)
    if family.kind != renderer.kind:
        raise RenderError(
            f"renderer family {family.name!r} has kind {family.kind!r}, "
            f"expected {renderer.kind!r} for {schema!r}"
        )
    return renderer.render(
        world,
        renderer_id=renderer_id,
        seed=seed,
        width=width,
        height=height,
        family=family,
    )


__all__ = [
    "FAMILIES",
    "CLEVR_FAMILIES",
    "ClevrRenderer",
    "ClevrBlenderConfig",
    "ClevrBlenderResult",
    "GEOMETRY_FAMILIES",
    "GlyphRecord",
    "PLOT_FAMILIES",
    "RENDERERS",
    "RenderError",
    "RenderedAssets",
    "Renderer",
    "RendererFamily",
    "RendererKind",
    "coverage_verdict",
    "blender_renderer_spec",
    "decode_uint32_png",
    "family_for",
    "get_renderer",
    "index_table",
    "link_verdict",
    "read_owners",
    "render",
    "render_clevr_blender_assets",
    "render_clevr_blender_rgba",
    "validate_rendered_assets",
]