code/tests/test_generation_v2.py

from __future__ import annotations

import json
import unittest
from collections import Counter, defaultdict
from pathlib import Path

from barbet_bgd.generation_v2 import (
    ALL_TASK_FAMILIES_V2,
    CONFIDENCE_SEMANTICS,
    FAMILY_INPUT_TYPES_V2,
    GenerationPlanV2,
    TASK_FAMILIES_V2,
    generate_record_v2,
)
from barbet_bgd.quality_v2 import expected_source_hash_v2, validate_record_quality_v2
from barbet_bgd.validation import validate_record


ROOT = Path(__file__).resolve().parents[1]


class GenerationV2Tests(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)

    def test_exact_scale_and_balanced_plan(self) -> None:
        self.assertEqual(self.config["total_records"], 1_000_000)
        self.assertEqual(self.config["dataset_name"], "barbet-bgd-synthetic-sft-1m-tw-v2")
        primitives = Counter(self.plan.position(index).primitive for index in range(100))
        mixtures = Counter(self.plan.position(index).mixture_category for index in range(100))
        serializers = Counter(self.plan.position(index).serializer for index in range(100))
        self.assertEqual(primitives, Counter(self.config["primitive_percent"]))
        self.assertEqual(mixtures, Counter(self.config["mixture_percent"]))
        self.assertEqual(serializers, Counter(self.config["serializer_percent"]))
        self.assertEqual(sum(self.plan.position(index).is_long_context for index in range(100)), 5)

    def test_generation_is_index_deterministic(self) -> None:
        indexes = (0, 5, 62, 99, 100, 1_762, 979_999, 980_000, 989_999, 990_000, 999_999)
        for index in indexes:
            self.assertEqual(
                generate_record_v2(self.config, self.plan, index),
                generate_record_v2(self.config, self.plan, index),
            )

    def test_source_group_split_lock(self) -> None:
        for boundary in (980_000, 990_000):
            before = generate_record_v2(self.config, self.plan, boundary - 1)
            after = generate_record_v2(self.config, self.plan, boundary)
            self.assertNotEqual(before["source_group"], after["source_group"])
            self.assertNotEqual(before["split"], after["split"])
        for start in (0, 5, 979_995, 980_000, 989_995, 990_000):
            rows = [generate_record_v2(self.config, self.plan, start + offset) for offset in range(5)]
            self.assertEqual(len({row["source_group"] for row in rows}), 1)
            self.assertEqual(len({row["split"] for row in rows}), 1)

    def test_all_51_families_are_reached_and_pass_independent_quality(self) -> None:
        seen: set[str] = set()
        for index in range(1_200):
            record = generate_record_v2(self.config, self.plan, index)
            seen.add(record["task_family"])
            self.assertEqual(validate_record(record), [])
            self.assertEqual(validate_record_quality_v2(record)["hard_failures"], [])
        self.assertEqual(seen, set(ALL_TASK_FAMILIES_V2))
        self.assertEqual(sum(len(value) for value in TASK_FAMILIES_V2.values()) + 4, 51)

    def test_visible_query_schema_and_honest_confidence(self) -> None:
        for index in range(300):
            record = generate_record_v2(self.config, self.plan, index)
            spec = record["task_spec"]
            self.assertIn("query", spec)
            self.assertIsInstance(spec["query"], str)
            self.assertTrue(spec["query"].strip())
            self.assertIsInstance(spec["requested_schema"], dict)
            self.assertEqual(record["target"]["confidence_semantics"], CONFIDENCE_SEMANTICS)
            self.assertEqual(record["quality"]["confidence_semantics"], CONFIDENCE_SEMANTICS)
            self.assertLess(len(spec["allowed_actions"]), 10)
            if record["primitive"] == "EXTRACT":
                self.assertEqual(
                    spec["requested_fields"],
                    [field["name"] for field in record["target"]["fields"]],
                )

    def test_domain_collision_and_transcription_policy_have_no_label_leakage(self) -> None:
        # This index pairs the organisation 「南風教育科技室」 with the
        # explicitly declared 文化典藏 domain.  The organisation name must not
        # create a second classification label.
        domain_record = generate_record_v2(self.config, self.plan, 30_033)
        self.assertEqual(domain_record["task_family"], "DOMAIN_CLASSIFICATION")
        self.assertEqual(domain_record["target"]["decision"], "CULTURE")
        self.assertEqual(validate_record_quality_v2(domain_record)["hard_failures"], [])

        transcription_records = []
        for index in range(2_000):
            record = generate_record_v2(self.config, self.plan, index)
            if record["task_family"] == "TRANSCRIPTION_MODE":
                transcription_records.append(record)
        self.assertTrue(transcription_records)
        for record in transcription_records:
            self.assertEqual(record["task_spec"]["constraints"], {})
            self.assertEqual(record["inputs"][0]["units"][0].get("attributes"), {})
            self.assertEqual(validate_record_quality_v2(record)["hard_failures"], [])

    def test_family_signatures_are_not_generic_aliases(self) -> None:
        seen: dict[str, set[str]] = {}
        for index in range(1_200):
            record = generate_record_v2(self.config, self.plan, index)
            seen.setdefault(
                record["task_family"], {item["type"] for item in record["inputs"]}
            )
        for family, required in FAMILY_INPUT_TYPES_V2.items():
            self.assertTrue(required.issubset(seen[family]), family)

    def test_rank_and_match_have_opaque_unlabelled_balanced_candidates(self) -> None:
        winner_positions: dict[str, Counter[int]] = defaultdict(Counter)
        for index in range(5_000):
            record = generate_record_v2(self.config, self.plan, index)
            if record["primitive"] not in {"RANK", "MATCH"}:
                continue
            candidate_input = next(
                item for item in record["inputs"] if "candidate" in item["type"]
            )
            candidates = candidate_input["units"]
            forbidden = {"relevance", "score", "grade", "rank", "is_correct", "gold", "winner"}
            for unit in candidates:
                self.assertTrue(unit["id"].startswith("cand:x7"))
                self.assertFalse(forbidden.intersection(unit))
            winner = (
                record["target"]["ranking"][0]
                if record["primitive"] == "RANK"
                else record["target"]["canonical_id"]
            )
            winner_positions[record["task_family"]][
                [unit["id"] for unit in candidates].index(winner)
            ] += 1
        for family, counts in winner_positions.items():
            expected_width = 5 if family.endswith("RANKING") else 4
            self.assertEqual(set(counts), set(range(expected_width)), family)

    def test_alignment_ids_are_opaque_and_permutations_vary(self) -> None:
        permutations: dict[str, set[tuple[int, ...]]] = defaultdict(set)
        for index in range(2_000):
            record = generate_record_v2(self.config, self.plan, index)
            if record["primitive"] != "ALIGN":
                continue
            source, destination = record["inputs"]
            destination_ids = [unit["id"] for unit in destination["units"]]
            pairs = {
                alignment["source"][0]: alignment["target"][0]
                for alignment in record["target"]["alignments"]
            }
            source_ids = [unit["id"] for unit in source["units"]]
            self.assertTrue(
                all(left.rsplit(":", 1)[-1] != right.rsplit(":", 1)[-1] for left, right in pairs.items())
            )
            permutations[record["task_family"]].add(
                tuple(destination_ids.index(pairs[source_id]) for source_id in source_ids)
            )
        for family, values in permutations.items():
            self.assertGreaterEqual(len(values), 4, family)

    def test_locate_abstention_has_no_attribute_match(self) -> None:
        negatives = 0
        for index in range(2_000):
            record = generate_record_v2(self.config, self.plan, index)
            if record["primitive"] != "LOCATE" or record["target"]["decision"] != "ABSTAIN":
                continue
            negatives += 1
            required = record["task_spec"]["constraints"]["required_attributes"]
            matches = [
                unit
                for item in record["inputs"]
                for unit in item["units"]
                if required.items() <= unit.get("attributes", {}).items()
            ]
            self.assertEqual(matches, [])
            self.assertEqual(record["target"]["evidence"], [])
        self.assertGreater(negatives, 0)

    def test_verify_outcomes_are_balanced_inside_every_family(self) -> None:
        decisions: dict[str, Counter[str]] = defaultdict(Counter)
        for index in range(5_000):
            record = generate_record_v2(self.config, self.plan, index)
            if record["primitive"] == "VERIFY":
                decisions[record["task_family"]][record["target"]["decision"]] += 1
        self.assertEqual(len(decisions), 6)
        for family, counts in decisions.items():
            self.assertEqual(set(counts), {"PASS", "FAIL", "UNCERTAIN"}, family)
            self.assertLessEqual(max(counts.values()) - min(counts.values()), 2, family)

    def test_classification_labels_do_not_alias_with_paraphrase_cycle(self) -> None:
        expected = {
            "INTENT_CLASSIFICATION": {"QUERY_STATUS", "UPDATE_SCHEDULE", "SUBMIT_APPLICATION", "RETRIEVE_EVIDENCE", "REQUEST_REVIEW", "CANCEL_REQUEST", "REPORT_INCIDENT", "VERIFY_BOOKING"},
            "EMOTION_CLASSIFICATION": {"POSITIVE", "NEGATIVE", "NEUTRAL", "CAUTIOUS"},
            "TRANSCRIPTION_MODE": {"VERBATIM", "READABLE", "SELECTIVE_SPEAKER", "ANONYMIZED"},
        }
        for start in (0, 980_000, 990_000):
            seen = defaultdict(set)
            for index in range(start, start + 1_000):
                if self.plan.position(index).primitive != "CLASSIFY":
                    continue
                record = generate_record_v2(self.config, self.plan, index)
                seen[record["task_family"]].add(record["target"]["decision"])
            for family, labels in expected.items():
                self.assertEqual(seen[family], labels, (start, family))

    def test_verifier_and_router_expose_no_candidate_gold_state(self) -> None:
        for index in range(300):
            if self.plan.position(index).primitive not in {"VERIFY", "ROUTE"}:
                continue
            record = generate_record_v2(self.config, self.plan, index)
            self.assertNotIn('"candidate_state"', json.dumps(record["inputs"]))
            if record["task_family"] == "MODALITY_ROUTING" and record["target"]["action"]["tool"].startswith("POINT_"):
                args = record["target"]["action"]["arguments"]
                self.assertNotIn("modality:u01", args["unit_ids"])

    def test_rank_negatives_are_plausible_values_not_error_sentinels(self) -> None:
        seen = set()
        for index in range(100):
            if self.plan.position(index).primitive != "RANK":
                continue
            record = generate_record_v2(self.config, self.plan, index)
            seen.add(record["task_family"])
            self.assertNotIn("不符-", json.dumps(record["inputs"], ensure_ascii=False))
            candidates = record["inputs"][1]["units"]
            for unit in candidates:
                for value in unit["attributes"].values():
                    self.assertIn(str(value), unit["text"])
        self.assertEqual(len(seen), 5)

    def test_speaker_identity_does_not_require_same_recording_channel(self) -> None:
        changed_channel = 0
        for index in range(400):
            if self.plan.position(index).primitive != "MATCH":
                continue
            record = generate_record_v2(self.config, self.plan, index)
            if record["task_family"] != "SPEAKER_MATCHING":
                continue
            query = record["inputs"][0]["units"][0]["attributes"]
            winner = next(unit for unit in record["inputs"][1]["units"] if unit["id"] == record["target"]["canonical_id"])
            self.assertEqual(winner["attributes"]["speaker_signature"], query["speaker_signature"])
            changed_channel += winner["attributes"]["channel"] != query["channel"]
        self.assertGreater(changed_channel, 0)

    def test_eight_train_templates_and_heldout_profiles(self) -> None:
        train_templates: dict[str, set[str]] = defaultdict(set)
        confidence_values: dict[str, set[float]] = defaultdict(set)
        for index in range(1_200):
            record = generate_record_v2(self.config, self.plan, index)
            train_templates[record["task_family"]].add(record["presentation"]["template_id"])
            confidence_values[record["task_family"]].add(record["target"]["confidence_target"])
        self.assertTrue(all(len(values) >= 8 for values in train_templates.values()))
        self.assertTrue(all(len(values) >= 2 for values in confidence_values.values()))

        heldout: dict[str, set[str]] = defaultdict(set)
        for start in (980_000, 990_000):
            for index in range(start, start + 600):
                record = generate_record_v2(self.config, self.plan, index)
                heldout[record["task_family"]].add(record["presentation"]["template_id"])
        for family, values in heldout.items():
            self.assertTrue(values.isdisjoint(train_templates[family]), family)

    def test_instructions_do_not_announce_evaluation_split(self) -> None:
        for index in (0, 980_000, 980_009, 990_000, 990_009):
            record = generate_record_v2(self.config, self.plan, index)
            query = record["task_spec"]["query"]
            for phrase in ("驗證集", "測試案例", "未見模板", "保留模板"):
                self.assertNotIn(phrase, query)

    def test_provenance_hash_covers_visible_source_content(self) -> None:
        for index in (0, 5, 62, 500, 1_762, 980_000, 990_000):
            record = generate_record_v2(self.config, self.plan, index)
            self.assertEqual(record["provenance"]["source_hash"], expected_source_hash_v2(record))
            mutated = json.loads(json.dumps(record, ensure_ascii=False))
            mutated["inputs"][0]["units"][0]["text"] += "異動"
            self.assertNotEqual(record["provenance"]["source_hash"], expected_source_hash_v2(mutated))

    def test_context_bucket_uses_measured_input_characters(self) -> None:
        short = generate_record_v2(self.config, self.plan, 0)
        self.assertEqual(short["quality"]["context_length_bucket"], "SHORT_LT_0.5K")
        self.assertEqual(short["quality"]["context_length_measure"], "input_unit_text_characters_v2")
        self.assertLess(short["quality"]["context_length_value"], 500)

        # long_index=86 is the first 64K slot in the deterministic permutation.
        cycle, rank = divmod(86, self.plan.long_per_cycle)
        index = cycle * 100 + self.plan.long_slots[rank]
        long_record = generate_record_v2(self.config, self.plan, index)
        self.assertEqual(long_record["quality"]["context_length_bucket"], "64K-128K")
        self.assertGreaterEqual(long_record["quality"]["context_length_value"], 64_000)
        self.assertLess(long_record["quality"]["context_length_value"], 128_000)
        self.assertEqual(validate_record_quality_v2(long_record)["hard_failures"], [])


if __name__ == "__main__":
    unittest.main()