"""``plotqa_dsl_v1`` operator table + dataset-level PlotQA program compiler (``docs/02`` §5.2, ``docs/07`` §4 P2). The compiler is **dataset-level** (per-template, not per-example): each allowlisted PlotQA template maps to a fixed typed-AST shape built in code from the QA's slot metadata. No per-example human labeling, no execution, no model calls — those are P3/P4. The ``TEMPLATE_DSL_MAPPING`` strings in :mod:`~explicit_learning.sources.plotqa` are the human-readable reference for the same shapes built here as typed :class:`~explicit_learning.dsl.ast.AstNode` trees. Slot extraction reads ``item.provenance["slots"]`` (the QA's ``series`` / ``x`` / ``x1`` / ``x2`` slots, carried through ``normalize``). The series label is resolved to its stable world id (``series:0``) so the program carries a real entity ``REF``; the x value is a literal string (x-axis values are not tracked entities). An unresolvable slot yields ``compile_status="unsupported"`` with a ``reason_code`` — never a guessed program (``docs/02`` §5.2, runbook: no faked ``compiled``). """ from __future__ import annotations from dataclasses import replace from typing import Any from ..ingest.base import NormalizedItem from ..sources.base import World from .ast import AstNode, Dsl, Program, lit, ref from .canonicalize import canonical_program_sha256 from .typecheck import OpSignature, typecheck DSL: Dsl = "plotqa_dsl_v1" # --- operator signature table (§5.2) --------------------------------------- # # ``selector_kind``: "scalar" (exactly one referent), "set" (zero or more, so a # zero-cardinality referent is NOT invalid — §11.3), or "none" (a value). # ``LOOKUP``/``SUBTRACT`` are order-significant; ``SUM`` is variadic-commutative. SIGNATURES: dict[str, OpSignature] = { "SELECT_SERIES": OpSignature( arg_types=("series",), return_type="series", selector_kind="scalar" ), "SELECT_X": OpSignature(arg_types=("string",), return_type="x", selector_kind="scalar"), "LOOKUP": OpSignature(arg_types=("series", "x"), return_type="value", selector_kind="none"), "POINTS": OpSignature(arg_types=("series",), return_type="points", selector_kind="set"), "ARGMAX": OpSignature( arg_types=("points", "string"), return_type="point", selector_kind="scalar" ), "ARGMIN": OpSignature( arg_types=("points", "string"), return_type="point", selector_kind="scalar" ), "SUBTRACT": OpSignature( arg_types=("value", "value"), return_type="value", selector_kind="none" ), "SUM": OpSignature( arg_types=("any",), return_type="value", commutative=True, variadic=True, selector_kind="none", ), "COUNT": OpSignature(arg_types=("points",), return_type="integer", selector_kind="set"), "EXIST": OpSignature(arg_types=("points",), return_type="boolean", selector_kind="set"), } # Canonicalization profile (§7.2 steps 3–5). COMMUTATIVE_OPS: frozenset[str] = frozenset({"SUM"}) ALIASES: dict[str, str] = {"GET_VALUE": "LOOKUP", "MAX": "ARGMAX", "MIN": "ARGMIN"} IDENTITY_CASTS: frozenset[str] = frozenset({"TO_VALUE"}) _UNSUPPORTED_NODE = AstNode(op="UNSUPPORTED", args=(), return_type="") # --- compile --------------------------------------------------------------- def compile_plotqa(item: NormalizedItem, world: World) -> Program: """Build the typed ``plotqa_dsl_v1`` program for one normalized PlotQA item. Returns a :class:`Program` with ``compile_status="compiled"`` (type-checked, canonical hash filled) or ``"unsupported"`` (with a ``reason_code``) when a slot is missing/unresolvable. Never guesses a program. """ prov = item.provenance template = prov.get("template") slots = prov.get("slots") or {} series_id = _series_id_for_label(world, slots.get("series")) if template == "T_LOOKUP": x = slots.get("x") if series_id is None or x is None: return _unsupported(item, "t_lookup_missing_series_or_x") program = _lookup(series_id, str(x)) referent = _select_series(series_id) elif template == "T_DIFFERENCE": x1, x2 = slots.get("x1"), slots.get("x2") if series_id is None or x1 is None or x2 is None: return _unsupported(item, "t_difference_missing_slots") program = AstNode( op="SUBTRACT", args=(_lookup(series_id, str(x1)), _lookup(series_id, str(x2))), return_type="value", ) referent = _select_series(series_id) elif template in ("T_MAX_YEAR", "T_MIN_YEAR"): if series_id is None: return _unsupported(item, f"{template.lower()}_missing_series") op = "ARGMAX" if template == "T_MAX_YEAR" else "ARGMIN" program = AstNode(op=op, args=(_points(series_id), "value"), return_type="point") referent = _select_series(series_id) elif template == "T_SUM": if series_id is None: return _unsupported(item, "t_sum_missing_series") program = AstNode(op="SUM", args=(_points(series_id),), return_type="value") referent = _select_series(series_id) else: return _unsupported(item, f"template_{template}_not_compilable") program_node = typecheck( Program( dsl=DSL, program=program, base_id=item.base_id, question_sha256=item.question_sha256, choices_sha256=item.choices_sha256, compile_status="compiled", referent_selector=referent, required_referent_cardinality=1, ), world=world, ) return replace( program_node, canonical_program_sha256=canonical_program_sha256(program_node, world=world) ) # --- AST builders ---------------------------------------------------------- def _select_series(series_id: str) -> AstNode: return AstNode( op="SELECT_SERIES", args=(ref(series_id, return_type="series"),), return_type="series" ) def _select_x(x_label: str) -> AstNode: return AstNode(op="SELECT_X", args=(lit(x_label, return_type="string"),), return_type="x") def _lookup(series_id: str, x_label: str) -> AstNode: return AstNode( op="LOOKUP", args=(_select_series(series_id), _select_x(x_label)), return_type="value" ) def _points(series_id: str) -> AstNode: return AstNode(op="POINTS", args=(_select_series(series_id),), return_type="points") def _unsupported(item: NormalizedItem, reason: str) -> Program: return Program( dsl=DSL, program=_UNSUPPORTED_NODE, base_id=item.base_id, question_sha256=item.question_sha256, choices_sha256=item.choices_sha256, compile_status="unsupported", reason_code=reason, ) # --- world helpers --------------------------------------------------------- def _series_id_for_label(world: World, label: Any) -> str | None: """Resolve a series label to its stable world id (``series:0``); None if absent.""" if not isinstance(label, str) or not label: return None for series in world.get("series", []) or []: if isinstance(series, dict) and series.get("label") == label and series.get("id"): return str(series["id"]) return None __all__ = [ "ALIASES", "COMMUTATIVE_OPS", "DSL", "IDENTITY_CASTS", "SIGNATURES", "compile_plotqa", ]