openmetadata-ingestion 1.9.0.0__py3-none-any.whl → 1.10.14.4__py3-none-any.whl

metadata/pii/algorithms/classifiers.py

@@ -19,6 +19,7 @@ from typing import (
     Dict,
     Generic,
     Hashable,
+    Iterable,
     Mapping,
     Optional,
     Sequence,
@@ -29,7 +30,7 @@ from typing import (
 
 from presidio_analyzer import AnalyzerEngine
 
-from metadata.generated.schema.entity.data.table import DataType
+from metadata.generated.schema.entity.data.table import Column, DataType
 from metadata.pii.algorithms.column_patterns import get_pii_column_name_patterns
 from metadata.pii.algorithms.feature_extraction import (
     extract_pii_from_column_names,
@@ -48,6 +49,7 @@ from metadata.pii.algorithms.presidio_utils import (
     set_presidio_logger_level,
 )
 from metadata.pii.algorithms.tags import PIISensitivityTag, PIITag
+from metadata.pii.tag_analyzer import TagAnalyzer
 
 T = TypeVar("T", bound=Hashable)
 
@@ -72,6 +74,11 @@ class ColumnClassifier(ABC, Generic[T]):
         higher scores indicate a higher likelihood of the class for the given inputs.
         """
 
+    def classify(self, column: Column, sample_data: Sequence[Any]) -> Mapping[T, float]:
+        return self.predict_scores(
+            sample_data, column_name=column.name.root, column_data_type=column.dataType
+        )
+
 
 @final
 class HeuristicPIIClassifier(ColumnClassifier[PIITag]):
@@ -178,3 +185,58 @@ class PIISensitiveClassifier(ColumnClassifier[PIISensitivityTag]):
                 results[tag] /= counts[tag]
 
         return results
+
+
+@final
+class TagClassifier(ColumnClassifier[str]):
+    """
+    Heuristic PII Column Classifier
+    """
+
+    def __init__(
+        self,
+        *,
+        tag_analyzers: Iterable[TagAnalyzer],
+        column_name_contribution: float = 0.5,
+        score_cutoff: float = 0.1,
+        relative_cardinality_cutoff: float = 0.01,
+    ):
+        set_presidio_logger_level()
+
+        self._analyzers = tag_analyzers
+
+        self._column_name_contribution = column_name_contribution
+        self._score_cutoff = score_cutoff
+        self._relative_cardinality_cutoff = relative_cardinality_cutoff
+
+    def predict_scores(
+        self,
+        sample_data: Sequence[Any],
+        column_name: Optional[str] = None,
+        column_data_type: Optional[DataType] = None,
+    ) -> Mapping[str, float]:
+        str_values = preprocess_values(sample_data)
+
+        if not str_values:
+            return {}
+
+        # Relative cardinality test
+        unique_values = set(str_values)
+        if len(unique_values) / len(str_values) < self._relative_cardinality_cutoff:
+            return {}
+
+        results: dict[str, float] = defaultdict(float)
+        for analyzer in self._analyzers:
+            content_score = analyzer.analyze_content(values=str_values)
+            column_score = 0.0
+            if column_name is not None:
+                column_score = analyzer.analyze_column()
+                column_score *= max(column_score, self._column_name_contribution)
+
+            total_score = content_score + column_score
+            if total_score > self._score_cutoff:
+                results[str(analyzer.tag.fullyQualifiedName)] = (
+                    content_score + column_score
+                )
+
+        return results

metadata/pii/algorithms/feature_extraction.py

@@ -86,11 +86,22 @@ def split_column_name(column_name: str) -> List[str]:
     """
     Split a column name into its components.
     This is used for passing column names to the analyzer as context.
+    Handles both delimiters (_-. /) and camelCase.
     """
-    # Split by common delimiters
+    # First split by common delimiters
     delimiters = ["_", "-", " ", ".", "/"]
     regex_pattern = "|".join(map(re.escape, delimiters))
-    return list(re.split(regex_pattern, column_name.lower()))
+    parts = re.split(regex_pattern, column_name)
+
+    # Then split each part by camelCase
+    result: List[str] = []
+    for part in parts:
+        if not part:
+            continue
+        camel_parts = re.sub("([a-z])([A-Z])", r"\1 \2", part).split()
+        result.extend([p.lower() for p in camel_parts])
+
+    return result
 
 
 def extract_pii_from_column_names(

metadata/pii/algorithms/patterns.py

@@ -0,0 +1,171 @@
+from presidio_analyzer import Pattern
+
+credit_cards = [
+    Pattern("Credit Card Number", pattern, 0.7)
+    for pattern in (
+        # Visa: 13 or 16 digits, starts with 4
+        r"^4\d{12}(?:\d{3})?$",
+        # Mastercard: 16 digits
+        # Includes both old range (51-55) and new range (2221-2720)
+        r"^(?:5[1-5]\d{2}|2(?:22[1-9]|2[3-9]\d|[3-6]\d{2}|7[01]\d|720))\d{12}$",
+        # American Express: 15 digits, starts with 34 or 37
+        r"^3[47]\d{13}$",
+        # Diners Club: 14 digits, starts with 300-305, 36, or 38
+        r"^3(?:0[0-5]|[68]\d)\d{11}$",
+        # Discover: 16 digits
+        # Starts with 6011, 622126-622925, 644-649, or 65
+        r"^(?:6011|65\d{2}|64[4-9]\d|622(?:1(?:2[6-9]|[3-9]\d)|[2-8]\d{2}|9(?:[01]\d|2[0-5])))\d{12}$",
+        # JCB: 16 digits, starts with 3528-3589
+        r"^35(?:2[89]|[3-8]\d)\d{12}$",
+        # Maestro: 12-19 digits
+        # Starts with 5018, 5020, 5038, 5893, 6304, 6759, 6761-6763
+        r"^(?:50(?:18|20|38)|5893|6(?:304|759|76[1-3]))\d{8,15}$",
+        # UnionPay: 16-19 digits, starts with 62
+        r"^62\d{14,17}$",
+    )
+]
+
+us_driving_license = [
+    Pattern("US Driving License", pattern, 0.3)
+    for pattern in (
+        r"^\d{7}$",
+        r"^[a-zA-Z]\d{8}$",
+        r"^\d{9}$",
+        r"^9\d{8}$",
+        r"^[a-zA-Z]\d{7}$",
+        r"^\d{2}-\d{3}-\d{4}$",
+        r"^[a-zA-Z] \d{3} \d{3} \d{3} \d{3}$",
+        r"^[a-zA-Z]\d{12}$",
+        r"^[a-zA-Z]\d{3}-\d{3}-\d{2}-\d{3}-\d$",
+        r"^[a-zA-Z]-\d{3}-\d{3}-\d{3}-\d{3}$",
+        r"^[a-zA-Z]\s\d{3}\s\d{3}\s\d{3}\s\d{3}$",
+        r"^[a-zA-Z]\d{12}$",
+        r"^[a-zA-Z]{2}\d{6}[a-zA-Z]$",
+        r"^[a-zA-Z]\d{3}-\d{4}-\d{4}$",
+        r"^[a-zA-Z]\d{11}$",
+        r"^\d{4}-\d{2}-\d{4}$",
+        r"^\d{3}[a-zA-Z]{2}\d{4}$",
+        r"^[a-zA-Z]\d{2}-\d{2}-\d{4}$",
+        r"^[a-zA-Z]\d{2}-\d{3}-\d{3}$",
+        r"^[a-zA-Z]\d{9}$",
+        r"^\d{3}-\d{2}-\d{4}$",
+        r"^[a-zA-Z]\d{9}$",
+        r"^(([0][1-9]|[1][0-2])\d{3}([1-9][0-9]{3})41([0][1-9]|[1][0-9]|[3][0-1]))\d{10}$",
+        r"^([0][1-9]|[1][0-2])[a-zA-Z]{3}\d{2}(0[1-9]|[1-2][0-9]|3[0-1])\d$",
+        r"^[a-zA-Z]\d{4}-\d{5}-\d{5}$",
+        r"^[a-zA-Z]\d{14}$",
+        r"^\d{3} \d{3} \d{3}$",
+        r"^\d{12}$",
+        r"^[a-zA-Z]{3}-\d{2}-\d{4}$",
+        r"^[a-zA-Z]{1}[0-9]{4,8}$",
+        r"^[a-zA-Z]{2}[0-9]{3,7}$",
+        r"^\d{2}\s\d{3}\s\d{3}$",
+        r"^[1-9]{2}\d{5}$",
+        r"^\d{8}$",
+        r"^\d{7,9}$",
+        r"^\d{7}[a-zA-Z]$",
+        r"^[a-zA-Z]\d{8}$",
+        r"^[a-zA-Z*]{1,6}[a-zA-Z]{2}\d[a-zA-Z0-9]{4,6}$",
+        r"^[a-zA-Z]\d{6}$",
+        r"^[a-zA-Z]\d{3}-\d{4}-\d{4}-\d{2}$",
+        r"^\d{6}-\d{3}$",
+        r"^\d{2}[a-zA-Z]{3}\d{5}$",
+        r"^\d{13}$",
+        r"^\d[A-Z]{2}\d{4}$",  # #??####
+        r"^\d{2}[A-Z]{2}\d{3}$",  # ##??###
+        r"^\d{3}\s[A-Z]{3}$",  # ### ???
+        r"^\d{4}$",  # ####
+        r"^[A-Z]{3}\d{4}$",  # ???####
+        r"^\d{3}\s?[A-Z]{3}$",  # ### ??? or ###???
+        r"^\d[A-Z]{3}\d{3}$",  # #???###
+        r"^\d{3}-[A-Z]{3}$",  # ###-???
+        r"^[A-Z]{3}-\d{3}$",  # ???-###
+        r"^\d{6}$",  # ######
+        r"^[A-Z]{2}-\d{4}$",  # ??-####
+        r"^[A-Z]{3}\s[A-Z]\d{2}$",  # ??? ?##
+        r"^[A-Z]\d{2}\s\d[A-Z]{2}$",  # ?## #??
+        r"^\d{3}\s\d[A-Z]{2}$",  # ### #??
+        r"^[A-Z]{2}\s\d{4}$",  # ?? ####
+        r"^[A-Z]{3}\s\d{3}$",  # ??? ###
+        r"^[HZKLMhzklm][A-Z]{2}\s\d{3}$",  # H?? ### (etc)
+        r"^[A-Z]\s\d{6}$",  # ? ######
+        r"^\d[A-Z]\s\d{5}$",  # #? #####
+        r"^\d[A-Z]\s[A-Z]\d{4}$",  # #? ?####
+        r"^\d[A-Z]\s[A-Z]{2}\d{3}$",  # #? ??###
+        r"^\d[A-Z]\s\d[A-Z]\d[A-Z]{3}$",  # #? #?#???
+        r"^\d[A-Z]\s\d{4}[A-Z]$",  # #? ####?
+        r"^\d{2}[A-Z]\s\d{4}$",  # ##? ####
+        r"^[A-Z]{2}\s\d{5}$",  # ?? #####
+        r"^[A-Z]{2}\d\s\d{4}$",  # ??# ####
+        r"^\d{3}[A-Z]{1,3}$",  # ###?, ###??, ###???
+        r"^\d{4}\s[A-Z]{2}$",  # #### ??
+        r"^\d[A-Z]{3}\s\d{2}$",  # #??? ##
+        r"^\d[A-Z]{2}\s\d{3}$",  # #?? ###
+        r"^\d{3}\s[A-Z]{2}\d$",  # ### ??#
+        r"^\d{2}[A-Z]\s[A-Z]\d{2}$",  # ##? ?##
+        r"^\d[A-Z]{2}\s[A-Z]\d{2}$",  # #?? ?##
+        r"^\d{3}-[A-Z]{3}$",  # ###-???
+        r"^[A-Z]{2}\d\s[A-Z]\d[A-Z]$",  # ??# ?#?
+        r"^\d-\d{5}[A-Z]$",  # #-#####?
+        r"^\d{2}-\d{4}[A-Z]$",  # ##-####?
+        r"^\d-[A-Z]\d{4}$",  # #-?####
+        r"^\d{2}-[A-Z]\d{3}$",  # ##-?###
+        r"^\d{2}-[A-Z]{2}\d{2}$",  # ##-??##
+        r"^\d{2}[A-Z]•\d{3}$",  # ##?•###
+        r"^\d{3}\s\d{4}$",  # ### ####
+        r"^[A-Z]\d{2}-[A-Z]{3}$",  # ?##-???
+        r"^[A-Z]{3}-\d{4}$",  # ???-####
+        r"^\d{3}-[A-Z]{4}$",  # ###-????
+        r"^[A-Z]{3}\s\d{4}$",  # ??? ####
+        r"^\d{3}\s\d[A-Z]{2}$",  # ### #??
+        r"^\d[A-Z]{2}\s\d{3}$",  # #?? ###
+        r"^\d[A-Z]{2}\s[A-Z]\d{2}$",  # #?? ?##
+        r"^\d{2}[A-Z]\s\d{3}$",  # ##? ###
+        r"^\d{2}[A-Z]\s[A-Z]\d{2}$",  # ##? ?##
+        r"^\d{2}[A-Z]\s[A-Z]{2}\d$",  # ##? ??#
+        r"^[A-Z]\d{2}-\d{2}[A-Z]$",  # ?##-##?
+        r"^[A-Z]\d{2}\s\d[A-Z]{2}$",  # ?## #??
+        r"^\d{2}[A-Z]{2}\d$",  # ##??#
+        r"^\d[A-Z]{2}\d{2}$",  # #??##
+        r"^\d{3}[A-Z]\d$",  # ###?#
+        r"^\d[A-Z]\d{3}$",  # #?###
+        r"^[A-Z]{3}\d{4}$",  # ???####
+        r"^\d[A-Z]{2}\s\d{3}$",  # #?? ###
+        r"^\d-\d{5}$",  # #-#####
+        r"^\d-\d{4}[A-Z]$",  # #-####?
+        r"^\d{2}-\d{5}$",  # ##-#####
+    )
+]
+
+au_tfn_number = [
+    Pattern(
+        "TFN (High)",
+        r"\bTFN:\s?\d{3}\s\d{3}\s\d{3}\b",
+        0.7,
+    ),
+    Pattern(
+        "TFN (High)",
+        r"\bTFN:\s?\d{3}-\d{3}-\d{3}\b",
+        0.7,
+    ),
+    Pattern(
+        "TFN (High)",
+        r"\bTFN:\s?\d{9}\b",
+        0.7,
+    ),
+    Pattern(
+        "TFN (Medium)",
+        r"\b\d{3}\s\d{3}\s\d{3}\b",
+        0.1,
+    ),
+    Pattern(
+        "TFN (Medium)",
+        r"\b\d{3}-\d{3}-\d{3}\b",
+        0.1,
+    ),
+    Pattern(
+        "TFN (Low)",
+        r"\b\d{9}\b",
+        0.01,
+    ),
+]

metadata/pii/algorithms/preprocessing.py

@@ -12,8 +12,7 @@
 Preprocessing functions for the classification tasks.
 """
 import datetime
-import json
-from typing import Any, List, Mapping, Optional, Sequence
+from typing import Any, List, Mapping, Optional, Sequence, Union, cast
 
 from metadata.utils.logger import pii_logger
 
@@ -21,7 +20,7 @@ logger = pii_logger()
 
 
 # pylint: disable=too-many-return-statements
-def convert_to_str(value: Any) -> Optional[str]:
+def convert_to_str(value: Any) -> Optional[Union[List[str], str]]:
     """
     Convert the given value to a string. This is a conversion
     tailored to our use case, not a generic one.
@@ -32,14 +31,18 @@ def convert_to_str(value: Any) -> Optional[str]:
         # Values we want to convert to string out of the box
         return str(value)
     if isinstance(value, bytes):
-        return value.decode("utf-8", errors="ignore")
+        # Don't classify binary columns, which might contain misleading or outright invalid strings
+        return None
     if isinstance(value, (Sequence, Mapping)):
-        try:
-            return json.dumps(value, default=str)
-        except (TypeError, ValueError, OverflowError) as e:
-            # If the value cannot be serialized to JSON, return None
-            logger.warning(f"Failed to convert value to JSON: {e}")
-            return None
+        if isinstance(value, Mapping):
+            value = list(value.values())
+        converted = [convert_to_str(el) for el in cast(List[Any], value)]
+        return [
+            item
+            for sublist in converted
+            for item in (sublist if isinstance(sublist, list) else [sublist])
+            if item is not None
+        ]
     if value is None:
         # We want to skip None values, not convert them to "None"
         return None
@@ -53,10 +56,13 @@ def preprocess_values(values: Sequence[Any]) -> List[str]:
         if converted_value is None:
             # Skip None values
             continue
+
+        if not isinstance(converted_value, list):
+            converted_value = [converted_value]
+
         # skip empty strings
-        if not converted_value.strip():
-            continue
+        converted_value = [el.strip() for el in converted_value if el.strip()]
         # Add the converted value as is, without any further processing
-        result.append(converted_value)
+        result.extend(converted_value)
 
     return result

metadata/pii/algorithms/presidio_recognizer_factory.py

@@ -0,0 +1,302 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""
+Factory for creating Presidio recognizers from OpenMetadata recognizer configurations.
+"""
+import re
+from typing import Dict, List, Optional, cast
+
+from presidio_analyzer import EntityRecognizer
+from presidio_analyzer import Pattern as PresidioPattern
+from presidio_analyzer import PatternRecognizer as PresidioPatternRecognizer
+from presidio_analyzer import predefined_recognizers
+
+from metadata.generated.schema.entity.classification.tag import Tag
+from metadata.generated.schema.type.contextRecognizer import ContextRecognizer
+from metadata.generated.schema.type.customRecognizer import CustomRecognizer
+from metadata.generated.schema.type.denyListRecognizer import DenyListRecognizer
+from metadata.generated.schema.type.patternRecognizer import PatternRecognizer
+from metadata.generated.schema.type.predefinedRecognizer import PredefinedRecognizer
+from metadata.generated.schema.type.recognizer import Recognizer
+from metadata.generated.schema.type.recognizers.regexFlags import RegexFlags
+from metadata.pii.algorithms.presidio_utils import apply_confidence_threshold
+from metadata.utils.logger import pii_logger
+
+logger = pii_logger()
+
+
+class PresidioRecognizerFactory:
+    """Factory for creating Presidio recognizers from OpenMetadata configurations."""
+
+    @staticmethod
+    def create_recognizer(recognizer_config: Recognizer) -> Optional[EntityRecognizer]:
+        """
+        Create a Presidio recognizer from an OpenMetadata recognizer configuration.
+
+        Args:
+            recognizer_config: The recognizer configuration from OpenMetadata
+            tag_name: The name of the tag this recognizer belongs to
+
+        Returns:
+            A Presidio EntityRecognizer or None if creation fails
+        """
+        if not recognizer_config.enabled:
+            return None
+
+        config = recognizer_config.recognizerConfig.root
+
+        if isinstance(config, PatternRecognizer):
+            recognizer = PresidioRecognizerFactory._create_pattern_recognizer(
+                config, recognizer_config
+            )
+        elif isinstance(config, DenyListRecognizer):
+            recognizer = PresidioRecognizerFactory._create_deny_list_recognizer(
+                config, recognizer_config
+            )
+        elif isinstance(config, ContextRecognizer):
+            recognizer = PresidioRecognizerFactory._create_context_recognizer(
+                config, recognizer_config
+            )
+        elif isinstance(config, CustomRecognizer):
+            recognizer = PresidioRecognizerFactory._create_custom_recognizer(
+                config, recognizer_config
+            )
+        elif isinstance(
+            config, PredefinedRecognizer
+        ):  # pyright: ignore[reportUnnecessaryIsInstance]
+            recognizer = PresidioRecognizerFactory._create_predefined_recognizer(
+                config, recognizer_config
+            )
+        else:
+            logger.warning(f"Unknown recognizer type for {recognizer_config.name}")
+            return None
+
+        if recognizer and (threshold := recognizer_config.confidenceThreshold):
+            patch_analyze = apply_confidence_threshold(threshold)
+            recognizer = patch_analyze(recognizer)
+
+        return recognizer
+
+    @staticmethod
+    def _get_regex_flags(flags: Optional[RegexFlags]) -> Optional[int]:
+        if flags is None:
+            return re.IGNORECASE | re.DOTALL | re.MULTILINE
+
+        re_flags = 0
+        if flags.ignoreCase:
+            re_flags |= re.IGNORECASE
+        if flags.dotAll:
+            re_flags |= re.DOTALL
+        if flags.multiline:
+            re_flags |= re.MULTILINE
+
+        return re_flags
+
+    @staticmethod
+    def _create_pattern_recognizer(
+        config: PatternRecognizer,
+        recognizer_config: Recognizer,
+    ) -> PresidioPatternRecognizer:
+        """Create a pattern-based recognizer."""
+        patterns: List[PresidioPattern] = []
+        for pattern_config in config.patterns:
+            patterns.append(
+                PresidioPattern(
+                    name=pattern_config.name,
+                    regex=pattern_config.regex,
+                    score=pattern_config.score or 0.8,
+                )
+            )
+
+        return PresidioPatternRecognizer(
+            supported_entity=config.supportedEntity.value,
+            patterns=patterns,
+            name=recognizer_config.name.root,
+            supported_language=config.supportedLanguage,
+            global_regex_flags=PresidioRecognizerFactory._get_regex_flags(
+                config.regexFlags
+            ),
+        )
+
+    @staticmethod
+    def _create_deny_list_recognizer(
+        config: DenyListRecognizer, recognizer_config: Recognizer
+    ) -> PresidioPatternRecognizer:
+        """Create a deny list recognizer using patterns."""
+        patterns: List[PresidioPattern] = []
+        for value in config.denyList:
+            # Escape special regex characters in the value
+            escaped_value = re.escape(value)
+
+            patterns.append(
+                PresidioPattern(
+                    name=f"deny_{value}",
+                    regex=escaped_value,
+                    score=0.9,  # High confidence for exact matches
+                )
+            )
+
+        return PresidioPatternRecognizer(
+            supported_entity=config.supportedEntity.value,
+            patterns=patterns,
+            name=recognizer_config.name.root,
+            supported_language=config.supportedLanguage,
+            global_regex_flags=PresidioRecognizerFactory._get_regex_flags(
+                config.regexFlags
+            ),
+        )
+
+    @staticmethod
+    def _create_context_recognizer(
+        config: ContextRecognizer, recognizer_config: Recognizer
+    ) -> PresidioPatternRecognizer:
+        """Create a context-aware recognizer."""
+        # For context recognizers, we can use a pattern recognizer with context words
+        # or implement a custom recognizer that uses NLP
+        context_patterns: List[PresidioPattern] = []
+
+        # Create patterns that look for context words near potential entities
+        for context_word in config.contextWords:
+            # Pattern to match words near context words
+            pattern = f"(?i)(?:{context_word})\\s+\\w+|\\w+\\s+(?:{context_word})"
+            context_patterns.append(
+                PresidioPattern(
+                    name=f"context_{context_word}",
+                    regex=pattern,
+                    score=(config.minScore + config.maxScore) / 2
+                    if config.minScore and config.maxScore
+                    else 0.6,
+                )
+            )
+
+        return PresidioPatternRecognizer(
+            supported_entity=config.supportedEntity.value,
+            patterns=context_patterns,
+            name=recognizer_config.name.root,
+            supported_language=config.supportedLanguage,
+        )
+
+    @staticmethod
+    def _create_custom_recognizer(
+        config: CustomRecognizer,  # pyright: ignore[reportUnusedParameter]
+        recognizer_config: Recognizer,
+    ) -> Optional[EntityRecognizer]:
+        """
+        Create a custom recognizer with user-defined logic.
+
+        For security reasons, we don't execute arbitrary Python code.
+        Instead, we could support a limited set of custom behaviors
+        or require custom recognizers to be implemented as plugins.
+        """
+        logger.warning(
+            f"Custom recognizer {recognizer_config.name} requires implementation. "
+            + "Consider using pattern, deny_list, or context recognizers instead."
+        )
+        return None
+
+    @staticmethod
+    def _create_predefined_recognizer(
+        config: PredefinedRecognizer,
+        recognizer: Recognizer,  # pyright: ignore[reportUnusedParameter]
+    ) -> Optional[EntityRecognizer]:
+        """Create a custom recognizer with user-defined logic."""
+        try:
+            predefined_class = getattr(predefined_recognizers, config.name.value)
+        except AttributeError:
+            logger.error(f"Recognizer {config.name} not found")
+            return None
+
+        args = {}
+        if supported_language := config.supportedLanguage:
+            args["supported_language"] = supported_language
+        if context := config.context:
+            args["context"] = context
+
+        return predefined_class(**args)
+
+    @staticmethod
+    def create_recognizers_for_tag(tag: Tag) -> List[EntityRecognizer]:
+        """
+        Create all enabled recognizers for a given tag.
+
+        Args:
+            tag: The tag containing recognizer configurations
+
+        Returns:
+            List of Presidio EntityRecognizer instances
+        """
+        recognizers: List[EntityRecognizer] = []
+
+        if not tag.autoClassificationEnabled or not tag.recognizers:
+            return recognizers
+
+        for recognizer_config in tag.recognizers:
+            recognizer = PresidioRecognizerFactory.create_recognizer(recognizer_config)
+            if recognizer:
+                recognizers.append(recognizer)
+                logger.info(
+                    f"Created recognizer {recognizer_config.name} for tag {tag.name}"
+                )
+
+        return recognizers
+
+
+class RecognizerRegistry:
+    """Registry for managing custom recognizers from OpenMetadata."""
+
+    def __init__(self):
+        self.recognizers: Dict[str, List[EntityRecognizer]] = {}
+        self.tag_priority: Dict[str, int] = {}
+        self.tag_confidence_threshold: Dict[str, float] = {}
+
+    def register_tag_recognizers(self, tag: Tag) -> None:
+        """
+        Register all recognizers for a tag.
+
+        Args:
+            tag: The tag with recognizer configurations
+        """
+        if not tag.autoClassificationEnabled:
+            return
+
+        tag_fqn = cast(str, tag.fullyQualifiedName)
+        self.recognizers[
+            tag_fqn
+        ] = PresidioRecognizerFactory.create_recognizers_for_tag(tag)
+        self.tag_priority[tag_fqn] = tag.autoClassificationPriority or 50
+
+        # Calculate minimum confidence from all recognizers
+        min_confidence = 1.0
+        for recognizer_config in tag.recognizers or []:
+            if recognizer_config.confidenceThreshold:
+                min_confidence = min(
+                    min_confidence, recognizer_config.confidenceThreshold
+                )
+        self.tag_confidence_threshold[tag_fqn] = min_confidence
+
+    def get_recognizers_for_tag(self, tag_fqn: str) -> List[EntityRecognizer]:
+        """Get all recognizers registered for a tag."""
+        return self.recognizers.get(tag_fqn, [])
+
+    def get_all_recognizers(self) -> List[EntityRecognizer]:
+        """Get all registered recognizers across all tags."""
+        all_recognizers: list[EntityRecognizer] = []
+        for recognizers in self.recognizers.values():
+            all_recognizers.extend(recognizers)
+        return all_recognizers
+
+    def get_tag_priority(self, tag_fqn: str) -> int:
+        """Get the priority for a tag (used in conflict resolution)."""
+        return self.tag_priority.get(tag_fqn, 50)
+
+    def get_tag_confidence_threshold(self, tag_fqn: str) -> float:
+        """Get the minimum confidence threshold for a tag."""
+        return self.tag_confidence_threshold.get(tag_fqn, 0.6)