Datasets:
Download code/src/pvr_eval/question_eval/dag.py from wenjieshu/solveedit_benchmark_2728: direct link, hf CLI and curl.
- Browser
- Download file 4.03 kB
-
https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/question_eval/dag.py
- Command line
-
hf download hf://datasets/wenjieshu/solveedit_benchmark_2728/code/src/pvr_eval/question_eval/dag.py
-
curl -L -o dag.py https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/question_eval/dag.py
4.03 kB
| """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 | |
| 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)) | |