| from __future__ import annotations |
|
|
| import json |
| import pickle |
| import unittest |
| from copy import deepcopy |
| from pathlib import Path |
| from typing import Any, Callable |
|
|
| from barbet_bgd.generation_v2 import GenerationPlanV2, generate_record_v2 |
| from barbet_bgd.quality_v2 import ( |
| EXPECTED_TASK_FAMILIES_V2, |
| PromotionAccumulator, |
| expected_source_hash_v2, |
| validate_record_quality_v2, |
| ) |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
|
|
| def _rehash(record: dict[str, Any]) -> None: |
| record["provenance"]["source_hash"] = expected_source_hash_v2(record) |
|
|
|
|
| def _replace_strings(value: Any, replacements: dict[str, str]) -> Any: |
| if isinstance(value, str): |
| return replacements.get(value, value) |
| if isinstance(value, list): |
| return [_replace_strings(item, replacements) for item in value] |
| if isinstance(value, dict): |
| return { |
| replacements.get(key, key): _replace_strings(item, replacements) |
| for key, item in value.items() |
| } |
| return value |
|
|
|
|
| class QualityV2Tests(unittest.TestCase): |
| @classmethod |
| def setUpClass(cls) -> None: |
| cls.config = json.loads( |
| (ROOT / "configs/selected_sft_1m_v2.json").read_text(encoding="utf-8") |
| ) |
| cls.plan = GenerationPlanV2(cls.config) |
| cls.records = [generate_record_v2(cls.config, cls.plan, index) for index in range(1_200)] |
|
|
| @classmethod |
| def one(cls, predicate: Callable[[dict[str, Any]], bool]) -> dict[str, Any]: |
| return deepcopy(next(record for record in cls.records if predicate(record))) |
|
|
| def assert_rejected(self, record: dict[str, Any], failure: str) -> dict[str, Any]: |
| verdict = validate_record_quality_v2(record) |
| self.assertEqual(verdict["disposition"], "REJECT") |
| self.assertFalse(verdict["training_ready"]) |
| self.assertIn(failure, verdict["hard_failures"]) |
| return verdict |
|
|
| def test_positive_one_record_from_every_family(self): |
| by_family = {} |
| for record in self.records: |
| by_family.setdefault(record["task_family"], record) |
| self.assertEqual(set(by_family), set(EXPECTED_TASK_FAMILIES_V2)) |
| for family, record in by_family.items(): |
| with self.subTest(family=family): |
| verdict = validate_record_quality_v2(record) |
| self.assertEqual(verdict["hard_failures"], []) |
| self.assertEqual(verdict["disposition"], "KEEP") |
|
|
| def test_visible_query_and_schema_are_hard_gates(self): |
| record = self.one(lambda row: row["primitive"] == "EXTRACT") |
| del record["task_spec"]["query"] |
| del record["task_spec"]["requested_schema"] |
| _rehash(record) |
| verdict = self.assert_rejected(record, "MODEL_VISIBLE_QUERY_FIELD_MISSING_OR_INVALID") |
| self.assertIn("MODEL_VISIBLE_REQUESTED_SCHEMA_MISSING", verdict["hard_failures"]) |
|
|
| def test_family_input_signature_mutation_is_rejected(self): |
| record = self.one(lambda row: row["task_family"] == "ASR_NBEST_RANKING") |
| record["inputs"][0]["type"] = "generic_retrieval_query" |
| _rehash(record) |
| self.assert_rejected(record, "TASK_FAMILY_INPUT_SIGNATURE_MISMATCH") |
|
|
| def test_locate_found_wrong_valid_unit_is_rejected(self): |
| record = self.one( |
| lambda row: row["primitive"] == "LOCATE" |
| and row["target"]["decision"] == "FOUND" |
| and not row["task_family"].startswith("LONG_CONTEXT") |
| ) |
| correct = record["target"]["locations"][0] |
| wrong = next( |
| unit["id"] |
| for item in record["inputs"] |
| for unit in item["units"] |
| if unit["id"] != correct |
| ) |
| record["target"]["locations"] = [wrong] |
| record["target"]["evidence"] = [wrong] |
| record["target"]["action"]["arguments"]["unit_ids"] = [wrong] |
| self.assert_rejected( |
| record, "LOCATE_GOLD_NOT_REPRODUCIBLE_FROM_VISIBLE_ATTRIBUTES" |
| ) |
|
|
| def test_locate_contradictory_abstention_is_rejected(self): |
| record = self.one( |
| lambda row: row["primitive"] == "LOCATE" |
| and row["target"]["decision"] == "ABSTAIN" |
| and not row["task_family"].startswith("LONG_CONTEXT") |
| ) |
| required = record["task_spec"]["constraints"]["required_attributes"] |
| unit = record["inputs"][0]["units"][0] |
| unit.setdefault("attributes", {}).update(required) |
| unit["text"] += "；" + "；".join(str(value) for value in required.values()) |
| _rehash(record) |
| self.assert_rejected( |
| record, "LOCATE_ABSTAIN_CONTRADICTED_BY_VISIBLE_INPUT" |
| ) |
|
|
| def test_rank_synchronised_winner_tamper_is_rejected(self): |
| record = self.one(lambda row: row["primitive"] == "RANK") |
| ranking = record["target"]["ranking"] |
| ranking[0], ranking[1] = ranking[1], ranking[0] |
| |
| descending = sorted(record["target"]["graded_relevance"].values(), reverse=True) |
| record["target"]["graded_relevance"] = dict(zip(ranking, descending)) |
| record["target"]["evidence"] = [ranking[0]] |
| record["target"]["action"]["arguments"]["ordered_ids"] = list(ranking) |
| self.assert_rejected( |
| record, "RANK_GRADES_NOT_REPRODUCIBLE_FROM_VISIBLE_ATTRIBUTES" |
| ) |
|
|
| def test_rank_relevance_leak_is_rejected(self): |
| record = self.one(lambda row: row["primitive"] == "RANK") |
| candidates = next(item for item in record["inputs"] if "candidate" in item["type"]) |
| candidates["units"][0]["relevance"] = 3 |
| _rehash(record) |
| self.assert_rejected(record, "GOLD_SIGNAL_EXPOSED_IN_CANDIDATE_INPUT") |
|
|
| def test_match_synchronised_id_tamper_is_rejected(self): |
| record = self.one(lambda row: row["primitive"] == "MATCH") |
| candidates = next(item for item in record["inputs"] if "candidate" in item["type"]) |
| winner = record["target"]["canonical_id"] |
| wrong = next(unit["id"] for unit in candidates["units"] if unit["id"] != winner) |
| record["target"]["decision"] = wrong |
| record["target"]["canonical_id"] = wrong |
| record["target"]["matches"] = [wrong] |
| record["target"]["action"]["arguments"]["candidate_id"] = wrong |
| record["target"]["evidence"] = [record["inputs"][0]["units"][0]["id"], wrong] |
| self.assert_rejected( |
| record, "MATCH_GOLD_NOT_REPRODUCIBLE_FROM_VISIBLE_ATTRIBUTES" |
| ) |
|
|
| def test_align_suffix_shortcut_is_rejected(self): |
| record = self.one(lambda row: row["primitive"] == "ALIGN") |
| replacements = {} |
| for index, alignment in enumerate(record["target"]["alignments"], 1): |
| replacements[alignment["source"][0]] = f"src:u{index:02d}" |
| replacements[alignment["target"][0]] = f"tgt:u{index:02d}" |
| mutated = _replace_strings(record, replacements) |
| _rehash(mutated) |
| verdict = self.assert_rejected(mutated, "ALIGNMENT_IDS_NOT_OPAQUE") |
| self.assertIn("ALIGNMENT_ID_SUFFIX_LEAKS_GOLD", verdict["hard_failures"]) |
|
|
| def test_align_opaque_destination_swap_is_rejected(self): |
| record = self.one(lambda row: row["primitive"] == "ALIGN") |
| alignments = record["target"]["alignments"] |
| alignments[0]["target"], alignments[1]["target"] = ( |
| alignments[1]["target"], |
| alignments[0]["target"], |
| ) |
| self.assert_rejected( |
| record, "ALIGN_GOLD_NOT_REPRODUCIBLE_FROM_VISIBLE_CONTENT" |
| ) |
|
|
| def test_edit_replacement_and_output_tamper_is_rejected(self): |
| record = self.one( |
| lambda row: row["primitive"] == "EDIT" |
| and row["target"]["action"]["arguments"].get("op") == "REPLACE" |
| ) |
| operation = record["target"]["edit_operations"][0] |
| operation["replacement"] = "這是同步竄改後的錯誤內容。" |
| record["target"]["action"]["arguments"] = deepcopy(operation) |
| hypothesis = next(item for item in record["inputs"] if item["id"] == "hyp") |
| record["target"]["output_text"] = "".join( |
| operation["replacement"] if unit["id"] == operation["target"] else unit["text"] |
| for unit in hypothesis["units"] |
| ) |
| self.assert_rejected(record, "EDIT_OPERATION_NOT_EXECUTABLE_TO_GOLD_OUTPUT") |
|
|
| def test_classify_synchronised_label_tamper_is_rejected(self): |
| record = self.one(lambda row: row["primitive"] == "CLASSIFY") |
| old = record["target"]["decision"] |
| wrong = next(label for label in record["task_spec"]["allowed_labels"] if label != old) |
| record["target"]["decision"] = wrong |
| record["target"]["label"] = wrong |
| record["target"]["action"]["arguments"]["label"] = wrong |
| self.assert_rejected(record, "CLASSIFY_GOLD_DIFFERS_FROM_VISIBLE_CONTENT_RULE") |
|
|
| def test_domain_cue_ignores_domain_words_inside_organisation_name(self): |
| record = generate_record_v2(self.config, self.plan, 30_033) |
| self.assertEqual(record["task_family"], "DOMAIN_CLASSIFICATION") |
| self.assertIn("南風教育科技室", record["inputs"][0]["units"][0]["text"]) |
| self.assertIn("文化典藏領域", record["inputs"][0]["units"][0]["text"]) |
| self.assertEqual(record["target"]["decision"], "CULTURE") |
| self.assertEqual(validate_record_quality_v2(record)["hard_failures"], []) |
|
|
| def test_extract_alternate_substring_tamper_is_rejected(self): |
| record = self.one(lambda row: row["primitive"] == "EXTRACT") |
| field = record["target"]["fields"][0] |
| evidence_text = next( |
| unit["text"] |
| for item in record["inputs"] |
| for unit in item["units"] |
| if unit["id"] == field["evidence"][0] |
| ) |
| field["value"] = evidence_text[:2] |
| self.assert_rejected( |
| record, "EXTRACT_GOLD_NOT_REPRODUCIBLE_FROM_FIELD_ORACLE" |
| ) |
|
|
| def test_extract_swapped_field_values_are_rejected(self): |
| record = self.one(lambda row: row["primitive"] == "EXTRACT") |
| fields = record["target"]["fields"] |
| fields[0]["value"], fields[1]["value"] = fields[1]["value"], fields[0]["value"] |
| self.assert_rejected( |
| record, "EXTRACT_GOLD_NOT_REPRODUCIBLE_FROM_FIELD_ORACLE" |
| ) |
|
|
| def test_verify_pass_candidate_tamper_is_rejected(self): |
| record = self.one( |
| lambda row: row["primitive"] == "VERIFY" |
| and row["target"]["decision"] == "PASS" |
| and not row["task_family"].startswith("LONG_CONTEXT") |
| ) |
| candidate = next(item for item in record["inputs"] if "candidate" in item["type"] or "hypothesis" in item["type"]) |
| candidate["units"][0]["text"] += "錯誤增補" |
| _rehash(record) |
| self.assert_rejected(record, "VERIFY_PASS_REFERENCE_CANDIDATE_NOT_EQUAL") |
|
|
| def test_verify_false_pass_target_tamper_is_rejected(self): |
| record = self.one( |
| lambda row: row["primitive"] == "VERIFY" |
| and row["target"]["decision"] == "FAIL" |
| and not row["task_family"].startswith("LONG_CONTEXT") |
| ) |
| candidate = next(item for item in record["inputs"] if "candidate" in item["type"] or "hypothesis" in item["type"]) |
| record["target"].update( |
| { |
| "decision": "PASS", |
| "quality_score": 1.0, |
| "errors": [], |
| "action": {"tool": "ACCEPT", "arguments": {"candidate_id": candidate["units"][0]["id"]}}, |
| } |
| ) |
| self.assert_rejected(record, "VERIFY_PASS_REFERENCE_CANDIDATE_NOT_EQUAL") |
|
|
| def test_verify_repair_tamper_is_rejected(self): |
| record = self.one( |
| lambda row: row["primitive"] == "VERIFY" |
| and row["target"]["decision"] == "FAIL" |
| and not row["task_family"].startswith("LONG_CONTEXT") |
| ) |
| record["target"]["action"]["arguments"]["replacement"] = "錯誤修復結果。" |
| self.assert_rejected(record, "VERIFY_REPAIR_DOES_NOT_REACH_REFERENCE") |
|
|
| def test_long_context_verify_all_three_outcomes_are_executable(self): |
| outcomes = {} |
| for record in self.records: |
| if record["task_family"] == "LONG_CONTEXT_CONTRADICTION": |
| outcomes.setdefault(record["target"]["decision"], record) |
| self.assertEqual(set(outcomes), {"PASS", "FAIL", "UNCERTAIN"}) |
| for outcome, record in outcomes.items(): |
| with self.subTest(outcome=outcome): |
| self.assertEqual(validate_record_quality_v2(record)["disposition"], "KEEP") |
|
|
| def test_long_context_uncertainty_without_two_conflicts_is_rejected(self): |
| record = self.one( |
| lambda row: row["task_family"] == "LONG_CONTEXT_CONTRADICTION" |
| and row["target"]["decision"] == "UNCERTAIN" |
| ) |
| conflict = next( |
| unit |
| for item in record["inputs"] |
| for unit in item["units"] |
| if unit.get("attributes", {}).get("status") == "active_conflict" |
| ) |
| conflict["attributes"]["status"] = "context" |
| _rehash(record) |
| self.assert_rejected(record, "VERIFY_UNCERTAIN_LEDGER_CONFLICT_NOT_REPRODUCIBLE") |
|
|
| def test_route_synchronised_action_tamper_is_rejected(self): |
| record = self.one( |
| lambda row: row["primitive"] == "ROUTE" |
| and row["task_family"] == "TOOL_ROUTING" |
| and row["target"]["decision"] == "EDIT" |
| ) |
| record["target"]["decision"] = "RETRIEVE" |
| record["target"]["action"] = { |
| "tool": "RETRIEVE", |
| "arguments": {"query": "查詢另一份紀錄"}, |
| } |
| self.assert_rejected(record, "ROUTE_GOLD_NOT_REPRODUCIBLE_FROM_VISIBLE_ATTRIBUTES") |
|
|
| def test_verify_uncertainty_is_rejected_when_any_authority_restores_date(self): |
| for family in ("ASR_QUALITY", "OCR_QUALITY", "MT_QUALITY"): |
| record = self.one(lambda row: row["task_family"] == family and row["target"]["decision"] == "UNCERTAIN") |
| candidate = next(item for item in record["inputs"] if item["id"] == "hyp") |
| dated_text = next(unit["text"] for unit in candidate["units"] if " 年 " in unit["text"]) |
| authority = next(item for item in record["inputs"] if item["id"] == ("source" if family == "MT_QUALITY" else "ref")) |
| authority["units"].append({"id": "ref:restored", "text": dated_text}) |
| _rehash(record) |
| self.assert_rejected(record, "VERIFY_UNCERTAIN_DECISIVE_DATE_STILL_VISIBLE") |
|
|
| def test_candidate_state_gold_leak_is_rejected(self): |
| for primitive in ("VERIFY", "ROUTE"): |
| record = self.one(lambda row: row["primitive"] == primitive) |
| record["inputs"][0]["units"][0].setdefault("attributes", {})["candidate_state"] = "consistent" |
| _rehash(record) |
| self.assert_rejected(record, "GOLD_ANNOTATION_EXPOSED_IN_INPUT") |
|
|
| def test_character_confusion_is_not_a_numeric_value_error(self): |
| for family in ("ASR_CORRECTION", "OCR_CORRECTION"): |
| record = self.one(lambda row: row["task_family"] == family) |
| record["target"]["errors"][0]["type"] = "VALUE_CORRUPTION" |
| self.assert_rejected(record, "VALUE_CORRUPTION_WITHOUT_NUMERIC_CHANGE") |
|
|
| def test_rank_error_sentinel_is_rejected(self): |
| record = self.one(lambda row: row["primitive"] == "RANK") |
| record["inputs"][1]["units"][0]["text"] += " 不符-location-1-9" |
| _rehash(record) |
| self.assert_rejected(record, "GOLD_SIGNAL_EXPOSED_IN_CANDIDATE_TEXT") |
|
|
| def test_route_edit_must_modify_candidate_not_observation(self): |
| record = self.one(lambda row: row["task_family"] == "TOOL_ROUTING" and row["target"]["decision"] == "EDIT") |
| record["target"]["action"]["arguments"]["target"] = "obs:u01" |
| self.assert_rejected(record, "ROUTE_EDIT_TARGET_NOT_CANDIDATE") |
|
|
| def test_route_pointer_must_address_matching_coordinate_unit(self): |
| record = self.one(lambda row: row["task_family"] == "MODALITY_ROUTING" and row["target"]["decision"] == "POINT_TIME") |
| record["target"]["action"]["arguments"]["unit_ids"] = ["modality:u01"] |
| self.assert_rejected(record, "ROUTE_POINTER_COORDINATE_TYPE_MISMATCH") |
|
|
| def test_classifier_corpus_gate_detects_missing_labels(self): |
| record = self.one(lambda row: row["task_family"] == "EMOTION_CLASSIFICATION") |
| accumulator = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1) |
| for split in ("train", "validation", "test"): |
| example = deepcopy(record) |
| example["split"] = split |
| accumulator.add(example, {"disposition": "KEEP", "hard_failures": []}) |
| gate = accumulator.finalize()["gates"]["classification_label_coverage:EMOTION_CLASSIFICATION"] |
| self.assertFalse(gate["passed"]) |
| self.assertEqual(len(gate["missing_by_split"]["train"]), 3) |
|
|
| def test_provenance_source_content_hash_tamper_is_rejected(self): |
| record = deepcopy(self.records[0]) |
| record["provenance"]["source_hash"] = "0" * 64 |
| self.assert_rejected(record, "PROVENANCE_SOURCE_CONTENT_HASH_MISMATCH") |
|
|
| def test_serializer_target_non_json_tamper_is_rejected(self): |
| record = deepcopy(self.records[0]) |
| record["target"]["non_json_probe"] = ("tuple", "is", "not", "canonical-json") |
| self.assert_rejected(record, "SERIALIZER_SEMANTIC_ROUNDTRIP_FAILED") |
|
|
| def test_confidence_cannot_claim_calibration_gold(self): |
| record = deepcopy(self.records[0]) |
| record["target"]["confidence_semantics"] = "calibration_gold" |
| self.assert_rejected(record, "TARGET_CONFIDENCE_SEMANTICS_MISLABELLED") |
|
|
| def test_traditional_chinese_term_gate(self): |
| record = deepcopy(self.records[0]) |
| record["inputs"][0]["units"][0]["text"] += "软件與服務器" |
| _rehash(record) |
| self.assert_rejected(record, "SIMPLIFIED_OR_NON_TW_TERM_DETECTED") |
|
|
| def test_long_ledger_repetition_gate(self): |
| record = self.one(lambda row: row["task_family"] == "LONG_CONTEXT_ACTIVE_VALUE") |
| repeated = "更新：同一段填充內容反覆出現。" |
| for unit in record["inputs"][0]["units"]: |
| unit["text"] = repeated |
| _rehash(record) |
| verdict = validate_record_quality_v2(record) |
| self.assertIn("WITHIN_RECORD_TEMPLATE_REPETITION_HIGH", verdict["hard_failures"]) |
| self.assertIn("LONG_LEDGER_TEMPLATE_DIVERSITY_TOO_LOW", verdict["hard_failures"]) |
|
|
| def test_ledger_event_type_must_agree_with_visible_sentence(self): |
| record = self.one(lambda row: row["task_family"] == "LONG_CONTEXT_ACTIVE_VALUE") |
| event = record["inputs"][0]["units"][0] |
| event["attributes"]["event_type"] = "not_the_visible_event" |
| _rehash(record) |
| self.assert_rejected(record, "LEDGER_EVENT_TYPE_CONTRADICTS_VISIBLE_TEXT") |
|
|
| def test_context_bucket_and_measure_tamper_are_rejected(self): |
| record = self.one(lambda row: row["quality"]["context_length_bucket"] == "SHORT_LT_0.5K") |
| record["quality"]["context_length_bucket"] = "64K-128K" |
| record["quality"]["context_length_measure"] = "pangolin_tokens" |
| verdict = self.assert_rejected( |
| record, "CONTEXT_LENGTH_BUCKET_DOES_NOT_MATCH_VISIBLE_TEXT_CHARS" |
| ) |
| self.assertIn("CONTEXT_LENGTH_MEASURE_MISSING_OR_MISLABELLED", verdict["hard_failures"]) |
|
|
| def test_accumulator_merge_matches_single_pass_and_is_pickle_safe(self): |
| records = self.records[:120] |
| single = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1) |
| left = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1) |
| right = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1) |
| for index, record in enumerate(records): |
| verdict = validate_record_quality_v2(record) |
| single.add(record, verdict) |
| (left if index < 60 else right).add(record, verdict) |
| pickle.loads(pickle.dumps(left)) |
| left.merge(right) |
| self.assertEqual(left.finalize(), single.finalize()) |
|
|
| def test_accumulator_fails_closed_for_missing_families_and_splits(self): |
| accumulator = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1) |
| record = self.records[0] |
| accumulator.add(record, validate_record_quality_v2(record)) |
| report = accumulator.finalize() |
| self.assertFalse(report["promotion_passed"]) |
| self.assertFalse(report["gates"]["task_family_coverage"]["passed"]) |
| self.assertFalse(report["gates"]["split_coverage"]["passed"]) |
|
|
| def test_accumulator_detects_source_group_split_conflict(self): |
| accumulator = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1) |
| first = deepcopy(self.records[0]) |
| second = deepcopy(first) |
| second["split"] = "validation" |
| second["presentation"]["template_profile"] = "heldout_validation" |
| accumulator.add(first, {"disposition": "KEEP", "hard_failures": []}) |
| accumulator.add(second, {"disposition": "KEEP", "hard_failures": []}) |
| gate = accumulator.finalize()["gates"]["source_group_split_lock"] |
| self.assertFalse(gate["passed"]) |
| self.assertEqual(gate["conflict_count"], 1) |
|
|
| def test_accumulator_detects_heldout_template_overlap_and_profile_mismatch(self): |
| accumulator = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1) |
| base = deepcopy(self.records[0]) |
| for split, profile in ( |
| ("train", "train_core"), |
| ("validation", "heldout_validation"), |
| ("test", "wrong_profile"), |
| ): |
| record = deepcopy(base) |
| record["record_id"] = f"bgd_tw_v2_{len(accumulator.family_counts):07d}" |
| record["source_group"] = f"template-overlap:{split}" |
| record["split"] = split |
| record["presentation"]["template_profile"] = profile |
| record["presentation"]["template_id"] = "deliberately-shared-template" |
| accumulator.add(record, {"disposition": "KEEP", "hard_failures": []}) |
| report = accumulator.finalize() |
| self.assertFalse(report["gates"]["heldout_template_isolation"]["passed"]) |
| self.assertFalse(report["gates"]["template_profile_split_contract"]["passed"]) |
| self.assertFalse(report["gates"]["context_bucket_distribution"]["passed"]) |
|
|
| def test_accumulator_rejects_skewed_winner_position(self): |
| record = self.one(lambda row: row["primitive"] == "RANK") |
| family = record["task_family"] |
| accumulator = PromotionAccumulator(minimum_family_records=40, minimum_template_variants=1) |
| verdict = validate_record_quality_v2(record) |
| for _ in range(40): |
| accumulator.add(record, verdict) |
| gate = accumulator.finalize()["gates"][f"winner_position_balance:{family}"] |
| self.assertFalse(gate["passed"]) |
| self.assertGreater(gate["max_relative_deviation"], 0.25) |
|
|
| def test_accumulator_verify_outcome_distribution(self): |
| family = "ASR_QUALITY" |
| outcomes = {} |
| for record in self.records: |
| if record["task_family"] == family: |
| outcomes.setdefault(record["target"]["decision"], record) |
| self.assertEqual(set(outcomes), {"PASS", "FAIL", "UNCERTAIN"}) |
| accumulator = PromotionAccumulator(minimum_family_records=3, minimum_template_variants=1) |
| for record in outcomes.values(): |
| accumulator.add(record, validate_record_quality_v2(record)) |
| report = accumulator.finalize() |
| gate = report["gates"][f"verify_outcome_balance:{family}"] |
| self.assertTrue(gate["passed"]) |
| self.assertEqual(gate["decisions"], {"FAIL": 1, "PASS": 1, "UNCERTAIN": 1}) |
| self.assertIn(family, report["family_confidence_distribution"]) |
| self.assertIn(family, report["family_normalized_template_counts"]) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
