Merge nucleic/sleek-ember-seal-uady into dev

tests/test_audit_data.py

@@ -0,0 +1,92 @@
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+import numpy as np
+
+
+MODULE_DIR = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(MODULE_DIR))
+
+import audit_data
+from purpose_data import SourceRecord
+
+
+def record(index, purpose, slice_name="core", language="en"):
+    return SourceRecord(
+        value={
+            "prompt": f"prompt {index}",
+            "purpose": purpose,
+            "secondary": None,
+            "mixed": False,
+            "difficulty": 0.5,
+            "slice": slice_name,
+            "lang": language,
+        },
+        source=Path("source.jsonl"),
+        line=index + 1,
+    )
+
+
+class ReviewSampleTests(unittest.TestCase):
+    def test_sample_is_exact_and_deterministic(self):
+        records = [
+            record(index, audit_data.LABELS[index % len(audit_data.LABELS)])
+            for index in range(101)
+        ]
+        first = audit_data.stratified_review_sample(records, fraction=0.1, seed=42)
+        second = audit_data.stratified_review_sample(records, fraction=0.1, seed=42)
+        self.assertEqual(10, len(first))
+        self.assertEqual(
+            [item.value["prompt"] for item in first],
+            [item.value["prompt"] for item in second],
+        )
+
+    def test_review_csv_has_blank_reviewer_fields(self):
+        records = [record(0, "planning")]
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary) / "review.csv"
+            audit_data.write_review_csv(path, records)
+            text = path.read_text(encoding="utf-8")
+        self.assertIn("reviewedPurpose", text)
+        self.assertIn("prompt 0", text)
+
+
+class SemanticCandidateTests(unittest.TestCase):
+    def test_threshold_depends_on_label_agreement(self):
+        embeddings = np.asarray(
+            [
+                [1.0, 0.0],
+                [0.98, 0.2],
+                [0.98, -0.2],
+            ],
+            dtype=np.float32,
+        )
+        candidates = audit_data.semantic_candidates(
+            embeddings,
+            ["planning", "planning", "writing"],
+            same_label_threshold=0.97,
+            cross_label_threshold=0.99,
+            neighbors=2,
+            block_size=2,
+        )
+        pairs = {(item.left, item.right) for item in candidates}
+        self.assertIn((0, 1), pairs)
+        self.assertNotIn((0, 2), pairs)
+
+    def test_candidate_pairs_are_deduplicated(self):
+        embeddings = np.asarray([[1.0, 0.0], [1.0, 0.0]], dtype=np.float32)
+        candidates = audit_data.semantic_candidates(
+            embeddings,
+            ["review", "review"],
+            same_label_threshold=0.9,
+            cross_label_threshold=0.9,
+            neighbors=1,
+            block_size=1,
+        )
+        self.assertEqual(1, len(candidates))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_eval.py

@@ -0,0 +1,27 @@
+import sys
+import unittest
+from pathlib import Path
+
+
+MODULE_DIR = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(MODULE_DIR))
+
+import eval as purpose_eval
+
+
+class TierDriftTests(unittest.TestCase):
+    def test_current_routing_matrix_bounds_every_label_pair(self):
+        records = [{"prompt": f"prompt {index}"} for index in range(8 * 8)]
+        actual = []
+        predicted = []
+        for expected in range(8):
+            for got in range(8):
+                actual.append(expected)
+                predicted.append(got)
+        report = purpose_eval.routing_tier_drift(records, actual, predicted)
+        self.assertTrue(report["passed"])
+        self.assertLessEqual(report["maximumTierDrift"], 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_purpose_data.py

@@ -84,6 +84,26 @@ class CurationTests(unittest.TestCase):
                 near_duplicate_threshold=0.92,
             )
 
+    def test_reviewed_semantic_exclusions_fail_closed_on_corpus_drift(self):
+        first = source(example(0, prompt="Plan the cache migration", purpose="planning"), 1)
+        second = source(
+            example(1, prompt="Propose a cache migration plan", purpose="planning"), 2
+        )
+        decision = {
+            "droppedPromptHash": purpose_data.prompt_hash(second.value["prompt"]),
+            "matchedPromptHash": purpose_data.prompt_hash(first.value["prompt"]),
+            "similarity": 0.98,
+        }
+        result = purpose_data.exclude_reviewed_duplicates(
+            [first, second], [decision]
+        )
+        self.assertEqual([first], result.records)
+        self.assertEqual("semantic-reviewed", result.duplicates[0].kind)
+        with self.assertRaisesRegex(
+            purpose_data.DataError, "no longer matches the curated corpus"
+        ):
+            purpose_data.exclude_reviewed_duplicates([first], [decision])
+
 
 class SplitTests(unittest.TestCase):
     def test_split_is_deterministic_stratified_and_keeps_vague_out_of_train(self):

tests/test_train.py

@@ -2,6 +2,8 @@ import sys
 import unittest
 from pathlib import Path
 
+import torch
+
 
 MODULE_DIR = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(MODULE_DIR))
@@ -42,5 +44,45 @@ class MetricsTests(unittest.TestCase):
         )
 
 
+class FixedShapeTokenizerTests(unittest.TestCase):
+    class Tokenizer:
+        pad_token_id = 0
+        cls_token_id = 1
+        sep_token_id = 2
+        padding_side = "right"
+        model_input_names = ["input_ids", "attention_mask", "token_type_ids"]
+
+        def __call__(self, texts, **_):
+            return {
+                "input_ids": [
+                    list(range(10, 10 + int(text.split()[-1]))) for text in texts
+                ]
+            }
+
+        @staticmethod
+        def num_special_tokens_to_add(pair=False):
+            return 3 if pair else 2
+
+    def test_long_input_keeps_head_and_tail_in_fixed_pair_shape(self):
+        encoded = train.encode_fixed_shape(
+            self.Tokenizer(), ["tokens 200"], torch
+        )
+        self.assertEqual((1, train.MAX_LENGTH), tuple(encoded["input_ids"].shape))
+        row = encoded["input_ids"][0].tolist()
+        self.assertEqual(list(range(10, 10 + train.HEAD_TOKENS)), row[1:64])
+        self.assertEqual(2, row[64])
+        self.assertEqual(
+            list(range(10 + 200 - train.TAIL_TOKENS, 10 + 200)),
+            row[65:127],
+        )
+        self.assertEqual(2, row[127])
+        self.assertEqual(1, encoded["token_type_ids"][0, 65].item())
+
+    def test_short_input_is_padded_as_one_sequence(self):
+        encoded = train.encode_fixed_shape(self.Tokenizer(), ["tokens 3"], torch)
+        self.assertEqual([1, 10, 11, 12, 2], encoded["input_ids"][0, :5].tolist())
+        self.assertEqual(0, encoded["attention_mask"][0, 5].item())
+
+
 if __name__ == "__main__":
     unittest.main()