fix(analyzer): make every listed recognizer loadable from the registry YAML

Three recognizers ship in default_recognizers.yaml with enabled: false but
cannot be turned on. KrBrnRecognizer, KrDriverLicenseRecognizer and
UsMbiRecognizer do not accept the name keyword argument that
RecognizerListLoader passes to every predefined recognizer, so flipping
enabled to true raises

    TypeError: __init__() got an unexpected keyword argument 'name'

before the registry finishes loading. enabled: false is an opt-in switch,
not a disclaimer: an entry that cannot be enabled should not be listed.
The failure also reads as a user configuration error even though the YAML
is correct, unlike the optional-dependency entries, which refuse to load
with an actionable ImportError.

Adds the argument to the three constructors, and adds contract tests so
the next one is caught by CI.

Why this survived: the constructor signature is part of a contract that
nothing enforced. Each recognizer's own tests instantiate the class
directly, where no name is passed, so they all pass. The registry-level
tests build the default configuration, in which roughly 60 entries are
disabled and therefore never constructed. Nothing in between ever looked.

The new tests close that gap from both sides:

- Every predefined PatternRecognizer subclass must accept the kwargs the
  loader passes. This fires when the class is added, before it reaches the
  YAML at all, which is the point at which KrPassportRecognizer went
  wrong in #1814.
- Every entry in default_recognizers.yaml must resolve to a class and must
  load once enabled, exercised entry by entry so a failure names the
  recognizer. Optional-dependency recognizers are skipped.
- A class_name plus name entry must produce an instance with the
  configured name, which is the documented reason the loader passes name
  and what makes the kwarg contract load-bearing.

Verified by reverting the three constructors: the signature test and the
load test each fail for exactly those three, with no other failures.

Non-pattern recognizers are out of scope. Several are not registrable from
default_recognizers.yaml, and AzureAILanguageRecognizer deliberately fixes
its own display name.

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

Author: developer0hye

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

@@ -58,6 +58,7 @@ def __init__(
         supported_language: str = "ko",
         supported_entity: str = "KR_BRN",
         replacement_pairs: Optional[List[Tuple[str, str]]] = None,
+        name: Optional[str] = None,
     ):
         self.replacement_pairs = replacement_pairs if replacement_pairs else [("-", "")]
 
@@ -68,6 +69,7 @@ def __init__(
             patterns=patterns,
             context=context,
             supported_language=supported_language,
+            name=name,
         )
 
     def validate_result(self, pattern_text: str) -> Union[bool, None]:

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

