Datasets:
Download code/src/pvr_eval/question_eval/schema.py from wenjieshu/solveedit_benchmark_2728: direct link, hf CLI and curl.
- Browser
- Download file 17 kB
-
https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/question_eval/schema.py
- Command line
-
hf download hf://datasets/wenjieshu/solveedit_benchmark_2728/code/src/pvr_eval/question_eval/schema.py
-
curl -L -o schema.py https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/question_eval/schema.py
17 kB
| """Strongly typed records for the question-first evaluator. | |
| The v1 evaluator placed executable semantics inside a free-form ``params`` | |
| dictionary. V2 makes the normalized predicate, evidence dependencies and | |
| answer provenance first-class records. Unknown semantics are valid, but they | |
| must be marked ``manual_required`` and can never reach either a deterministic | |
| scorer or an implicit VLM fallback. | |
| """ | |
| from __future__ import annotations | |
| import hashlib | |
| import json | |
| from dataclasses import dataclass, field | |
| from typing import Any, Mapping | |
| SCHEMA_VERSION = "pvr.question_eval.v2" | |
| TERMINAL_EVIDENCE_STATUSES = {"success", "insufficient", "unsupported", "error"} | |
| ANSWER_STATUSES = {"pass", "partial", "fail", "uncertain"} | |
| ANSWER_MODES = {"deterministic", "deterministic_or_vlm", "vlm_required", "manual_only"} | |
| COMPILE_STATUSES = {"executable", "manual_required", "vlm_required"} | |
| DECISION_MODES = {"objective", "manual_only"} | |
| OBJECTIVE_PREDICATE_KINDS = { | |
| "attribute_object_in_region", | |
| "change_fraction", | |
| "count_in_region", | |
| "source_normalized_clearance", | |
| "text_match", | |
| } | |
| def _tuple_strings(value: Any) -> tuple[str, ...]: | |
| if isinstance(value, str): | |
| return tuple(item.strip() for item in value.split("|") if item.strip()) | |
| if isinstance(value, (list, tuple, set)): | |
| return tuple(str(item).strip() for item in value if str(item).strip()) | |
| return () | |
| def _jsonable(value: Any) -> Any: | |
| if value.__class__.__module__.startswith("numpy"): | |
| if getattr(value, "ndim", 0) == 0: | |
| return value.item() | |
| # Runtime adapters may carry full masks between DAG nodes. Persist a | |
| # stable, compact summary rather than megabytes of pixels; visual mask | |
| # artifacts and source call IDs remain separately auditable. | |
| return { | |
| "array_summary": True, | |
| "shape": [int(item) for item in value.shape], | |
| "dtype": str(value.dtype), | |
| "nonzero": int(value.astype(bool).sum()), | |
| } | |
| if isinstance(value, tuple): | |
| return [_jsonable(item) for item in value] | |
| if isinstance(value, list): | |
| return [_jsonable(item) for item in value] | |
| if isinstance(value, dict): | |
| return {str(key): _jsonable(item) for key, item in value.items()} | |
| return value | |
| def stable_hash(payload: Mapping[str, Any]) -> str: | |
| text = json.dumps(_jsonable(dict(payload)), ensure_ascii=False, sort_keys=True, separators=(",", ":")) | |
| return hashlib.sha256(text.encode("utf-8")).hexdigest() | |
| class QuestionRubric: | |
| case_id: str | |
| check_id: str | |
| question: str | |
| pass_criteria: str | |
| partial_criteria: str | |
| fail_criteria: str | |
| role: str | |
| dimension: str | |
| weight: float | |
| hard_fail: bool = False | |
| def __post_init__(self) -> None: | |
| if not self.case_id or not self.check_id: | |
| raise ValueError("question rubric requires case_id and check_id") | |
| if not self.question.strip(): | |
| raise ValueError(f"question rubric {self.check_id!r} has no question") | |
| if self.role not in {"reward", "penalty"}: | |
| raise ValueError(f"invalid rubric role: {self.role}") | |
| if self.weight < 0: | |
| raise ValueError("rubric weight must be non-negative") | |
| def from_contract_item(cls, case_id: str, item: Mapping[str, Any]) -> "QuestionRubric": | |
| role = "penalty" if str(item.get("role", "")).lower() == "penalty" or "max_deduct" in item else "reward" | |
| weight_key = "max_deduct" if role == "penalty" else "points" | |
| return cls( | |
| case_id=case_id, | |
| check_id=str(item.get("id") or item.get("check_id") or ""), | |
| question=str(item.get("question") or item.get("description") or ""), | |
| pass_criteria=str(item.get("pass_criteria") or ""), | |
| partial_criteria=str(item.get("partial_criteria") or ""), | |
| fail_criteria=str(item.get("fail_criteria") or ""), | |
| role=role, | |
| dimension=str(item.get("dimension") or ("penalty" if role == "penalty" else "target_completion")), | |
| weight=float(item.get(weight_key, item.get("weight", 0.0)) or 0.0), | |
| hard_fail=bool(item.get("hard_fail", False)), | |
| ) | |
| def to_dict(self) -> dict[str, Any]: | |
| return _jsonable(self.__dict__) | |
| class PredicateSpec: | |
| """Finite, executable predicate semantics. | |
| ``kind`` belongs to a small registry. ``metric`` names the derived fact | |
| consumed by the predicate. Bands are explicit numeric intervals such as | |
| ``{"pass": {"max": 0}, "partial": {"min": 1, "max": 2}}``. | |
| A semantic VLM predicate has ``deterministic=False`` and no executable | |
| bands; its frozen rubric remains the source of truth. | |
| """ | |
| kind: str | |
| metric: str = "" | |
| subject_queries: tuple[str, ...] = () | |
| region_ids: tuple[str, ...] = () | |
| bands: dict[str, dict[str, float | None]] = field(default_factory=dict) | |
| parameters: dict[str, Any] = field(default_factory=dict) | |
| deterministic: bool = False | |
| source_rule_type: str = "" | |
| def __post_init__(self) -> None: | |
| if not self.kind: | |
| raise ValueError("predicate kind is required") | |
| if self.deterministic: | |
| if not self.metric: | |
| raise ValueError("deterministic predicate requires a metric") | |
| if "pass" not in self.bands or "fail" not in self.bands: | |
| raise ValueError("deterministic predicate requires pass and fail bands") | |
| for status, band in self.bands.items(): | |
| if status not in {"pass", "partial", "fail"}: | |
| raise ValueError(f"invalid predicate band: {status}") | |
| low, high = band.get("min"), band.get("max") | |
| if low is not None and high is not None and float(low) > float(high): | |
| raise ValueError(f"invalid band interval for {status}") | |
| def to_dict(self) -> dict[str, Any]: | |
| return _jsonable(self.__dict__) | |
| class DecisionSpec: | |
| """Contract-owned instructions for turning evidence into one answer. | |
| Free-form ``decision_rule.type`` names describe intent but are not an | |
| executable interface. This finite record either names a validated | |
| objective predicate or explicitly sends the question to human review. | |
| """ | |
| mode: str | |
| predicate: PredicateSpec | |
| subject_region_ids: tuple[str, ...] = () | |
| target_region_ids: tuple[str, ...] = () | |
| required_tools: tuple[str, ...] = () | |
| manual_reasons: tuple[str, ...] = () | |
| schema_version: str = "pvr.decision_spec.v1" | |
| def __post_init__(self) -> None: | |
| if self.mode not in DECISION_MODES: | |
| raise ValueError(f"invalid decision mode: {self.mode}") | |
| if self.mode == "objective" and not self.predicate.deterministic: | |
| raise ValueError("objective decision spec requires deterministic predicate") | |
| if self.mode == "objective" and self.predicate.kind not in OBJECTIVE_PREDICATE_KINDS: | |
| raise ValueError(f"unsupported objective predicate kind: {self.predicate.kind}") | |
| if self.mode == "manual_only" and self.predicate.deterministic: | |
| raise ValueError("manual-only decision spec cannot carry deterministic predicate") | |
| overlap = set(self.subject_region_ids) & set(self.target_region_ids) | |
| if overlap: | |
| raise ValueError(f"subject and target regions must be disjoint: {sorted(overlap)}") | |
| if self.mode == "objective" and any("vlm" in tool.lower() for tool in self.required_tools): | |
| raise ValueError("objective decision spec cannot require a VLM tool") | |
| if self.mode == "objective" and set(self.predicate.region_ids) != set(self.target_region_ids): | |
| raise ValueError("objective predicate regions must exactly match target regions") | |
| def from_mapping(cls, value: Mapping[str, Any]) -> "DecisionSpec": | |
| predicate_value = value.get("predicate") if isinstance(value.get("predicate"), Mapping) else {} | |
| evidence = value.get("evidence") if isinstance(value.get("evidence"), Mapping) else {} | |
| predicate = PredicateSpec( | |
| kind=str(predicate_value.get("kind") or "manual_review"), | |
| metric=str(predicate_value.get("metric") or ""), | |
| subject_queries=_tuple_strings(predicate_value.get("subject_queries")), | |
| region_ids=_tuple_strings(predicate_value.get("region_ids") or evidence.get("target_region_ids")), | |
| bands={ | |
| str(status): {str(key): item for key, item in dict(band).items()} | |
| for status, band in dict(predicate_value.get("bands") or {}).items() | |
| if isinstance(band, Mapping) | |
| }, | |
| parameters=dict(predicate_value.get("parameters") or {}), | |
| deterministic=bool(predicate_value.get("deterministic", value.get("mode") == "objective")), | |
| source_rule_type=str(predicate_value.get("source_rule_type") or "decision_spec_v1"), | |
| ) | |
| return cls( | |
| mode=str(value.get("mode") or "manual_only"), | |
| predicate=predicate, | |
| subject_region_ids=_tuple_strings(evidence.get("subject_region_ids")), | |
| target_region_ids=_tuple_strings(evidence.get("target_region_ids") or predicate.region_ids), | |
| required_tools=_tuple_strings(evidence.get("required_tools")), | |
| manual_reasons=_tuple_strings(value.get("manual_reasons")), | |
| schema_version=str(value.get("schema_version") or "pvr.decision_spec.v1"), | |
| ) | |
| def to_dict(self) -> dict[str, Any]: | |
| return { | |
| "schema_version": self.schema_version, | |
| "mode": self.mode, | |
| "predicate": self.predicate.to_dict(), | |
| "evidence": { | |
| "subject_region_ids": list(self.subject_region_ids), | |
| "target_region_ids": list(self.target_region_ids), | |
| "required_tools": list(self.required_tools), | |
| }, | |
| "manual_reasons": list(self.manual_reasons), | |
| } | |
| class EvidenceNodeSpec: | |
| node_id: str | |
| operation: str | |
| tool: str | |
| image_roles: tuple[str, ...] | |
| depends_on: tuple[str, ...] = () | |
| region_ids: tuple[str, ...] = () | |
| inputs: tuple[str, ...] = () | |
| required: bool = True | |
| parameters: dict[str, Any] = field(default_factory=dict) | |
| def __post_init__(self) -> None: | |
| if not self.node_id or not self.operation or not self.tool: | |
| raise ValueError("evidence node requires id, operation and tool") | |
| if self.node_id in self.depends_on: | |
| raise ValueError(f"evidence node {self.node_id!r} depends on itself") | |
| def to_dict(self) -> dict[str, Any]: | |
| return _jsonable(self.__dict__) | |
| class EvalProcedure: | |
| rubric: QuestionRubric | |
| predicate: PredicateSpec | |
| nodes: tuple[EvidenceNodeSpec, ...] | |
| answer_mode: str | |
| compile_status: str | |
| compile_reasons: tuple[str, ...] = () | |
| gt_policy: str = "not_allowed" | |
| source_decision_rule: dict[str, Any] = field(default_factory=dict) | |
| decision_spec: DecisionSpec | None = None | |
| schema_version: str = SCHEMA_VERSION | |
| def __post_init__(self) -> None: | |
| if self.answer_mode not in ANSWER_MODES: | |
| raise ValueError(f"invalid answer mode: {self.answer_mode}") | |
| if self.compile_status not in COMPILE_STATUSES: | |
| raise ValueError(f"invalid compile status: {self.compile_status}") | |
| node_ids = [node.node_id for node in self.nodes] | |
| if len(node_ids) != len(set(node_ids)): | |
| raise ValueError("duplicate evidence node ids") | |
| known = set(node_ids) | |
| for node in self.nodes: | |
| missing = set(node.depends_on) - known | |
| if missing: | |
| raise ValueError(f"node {node.node_id!r} has unknown dependencies: {sorted(missing)}") | |
| if self.predicate.deterministic and self.answer_mode == "vlm_required": | |
| raise ValueError("deterministic predicate cannot require VLM-only answering") | |
| if self.answer_mode == "manual_only" and self.compile_status != "manual_required": | |
| raise ValueError("manual-only answer mode requires manual_required compile status") | |
| if self.answer_mode == "manual_only" and self.predicate.deterministic: | |
| raise ValueError("manual-only procedure cannot carry deterministic predicate") | |
| def procedure_hash(self) -> str: | |
| return stable_hash(self.to_dict(include_hash=False)) | |
| def to_dict(self, *, include_hash: bool = True) -> dict[str, Any]: | |
| payload = { | |
| "schema_version": self.schema_version, | |
| "rubric": self.rubric.to_dict(), | |
| "predicate": self.predicate.to_dict(), | |
| "nodes": [node.to_dict() for node in self.nodes], | |
| "answer_mode": self.answer_mode, | |
| "compile_status": self.compile_status, | |
| "compile_reasons": list(self.compile_reasons), | |
| "gt_policy": self.gt_policy, | |
| "source_decision_rule": _jsonable(self.source_decision_rule), | |
| "decision_spec": self.decision_spec.to_dict() if self.decision_spec is not None else None, | |
| } | |
| if include_hash: | |
| payload["procedure_hash"] = stable_hash(payload) | |
| return payload | |
| class QuestionSpec(EvalProcedure): | |
| """Frozen, executable specification for one audited atomic question. | |
| ``EvalProcedure`` remains as the compatibility/base type used by DAG | |
| utilities; compilers emit this more explicit public type. | |
| """ | |
| pass | |
| class EvidenceNodeResult: | |
| node_id: str | |
| status: str | |
| call_ids: tuple[str, ...] = () | |
| facts: dict[str, Any] = field(default_factory=dict) | |
| artifacts: tuple[dict[str, Any], ...] = () | |
| limitations: tuple[str, ...] = () | |
| def __post_init__(self) -> None: | |
| if self.status not in TERMINAL_EVIDENCE_STATUSES: | |
| raise ValueError(f"invalid evidence status: {self.status}") | |
| if self.status == "success" and not self.call_ids and self.node_id not in {"derive_facts", "render_overlay"}: | |
| raise ValueError(f"successful evidence node {self.node_id!r} requires provenance call_ids") | |
| def to_dict(self) -> dict[str, Any]: | |
| return _jsonable(self.__dict__) | |
| class EvidencePacket: | |
| case_id: str | |
| check_id: str | |
| procedure_hash: str | |
| nodes: tuple[EvidenceNodeResult, ...] | |
| derived_facts: dict[str, Any] | |
| visual_artifacts: tuple[dict[str, Any], ...] = () | |
| status: str = "insufficient" | |
| reasons: tuple[str, ...] = () | |
| schema_version: str = "pvr.evidence_packet.v2" | |
| def __post_init__(self) -> None: | |
| if self.status not in TERMINAL_EVIDENCE_STATUSES: | |
| raise ValueError(f"invalid evidence packet status: {self.status}") | |
| ids = [node.node_id for node in self.nodes] | |
| if len(ids) != len(set(ids)): | |
| raise ValueError("duplicate node results in evidence packet") | |
| def successful_call_ids(self) -> tuple[str, ...]: | |
| values = {call_id for node in self.nodes if node.status == "success" for call_id in node.call_ids if call_id} | |
| return tuple(sorted(values)) | |
| def packet_hash(self) -> str: | |
| return stable_hash(self.to_dict(include_hash=False)) | |
| def to_dict(self, *, include_hash: bool = True) -> dict[str, Any]: | |
| payload = { | |
| "schema_version": self.schema_version, | |
| "case_id": self.case_id, | |
| "check_id": self.check_id, | |
| "procedure_hash": self.procedure_hash, | |
| "nodes": [node.to_dict() for node in self.nodes], | |
| "derived_facts": _jsonable(self.derived_facts), | |
| "visual_artifacts": [_jsonable(item) for item in self.visual_artifacts], | |
| "status": self.status, | |
| "reasons": list(self.reasons), | |
| } | |
| if include_hash: | |
| payload["packet_hash"] = stable_hash(payload) | |
| return payload | |
| class AnswerRecord: | |
| case_id: str | |
| check_id: str | |
| status: str | |
| score: float | |
| confidence: float | |
| answer_source: str | |
| evidence_packet_hash: str | |
| cited_call_ids: tuple[str, ...] | |
| rationale: str | |
| formal_eligible: bool | |
| reasons: tuple[str, ...] = () | |
| schema_version: str = "pvr.answer_record.v2" | |
| def __post_init__(self) -> None: | |
| if self.status not in ANSWER_STATUSES: | |
| raise ValueError(f"invalid answer status: {self.status}") | |
| if not 0.0 <= self.score <= 1.0 or not 0.0 <= self.confidence <= 1.0: | |
| raise ValueError("answer score and confidence must be in [0, 1]") | |
| if self.formal_eligible and (self.status == "uncertain" or not self.cited_call_ids): | |
| raise ValueError("formal answer requires a resolved status and cited tool calls") | |
| def to_dict(self) -> dict[str, Any]: | |
| return _jsonable(self.__dict__) | |