| """Replacement correctness is independent of model recognition accuracy.""" |
|
|
| import pytest |
| from ocr.anonymization.detectors import detect |
| from ocr.anonymization.model import MODEL_REVISION |
| from ocr.anonymization.replacement import replace |
| from ocr.anonymization.schemas import Entity |
| from ocr.schemas import SafeError |
|
|
|
|
| def entity(text, label, start, end): |
| return Entity( |
| start=start, |
| end=end, |
| label=label, |
| text=text[start:end], |
| source="multilingual_ner", |
| model_revision=MODEL_REVISION, |
| score=0.8, |
| ) |
|
|
|
|
| def test_every_qualification_gold_span_replaces_exactly(): |
| |
| |
| from ocr.tests.test_anonymization_qualification import SYNTHETIC_CASES |
|
|
| for case in SYNTHETIC_CASES: |
| predictions = [ |
| entity(case["text"], s["label"], s["start"], s["end"]) for s in case["spans"] |
| ] |
| output, tags = replace(case["text"], predictions) |
| |
| |
| |
| expected = case["expected"] |
| if case["text"] == "I work for Google Inc.": |
| expected = "I work for [ORGANIZATION]" |
| assert output == expected |
| assert len(tags) == len(predictions) |
| assert all("text" not in t.model_dump() for t in tags) |
|
|
|
|
| def test_repeated_umlaut_hyphenated_broken_words_preserve_other_spacing(): |
| text = "Änne-Marie grüßt\nÄnne-Marie.\n\nBer-\nlin!" |
| spans = [ |
| entity(text, "PERSON", 0, 10), |
| entity(text, "PERSON", 18, 28), |
| entity(text, "CITY", 31, 39), |
| ] |
| output, _ = replace(text, spans) |
| assert output == "[PERSON] grüßt\n[PERSON].\n\n[CITY]!" |
|
|
|
|
| def test_containment_and_duplicate_policy(): |
| text = "Mary Jane Doe" |
| spans = [ |
| entity(text, "PERSON", 0, len(text)), |
| entity(text, "PERSON", 5, len(text)), |
| entity(text, "PERSON", 0, len(text)), |
| ] |
| output, tags = replace(text, spans) |
| assert output == "[PERSON]" and len(tags) == 1 |
|
|
|
|
| def test_crossing_or_conflicting_overlap_blocks_whole_transformation(): |
| text = "Mary Jane Doe" |
| with pytest.raises(SafeError, match="ambiguous_entity_overlap"): |
| replace(text, [entity(text, "PERSON", 0, 9), entity(text, "PERSON", 5, len(text))]) |
| with pytest.raises(SafeError, match="ambiguous_entity_overlap"): |
| replace(text, [entity(text, "PERSON", 0, 4), entity(text, "CITY", 0, 4)]) |
|
|
|
|
| @pytest.mark.parametrize( |
| "text,expected", |
| [ |
| ("Mail: föö@example.de.\nCall +49 30 12345678!", "Mail: [EMAIL].\nCall [PHONE]!"), |
| ("test@example.com and 555-0199.", "[EMAIL] and [PHONE]."), |
| ("12345 is a number.", "12345 is a number."), |
| ], |
| ) |
| def test_contact_patterns(text, expected): |
| output, tags = replace(text, detect(text)) |
| assert output == expected |
| assert all(t.score is None for t in tags) |
|
|
|
|
| def test_dehyphenation_preserves_original_character_mapping(): |
| from ocr.anonymization.normalization import dehyphenate |
|
|
| text = "Än-\nne in Ber-\r\nlin, and Anne-Marie." |
| normalized, positions = dehyphenate(text) |
| assert normalized == "Änne in Berlin, and Anne-Marie." |
| start = normalized.index("Berlin") |
| end = start + len("Berlin") |
| assert text[positions[start] : positions[end - 1] + 1] == "Ber-\r\nlin" |
| assert all(normalized[i] == text[p] for i, p in enumerate(positions)) |
|
|
|
|
| def test_recognizer_maps_normalized_predictions_without_inventing_offsets(): |
| from ocr.anonymization.recognizer import GLiNERRecognizer |
|
|
| model = GLiNERRecognizer.__new__(GLiNERRecognizer) |
|
|
| def view(text): |
| if text != "Berlin": |
| return [] |
| return [entity(text, "CITY", 0, 6)] |
|
|
| model._recognize_view = view |
| found = model.recognize("Ber-\nlin") |
| assert len(found) == 1 and found[0].text == "Ber-\nlin" |
| assert found[0].normalization == "dehyphenation-v1" |
| assert replace("Ber-\nlin", found)[0] == "[CITY]" |
|
|
|
|
| def test_entity_level_evaluator_separates_labels_coverage_and_partial_masking(): |
| from ocr.anonymization.evaluate import score_cases |
|
|
| class Recognition: |
| def recognize(self, text): |
| return [entity(text, "ORGANIZATION", 0, 3)] |
|
|
| case = dict( |
| text="ABC DEF", |
| expected="[PERSON]", |
| spans=[dict(start=0, end=7, label="PERSON", text="ABC DEF")], |
| ) |
| report = score_cases(Recognition(), [case]) |
| assert report["combined_entity_metrics"]["PERSON"]["fn"] == 1 |
| assert report["combined_entity_metrics"]["ORGANIZATION"]["fp"] == 1 |
| assert report["unredacted_canaries"]["PERSON"] == 1 |
| assert report["literal_unredacted_canaries"]["PERSON"] == 0 |
| assert report["qualification_passed"] is False |
|
|
