| """Small independent PlotQA reference executor used for certified evaluation. |
| |
| This implementation intentionally does not call :class:`PlotExecutor`. It |
| supports the v1 certified-release contract (a scalar series/x ``LOOKUP``) using |
| a separate iterative code path and trace representation. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from fractions import Fraction |
| from typing import Any |
|
|
| from ..dsl.ast import AstNode, Program, canonical_number_str |
| from ..hashing import canonical_json_hash |
| from ..sources.base import World |
| from .base import ExecutionResult |
|
|
| NAME = "reference_plot_lookup_executor" |
| VERSION = "plotqa_reference_lookup_v1/1" |
|
|
|
|
| class ReferencePlotExecutor: |
| """Independent evaluator for the certified PlotQA lookup subset.""" |
|
|
| name = NAME |
| version = VERSION |
|
|
| def execute(self, program: Program, *, world: World) -> ExecutionResult: |
| steps: list[dict[str, Any]] = [] |
| try: |
| series_id, x_label = _decode_lookup(program.program) |
| except ValueError as exc: |
| return _result("ERROR", None, (), None, [{"error": str(exc)}]) |
|
|
| series_matches = [ |
| s |
| for s in world.get("series", []) |
| if isinstance(s, dict) and str(s.get("id")) == series_id |
| ] |
| steps.append({"op": "series_cardinality", "id": series_id, "count": len(series_matches)}) |
| if len(series_matches) != 1: |
| return _result("INVALID_REFERENT", None, (), len(series_matches), steps) |
|
|
| points = [ |
| p |
| for p in series_matches[0].get("points", []) |
| if isinstance(p, dict) and str(p.get("x")) == x_label |
| ] |
| steps.append( |
| { |
| "op": "x_cardinality", |
| "x": x_label, |
| "ids": sorted(str(p.get("id")) for p in points), |
| } |
| ) |
| if len(points) != 1 or points[0].get("y") in (None, "", "nan"): |
| deps = (series_id, *(str(p.get("id")) for p in points if p.get("id"))) |
| return _result("MISSING_INFORMATION", None, deps, 1, steps) |
| try: |
| value = Fraction(str(points[0]["y"])) |
| except (ValueError, ZeroDivisionError): |
| return _result("ERROR", None, (series_id, str(points[0].get("id"))), 1, steps) |
| steps.append({"op": "value", "value": canonical_number_str(value)}) |
| return _result( |
| "UNIQUE", |
| canonical_number_str(value), |
| (series_id, str(points[0].get("id"))), |
| 1, |
| steps, |
| ) |
|
|
|
|
| def _decode_lookup(node: AstNode) -> tuple[str, str]: |
| if node.op != "LOOKUP" or len(node.args) != 2: |
| raise ValueError("reference executor only supports LOOKUP") |
| series_selector, x_selector = node.args |
| if not isinstance(series_selector, AstNode) or series_selector.op != "SELECT_SERIES": |
| raise ValueError("LOOKUP series operand is not SELECT_SERIES") |
| if not isinstance(x_selector, AstNode) or x_selector.op != "SELECT_X": |
| raise ValueError("LOOKUP x operand is not SELECT_X") |
| series_ref = series_selector.args[0] |
| x_literal = x_selector.args[0] |
| if not isinstance(series_ref, AstNode) or not series_ref.is_ref(): |
| raise ValueError("SELECT_SERIES does not contain a REF") |
| if not isinstance(x_literal, AstNode) or not x_literal.is_literal() or not x_literal.args: |
| raise ValueError("SELECT_X does not contain a literal") |
| return series_ref.ref_id(), str(x_literal.args[0]) |
|
|
|
|
| def _result( |
| status: str, |
| answer: str | None, |
| dependencies: tuple[str, ...], |
| cardinality: int | None, |
| steps: list[dict[str, Any]], |
| ) -> ExecutionResult: |
| return ExecutionResult( |
| status=status, |
| answer_value=Fraction(answer) if status == "UNIQUE" and answer is not None else None, |
| answer_canonical=answer, |
| dependency_node_ids=tuple(sorted(set(dependencies))), |
| referent_cardinality=cardinality, |
| trace_sha256=canonical_json_hash(steps), |
| executor_name=NAME, |
| executor_version=VERSION, |
| ) |
|
|
|
|
| __all__ = ["ReferencePlotExecutor"] |
|
|
