"""Question-first v2 runner and role-aware score aggregation.""" from __future__ import annotations from dataclasses import dataclass from typing import Callable, Mapping, Sequence from pvr_eval.question_eval.dag import EvidenceDagExecutor, ExecutionContext, NodeAdapter from pvr_eval.question_eval.predicates import answer_deterministically from pvr_eval.question_eval.schema import AnswerRecord, EvidencePacket, EvalProcedure VlmAnswerer = Callable[[EvalProcedure, EvidencePacket, ExecutionContext], AnswerRecord] class QuestionEvalRunner: def __init__(self, adapters: Mapping[str, NodeAdapter], *, vlm_answerer: VlmAnswerer | None = None) -> None: self.executor = EvidenceDagExecutor(adapters) self.vlm_answerer = vlm_answerer def collect_evidence(self, procedure: EvalProcedure, context: ExecutionContext) -> EvidencePacket: if context.case_id != procedure.rubric.case_id or context.check_id != procedure.rubric.check_id: raise ValueError("execution context does not match question spec") results = self.executor.execute(procedure, context) required = {node.node_id for node in procedure.nodes if node.required} failed = [result for result in results if result.node_id in required and result.status != "success"] facts = {} artifacts = [] for result in results: if result.node_id == "derive_facts": facts.update(result.facts) artifacts.extend(result.artifacts) if not facts: for result in results: facts.update(result.facts) reasons = tuple( f"{result.node_id}:{result.status}:{'|'.join(result.limitations)}" for result in failed ) status = "success" if procedure.nodes and not failed else "insufficient" return EvidencePacket( case_id=context.case_id, check_id=context.check_id, procedure_hash=procedure.procedure_hash, nodes=results, derived_facts=facts, visual_artifacts=tuple(artifacts), status=status, reasons=reasons or (() if status == "success" else ("procedure_has_no_executable_evidence_nodes",)), ) def answer(self, procedure: EvalProcedure, packet: EvidencePacket, context: ExecutionContext) -> AnswerRecord: deterministic = answer_deterministically(procedure, packet) if deterministic.formal_eligible: return deterministic may_use_vlm = procedure.answer_mode in {"vlm_required", "deterministic_or_vlm"} if not may_use_vlm or self.vlm_answerer is None: return deterministic answer = self.vlm_answerer(procedure, packet, context) if packet.successful_call_ids and not (set(answer.cited_call_ids) & set(packet.successful_call_ids)): raise ValueError("VLM answer does not cite any successful evidence call from its packet") return answer def run(self, procedure: EvalProcedure, context: ExecutionContext) -> tuple[EvidencePacket, AnswerRecord]: packet = self.collect_evidence(procedure, context) return packet, self.answer(procedure, packet, context) def run_case( self, procedures: Sequence[EvalProcedure], contexts: Sequence[ExecutionContext] ) -> tuple[list[EvidencePacket], list[AnswerRecord]]: """Run a case, batching unresolved questions into one VLM request.""" if len(procedures) != len(contexts): raise ValueError("procedures and contexts must have equal length") packets = [self.collect_evidence(procedure, context) for procedure, context in zip(procedures, contexts)] answers: list[AnswerRecord | None] = [None] * len(procedures) unresolved: list[tuple[EvalProcedure, EvidencePacket, ExecutionContext]] = [] unresolved_indices: list[int] = [] for index, (procedure, packet, context) in enumerate(zip(procedures, packets, contexts)): deterministic = answer_deterministically(procedure, packet) if deterministic.formal_eligible or procedure.answer_mode not in {"vlm_required", "deterministic_or_vlm"}: answers[index] = deterministic else: unresolved.append((procedure, packet, context)) unresolved_indices.append(index) if unresolved and self.vlm_answerer is not None and hasattr(self.vlm_answerer, "answer_case"): batch_answers = self.vlm_answerer.answer_case(unresolved) # type: ignore[attr-defined] if len(batch_answers) != len(unresolved): raise ValueError("batch VLM answer count does not match unresolved question count") for index, answer in zip(unresolved_indices, batch_answers): answers[index] = answer else: for index in unresolved_indices: procedure, packet, context = procedures[index], packets[index], contexts[index] answers[index] = self.answer(procedure, packet, context) return packets, [answer for answer in answers if answer is not None] @dataclass(frozen=True) class ScoreSummary: reward_earned: float reward_possible: float penalty_deducted: float penalty_possible: float overall: float provisional_overall: float formal_eligible: bool unresolved: tuple[str, ...] manual_excluded: tuple[str, ...] def aggregate_answers(procedures: Sequence[EvalProcedure], answers: Sequence[AnswerRecord]) -> ScoreSummary: """Aggregate positive-satisfaction answers without reversing penalties early.""" by_key = {(answer.case_id, answer.check_id): answer for answer in answers} reward_earned = reward_possible = penalty_deducted = penalty_possible = 0.0 unresolved: list[str] = [] manual_excluded: list[str] = [] for procedure in procedures: rubric = procedure.rubric if procedure.compile_status == "manual_required" or procedure.answer_mode == "manual_only": manual_excluded.append(rubric.check_id) continue if rubric.role == "reward": reward_possible += rubric.weight else: penalty_possible += rubric.weight answer = by_key.get((rubric.case_id, rubric.check_id)) if answer is None or not answer.formal_eligible: unresolved.append(rubric.check_id) continue if rubric.role == "reward": reward_earned += rubric.weight * answer.score else: penalty_deducted += rubric.weight * (1.0 - answer.score) reward_score = reward_earned / reward_possible if reward_possible > 0 else 0.0 provisional = max(0.0, min(1.0, reward_score - penalty_deducted)) formal_eligible = not unresolved overall = provisional if formal_eligible else 0.0 return ScoreSummary( reward_earned, reward_possible, penalty_deducted, penalty_possible, overall, provisional, formal_eligible, tuple(unresolved), tuple(manual_excluded), )