Datasets:
Download code/src/pvr_eval/checkers/base.py from wenjieshu/solveedit_benchmark_2728: direct link, hf CLI and curl.
- Browser
- Download file 7.58 kB
-
https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/checkers/base.py
- Command line
-
hf download hf://datasets/wenjieshu/solveedit_benchmark_2728/code/src/pvr_eval/checkers/base.py
-
curl -L -o base.py https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/checkers/base.py
7.58 kB
| """Checker protocol and registry.""" | |
| from __future__ import annotations | |
| from dataclasses import dataclass, field | |
| from pathlib import Path | |
| from typing import Any, Protocol | |
| from pvr_eval.core.schema import AtomicCheckSpec, CheckResult, EvalContract | |
| from pvr_eval.core.scoring import clamp01, score_to_status | |
| class CheckerContext: | |
| """Runtime inputs shared by all checkers.""" | |
| contract: EvalContract | |
| input_image: Path | None | |
| pred_image: Path | |
| observations: dict[str, Any] = field(default_factory=dict) | |
| work_dir: Path | None = None | |
| class Checker(Protocol): | |
| name: str | |
| def run(self, context: CheckerContext, spec: AtomicCheckSpec) -> CheckResult: | |
| """Run a single atomic check.""" | |
| class CheckerRegistry: | |
| """Simple in-process checker registry.""" | |
| def __init__(self) -> None: | |
| self._checkers: dict[str, Checker] = {} | |
| def register(self, checker: Checker) -> None: | |
| self._checkers[checker.name] = checker | |
| def get(self, name: str) -> Checker | None: | |
| return self._checkers.get(name) | |
| def require(self, name: str) -> Checker: | |
| checker = self.get(name) | |
| if checker is None: | |
| raise KeyError(f"checker is not registered: {name}") | |
| return checker | |
| def result_from_observation(spec: AtomicCheckSpec, observed: Any, *, checker_name: str) -> CheckResult: | |
| if observed is None: | |
| if bool(getattr(spec, "params", {}).get("audit_only", False)): | |
| score = 0.0 if spec.role == "penalty" else 0.0 | |
| return CheckResult( | |
| check_id=spec.check_id, | |
| dimension=spec.dimension, | |
| checker=checker_name, | |
| weight=spec.weight, | |
| role=spec.role, | |
| hard_fail=spec.hard_fail, | |
| status="clean" if spec.role == "penalty" else "uncertain", | |
| score=score, | |
| confidence=0.0, | |
| evidence={ | |
| "reason": "audit_only_observation_missing", | |
| "audit_only": True, | |
| "note": getattr(spec, "params", {}).get("reason", ""), | |
| }, | |
| ) | |
| return CheckResult( | |
| check_id=spec.check_id, | |
| dimension=spec.dimension, | |
| checker=checker_name, | |
| weight=spec.weight, | |
| role=spec.role, | |
| hard_fail=spec.hard_fail, | |
| status="uncertain", | |
| score=0.0, | |
| confidence=0.0, | |
| evidence={"reason": "missing_observation"}, | |
| ) | |
| if isinstance(observed, bool): | |
| score = 1.0 if observed else 0.0 | |
| return CheckResult( | |
| check_id=spec.check_id, | |
| dimension=spec.dimension, | |
| checker=checker_name, | |
| weight=spec.weight, | |
| role=spec.role, | |
| hard_fail=spec.hard_fail, | |
| status=score_to_status(score), | |
| score=score, | |
| confidence=1.0, | |
| evidence={"source": "boolean_observation"}, | |
| ) | |
| if isinstance(observed, (int, float)): | |
| score = clamp01(float(observed)) | |
| return CheckResult( | |
| check_id=spec.check_id, | |
| dimension=spec.dimension, | |
| checker=checker_name, | |
| weight=spec.weight, | |
| role=spec.role, | |
| hard_fail=spec.hard_fail, | |
| status=score_to_status(score), | |
| score=score, | |
| confidence=1.0, | |
| evidence={"source": "numeric_observation"}, | |
| ) | |
| if isinstance(observed, dict): | |
| raw_score = observed.get("score", 0.0) | |
| requested_status = str(observed.get("status") or "").strip().lower() | |
| evidence = dict(observed.get("evidence", {})) | |
| if raw_score is None: | |
| # Contract metrics use ``score: null`` to represent an explicit | |
| # abstention. Do not feed it through ``float`` (which raises) or | |
| # infer a numeric fail. Malformed conclusive statuses with no | |
| # score also fail closed. | |
| status = ( | |
| requested_status | |
| if requested_status in {"unknown", "uncertain", "error", "abstain"} | |
| else "uncertain" | |
| ) | |
| score = 0.0 | |
| confidence = 0.0 | |
| evidence.setdefault("reason", "observation_score_missing") | |
| else: | |
| score = clamp01(float(raw_score)) | |
| status = requested_status or score_to_status(score) | |
| confidence = clamp01( | |
| float(observed.get("confidence", 1.0 if status not in {"unknown", "uncertain", "error", "abstain"} else 0.0)) | |
| ) | |
| return CheckResult( | |
| check_id=spec.check_id, | |
| dimension=spec.dimension, | |
| checker=checker_name, | |
| weight=spec.weight, | |
| role=spec.role, | |
| hard_fail=spec.hard_fail, | |
| status=status, | |
| score=score, | |
| confidence=confidence, | |
| evidence=evidence, | |
| ) | |
| return CheckResult( | |
| check_id=spec.check_id, | |
| dimension=spec.dimension, | |
| checker=checker_name, | |
| weight=spec.weight, | |
| role=spec.role, | |
| hard_fail=spec.hard_fail, | |
| status="uncertain", | |
| score=0.0, | |
| confidence=0.0, | |
| evidence={"reason": f"unsupported_observation_type:{type(observed).__name__}"}, | |
| ) | |
| class ObservationChecker: | |
| """Compatibility checker that reads precomputed atomic observations.""" | |
| name = "observation" | |
| def run(self, context: CheckerContext, spec: AtomicCheckSpec) -> CheckResult: | |
| observed = context.observations.get("atomic_checks", {}).get(spec.check_id) | |
| return result_from_observation(spec, observed, checker_name=self.name) | |
| class ObservationAliasChecker: | |
| """Read precomputed observations while preserving the intended checker name. | |
| This is useful for smoke tests and migration dashboards where the contract | |
| already names the future objective checker, but the current run only has | |
| cached atomic observations. It should be registered explicitly by the caller; | |
| the production default registry intentionally does not alias unknown | |
| checkers to observations. | |
| """ | |
| def __init__(self, name: str) -> None: | |
| self.name = name | |
| def run(self, context: CheckerContext, spec: AtomicCheckSpec) -> CheckResult: | |
| observed = context.observations.get("atomic_checks", {}).get(spec.check_id) | |
| return result_from_observation(spec, observed, checker_name=self.name) | |
| def register_observation_aliases( | |
| registry: CheckerRegistry, | |
| names: list[str] | tuple[str, ...] | set[str], | |
| *, | |
| overwrite: bool = False, | |
| ) -> None: | |
| for name in sorted({str(item).strip() for item in names if str(item).strip()}): | |
| if overwrite or registry.get(name) is None: | |
| registry.register(ObservationAliasChecker(name)) | |
| def default_registry() -> CheckerRegistry: | |
| registry = CheckerRegistry() | |
| registry.register(ObservationChecker()) | |
| from pvr_eval.checkers.object import register_object_checkers | |
| from pvr_eval.checkers.state import register_state_checkers | |
| from pvr_eval.checkers.text_symbol import register_text_symbol_checkers | |
| from pvr_eval.checkers.vision import register_lightweight_vision_checkers | |
| from pvr_eval.checkers.vlm import register_vlm_checkers | |
| register_lightweight_vision_checkers(registry) | |
| register_object_checkers(registry) | |
| register_text_symbol_checkers(registry) | |
| register_state_checkers(registry) | |
| register_vlm_checkers(registry) | |
| return registry | |