Datasets:
Download code/src/pvr_eval/contracts/compilation_gate.py from wenjieshu/solveedit_benchmark_2728: direct link, hf CLI and curl.
- Browser
- Download file 21.4 kB
-
https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/contracts/compilation_gate.py
- Command line
-
hf download hf://datasets/wenjieshu/solveedit_benchmark_2728/code/src/pvr_eval/contracts/compilation_gate.py
-
curl -L -o compilation_gate.py https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/contracts/compilation_gate.py
21.4 kB
| """Release gate for natural-language contract to typed-predicate compilation. | |
| Schema validation answers whether a predicate record is well formed. This | |
| module answers the stricter question needed before an evaluation run: did | |
| every scored contract check become an executable, tool-backed predicate? | |
| """ | |
| from __future__ import annotations | |
| from collections import Counter | |
| from dataclasses import dataclass | |
| import hashlib | |
| from typing import Any, Mapping | |
| from pvr_eval.agent.executable_predicate import validate_executable_predicate | |
| from pvr_eval.agent.source_instance_selector import has_relational_identity_query | |
| from pvr_eval.contracts.fact_producer_registry import ( | |
| objective_obligation_producer, | |
| objective_producer_for_binding, | |
| runtime_producer_supports_binding, | |
| ) | |
| from pvr_eval.contracts.predicate_lowering import ( | |
| reviewed_region_policy_reasons, | |
| reviewed_source_check_sha256, | |
| ) | |
| from pvr_eval.contracts.region_materializer_registry import executable_region_materializer | |
| from pvr_eval.core.schema import EvalContract | |
| class CompilationGatePolicy: | |
| """Policy controlling which compiled contracts may enter evaluation.""" | |
| name: str = "strict-zero-vlm" | |
| minimum_executable_weight_coverage: float = 1.0 | |
| allow_manual_review: bool = False | |
| allow_vlm_fallback: bool = False | |
| require_physical_tool_calls: bool = True | |
| def policy_for_name(name: str) -> CompilationGatePolicy: | |
| normalized = str(name or "").strip().lower() | |
| if normalized == "strict-zero-vlm": | |
| return CompilationGatePolicy() | |
| if normalized == "hybrid-review": | |
| return CompilationGatePolicy( | |
| name="hybrid-review", | |
| minimum_executable_weight_coverage=0.0, | |
| allow_manual_review=True, | |
| allow_vlm_fallback=True, | |
| ) | |
| if normalized == "report-only": | |
| return CompilationGatePolicy( | |
| name="report-only", | |
| minimum_executable_weight_coverage=0.0, | |
| allow_manual_review=True, | |
| allow_vlm_fallback=True, | |
| require_physical_tool_calls=False, | |
| ) | |
| raise ValueError(f"unknown compilation gate policy: {name!r}") | |
| def _mapping(value: Any) -> Mapping[str, Any]: | |
| return value if isinstance(value, Mapping) else {} | |
| def _predicate_from_compiled_check(compiled: Mapping[str, Any]) -> Mapping[str, Any]: | |
| direct = compiled.get("executable_predicate") | |
| if isinstance(direct, Mapping): | |
| return direct | |
| params = _mapping(compiled.get("params")) | |
| nested = params.get("executable_predicate") | |
| return nested if isinstance(nested, Mapping) else {} | |
| def _region_ids(values: Any) -> set[str]: | |
| if not isinstance(values, (list, tuple)): | |
| return set() | |
| return { | |
| str(item.get("region_id") or item.get("id") or "").strip() | |
| for item in values | |
| if isinstance(item, Mapping) and str(item.get("region_id") or item.get("id") or "").strip() | |
| } | |
| def _source_contract_sha256(contract: EvalContract) -> str: | |
| if contract.source_path is None or not contract.source_path.is_file(): | |
| return "" | |
| return hashlib.sha256(contract.source_path.read_bytes()).hexdigest() | |
| def validate_contract_compilation( | |
| contract: EvalContract, | |
| plan: Mapping[str, Any], | |
| *, | |
| policy: CompilationGatePolicy | None = None, | |
| ) -> dict[str, Any]: | |
| """Validate semantic executability of one compiled contract and plan. | |
| ``blocked_uncompiled`` is a valid serialization state, but it is never a | |
| successful compilation in strict mode. The report keeps that distinction | |
| explicit so a batch cannot receive a green light merely because all JSON | |
| records conform to their schemas. | |
| """ | |
| policy = policy or CompilationGatePolicy() | |
| checks_by_id = {check.check_id: check for check in contract.atomic_checks} | |
| plan_rows = { | |
| str(item.get("check_id") or ""): item | |
| for item in plan.get("check_plans", []) | |
| if isinstance(item, Mapping) and item.get("check_id") | |
| } | |
| compiled_rows = _mapping(plan.get("compiled_checks")) | |
| total_weight = sum(max(0.0, check.weight) for check in contract.atomic_checks) | |
| executable_weight = 0.0 | |
| manual_weight = 0.0 | |
| fallback_weight = 0.0 | |
| status_counts: Counter[str] = Counter() | |
| reason_counts: Counter[str] = Counter() | |
| detail_rows: list[dict[str, Any]] = [] | |
| fatal_reasons: list[str] = [] | |
| expected_ids = set(checks_by_id) | |
| plan_ids = set(plan_rows) | |
| for missing in sorted(expected_ids - plan_ids): | |
| fatal_reasons.append(f"missing_check_plan:{missing}") | |
| for extra in sorted(plan_ids - expected_ids): | |
| fatal_reasons.append(f"orphan_check_plan:{extra}") | |
| for check_id, check in checks_by_id.items(): | |
| check_plan = _mapping(plan_rows.get(check_id)) | |
| compiled = _mapping(compiled_rows.get(check_id)) | |
| predicate = _predicate_from_compiled_check(compiled) | |
| plan_status = str(check_plan.get("status") or "missing") | |
| predicate_status = str(predicate.get("status") or "missing") | |
| plan_reasons = [str(item) for item in check_plan.get("reasons", []) or []] | |
| validation = validate_executable_predicate(predicate) if predicate else None | |
| check_reasons: list[str] = [] | |
| runtime_missing_fact_capabilities: list[dict[str, str]] = [] | |
| status_counts[plan_status] += 1 | |
| for reason in plan_reasons: | |
| reason_counts[reason] += 1 | |
| if not check_plan: | |
| check_reasons.append("missing_check_plan") | |
| if not predicate: | |
| check_reasons.append("missing_executable_predicate") | |
| elif validation is not None and not validation.valid: | |
| check_reasons.extend(f"invalid_predicate:{item}" for item in validation.reasons) | |
| unmapped = list(predicate.get("unmapped_contract_parameters", []) or []) if predicate else [] | |
| if unmapped: | |
| check_reasons.append("unmapped_contract_parameters") | |
| if ( | |
| predicate | |
| and str(predicate.get("family") or "") == "source_region_clearance" | |
| and has_relational_identity_query(predicate) | |
| and not str(_mapping(predicate.get("parameters")).get("source_selector_profile") or "") | |
| ): | |
| check_reasons.append("relational_identity_without_typed_selector") | |
| compiled_params = _mapping(compiled.get("params")) | |
| declared_region_ids = _region_ids(compiled_params.get("planned_regions")) | |
| consumed_region_ids = _region_ids(predicate.get("regions")) if predicate else set() | |
| ignored_region_ids = { | |
| str(item) for item in predicate.get("explicitly_ignored_region_ids", []) or [] | |
| } if predicate else set() | |
| unconsumed_region_ids = sorted(declared_region_ids - consumed_region_ids - ignored_region_ids) | |
| if unconsumed_region_ids and not ( | |
| plan_status == "manual_review_required" and policy.allow_manual_review | |
| ): | |
| check_reasons.append("unconsumed_contract_regions") | |
| # Reviewed golden-IR predicates carry stronger semantic evidence than | |
| # the base executable schema. Validate that every source parameter is | |
| # bound, every materializer is concrete, and all mutation witnesses ran. | |
| if predicate and predicate.get("capability_versions"): | |
| policy_reasons = reviewed_region_policy_reasons(predicate) | |
| if policy_reasons: | |
| check_reasons.extend(policy_reasons) | |
| source_parameters = _mapping(_mapping(compiled_params.get("decision_rule")).get("parameters")) | |
| parameter_bindings = [ | |
| item for item in predicate.get("parameter_bindings", []) or [] | |
| if isinstance(item, Mapping) | |
| ] | |
| bound_keys = { | |
| str(item.get("source_key") or "") for item in parameter_bindings | |
| if str(item.get("source_key") or "") in source_parameters | |
| } | |
| missing_parameter_bindings = sorted(set(source_parameters) - bound_keys) | |
| if missing_parameter_bindings: | |
| check_reasons.append("source_parameters_without_bindings") | |
| materializer_failures = [ | |
| str(item.get("region_id") or "") | |
| for item in predicate.get("regions", []) or [] | |
| if isinstance(item, Mapping) | |
| and str(_mapping(item.get("materializer")).get("kind") or "") in {"", "unsupported"} | |
| ] | |
| if materializer_failures: | |
| check_reasons.append("unregistered_region_materializers") | |
| runtime_materializer_failures = [ | |
| str(item.get("region_id") or "") | |
| for item in predicate.get("regions", []) or [] | |
| if isinstance(item, Mapping) | |
| and not executable_region_materializer( | |
| str(_mapping(item.get("materializer")).get("kind") or "") | |
| ) | |
| ] | |
| if runtime_materializer_failures: | |
| check_reasons.append("region_materializer_runtime_unavailable") | |
| witnesses = [ | |
| item for item in predicate.get("witness_results", []) or [] | |
| if isinstance(item, Mapping) | |
| ] | |
| if not witnesses: | |
| check_reasons.append("missing_compilation_witnesses") | |
| elif any(not bool(item.get("passed")) for item in witnesses): | |
| check_reasons.append("compilation_witness_failed") | |
| if not str(predicate.get("source_check_sha256") or ""): | |
| check_reasons.append("missing_source_check_sha256") | |
| elif ( | |
| _mapping(predicate.get("provenance")).get("compiler") | |
| == "pvr_eval.contracts.predicate_lowering.lower_reviewed_predicate" | |
| and check.source_payload | |
| and | |
| str(predicate.get("source_check_sha256") or "") | |
| != reviewed_source_check_sha256(check.source_payload) | |
| ): | |
| check_reasons.append("source_check_hash_mismatch") | |
| decision_bindings = [ | |
| item for item in predicate.get("parameter_bindings", []) or [] | |
| if isinstance(item, Mapping) and item.get("consumer") == "decision_clause" | |
| ] | |
| producer_rows = [ | |
| item for item in predicate.get("fact_producers", []) or [] | |
| if isinstance(item, Mapping) | |
| ] | |
| producers_by_clause = { | |
| str(item.get("clause_id") or ""): item for item in producer_rows | |
| } | |
| missing_fact_producers = [ | |
| str(item.get("clause_id") or item.get("fact") or "missing") | |
| for item in decision_bindings | |
| if not str(_mapping(producers_by_clause.get(str(item.get("clause_id") or ""))).get("producer") or "") | |
| ] | |
| if missing_fact_producers: | |
| check_reasons.append("decision_facts_without_registered_producers") | |
| producer_mismatches: list[str] = [] | |
| predicate_family = str(predicate.get("family") or "") | |
| predicate_rule = str(predicate.get("source_rule_type") or "") | |
| expected_obligation_producer = objective_obligation_producer( | |
| predicate_family, | |
| predicate_rule, | |
| ) | |
| for binding in decision_bindings: | |
| clause_id = str(binding.get("clause_id") or binding.get("fact") or "missing") | |
| producer_row = _mapping(producers_by_clause.get(str(binding.get("clause_id") or ""))) | |
| declared_producer = str(producer_row.get("producer") or "") | |
| declared_mode = str(producer_row.get("mode") or "") | |
| binding_producer = str(binding.get("producer") or "") | |
| binding_mode = str(binding.get("producer_mode") or "") | |
| fact = str(binding.get("fact") or "") | |
| expected_objective = objective_producer_for_binding( | |
| predicate_family, | |
| binding, | |
| _mapping(predicate.get("parameters")), | |
| ) | |
| if fact.startswith("obligation:"): | |
| if expected_obligation_producer: | |
| valid = ( | |
| declared_producer == expected_obligation_producer | |
| and declared_mode == "objective" | |
| ) | |
| else: | |
| valid = ( | |
| declared_producer == "reviewed_semantic_vlm" | |
| and declared_mode == "semantic_vlm" | |
| ) | |
| elif expected_objective: | |
| valid = declared_producer == expected_objective and declared_mode == "objective" | |
| else: | |
| valid = declared_producer == "reviewed_semantic_vlm" and declared_mode == "semantic_vlm" | |
| valid = bool( | |
| valid | |
| and binding_producer == declared_producer | |
| and binding_mode == declared_mode | |
| ) | |
| if not valid: | |
| producer_mismatches.append(clause_id) | |
| elif declared_mode == "objective" and not runtime_producer_supports_binding( | |
| declared_producer, | |
| binding, | |
| predicate, | |
| ): | |
| runtime_missing_fact_capabilities.append( | |
| { | |
| "clause_id": clause_id, | |
| "fact": fact, | |
| "producer": declared_producer, | |
| } | |
| ) | |
| if producer_mismatches: | |
| check_reasons.append("fact_producer_runtime_mismatch") | |
| if runtime_missing_fact_capabilities: | |
| check_reasons.append("objective_fact_runtime_capability_missing") | |
| semantic_requirements = [ | |
| item for item in producer_rows | |
| if str(item.get("mode") or "") == "semantic_vlm" | |
| ] | |
| if semantic_requirements and not policy.allow_vlm_fallback: | |
| check_reasons.append("semantic_vlm_forbidden_by_policy") | |
| decision = _mapping(predicate.get("decision")) if predicate else {} | |
| if plan_status in {"executable", "fallback_required"}: | |
| allowed_outcomes = { | |
| str(item) for item in decision.get("allowed_outcomes", []) or [] | |
| } | |
| explicit_or_allowed = set(decision) | allowed_outcomes | |
| missing_branches = [ | |
| branch for branch in ("pass", "fail", "unknown") | |
| if branch not in explicit_or_allowed | |
| ] | |
| if missing_branches: | |
| check_reasons.append("incomplete_decision_table:" + ",".join(missing_branches)) | |
| source_decision = _mapping(compiled_params.get("decision_rule")) | |
| if ( | |
| str(source_decision.get("partial_condition") or "").strip() | |
| and "partial" not in explicit_or_allowed | |
| ): | |
| check_reasons.append("missing_partial_decision_branch") | |
| tool_call_ids = [str(item) for item in check_plan.get("tool_call_ids", []) or []] | |
| if plan_status == "executable": | |
| if predicate_status != "executable": | |
| check_reasons.append(f"predicate_status_mismatch:{predicate_status}") | |
| if policy.require_physical_tool_calls and not tool_call_ids: | |
| check_reasons.append("executable_check_has_no_physical_tool_calls") | |
| if not check_reasons: | |
| executable_weight += max(0.0, check.weight) | |
| elif plan_status == "manual_review_required": | |
| manual_weight += max(0.0, check.weight) | |
| if not policy.allow_manual_review: | |
| check_reasons.append("manual_review_forbidden_by_policy") | |
| elif plan_status == "fallback_required": | |
| fallback = str(check_plan.get("fallback") or "") | |
| if not fallback: | |
| check_reasons.append("fallback_required_without_explicit_executor") | |
| if predicate_status != "executable": | |
| check_reasons.append(f"predicate_status_mismatch:{predicate_status}") | |
| if not policy.allow_vlm_fallback: | |
| check_reasons.append("vlm_fallback_forbidden_by_policy") | |
| if policy.require_physical_tool_calls and not tool_call_ids: | |
| check_reasons.append("fallback_check_has_no_physical_tool_calls") | |
| if not check_reasons: | |
| fallback_weight += max(0.0, check.weight) | |
| else: | |
| check_reasons.append(f"non_executable_plan_status:{plan_status}") | |
| for reason in check_reasons: | |
| reason_counts[reason] += 1 | |
| fatal_reasons.append(f"{check_id}:{reason}") | |
| detail_rows.append( | |
| { | |
| "check_id": check_id, | |
| "role": check.role, | |
| "weight": check.weight, | |
| "checker": check.checker, | |
| "plan_status": plan_status, | |
| "predicate_status": predicate_status, | |
| "predicate_family": str(predicate.get("family") or ""), | |
| "source_rule_type": str(predicate.get("source_rule_type") or ""), | |
| "tool_call_count": len(tool_call_ids), | |
| "unmapped_contract_parameters": unmapped, | |
| "declared_region_ids": sorted(declared_region_ids), | |
| "consumed_region_ids": sorted(consumed_region_ids), | |
| "unconsumed_region_ids": unconsumed_region_ids, | |
| "runtime_unavailable_region_ids": ( | |
| runtime_materializer_failures | |
| if predicate and predicate.get("capability_versions") | |
| else [] | |
| ), | |
| "witness_count": len(predicate.get("witness_results", []) or []) if predicate else 0, | |
| "semantic_fact_count": len(predicate.get("semantic_fact_requirements", []) or []) if predicate else 0, | |
| "runtime_missing_fact_capabilities": runtime_missing_fact_capabilities, | |
| "plan_reasons": plan_reasons, | |
| "gate_reasons": check_reasons, | |
| "passed": not check_reasons, | |
| } | |
| ) | |
| coverage = executable_weight / total_weight if total_weight > 0 else 0.0 | |
| if coverage + 1e-12 < policy.minimum_executable_weight_coverage: | |
| fatal_reasons.append( | |
| "executable_weight_coverage_below_minimum:" | |
| f"{coverage:.6f}<{policy.minimum_executable_weight_coverage:.6f}" | |
| ) | |
| # report-only is intentionally non-blocking, but still exposes whether the | |
| # same batch would pass the semantic release gate. | |
| semantic_passed = not fatal_reasons | |
| enforced_passed = True if policy.name == "report-only" else semantic_passed | |
| return { | |
| "schema_version": "pvr.contract_compilation_gate.v1", | |
| "case_id": contract.case_id, | |
| "source_contract_sha256": _source_contract_sha256(contract), | |
| "policy": policy.name, | |
| "passed": enforced_passed, | |
| "semantic_passed": semantic_passed, | |
| "check_count": len(contract.atomic_checks), | |
| "total_weight": round(total_weight, 6), | |
| "executable_weight": round(executable_weight, 6), | |
| "manual_review_weight": round(manual_weight, 6), | |
| "fallback_weight": round(fallback_weight, 6), | |
| "executable_weight_coverage": round(coverage, 6), | |
| "minimum_executable_weight_coverage": policy.minimum_executable_weight_coverage, | |
| "status_counts": dict(sorted(status_counts.items())), | |
| "reason_counts": dict(reason_counts.most_common()), | |
| "fatal_reasons": fatal_reasons, | |
| "checks": detail_rows, | |
| } | |
| def summarize_compilation_gates( | |
| reports: list[Mapping[str, Any]], | |
| *, | |
| policy_name: str, | |
| ) -> dict[str, Any]: | |
| status_counts: Counter[str] = Counter() | |
| reason_counts: Counter[str] = Counter() | |
| total_checks = 0 | |
| total_weight = executable_weight = fallback_weight = 0.0 | |
| failed_cases: list[str] = [] | |
| for report in reports: | |
| total_checks += int(report.get("check_count", 0)) | |
| total_weight += float(report.get("total_weight", 0.0)) | |
| executable_weight += float(report.get("executable_weight", 0.0)) | |
| fallback_weight += float(report.get("fallback_weight", 0.0)) | |
| status_counts.update(_mapping(report.get("status_counts"))) | |
| reason_counts.update(_mapping(report.get("reason_counts"))) | |
| if not bool(report.get("passed")): | |
| failed_cases.append(str(report.get("case_id") or "")) | |
| return { | |
| "schema_version": "pvr.contract_compilation_gate_batch.v1", | |
| "policy": policy_name, | |
| "passed": not failed_cases, | |
| "case_count": len(reports), | |
| "failed_case_count": len(failed_cases), | |
| "failed_cases": failed_cases, | |
| "check_count": total_checks, | |
| "total_weight": round(total_weight, 6), | |
| "executable_weight": round(executable_weight, 6), | |
| "fallback_weight": round(fallback_weight, 6), | |
| "executable_weight_coverage": round(executable_weight / total_weight, 6) if total_weight else 0.0, | |
| "status_counts": dict(sorted(status_counts.items())), | |
| "reason_counts": dict(reason_counts.most_common()), | |
| } | |