Datasets:
File size: 4,026 Bytes
b8ea052 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 | """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))
|