@@ -70,6 +70,7 @@ def __init__(
         supported_language: str = "ko",
         supported_entity: str = "KR_DRIVER_LICENSE",
         replacement_pairs: Optional[List[Tuple[str, str]]] = None,
+        name: Optional[str] = None,
     ):
         self.replacement_pairs = (
             replacement_pairs if replacement_pairs else [("-", ""), (" ", "")]
@@ -82,6 +83,7 @@ def __init__(
             patterns=patterns,
             context=context,
             supported_language=supported_language,
+            name=name,
         )
 
     def validate_result(self, pattern_text: str) -> bool:

presidio-analyzer/presidio_analyzer/predefined_recognizers/country_specific/us/us_mbi_recognizer.py

@@ -90,6 +90,7 @@ def __init__(
         context: Optional[List[str]] = None,
         supported_language: str = "en",
         supported_entity: str = "US_MBI",
+        name: Optional[str] = None,
     ):
         patterns = patterns if patterns else self.PATTERNS
         context = context if context else self.CONTEXT
@@ -98,4 +99,5 @@ def __init__(
             patterns=patterns,
             context=context,
             supported_language=supported_language,
+            name=name,
         )

presidio-analyzer/tests/test_predefined_recognizer_contract.py

@@ -0,0 +1,173 @@
+"""Contract tests between the registry loader and predefined recognizers.
+
+``RecognizerListLoader`` builds predefined recognizers from YAML by passing the
+entry's keys as constructor kwargs. That makes the constructor signature part of
+a contract which nothing else enforces: a recognizer can satisfy every one of
+its own unit tests -- which instantiate it directly -- and still be impossible
+to load from a registry configuration.
+
+The gap is specifically in the *disabled* entries. ``default_recognizers.yaml``
+ships ~60 recognizers with ``enabled: false``, and no other test constructs
+them, so a broken constructor stays invisible until a user flips the switch.
+These tests construct every one of them.
+"""
+
+import inspect
+from pathlib import Path
+from typing import Dict, List
+
+import presidio_analyzer.predefined_recognizers as predefined
+import pytest
+import yaml
+from presidio_analyzer import EntityRecognizer, PatternRecognizer
+from presidio_analyzer.recognizer_registry import RecognizerRegistryProvider
+from presidio_analyzer.recognizer_registry.recognizers_loader_utils import (
+    RecognizerListLoader,
+)
+
+DEFAULT_CONF = (
+    Path(__file__).resolve().parent.parent
+    / "presidio_analyzer"
+    / "conf"
+    / "default_recognizers.yaml"
+)
+
+# Kwargs ``RecognizerListLoader`` passes to every predefined recognizer it
+# builds: ``name`` comes from the YAML entry (or its ``class_name`` alias) and
+# ``supported_language`` from the resolved per-language configuration.
+LOADER_KWARGS = ("name", "supported_language")
+
+
+def _pattern_recognizer_classes() -> Dict[str, type]:
+    """Predefined ``PatternRecognizer`` subclasses, which the YAML loader builds.
+
+    Non-pattern recognizers (NER/LLM/remote wrappers) are excluded: several are
+    not registrable from ``default_recognizers.yaml`` and some deliberately fix
+    their own display name.
+    """
+    classes = {}
+    for attr in dir(predefined):
+        obj = getattr(predefined, attr)
+        if not isinstance(obj, type) or not issubclass(obj, EntityRecognizer):
+            continue
+        if obj in (EntityRecognizer, PatternRecognizer):
+            continue
+        if issubclass(obj, PatternRecognizer):
+            classes[attr] = obj
+    return classes
+
+
+def _yaml_entries() -> List[Dict]:
+    """Normalize the shipped recognizer list to dict entries."""
+    data = yaml.safe_load(DEFAULT_CONF.read_text(encoding="utf-8"))
+    entries = []
+    for entry in data["recognizers"]:
+        entries.append({"name": entry} if isinstance(entry, str) else dict(entry))
+    return entries
+
+
+def _entry_languages(entry: Dict) -> List[str]:
+    """Languages an entry declares, in either supported YAML shape."""
+    languages = entry.get("supported_languages")
+    if not languages:
+        return ["en"]
+    if isinstance(languages[0], str):
+        return list(languages)
+    return [item["language"] for item in languages]
+
+
+def _entry_id(entry: Dict) -> str:
+    return entry.get("class_name") or entry["name"]
+
+
+PATTERN_CLASSES = _pattern_recognizer_classes()
+YAML_ENTRIES = _yaml_entries()
+
+
+def test_default_conf_has_entries():
+    """Guard the fixtures themselves: an empty parse would pass everything."""
+    assert PATTERN_CLASSES, "no predefined PatternRecognizer subclasses found"
+    assert YAML_ENTRIES, "no recognizers parsed from default_recognizers.yaml"
+
+
+@pytest.mark.parametrize("class_name", sorted(PATTERN_CLASSES))
+def test_pattern_recognizer_accepts_loader_kwargs(class_name):
+    """Constructor must accept every kwarg the YAML loader passes.
+
+    Catches the defect before the recognizer reaches the YAML at all: a class
+    added without ``name`` passes its own unit tests, and only fails once
+    someone tries to register it.
+    """
+    parameters = inspect.signature(PATTERN_CLASSES[class_name].__init__).parameters
+    if any(p.kind == inspect.Parameter.VAR_KEYWORD for p in parameters.values()):
+        return
+    missing = [kwarg for kwarg in LOADER_KWARGS if kwarg not in parameters]
+    assert not missing, (
+        f"{class_name}.__init__ does not accept {missing}, which "
+        f"RecognizerListLoader passes to every predefined recognizer. "
+        f"Loading it from a registry YAML raises TypeError."
+    )
+
+
+@pytest.mark.parametrize("entry", YAML_ENTRIES, ids=_entry_id)
+def test_yaml_entry_class_resolves(entry):
+    """Every shipped entry must name a real recognizer class."""
+    RecognizerListLoader.get_existing_recognizer_cls(recognizer_name=_entry_id(entry))
+
+
+@pytest.mark.parametrize("entry", YAML_ENTRIES, ids=_entry_id)
+def test_yaml_entry_loads_when_enabled(entry):
+    """Every shipped entry must load once ``enabled`` is true.
+
+    ``enabled: false`` is an opt-in switch, not a disclaimer -- an entry that
+    cannot be turned on should not be listed. Recognizers gated behind an
+    optional dependency are skipped: refusing to load with an actionable
+    ImportError is their intended behavior.
+    """
+    entry = dict(entry, enabled=True)
+    configuration = {
+        "global_regex_flags": yaml.safe_load(DEFAULT_CONF.read_text(encoding="utf-8"))[
+            "global_regex_flags"
+        ],
+        "supported_languages": _entry_languages(entry),
+        "recognizers": [entry],
+    }
+
+    try:
+        registry = RecognizerRegistryProvider(
+            registry_configuration=configuration
+        ).create_recognizer_registry()
+    except ImportError as exc:
+        pytest.skip(f"{_entry_id(entry)} needs an optional dependency: {exc}")
+
+    assert registry.recognizers, (
+        f"{_entry_id(entry)} is listed in default_recognizers.yaml but loaded "
+        f"nothing for languages {_entry_languages(entry)}"
+    )
+
+
+def test_yaml_entry_can_be_renamed_via_class_name():
+    """``class_name`` + ``name`` must give the instance the configured name.
+
+    This is the documented reason the loader passes ``name`` at all (see
+    ``RecognizerListLoader.get_recognizer_name``), so it is the behavior that
+    makes the kwarg contract above load-bearing rather than incidental.
+    """
+    configuration = {
+        "global_regex_flags": 26,
+        "supported_languages": ["en"],
+        "recognizers": [
+            {
+                "class_name": "UsSsnRecognizer",
+                "name": "MyRenamedSsnRecognizer",
+                "supported_languages": ["en"],
+                "type": "predefined",
+                "country_code": "us",
+            }
+        ],
+    }
+    registry = RecognizerRegistryProvider(
+        registry_configuration=configuration
+    ).create_recognizer_registry()
+
+    assert [r.name for r in registry.recognizers] == ["MyRenamedSsnRecognizer"]