fix(analyzer): register KrPassportRecognizer and align its default language

KrPassportRecognizer was the only Korean recognizer absent from
default_recognizers.yaml, for two reasons that also kept it out of the
predefined registry.

RecognizerListLoader.get instantiates every predefined recognizer with a
name keyword argument, taken from the YAML entry (or from name when
class_name supplies the class). KrPassportRecognizer.__init__ did not
accept it, so listing the recognizer in default_recognizers.yaml made the
registry raise TypeError on load. Adding the argument is what makes the
entry possible.

Its default supported_language was kr, while every other Korean
recognizer defaults to ko, the ISO 639-1 code. #1742 migrated the Korean
recognizers from kr to ko; #1814 added this one afterwards and
reintroduced kr, so an AnalyzerEngine running ko silently skipped it. The
default is now ko. This only affects direct instantiation: when an entry
omits supported_languages the loader passes the registry's language
explicitly, so the class default never applies on the YAML path.

Registers the recognizer with enabled: false and country_code: kr,
matching its siblings, and covers all three points with tests.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: developer0hye

presidio-analyzer/presidio_analyzer/conf/default_recognizers.yaml

@@ -311,6 +311,14 @@ recognizers:
     enabled: false
     country_code: kr
 
+  - name: KrPassportRecognizer
+    supported_languages:
+    - ko
+    - kr
+    type: predefined
+    enabled: false
+    country_code: kr
+
   - name: SeOrganisationsnummerRecognizer
     supported_languages:
     - sv

presidio-analyzer/presidio_analyzer/predefined_recognizers/country_specific/korea/kr_passport_recognizer.py

@@ -48,8 +48,9 @@ def __init__(
         self,
         patterns: Optional[List[Pattern]] = None,
         context: Optional[List[str]] = None,
-        supported_language: str = "kr",
+        supported_language: str = "ko",
         supported_entity: str = "KR_PASSPORT",
+        name: Optional[str] = None,
     ):
         patterns = patterns if patterns else self.PATTERNS
         context = context if context else self.CONTEXT
@@ -58,4 +59,5 @@ def __init__(
             patterns=patterns,
             context=context,
             supported_language=supported_language,
+            name=name,
         )

presidio-analyzer/tests/test_kr_passport_recognizer.py

@@ -1,7 +1,17 @@
+import copy
+import tempfile
+from pathlib import Path
+
+import presidio_analyzer
 import pytest
+import yaml
+from presidio_analyzer.predefined_recognizers.country_specific.korea.kr_passport_recognizer import (
+    KrPassportRecognizer,
+)
+from presidio_analyzer.recognizer_registry import RecognizerRegistryProvider
 
 from tests import assert_result_within_score_range
-from presidio_analyzer.predefined_recognizers.country_specific.korea.kr_passport_recognizer import KrPassportRecognizer
+
 
 @pytest.fixture(scope="module")
 def recognizer():
@@ -25,18 +35,18 @@ def entities():
         ("My passport number is M123A4567", 1, ((22, 31),), ((0.1, 0.1),)),
         ("Korean passport: M456B7890", 1, ((17, 26),), ((0.1, 0.1),)),
         ("여권번호는 M789C1234입니다", 1, ((6, 15),), ((0.1, 0.1),)),
-        
+
         # Valid previous format passports (M + 8 digits)
         ("M12345678", 1, ((0, 9),), ((0.05, 0.05),)),
         ("m87654321", 1, ((0, 9),), ((0.05, 0.05),)),
         ("d11223344", 1, ((0, 9),), ((0.05, 0.05),)),
         ("s99887766", 1, ((0, 9),), ((0.05, 0.05),)),
         ("My old passport M12345678", 1, ((16, 25),), ((0.05, 0.05),)),
         ("대한민국 여권 S87654321", 1, ((8, 17),), ((0.05, 0.05),)),
-        
+
         # Multiple passport numbers
         ("M123A4567 and M456B7890", 2, ((0, 9), (14, 23)), ((0.1, 0.1), (0.1, 0.1))),
-        
+
         # Invalid formats - should not match
         ("A123B4567", 0, (), ()),  # Wrong first letter
         ("M12A4567", 0, (), ()),   # Too few digits before letter
@@ -69,7 +79,7 @@ def test_when_all_passports_then_succeed(
     assert len(results) == expected_len
     for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
         results, expected_positions, expected_score_ranges
-    ):  
+    ):
         print(f"res: {res}, st_pos: {st_pos}, fn_pos: {fn_pos}, st_score: {st_score}, fn_score: {fn_score}")
         if fn_score == "max":
             fn_score = max_score
@@ -104,7 +114,53 @@ def test_when_no_passport_then_no_results(recognizer, entities):
         "M123456789", # Too long for old format
         "123A4567",   # Missing M prefix
     ]
-    
+
     for text in invalid_texts:
         results = recognizer.analyze(text, entities)
-        assert len(results) == 0, f"Expected no results for text: {text}"
+        assert len(results) == 0, f"Expected no results for text: {text}"
+
+
+def test_default_supported_language_is_ko():
+    """Default language must be ``ko``, like the other Korean recognizers.
+
+    It was previously ``kr``, which registered the recognizer under a language
+    code that an AnalyzerEngine running ``ko`` never queried.
+    """
+    assert KrPassportRecognizer().supported_language == "ko"
+
+
+def test_accepts_name_kwarg():
+    """Constructor must accept the ``name`` kwarg the YAML loader passes.
+
+    Without it, loading the recognizer from a registry YAML raises
+    ``TypeError``, which is why it could not be listed there before.
+    """
+    recognizer = KrPassportRecognizer(name="CustomKrPassport")
+    assert recognizer.name == "CustomKrPassport"
+
+
+@pytest.mark.parametrize("language", ["ko", "kr"])
+def test_loads_from_default_recognizers_yaml(language):
+    """Recognizer is registered in the default YAML and loads once enabled."""
+    conf = (
+        Path(presidio_analyzer.__file__).parent
+        / "conf"
+        / "default_recognizers.yaml"
+    )
+    recognizers = yaml.safe_load(conf.read_text())["recognizers"]
+    entries = [r for r in recognizers if r.get("name") == "KrPassportRecognizer"]
+    assert len(entries) == 1, "KrPassportRecognizer missing from YAML"
+    entry = entries[0]
+    assert entry["country_code"] == "kr"
+    assert language in entry["supported_languages"]
+
+    entry = copy.deepcopy(entry)
+    entry["enabled"] = True
+    tmp = Path(tempfile.mkdtemp()) / "conf.yaml"
+    tmp.write_text(
+        yaml.safe_dump({"supported_languages": [language], "recognizers": [entry]})
+    )
+    provider = RecognizerRegistryProvider(conf_file=str(tmp))
+    registry = provider.create_recognizer_registry()
+    entities = {e for rec in registry.recognizers for e in rec.supported_entities}
+    assert "KR_PASSPORT" in entities