Datasets:
Download code/src/pvr_eval/agent/execution_ledger.py from wenjieshu/solveedit_benchmark_2728: direct link, hf CLI and curl.
- Browser
- Download file 23.5 kB
-
https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/agent/execution_ledger.py
- Command line
-
hf download hf://datasets/wenjieshu/solveedit_benchmark_2728/code/src/pvr_eval/agent/execution_ledger.py
-
curl -L -o execution_ledger.py https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/agent/execution_ledger.py
23.5 kB
| """Strict execution-completeness audit for typed PVR agent tool plans. | |
| The ledger deliberately separates *an artifact exists* from *a planned call | |
| completed*. A call is complete only when evidence contains its exact | |
| ``call_id``, a recognized terminal status, and valid ``check_id`` provenance. | |
| Dependencies must also have completed successfully before a call, check, or | |
| case is eligible for fixed scoring or a leaderboard. | |
| """ | |
| from __future__ import annotations | |
| import csv | |
| import json | |
| from dataclasses import dataclass | |
| from pathlib import Path | |
| from typing import Any, Iterable, Mapping, Sequence | |
| csv.field_size_limit(16 * 1024 * 1024) | |
| LEDGER_SCHEMA_VERSION = "pvr.agent_execution_ledger.v1" | |
| SUCCESS_STATUSES = frozenset( | |
| { | |
| "ok", | |
| "success", | |
| "succeeded", | |
| "complete", | |
| "completed", | |
| # A negative observation is still successful tool execution. | |
| "no_detections", | |
| "no_detection", | |
| "no_text", | |
| "no_matches", | |
| "empty_result", | |
| } | |
| ) | |
| INSUFFICIENT_STATUSES = frozenset( | |
| { | |
| "error", | |
| "failed", | |
| "failure", | |
| "timeout", | |
| "cancelled", | |
| "canceled", | |
| "invalid", | |
| "insufficient", | |
| "uncertain", | |
| "low_confidence", | |
| "conflict", | |
| "partial", | |
| } | |
| ) | |
| UNSUPPORTED_STATUSES = frozenset( | |
| {"unsupported", "not_supported", "unimplemented", "not_implemented", "tool_unavailable"} | |
| ) | |
| NONTERMINAL_STATUSES = frozenset({"", "planned", "pending", "queued", "running", "started"}) | |
| def _clean_status(value: Any) -> str: | |
| return str(value or "").strip().lower().replace("-", "_").replace(" ", "_") | |
| def _list_value(value: Any) -> tuple[str, ...]: | |
| if value is None: | |
| return () | |
| if isinstance(value, (list, tuple, set)): | |
| return tuple(dict.fromkeys(str(item).strip() for item in value if str(item).strip())) | |
| text = str(value).strip() | |
| if not text: | |
| return () | |
| if text[:1] in {"[", "{"}: | |
| try: | |
| decoded = json.loads(text) | |
| except (TypeError, ValueError, json.JSONDecodeError): | |
| decoded = None | |
| if isinstance(decoded, list): | |
| return _list_value(decoded) | |
| separator = "|" if "|" in text else "," | |
| return tuple(dict.fromkeys(item.strip() for item in text.split(separator) if item.strip())) | |
| def _bool_text(value: bool) -> str: | |
| return "true" if value else "false" | |
| def _json_text(value: Any) -> str: | |
| return json.dumps(value, ensure_ascii=False, separators=(",", ":")) | |
| class EvidenceRecord: | |
| """One evidence record loaded from a TSV row or JSON cache payload.""" | |
| source: str | |
| call_id: str | |
| status: str | |
| check_ids: tuple[str, ...] | |
| case_key: str = "" | |
| location: str = "" | |
| def status_class(self) -> str: | |
| if self.status in SUCCESS_STATUSES: | |
| return "success" | |
| if self.status in INSUFFICIENT_STATUSES: | |
| return "insufficient" | |
| if self.status in UNSUPPORTED_STATUSES: | |
| return "unsupported" | |
| return "nonterminal" | |
| def read_tsv_rows(path: str | Path) -> list[dict[str, str]]: | |
| with Path(path).open(encoding="utf-8") as handle: | |
| return list(csv.DictReader(handle, delimiter="\t")) | |
| def _evidence_from_mapping( | |
| item: Mapping[str, Any], *, source: Path, location: str, inferred_call_id: str = "" | |
| ) -> EvidenceRecord | None: | |
| status = _clean_status(item.get("status") or item.get("execution_status") or item.get("terminal_status")) | |
| call_id = str(item.get("call_id") or inferred_call_id or "").strip() | |
| if not call_id and not status: | |
| return None | |
| check_ids = _list_value(item.get("check_ids")) | |
| singular = str(item.get("check_id") or "").strip() | |
| if singular and singular not in check_ids: | |
| check_ids = (*check_ids, singular) | |
| return EvidenceRecord( | |
| source=str(source), | |
| call_id=call_id, | |
| status=status, | |
| check_ids=check_ids, | |
| case_key=str(item.get("case_key") or "").strip(), | |
| location=location, | |
| ) | |
| def load_evidence_file(path: str | Path) -> list[EvidenceRecord]: | |
| """Load evidence rows from a TSV or a JSON executor/cache artifact. | |
| JSON cache filenames may supply ``call_id`` only when their stem begins | |
| with ``call_``. This supports current per-call caches while preventing an | |
| arbitrary JSON file from being mistaken for execution evidence. | |
| """ | |
| evidence_path = Path(path) | |
| records: list[EvidenceRecord] = [] | |
| if evidence_path.suffix.lower() == ".tsv": | |
| for index, item in enumerate(read_tsv_rows(evidence_path), 2): | |
| record = _evidence_from_mapping(item, source=evidence_path, location=f"row:{index}") | |
| if record is not None: | |
| records.append(record) | |
| return records | |
| if evidence_path.suffix.lower() != ".json": | |
| raise ValueError(f"unsupported evidence file type: {evidence_path}") | |
| payload = json.loads(evidence_path.read_text(encoding="utf-8")) | |
| inferred = evidence_path.stem if evidence_path.stem.startswith("call_") else "" | |
| if isinstance(payload, list): | |
| items: Sequence[Any] = payload | |
| elif isinstance(payload, dict) and isinstance(payload.get("rows"), list) and payload["rows"]: | |
| # Executor rows carry finer status and provenance than the cache header. | |
| items = payload["rows"] | |
| elif isinstance(payload, dict): | |
| items = [payload] | |
| else: | |
| items = [] | |
| for index, item in enumerate(items): | |
| if not isinstance(item, Mapping): | |
| continue | |
| record = _evidence_from_mapping( | |
| item, | |
| source=evidence_path, | |
| location=f"json:{index}", | |
| inferred_call_id=inferred, | |
| ) | |
| if record is not None: | |
| records.append(record) | |
| return records | |
| def load_evidence(paths: Iterable[str | Path]) -> list[EvidenceRecord]: | |
| """Load one or more evidence files or recursively scanned cache dirs.""" | |
| files: list[Path] = [] | |
| for raw_path in paths: | |
| path = Path(raw_path) | |
| if path.is_dir(): | |
| files.extend(sorted(item for item in path.rglob("*") if item.suffix.lower() in {".tsv", ".json"})) | |
| elif path.is_file(): | |
| files.append(path) | |
| else: | |
| raise FileNotFoundError(path) | |
| return [record for path in files for record in load_evidence_file(path)] | |
| def _plan_calls(rows: Sequence[Mapping[str, Any]]) -> dict[str, dict[str, Any]]: | |
| planned: dict[str, dict[str, Any]] = {} | |
| for row in rows: | |
| call_id = str(row.get("call_id") or "").strip() | |
| if not call_id: | |
| raise ValueError("tool_calls row is missing call_id") | |
| if call_id in planned: | |
| raise ValueError(f"duplicate planned call_id: {call_id}") | |
| check_ids = _list_value(row.get("check_ids")) | |
| if not check_ids: | |
| raise ValueError(f"planned call has no check_ids: {call_id}") | |
| planned[call_id] = { | |
| "call_id": call_id, | |
| "case_key": str(row.get("case_key") or "").strip(), | |
| "tool": str(row.get("tool") or "").strip(), | |
| "check_ids": check_ids, | |
| "depends_on": _list_value(row.get("depends_on")), | |
| } | |
| return planned | |
| def _intrinsic_call_row(plan: Mapping[str, Any], records: Sequence[EvidenceRecord]) -> dict[str, Any]: | |
| planned_checks = set(plan["check_ids"]) | |
| terminal = [record for record in records if record.status_class != "nonterminal"] | |
| unknown_statuses = sorted({record.status for record in records if record.status not in NONTERMINAL_STATUSES and record.status_class == "nonterminal"}) | |
| provenance_errors: list[str] = [] | |
| evidenced_checks: set[str] = set() | |
| for record in terminal: | |
| record_checks = set(record.check_ids) | |
| evidenced_checks.update(record_checks) | |
| if not record_checks: | |
| provenance_errors.append(f"missing_check_id@{record.source}:{record.location}") | |
| extra = sorted(record_checks - planned_checks) | |
| if extra: | |
| provenance_errors.append(f"unplanned_check_ids:{'|'.join(extra)}@{record.source}:{record.location}") | |
| if record.case_key and plan["case_key"] and record.case_key != plan["case_key"]: | |
| provenance_errors.append(f"case_key_mismatch:{record.case_key}@{record.source}:{record.location}") | |
| missing_checks = sorted(planned_checks - evidenced_checks) | |
| if terminal and missing_checks: | |
| provenance_errors.append(f"planned_check_ids_without_evidence:{'|'.join(missing_checks)}") | |
| classes = {record.status_class for record in terminal} | |
| classes_by_source: dict[str, set[str]] = {} | |
| for record in terminal: | |
| classes_by_source.setdefault(record.source, set()).add(record.status_class) | |
| successful_sources = sorted(source for source, values in classes_by_source.items() if values == {"success"}) | |
| degraded_sources = sorted(source for source, values in classes_by_source.items() if values != {"success"}) | |
| reasons: list[str] = [] | |
| if not records: | |
| status = "missing" | |
| reasons.append("no_matching_call_id_evidence") | |
| elif not terminal: | |
| status = "missing" | |
| reasons.append("no_recognized_terminal_evidence_status") | |
| if unknown_statuses: | |
| reasons.append(f"unknown_statuses:{'|'.join(unknown_statuses)}") | |
| elif provenance_errors: | |
| status = "insufficient" | |
| reasons.append("invalid_check_id_provenance") | |
| elif successful_sources: | |
| # DINO and YOLO-World are redundant backends for one typed detector | |
| # call. A complete, provenance-valid result from either backend is | |
| # sufficient; a failed corroborator must not erase primary evidence. | |
| status = "success" | |
| if degraded_sources: | |
| reasons.append("redundant_backend_degraded") | |
| elif classes == {"unsupported"}: | |
| status = "unsupported" | |
| reasons.append("executor_reported_unsupported") | |
| elif "insufficient" in classes or len(classes) > 1: | |
| status = "insufficient" | |
| reasons.append("terminal_evidence_not_uniformly_successful") | |
| elif classes == {"success"}: | |
| status = "success" | |
| else: | |
| status = "insufficient" | |
| reasons.append("unclassified_terminal_evidence") | |
| return { | |
| "call_id": plan["call_id"], | |
| "case_key": plan["case_key"], | |
| "tool": plan["tool"], | |
| "planned": True, | |
| "executed": bool(terminal), | |
| "status": status, | |
| "planned_check_ids": sorted(planned_checks), | |
| "evidenced_check_ids": sorted(evidenced_checks), | |
| "depends_on": list(plan["depends_on"]), | |
| "dependency_valid": True, | |
| "dependency_errors": [], | |
| "provenance_valid": not provenance_errors, | |
| "provenance_errors": provenance_errors, | |
| "evidence_records": len(records), | |
| "terminal_records": len(terminal), | |
| "terminal_statuses": sorted({record.status for record in terminal}), | |
| "evidence_sources": sorted({record.source for record in records}), | |
| "successful_evidence_sources": successful_sources, | |
| "degraded_evidence_sources": degraded_sources, | |
| "reasons": reasons, | |
| } | |
| def _dependency_errors(call_id: str, planned: Mapping[str, Mapping[str, Any]], rows: Mapping[str, Mapping[str, Any]]) -> list[str]: | |
| errors: list[str] = [] | |
| visiting: set[str] = set() | |
| visited: set[str] = set() | |
| def visit(current: str) -> None: | |
| if current in visiting: | |
| errors.append(f"dependency_cycle:{current}") | |
| return | |
| if current in visited: | |
| return | |
| visiting.add(current) | |
| for dependency in planned[current]["depends_on"]: | |
| if dependency not in planned: | |
| errors.append(f"unknown_dependency:{dependency}") | |
| continue | |
| if rows[dependency]["status"] != "success": | |
| errors.append(f"dependency_not_successful:{dependency}:{rows[dependency]['status']}") | |
| visit(dependency) | |
| visiting.remove(current) | |
| visited.add(current) | |
| visit(call_id) | |
| return list(dict.fromkeys(errors)) | |
| def _check_plan_map( | |
| check_plan_rows: Sequence[Mapping[str, Any]] | None, | |
| planned_calls: Mapping[str, Mapping[str, Any]], | |
| ) -> dict[tuple[str, str], dict[str, Any]]: | |
| checks: dict[tuple[str, str], dict[str, Any]] = {} | |
| for call in planned_calls.values(): | |
| for check_id in call["check_ids"]: | |
| key = (call["case_key"], check_id) | |
| checks.setdefault(key, {"call_ids": [], "plan_status": "executable", "fallback": "", "reasons": []}) | |
| checks[key]["call_ids"].append(call["call_id"]) | |
| for row in check_plan_rows or []: | |
| key = (str(row.get("case_key") or "").strip(), str(row.get("check_id") or "").strip()) | |
| if not key[1]: | |
| raise ValueError("check_plans row is missing check_id") | |
| item = checks.setdefault(key, {"call_ids": [], "plan_status": "", "fallback": "", "reasons": []}) | |
| explicit_calls = _list_value(row.get("tool_call_ids")) | |
| item["call_ids"] = list(dict.fromkeys((*item["call_ids"], *explicit_calls))) | |
| item["plan_status"] = str(row.get("status") or item["plan_status"] or "").strip() | |
| item["fallback"] = str(row.get("fallback") or "").strip() | |
| item["reasons"] = list(_list_value(row.get("reasons"))) | |
| return checks | |
| def audit_execution( | |
| tool_call_rows: Sequence[Mapping[str, Any]], | |
| evidence_records: Sequence[EvidenceRecord], | |
| *, | |
| check_plan_rows: Sequence[Mapping[str, Any]] | None = None, | |
| ) -> dict[str, Any]: | |
| """Build strict per-call, per-check, and per-case execution ledgers.""" | |
| planned = _plan_calls(tool_call_rows) | |
| records_by_call: dict[str, list[EvidenceRecord]] = {call_id: [] for call_id in planned} | |
| orphan_records: list[EvidenceRecord] = [] | |
| for record in evidence_records: | |
| if record.call_id in records_by_call: | |
| records_by_call[record.call_id].append(record) | |
| else: | |
| orphan_records.append(record) | |
| call_by_id = { | |
| call_id: _intrinsic_call_row(plan, records_by_call[call_id]) | |
| for call_id, plan in planned.items() | |
| } | |
| for call_id, row in call_by_id.items(): | |
| dependency_errors = _dependency_errors(call_id, planned, call_by_id) | |
| terminal_result_owns_adequacy = bool( | |
| row["tool"] in {"contract_metric_binding", "structured_checker"} | |
| and row["status"] == "success" | |
| and row["provenance_valid"] | |
| ) | |
| # Terminal evaluators are fail-closed: they report ``insufficient`` | |
| # when a missing dependency is actually required for the verdict. A | |
| # provenance-valid known terminal result may therefore close the call | |
| # even when optional generic parser branches declared in the broad | |
| # plan were unsupported. Keep the degraded dependency list visible | |
| # for audit rather than rewriting history. | |
| row["dependency_valid"] = not dependency_errors or terminal_result_owns_adequacy | |
| row["dependency_errors"] = dependency_errors | |
| row["dependency_adequacy_overridden_by_terminal_result"] = bool( | |
| dependency_errors and terminal_result_owns_adequacy | |
| ) | |
| if dependency_errors and terminal_result_owns_adequacy: | |
| row["reasons"].append("known_terminal_result_closed_degraded_declared_dependencies") | |
| elif dependency_errors and row["status"] == "success": | |
| row["status"] = "insufficient" | |
| row["reasons"].append("dependency_validation_failed") | |
| row["success"] = row["status"] == "success" | |
| row["insufficient"] = row["status"] == "insufficient" | |
| row["unsupported"] = row["status"] == "unsupported" | |
| row["missing"] = row["status"] == "missing" | |
| row["leaderboard_eligible"] = row["success"] and row["dependency_valid"] and row["provenance_valid"] | |
| check_map = _check_plan_map(check_plan_rows, planned) | |
| check_rows: list[dict[str, Any]] = [] | |
| for (case_key, check_id), check in sorted(check_map.items()): | |
| call_ids = list(dict.fromkeys(check["call_ids"])) | |
| missing_plan_calls = [call_id for call_id in call_ids if call_id not in call_by_id] | |
| call_rows = [call_by_id[call_id] for call_id in call_ids if call_id in call_by_id] | |
| statuses = [row["status"] for row in call_rows] | |
| plan_status = check["plan_status"] or "executable" | |
| reasons = list(check["reasons"]) | |
| terminal_tools = {"contract_metric_binding", "structured_checker"} | |
| decision_rows = [row for row in call_rows if row["tool"] in terminal_tools] | |
| successful_decisions = [ | |
| row for row in decision_rows | |
| if row["status"] == "success" and row["dependency_valid"] and row["provenance_valid"] | |
| ] | |
| if missing_plan_calls: | |
| status = "missing" | |
| reasons.append(f"check_references_unknown_calls:{'|'.join(missing_plan_calls)}") | |
| elif successful_decisions and plan_status in {"executable", "fallback_required"}: | |
| # A fail-closed registered metric is the terminal decision node. | |
| # Its dependency closure is already validated at call level, so | |
| # a declared semantic fallback and unrelated auxiliary tools cannot | |
| # erase a conclusive result. Unknown contract metrics report an | |
| # insufficient executor status and therefore never enter here. | |
| status = "success" | |
| if any(value != "success" for value in statuses): | |
| terminal_names = {row["tool"] for row in successful_decisions} | |
| reasons.append( | |
| "terminal_structured_checker_succeeded_with_degraded_auxiliary_calls" | |
| if "structured_checker" in terminal_names | |
| else "terminal_contract_metric_succeeded_with_degraded_auxiliary_calls" | |
| ) | |
| elif plan_status != "executable": | |
| status = "unsupported" if not call_rows and any("unsupported" in reason for reason in reasons) else "insufficient" | |
| reasons.append(f"plan_status:{plan_status}") | |
| elif not call_rows: | |
| status = "missing" | |
| reasons.append("check_has_no_planned_tool_calls") | |
| else: | |
| # A registered metric binding is the terminal decision for its | |
| # check. Its own dependency closure has already been validated at | |
| # call level, so unrelated auxiliary parser failures must not | |
| # erase a conclusive, provenance-valid metric. Unknown metrics are | |
| # still insufficient because their executor never reports ok. | |
| if all(value == "success" for value in statuses): | |
| status = "success" | |
| elif "missing" in statuses: | |
| status = "missing" | |
| reasons.append("one_or_more_calls_missing") | |
| elif statuses and all(value == "unsupported" for value in statuses): | |
| status = "unsupported" | |
| reasons.append("all_calls_unsupported") | |
| else: | |
| status = "insufficient" | |
| reasons.append("one_or_more_calls_not_successful") | |
| leaderboard_eligible = status == "success" and ( | |
| plan_status == "executable" or bool(successful_decisions) | |
| ) | |
| check_rows.append( | |
| { | |
| "case_key": case_key, | |
| "check_id": check_id, | |
| "planned": True, | |
| "executed": bool(call_rows) and all(row["executed"] for row in call_rows), | |
| "status": status, | |
| "success": status == "success", | |
| "insufficient": status == "insufficient", | |
| "unsupported": status == "unsupported", | |
| "missing": status == "missing", | |
| "plan_status": plan_status, | |
| "fallback": check["fallback"], | |
| "call_ids": call_ids, | |
| "call_statuses": {row["call_id"]: row["status"] for row in call_rows}, | |
| "leaderboard_eligible": leaderboard_eligible, | |
| "reasons": list(dict.fromkeys(reasons)), | |
| } | |
| ) | |
| case_rows: list[dict[str, Any]] = [] | |
| case_keys = sorted({row["case_key"] for row in check_rows}) | |
| for case_key in case_keys: | |
| rows = [row for row in check_rows if row["case_key"] == case_key] | |
| counts = {status: sum(row["status"] == status for row in rows) for status in ("success", "insufficient", "unsupported", "missing")} | |
| case_rows.append( | |
| { | |
| "case_key": case_key, | |
| "checks": len(rows), | |
| "status_counts": counts, | |
| "leaderboard_eligible": bool(rows) and all(row["leaderboard_eligible"] for row in rows), | |
| } | |
| ) | |
| status_counts = {status: sum(row["status"] == status for row in call_by_id.values()) for status in ("success", "insufficient", "unsupported", "missing")} | |
| check_status_counts = {status: sum(row["status"] == status for row in check_rows) for status in ("success", "insufficient", "unsupported", "missing")} | |
| summary = { | |
| "planned_calls": len(call_by_id), | |
| "planned_checks": len(check_rows), | |
| "cases": len(case_rows), | |
| "call_status_counts": status_counts, | |
| "check_status_counts": check_status_counts, | |
| "orphan_evidence_records": len(orphan_records), | |
| "orphan_call_ids": sorted({record.call_id for record in orphan_records if record.call_id}), | |
| "leaderboard_eligible_cases": sum(row["leaderboard_eligible"] for row in case_rows), | |
| "leaderboard_eligible": bool(case_rows) and all(row["leaderboard_eligible"] for row in case_rows), | |
| } | |
| return { | |
| "schema_version": LEDGER_SCHEMA_VERSION, | |
| "summary": summary, | |
| "calls": [call_by_id[call_id] for call_id in sorted(call_by_id)], | |
| "checks": check_rows, | |
| "cases": case_rows, | |
| "orphan_evidence": [ | |
| { | |
| "source": record.source, | |
| "location": record.location, | |
| "call_id": record.call_id, | |
| "status": record.status, | |
| "check_ids": list(record.check_ids), | |
| "case_key": record.case_key, | |
| } | |
| for record in orphan_records | |
| ], | |
| } | |
| CALL_LEDGER_FIELDS = ( | |
| "call_id", "case_key", "tool", "planned", "executed", "status", "success", "insufficient", | |
| "unsupported", "missing", "planned_check_ids", "evidenced_check_ids", "depends_on", | |
| "dependency_valid", "dependency_errors", "provenance_valid", "provenance_errors", "evidence_records", | |
| "terminal_records", "terminal_statuses", "evidence_sources", "leaderboard_eligible", "reasons", | |
| ) | |
| CHECK_LEDGER_FIELDS = ( | |
| "case_key", "check_id", "planned", "executed", "status", "success", "insufficient", "unsupported", | |
| "missing", "plan_status", "fallback", "call_ids", "call_statuses", "leaderboard_eligible", "reasons", | |
| ) | |
| def tsv_row(row: Mapping[str, Any], fields: Sequence[str]) -> dict[str, Any]: | |
| """Encode nested ledger values for a stable TSV representation.""" | |
| encoded: dict[str, Any] = {} | |
| for field in fields: | |
| value = row.get(field, "") | |
| if isinstance(value, bool): | |
| encoded[field] = _bool_text(value) | |
| elif isinstance(value, (list, tuple, dict)): | |
| encoded[field] = _json_text(value) | |
| else: | |
| encoded[field] = value | |
| return encoded | |