"""Dependency-enforcing evidence DAG execution.""" from __future__ import annotations from collections import deque from dataclasses import dataclass, field from typing import Any, Callable, Mapping from pvr_eval.question_eval.schema import EvidenceNodeResult, EvidenceNodeSpec, EvalProcedure @dataclass class ExecutionContext: case_id: str check_id: str input_image: str = "" pred_image: str = "" gt_image: str = "" work_dir: str = "" evidence_case_id: str = "" resources: dict[str, Any] = field(default_factory=dict) NodeAdapter = Callable[[EvidenceNodeSpec, ExecutionContext, Mapping[str, EvidenceNodeResult]], EvidenceNodeResult] def topological_order(nodes: tuple[EvidenceNodeSpec, ...]) -> tuple[EvidenceNodeSpec, ...]: by_id = {node.node_id: node for node in nodes} incoming = {node.node_id: set(node.depends_on) for node in nodes} children: dict[str, set[str]] = {node.node_id: set() for node in nodes} for node in nodes: for dependency in node.depends_on: if dependency not in by_id: raise ValueError(f"unknown dependency {dependency!r} for node {node.node_id!r}") children[dependency].add(node.node_id) ready = deque(sorted(node_id for node_id, deps in incoming.items() if not deps)) ordered: list[EvidenceNodeSpec] = [] while ready: current = ready.popleft() ordered.append(by_id[current]) for child in sorted(children[current]): incoming[child].discard(current) if not incoming[child]: ready.append(child) if len(ordered) != len(nodes): cyclic = sorted(node_id for node_id, deps in incoming.items() if deps) raise ValueError(f"cyclic evidence DAG: {cyclic}") return tuple(ordered) class EvidenceDagExecutor: """Execute nodes only after their declared inputs are available. Unlike the v1 batch scripts, ``depends_on`` is an execution contract. A required upstream node that is not successful prevents downstream calls. This is what makes ``DINO region -> ROI detector`` a real data flow rather than provenance decoration. """ def __init__(self, adapters: Mapping[str, NodeAdapter]) -> None: self.adapters = dict(adapters) def execute(self, procedure: EvalProcedure, context: ExecutionContext) -> tuple[EvidenceNodeResult, ...]: results: dict[str, EvidenceNodeResult] = {} for node in topological_order(procedure.nodes): dependencies = {key: results[key] for key in node.depends_on} failed_required = [key for key, value in dependencies.items() if value.status != "success"] if failed_required: results[node.node_id] = EvidenceNodeResult( node_id=node.node_id, status="insufficient", limitations=(f"blocked_by_dependencies:{'|'.join(sorted(failed_required))}",), ) continue adapter = self.adapters.get(node.tool) if adapter is None: results[node.node_id] = EvidenceNodeResult( node_id=node.node_id, status="unsupported", limitations=(f"missing_tool_adapter:{node.tool}",), ) continue try: result = adapter(node, context, dependencies) if result.node_id != node.node_id: raise ValueError(f"adapter returned node_id={result.node_id!r}, expected {node.node_id!r}") results[node.node_id] = result except Exception as exc: # adapters must fail closed at the node boundary results[node.node_id] = EvidenceNodeResult( node_id=node.node_id, status="error", limitations=(f"{type(exc).__name__}:{exc}",), ) return tuple(results[node.node_id] for node in topological_order(procedure.nodes))