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))