"""Compile audited rubrics plus resolved plans into executable v2 procedures. The compiler is deliberately conservative. A novel free-form decision-rule name never becomes executable merely because it resembles a registered checker. Only explicit normalizers may create deterministic predicates. """ from __future__ import annotations from dataclasses import dataclass from typing import Any, Mapping from pvr_eval.question_eval.schema import DecisionSpec, EvidenceNodeSpec, PredicateSpec, QuestionRubric, QuestionSpec OBJECT_CHECKERS = { "object_zone_checker", "object_presence_checker", "object_preservation_checker", "source_vacated_checker", "forbidden_overlap", "vehicle_slot_checker", "vehicle_penalty_checker", } TEXT_CHECKERS = {"text_ocr_checker", "date_window_digit_checker"} ROUTE_CHECKERS = {"route_mask_checker", "endpoint_checker", "line_connectivity_checker"} STATE_CHECKERS = { "state_checker", "state_image_proxy_checker", "symbol_checker", "symbol_delta_checker", "checkbox_symbol_checker", "color_classifier", "watch_hand_angle_parser", } PREDICATE_CHECKERS = { "count_in_region": OBJECT_CHECKERS, "source_normalized_clearance": OBJECT_CHECKERS, "attribute_object_in_region": OBJECT_CHECKERS, "text_match": TEXT_CHECKERS, "change_fraction": {"preservation"}, } CHECKER_TOOLS = { "object": {"yolo_world_roi", "fastsam_roi", "object_fact_deriver"}, "text": {"rapidocr_roi"}, "preservation": {"image_registration", "change_analysis_roi"}, } def _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 _regions(check: Mapping[str, Any]) -> tuple[dict[str, Any], ...]: raw = check.get("regions", []) return tuple(dict(item) for item in raw if isinstance(item, Mapping) and (item.get("region_id") or item.get("id"))) def _region_ids(check: Mapping[str, Any], parameters: Mapping[str, Any]) -> tuple[str, ...]: values = [str(item.get("region_id") or item.get("id")) for item in _regions(check)] for key in ("search_scope", "slot", "target_region", "region_id"): candidate = str(parameters.get(key) or "") if not candidate or candidate in values: continue if not values: values.append(candidate) return tuple(dict.fromkeys(value for value in values if value)) def _manual_predicate(check: Mapping[str, Any]) -> PredicateSpec: rule = check.get("decision_rule") if isinstance(check.get("decision_rule"), Mapping) else {} return PredicateSpec( kind="manual_review", subject_queries=_strings(check.get("object_queries")), region_ids=_region_ids(check, rule.get("parameters", {}) if isinstance(rule.get("parameters"), Mapping) else {}), parameters={ "pass_condition": str(rule.get("pass_condition", "")), "partial_condition": str(rule.get("partial_condition", "")), "fail_condition": str(rule.get("fail_condition", "")), }, deterministic=False, source_rule_type=str(rule.get("type", "")), ) def normalize_decision_spec(check: Mapping[str, Any]) -> tuple[DecisionSpec, tuple[str, ...]]: explicit = check.get("decision_spec") if isinstance(explicit, Mapping): try: spec = DecisionSpec.from_mapping(explicit) except (TypeError, ValueError) as exc: predicate = _manual_predicate(check) reason = f"invalid_decision_spec:{type(exc).__name__}:{exc}" return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,) declared_regions = {str(item.get("region_id") or item.get("id")) for item in _regions(check)} missing_regions = (set(spec.subject_region_ids) | set(spec.target_region_ids)) - declared_regions if missing_regions: reason = f"decision_spec_references_unknown_regions:{'|'.join(sorted(missing_regions))}" predicate = _manual_predicate(check) return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,) checker = str(check.get("primary_checker") or "") allowed_checkers = PREDICATE_CHECKERS.get(spec.predicate.kind, set()) if spec.mode == "objective" and checker not in allowed_checkers: reason = f"objective_predicate_checker_mismatch:{spec.predicate.kind}:{checker or ''}" predicate = _manual_predicate(check) return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,) if spec.mode == "objective" and not spec.target_region_ids and spec.predicate.kind in { "count_in_region", "source_normalized_clearance", "attribute_object_in_region", "text_match", "change_fraction", }: reason = "objective_decision_spec_missing_target_regions" predicate = _manual_predicate(check) return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,) if spec.mode == "objective": family = "object" if checker in OBJECT_CHECKERS else "text" if checker in TEXT_CHECKERS else "preservation" unsupported_tools = set(spec.required_tools) - CHECKER_TOOLS[family] if unsupported_tools: reason = f"objective_decision_spec_has_unsupported_tools:{'|'.join(sorted(unsupported_tools))}" predicate = _manual_predicate(check) return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,) return spec, tuple(spec.manual_reasons) rule = check.get("decision_rule") if isinstance(check.get("decision_rule"), Mapping) else {} rule_type = str(rule.get("type") or "") parameters = dict(rule.get("parameters", {}) or {}) if isinstance(rule.get("parameters"), Mapping) else {} subjects = _strings(check.get("object_queries")) region_ids = _region_ids(check, parameters) if rule_type == "forbidden_instance_count": predicate = PredicateSpec( kind="count_in_region", metric="output_count_inside", subject_queries=subjects, region_ids=region_ids, bands={ "pass": {"max": 0.0}, "partial": {"min": 1.0, "max": 2.0}, "fail": {"min": 3.0}, }, parameters={**parameters, "count_semantics": "forbidden_residual_instances"}, deterministic=True, source_rule_type=rule_type, ) return DecisionSpec("objective", predicate, target_region_ids=region_ids), () if rule_type == "nonexempt_center_object_count": predicate = PredicateSpec( kind="count_in_region", metric="output_count_inside", subject_queries=subjects, region_ids=region_ids, bands={ "pass": {"max": 0.0}, "partial": {"min": 1.0, "max": 1.0}, "fail": {"min": 2.0}, }, parameters={**parameters, "count_semantics": "nonexempt_residual_instances"}, deterministic=True, source_rule_type=rule_type, ) return DecisionSpec("objective", predicate, target_region_ids=region_ids), () if rule_type == "source_normalized_zone_clearance": partial_max = float(parameters.get("partial_remaining_fraction_max", 0.4)) predicate = PredicateSpec( kind="source_normalized_clearance", metric="remaining_fraction", subject_queries=subjects, region_ids=region_ids, bands={ "pass": {"max": 0.0}, "partial": {"min": 1e-12, "max": partial_max}, "fail": {"min": partial_max + 1e-12}, }, parameters=parameters, deterministic=True, source_rule_type=rule_type, ) return DecisionSpec("objective", predicate, target_region_ids=region_ids), () if rule_type == "assigned_vehicle_slot_predicate": pass_containment = float(parameters.get("pass_mask_containment", 0.85)) partial_containment = float(parameters.get("partial_mask_containment", 0.65)) predicate = PredicateSpec( kind="attribute_object_in_region", metric="mask_containment", subject_queries=subjects, region_ids=region_ids, bands={ "pass": {"min": pass_containment}, "partial": {"min": partial_containment, "max": pass_containment - 1e-12}, "fail": {"max": partial_containment - 1e-12}, }, parameters=parameters, deterministic=True, source_rule_type=rule_type, ) return DecisionSpec("objective", predicate, target_region_ids=region_ids), () predicate = _manual_predicate(check) reason = "unregistered_decision_rule" if rule_type else "missing_decision_rule_type" detail = f"{reason}:{rule_type or ''}" return DecisionSpec("manual_only", predicate, manual_reasons=(detail,)), (detail,) def normalize_predicate(check: Mapping[str, Any]) -> tuple[PredicateSpec, tuple[str, ...]]: """Compatibility wrapper returning the predicate from the decision spec.""" decision, reasons = normalize_decision_spec(check) return decision.predicate, reasons def _region_node(region: Mapping[str, Any]) -> EvidenceNodeSpec: region_id = str(region.get("region_id") or region.get("id")) method = str(region.get("proposal_method") or "") has_geometry = any(region.get(key) for key in ("bbox", "rect", "polygon", "points")) if has_geometry or method in {"manual_bbox", "manual_polygon"}: tool = "contract_region" elif "vlm" in method: tool = "vlm_region_proposer" else: tool = "grounding_dino_region" roles = _strings(region.get("source_image")) or ("pred",) if roles == ("both",): roles = ("input", "pred") return EvidenceNodeSpec( node_id=f"region:{region_id}", operation="resolve_region", tool=tool, image_roles=roles, region_ids=(region_id,), parameters={ "proposal_method": method, "query_or_rule": str(region.get("query_or_rule") or ""), "description": str(region.get("description") or ""), **{key: region[key] for key in ("bbox", "rect", "polygon", "points") if key in region}, }, ) def build_evidence_nodes(check: Mapping[str, Any], predicate: PredicateSpec) -> tuple[EvidenceNodeSpec, ...]: checker = str(check.get("primary_checker") or "vlm_audit") relevant_region_ids = set(predicate.region_ids) region_nodes_list = [ _region_node(region) for region in _regions(check) if not relevant_region_ids or str(region.get("region_id") or region.get("id")) in relevant_region_ids ] if predicate.kind in {"count_in_region", "attribute_object_in_region", "text_match"}: region_nodes_list = [ EvidenceNodeSpec( node_id=node.node_id, operation=node.operation, tool=node.tool, image_roles=("pred",), depends_on=node.depends_on, region_ids=node.region_ids, inputs=node.inputs, required=node.required, parameters=node.parameters, ) for node in region_nodes_list ] elif predicate.kind == "source_normalized_clearance": region_nodes_list = [ EvidenceNodeSpec( node_id=node.node_id, operation=node.operation, tool=node.tool, image_roles=("input", "pred"), depends_on=node.depends_on, region_ids=node.region_ids, inputs=node.inputs, required=node.required, parameters=node.parameters, ) for node in region_nodes_list ] # Resolved parking plans keep the authoritative slot bbox in the decision # rule rather than duplicating it in the region proposal. Copy it into the # executable region node so replay never has to parse prose. slot_bbox = predicate.parameters.get("slot_bbox") slot_id = str(predicate.parameters.get("slot") or "") if isinstance(slot_bbox, (list, tuple)) and len(slot_bbox) == 4: for index, node in enumerate(region_nodes_list): if not slot_id or slot_id in node.region_ids or f"{slot_id}_exact" in node.region_ids: region_nodes_list[index] = EvidenceNodeSpec( node_id=node.node_id, operation=node.operation, tool="contract_region", image_roles=node.image_roles, depends_on=node.depends_on, region_ids=node.region_ids, inputs=node.inputs, required=node.required, parameters={**node.parameters, "bbox": list(slot_bbox)}, ) region_nodes = tuple(region_nodes_list) region_dependencies = tuple(node.node_id for node in region_nodes) declared_region_ids = tuple(node.region_ids[0] for node in region_nodes) region_ids = predicate.region_ids or declared_region_ids query_params = { "queries": list(predicate.subject_queries), "roi_required": bool(region_ids), "roi_region_ids": list(region_ids), } if checker in OBJECT_CHECKERS: detect = EvidenceNodeSpec( node_id="detect_objects", operation="detect_objects", tool="yolo_world_roi", image_roles=("input", "pred") if checker in {"object_preservation_checker", "source_vacated_checker"} else ("pred",), depends_on=region_dependencies, region_ids=region_ids, inputs=tuple(f"roi:{region_id}" for region_id in region_ids), parameters=query_params, ) mask = EvidenceNodeSpec( node_id="refine_masks", operation="refine_masks", tool="fastsam_roi", image_roles=detect.image_roles, depends_on=(*region_dependencies, detect.node_id), region_ids=region_ids, inputs=("detections:detect_objects",), parameters={"bbox_fallback_allowed": False}, ) derive = EvidenceNodeSpec( node_id="derive_facts", operation="derive_predicate_facts", tool="object_fact_deriver", image_roles=detect.image_roles, depends_on=(*region_dependencies, detect.node_id, mask.node_id), region_ids=region_ids, inputs=("detections:detect_objects", "masks:refine_masks"), parameters={"predicate": predicate.to_dict()}, ) overlay = EvidenceNodeSpec( node_id="render_overlay", operation="render_evidence_overlay", tool="overlay_renderer", image_roles=("pred",), depends_on=(*region_dependencies, derive.node_id), region_ids=region_ids, inputs=("facts:derive_facts",), ) return (*region_nodes, detect, mask, derive, overlay) if checker in TEXT_CHECKERS: ocr = EvidenceNodeSpec( node_id="read_text", operation="ocr", tool="rapidocr_roi", image_roles=("pred",), depends_on=region_dependencies, region_ids=region_ids, inputs=tuple(f"roi:{region_id}" for region_id in region_ids), parameters={"predicate": predicate.to_dict()}, ) overlay = EvidenceNodeSpec( node_id="render_overlay", operation="render_evidence_overlay", tool="overlay_renderer", image_roles=("pred",), depends_on=(*region_dependencies, ocr.node_id), region_ids=region_ids, parameters={"predicate": predicate.to_dict()}, ) return (*region_nodes, ocr, overlay) if checker in ROUTE_CHECKERS: route = EvidenceNodeSpec( node_id="parse_route", operation="parse_route", tool="route_parser_roi", image_roles=("pred",), depends_on=region_dependencies, region_ids=region_ids, inputs=tuple(f"roi:{region_id}" for region_id in region_ids), ) overlay = EvidenceNodeSpec( node_id="render_overlay", operation="render_evidence_overlay", tool="overlay_renderer", image_roles=("pred",), depends_on=(*region_dependencies, route.node_id), region_ids=region_ids, ) return (*region_nodes, route, overlay) if checker == "preservation": registration = EvidenceNodeSpec( node_id="register_images", operation="image_registration", tool="image_registration", image_roles=("input", "pred"), ) change = EvidenceNodeSpec( node_id="measure_change", operation="change_analysis", tool="change_analysis_roi", image_roles=("input", "pred"), # The cached change-analysis row already contains exact metrics # keyed by the contract region IDs. Re-resolving those regions is # unnecessary and can invalidate otherwise auditable evidence. depends_on=(registration.node_id,), region_ids=region_ids, parameters={"predicate": predicate.to_dict()}, ) overlay = EvidenceNodeSpec( node_id="render_overlay", operation="render_evidence_overlay", tool="overlay_renderer", image_roles=("pred",), depends_on=(change.node_id,), region_ids=region_ids, ) return (registration, change, overlay) if checker in STATE_CHECKERS: parser = EvidenceNodeSpec( node_id="parse_state", operation="parse_state", tool="structured_state_parser", image_roles=("pred",), depends_on=region_dependencies, region_ids=region_ids, ) overlay = EvidenceNodeSpec( node_id="render_overlay", operation="render_evidence_overlay", tool="overlay_renderer", image_roles=("pred",), depends_on=(*region_dependencies, parser.node_id), region_ids=region_ids, ) return (*region_nodes, parser, overlay) crop = EvidenceNodeSpec( node_id="render_overlay", operation="render_evidence_overlay", tool="overlay_renderer", image_roles=("input", "pred"), depends_on=region_dependencies, region_ids=region_ids, parameters={"semantic_vlm_packet": True}, ) return (*region_nodes, crop) def _contract_questions(contract: Mapping[str, Any]) -> dict[str, Mapping[str, Any]]: questions = list(contract.get("atomic_checks", [])) if not questions: questions = [ *({"role": "reward", **item} for item in contract.get("reward_questions", []) if isinstance(item, Mapping)), *({"role": "penalty", **item} for item in contract.get("penalty_questions", []) if isinstance(item, Mapping)), ] return {str(item.get("id") or item.get("check_id")): item for item in questions if isinstance(item, Mapping)} def compile_case(contract: Mapping[str, Any], resolved_plan: Mapping[str, Any]) -> tuple[QuestionSpec, ...]: case_id = str(contract.get("case_id") or resolved_plan.get("case_id") or "") questions = _contract_questions(contract) procedures: list[QuestionSpec] = [] seen: set[str] = set() for check in resolved_plan.get("checks", []): if not isinstance(check, Mapping): continue check_id = str(check.get("id") or "") source = questions.get(check_id) if source is None: continue seen.add(check_id) rubric = QuestionRubric.from_contract_item(case_id, source) decision_spec, reasons = normalize_decision_spec(check) predicate = decision_spec.predicate answer_mode = "deterministic" if decision_spec.mode == "objective" else "manual_only" procedures.append( QuestionSpec( rubric=rubric, predicate=predicate, nodes=build_evidence_nodes(check, predicate), answer_mode=answer_mode, compile_status="executable" if decision_spec.mode == "objective" else "manual_required", compile_reasons=reasons, gt_policy="not_allowed", source_decision_rule=dict(check.get("decision_rule", {}) or {}), decision_spec=decision_spec, ) ) for check_id, source in questions.items(): if check_id in seen: continue rubric = QuestionRubric.from_contract_item(case_id, source) predicate = PredicateSpec(kind="manual_review", deterministic=False, source_rule_type="") reason = "missing_resolved_check" decision_spec = DecisionSpec("manual_only", predicate, manual_reasons=(reason,)) procedures.append( QuestionSpec( rubric=rubric, predicate=predicate, nodes=(), answer_mode="manual_only", compile_status="manual_required", compile_reasons=(reason,), gt_policy="not_allowed", decision_spec=decision_spec, ) ) return tuple(procedures)