openmetadata-ingestion 1.7.0.1__py3-none-any.whl → 1.7.1.0__py3-none-any.whl

metadata/pii/algorithms/feature_extraction.py

@@ -0,0 +1,154 @@
+#  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.
+"""
+Extraction of PII features (from text, column names, and data types) to be used
+for the PII classification model.
+"""
+import logging
+import re
+from collections import defaultdict
+from typing import DefaultDict, Dict, Iterable, List, Mapping, Optional, Sequence, Set
+
+from presidio_analyzer import AnalyzerEngine
+
+from metadata.generated.schema.entity.data.table import DataType
+from metadata.pii.algorithms.presidio_patches import PresidioRecognizerResultPatcher
+from metadata.pii.algorithms.tags import PIITag
+from metadata.pii.scanners.ner_scanner import SUPPORTED_LANG
+from metadata.utils.logger import pii_logger
+
+logger = pii_logger()
+
+
+def extract_pii_tags(
+    analyzer: AnalyzerEngine,
+    texts: Sequence[str],
+    context: Optional[List[str]] = None,
+    recognizer_result_patcher: Optional[PresidioRecognizerResultPatcher] = None,
+) -> Dict[PIITag, float]:
+    """
+    Extract PII entities from a batch of texts.
+
+    The results are averaged over the batch. In general, the larger the batch,
+    the better the results, as some single texts might be noisy or contain
+    false positives.
+
+    Args:
+        analyzer (AnalyzerEngine): The analyzer engine to use for PII detection.
+        texts (Sequence[str]): A sequence of texts to analyze.
+        context (Optional[List[str]]): Optional context to provide to the analyzer.
+            This can be used to improve the accuracy of the PII detection.
+            For example, keywords extracted from column names.
+        recognizer_result_patcher (Optional[PresidioRecognizerResultPatcher]): A function
+            that takes a recognizer result and returns a modified result.
+    Returns:
+        Mapping[PIITag, float]: A mapping of PII entity types to their average scores.
+    """
+    entity_scores: DefaultDict[PIITag, float] = defaultdict(float)
+
+    if SUPPORTED_LANG not in analyzer.supported_languages:
+        raise ValueError(
+            f"The analyzer does not support {SUPPORTED_LANG}, which is required for this function."
+        )
+
+    for text in texts:
+        results = analyzer.analyze(
+            text, language=SUPPORTED_LANG, context=context, entities=PIITag.values()
+        )
+        if recognizer_result_patcher is not None:
+            results = recognizer_result_patcher(results, text)
+
+        for result in results:
+            try:
+                # This should be safe because the analyzer only considers the entities that we passed
+                pii_entity = PIITag[result.entity_type]
+                entity_scores[pii_entity] += result.score
+            except KeyError:
+                logging.error(f"Unrecognized PII entity type: {result.entity_type}.")
+
+    # normalize the scores if the batch is not empty
+    if len(texts):
+        for entity in entity_scores:
+            entity_scores[entity] /= len(texts)
+
+    return entity_scores
+
+
+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.
+    """
+    # Split by common delimiters
+    delimiters = ["_", "-", " ", ".", "/"]
+    regex_pattern = "|".join(map(re.escape, delimiters))
+    return list(re.split(regex_pattern, column_name.lower()))
+
+
+def extract_pii_from_column_names(
+    column_name: str, patterns: Mapping[PIITag, Iterable[re.Pattern[str]]]
+) -> Set[PIITag]:
+    """
+    Extract PII entities from a column name using a collection of regex patterns
+    for each PII type. This is used to match patterns in column names that might
+    indicate the presence of PII data.
+
+    Example: "user_email" might match the EMAIL_ADDRESS pattern, returning
+    a set containing the PII tag PIITag.EMAIL_ADDRESS.
+    """
+    results: Set[PIITag] = set()
+
+    for pii_type, pii_type_patterns in patterns.items():
+        for pattern in pii_type_patterns:
+            if pattern.match(column_name) is not None:
+                results.add(pii_type)
+                break  # No need to check other patterns for this PII type
+
+    return results
+
+
+def is_non_pii_datatype(dtype: DataType) -> bool:
+    """
+    Determine whether a column with the given data type is unlikely
+    to contain PII and can be safely excluded from PII detection or scanning.
+    """
+    non_pii_types = {
+        DataType.BOOLEAN,
+        DataType.BIT,
+        DataType.NULL,
+        DataType.ERROR,
+        DataType.FIXED,
+        DataType.AGGREGATEFUNCTION,
+        DataType.HLLSKETCH,
+        DataType.QUANTILE_STATE,
+        DataType.AGG_STATE,
+        DataType.BITMAP,
+        DataType.PG_LSN,
+        DataType.PG_SNAPSHOT,
+        DataType.TXID_SNAPSHOT,
+        DataType.TSQUERY,
+        DataType.TSVECTOR,
+        DataType.UNKNOWN,
+        DataType.LOWCARDINALITY,
+        DataType.MEASURE_HIDDEN,
+        DataType.MEASURE_VISIBLE,
+    }
+    geo_data_types = {
+        DataType.GEOGRAPHY,
+        DataType.GEOMETRY,
+        DataType.SPATIAL,
+        DataType.POINT,
+        DataType.POLYGON,
+    }
+
+    excluded_data_types = non_pii_types | geo_data_types
+
+    return dtype in excluded_data_types

metadata/pii/algorithms/preprocessing.py

@@ -0,0 +1,62 @@
+#  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.
+"""
+Preprocessing functions for the classification tasks.
+"""
+import datetime
+import json
+from typing import Any, List, Mapping, Optional, Sequence
+
+from metadata.utils.logger import pii_logger
+
+logger = pii_logger()
+
+
+# pylint: disable=too-many-return-statements
+def convert_to_str(value: Any) -> Optional[str]:
+    """
+    Convert the given value to a string. This is a conversion
+    tailored to our use case, not a generic one.
+    """
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (int, float, datetime.datetime, datetime.date)):
+        # 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")
+    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 value is None:
+        # We want to skip None values, not convert them to "None"
+        return None
+    return None
+
+
+def preprocess_values(values: Sequence[Any]) -> List[str]:
+    result: List[str] = []
+    for value in values:
+        converted_value = convert_to_str(value)
+        if converted_value is None:
+            # Skip None values
+            continue
+        # skip empty strings
+        if not converted_value.strip():
+            continue
+        # Add the converted value as is, without any further processing
+        result.append(converted_value)
+
+    return result

metadata/pii/algorithms/presidio_patches.py

@@ -0,0 +1,45 @@
+#  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.
+"""
+Patch the Presidio recognizer results to make adapt them to specific use cases.
+"""
+from typing import List, Protocol, Sequence
+
+from presidio_analyzer import RecognizerResult
+
+
+class PresidioRecognizerResultPatcher(Protocol):
+    """
+    A protocol for a function that takes a recognizer result and returns a modified result.
+    Sometimes we need to patch the recognizer result to make it compatible with our use case.
+    For instance, Presidio yields URL false positive with email address.
+    """
+
+    def __call__(
+        self, recognizer_results: Sequence[RecognizerResult], text: str
+    ) -> Sequence[RecognizerResult]:
+        ...
+
+
+def url_patcher(
+    recognizer_results: Sequence[RecognizerResult], text: str
+) -> Sequence[RecognizerResult]:
+    """
+    Patch the recognizer result to remove URL false positive with email address.
+    """
+    patched_result: List[RecognizerResult] = []
+    for result in recognizer_results:
+        if result.entity_type == "URL":
+            if text[: result.start].endswith("@"):
+                # probably an email address, skip the URL
+                continue
+        patched_result.append(result)
+    return patched_result

metadata/pii/algorithms/presidio_utils.py

@@ -0,0 +1,119 @@
+#  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.
+"""
+Utilities for working with the Presidio Library.
+"""
+import inspect
+import logging
+from typing import Iterable, Optional, Type
+
+import spacy
+from presidio_analyzer import (
+    AnalyzerEngine,
+    EntityRecognizer,
+    PatternRecognizer,
+    predefined_recognizers,
+)
+from presidio_analyzer.nlp_engine import SpacyNlpEngine
+from spacy.cli.download import download  # pyright: ignore[reportUnknownVariableType]
+
+from metadata.pii.constants import PRESIDIO_LOGGER, SPACY_EN_MODEL, SUPPORTED_LANG
+from metadata.utils.logger import METADATA_LOGGER, pii_logger
+
+logger = pii_logger()
+
+
+def build_analyzer_engine(
+    model_name: str = SPACY_EN_MODEL,
+) -> AnalyzerEngine:
+    """
+    Build a Presidio analyzer engine for the model_name and tailored to our use case.
+
+    If the model is not found locally, it will be downloaded.
+    """
+    _load_spacy_model(model_name)
+
+    model = {
+        "lang_code": SUPPORTED_LANG,
+        "model_name": model_name,
+    }
+
+    nlp_engine = SpacyNlpEngine(models=[model])
+    analyzer_engine = AnalyzerEngine(
+        nlp_engine=nlp_engine, supported_languages=[SUPPORTED_LANG]
+    )
+    for recognizer in _get_all_pattern_recognizers():
+        # Register the recognizer by setting the appropriate language.
+        # Presidio recognizers are language-dependent: when analyzing text,
+        # Presidio filters recognizers based on the specified language, assuming
+        # language-specific patterns (e.g., for country-specific formats).
+        # However, our use case involves analyzing structured table data rather than free text,
+        # so this language-based approach doesn't always make sense.
+        # To fix this, we manually set the recognizer supported language to the one we want.
+        recognizer.supported_language = SUPPORTED_LANG
+        analyzer_engine.registry.add_recognizer(recognizer)
+
+    return analyzer_engine
+
+
+def set_presidio_logger_level(log_level: Optional[int] = None) -> None:
+    """
+    Set the presidio logger to talk less about internal entities unless we are debugging.
+    """
+    if log_level is None:
+        log_level = (
+            logging.INFO
+            if logging.getLogger(METADATA_LOGGER).level == logging.DEBUG
+            else logging.ERROR
+        )
+
+    logging.getLogger(PRESIDIO_LOGGER).setLevel(log_level)
+
+
+def _load_spacy_model(model_name: str) -> None:
+    """
+    Load the spaCy model for the given language.
+    If the model is not found locally, it will be downloaded.
+    """
+
+    try:
+        _ = spacy.load(model_name)
+    except OSError:
+
+        logger.warning(f"Downloading {model_name} language model for the spaCy")
+        download(model_name)
+        _ = spacy.load(model_name)
+
+
+def _get_all_entity_recognizer_classes() -> Iterable[Type[EntityRecognizer]]:
+    """
+    Iterate over all subclasses of the `EntityRecognizer` exposed
+    in the predefined_recognizers module.
+    """
+    for name in getattr(predefined_recognizers, "__all__", []):
+        obj = getattr(predefined_recognizers, name, None)
+        if inspect.isclass(obj) and issubclass(obj, EntityRecognizer):
+            yield obj
+
+
+def _get_all_pattern_recognizers() -> Iterable[EntityRecognizer]:
+    for cls in _get_all_entity_recognizer_classes():
+        if issubclass(cls, PatternRecognizer):
+            try:
+                # Try to instantiate the recognizer
+                yield cls(
+                    supported_language=SUPPORTED_LANG
+                )  # pyright: ignore[reportCallIssue]
+            except Exception as e:
+                logger.warning(e)
+        elif cls == predefined_recognizers.PhoneRecognizer:
+            # Not a pattern recognizer, but pretty much the same
+            yield predefined_recognizers.PhoneRecognizer()

metadata/pii/algorithms/tags.py

@@ -0,0 +1,111 @@
+#  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.
+"""
+Definition of tags for the PII algorithms.
+These tags currently belong to the layer logic of the algorithms.
+"""
+import enum
+from typing import List
+
+
+class PIISensitivityTag(enum.Enum):
+    SENSITIVE = "Sensitive"
+    NONSENSITIVE = "NonSensitive"
+
+
+@enum.unique
+class PIITag(enum.Enum):
+    """
+    PII Tags (borrowed from Presidio https://microsoft.github.io/presidio/supported_entities/).
+    """
+
+    # Global
+    CREDIT_CARD = "CREDIT_CARD"
+    CRYPTO = "CRYPTO"  # Crypto Wallet Address
+    DATE_TIME = "DATE_TIME"
+    EMAIL_ADDRESS = "EMAIL_ADDRESS"
+    IBAN_CODE = "IBAN_CODE"
+    IP_ADDRESS = "IP_ADDRESS"
+    NRP = "NRP"
+    LOCATION = "LOCATION"
+    PERSON = "PERSON"
+    PHONE_NUMBER = "PHONE_NUMBER"
+    MEDICAL_LICENSE = "MEDICAL_LICENSE"
+    URL = "URL"
+
+    # USA
+    US_BANK_NUMBER = "US_BANK_NUMBER"
+    US_DRIVER_LICENSE = "US_DRIVER_LICENSE"
+    US_ITIN = "US_ITIN"
+    US_PASSPORT = "US_PASSPORT"
+    US_SSN = "US_SSN"
+
+    # UK
+    UK_NHS = "UK_NHS"
+
+    # Spain
+    ES_NIF = "ES_NIF"
+    ES_NIE = "ES_NIE"
+
+    # Italy
+    IT_FISCAL_CODE = "IT_FISCAL_CODE"
+    IT_DRIVER_LICENSE = "IT_DRIVER_LICENSE"
+    IT_VAT_CODE = "IT_VAT_CODE"
+    IT_PASSPORT = "IT_PASSPORT"
+    IT_IDENTITY_CARD = "IT_IDENTITY_CARD"
+
+    # Poland
+    PL_PESEL = "PL_PESEL"
+
+    # Singapore
+    SG_NRIC_FIN = "SG_NRIC_FIN"
+    SG_UEN = "SG_UEN"
+
+    # Australia
+    AU_ABN = "AU_ABN"
+    AU_ACN = "AU_ACN"
+    AU_TFN = "AU_TFN"
+    AU_MEDICARE = "AU_MEDICARE"
+
+    # India
+    IN_PAN = "IN_PAN"
+    IN_AADHAAR = "IN_AADHAAR"
+    IN_VEHICLE_REGISTRATION = "IN_VEHICLE_REGISTRATION"
+    IN_VOTER = "IN_VOTER"
+    IN_PASSPORT = "IN_PASSPORT"
+
+    # Finland
+    FI_PERSONAL_IDENTITY_CODE = "FI_PERSONAL_IDENTITY_CODE"
+
+    @classmethod
+    def values(cls) -> List[str]:
+        """
+        Get all the values of the enum as a set of strings.
+        """
+        return [tag.value for tag in cls]
+
+    def sensitivity(self) -> PIISensitivityTag:
+        """
+        Get the sensitivity level of the PII tag.
+        This map is opinionated and can be changed in the future according to users' needs.
+        """
+        if self in DEFAULT_NON_PII_SENSITIVE:
+            return PIISensitivityTag.NONSENSITIVE
+        return PIISensitivityTag.SENSITIVE
+
+
+DEFAULT_NON_PII_SENSITIVE = (
+    PIITag.DATE_TIME,
+    PIITag.NRP,
+    PIITag.LOCATION,
+    PIITag.PHONE_NUMBER,
+    PIITag.URL,
+)

metadata/pii/algorithms/utils.py

@@ -0,0 +1,38 @@
+#  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.
+"""
+Utility functions for PII algorithms
+"""
+from typing import Mapping, Sequence, TypeVar
+
+T = TypeVar("T")
+
+
+def normalize_scores(scores: Mapping[T, float], tol: float = 0.01) -> Mapping[T, float]:
+    """
+    Normalize the scores to sum to 1, while ignoring scores below the tolerance.
+    Scores must be positive.
+    """
+    scores = {key: score for key, score in scores.items() if score > tol}
+    total = sum(scores.values())
+    if total == 0:
+        return scores
+    return {key: score / total for key, score in scores.items()}
+
+
+def get_top_classes(scores: Mapping[T, float], n: int, threshold: float) -> Sequence[T]:
+    """
+    Get the top n scores from the scores mapping that are above the threshold.
+    The classes are sorted in descending order of their scores.
+    """
+    sorted_scores = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+    top_classes = [key for key, score in sorted_scores if score >= threshold]
+    return top_classes[:n]

metadata/pii/base_processor.py

@@ -0,0 +1,125 @@
+#  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.
+"""
+Base class for the Auto Classification Processor.
+"""
+import traceback
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Sequence, Type, TypeVar, cast, final
+
+from metadata.generated.schema.entity.data.table import Column
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
+from metadata.generated.schema.metadataIngestion.databaseServiceAutoClassificationPipeline import (
+    DatabaseServiceAutoClassificationPipeline,
+)
+from metadata.generated.schema.metadataIngestion.workflow import (
+    OpenMetadataWorkflowConfig,
+)
+from metadata.generated.schema.type.tagLabel import TagLabel
+from metadata.ingestion.api.models import Either
+from metadata.ingestion.api.parser import parse_workflow_config_gracefully
+from metadata.ingestion.api.steps import Processor
+from metadata.ingestion.models.table_metadata import ColumnTag
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.sampler.models import SamplerResponse
+
+C = TypeVar("C", bound="AutoClassificationProcessor")
+
+
+class AutoClassificationProcessor(Processor, ABC):
+    """
+    Abstract class for the Auto Classification Processor.
+
+    Implementations should only provide the logic for creating tags based on sample data,
+    and rely on the running part to be handled by the base class.
+    """
+
+    # Some methods are marked as final to prevent overriding in subclasses thus
+    # ensuring that the workflow is always run in the same way keeping implementer
+    # with the responsibility of *only* implementing the logic for creating tags.
+    def __init__(
+        self,
+        config: OpenMetadataWorkflowConfig,
+        metadata: OpenMetadata,
+    ):
+        super().__init__()
+        self.config = config
+        self.metadata = metadata
+
+        # Init and type the source config
+        self.source_config: DatabaseServiceAutoClassificationPipeline = cast(
+            DatabaseServiceAutoClassificationPipeline,
+            self.config.source.sourceConfig.config,
+        )  # Used to satisfy type checked
+
+    @abstractmethod
+    def create_column_tag_labels(
+        self, column: Column, sample_data: Sequence[Any]
+    ) -> Sequence[TagLabel]:
+        """
+        Create tags for the column based on the sample data.
+        """
+
+    @property
+    def name(self) -> str:
+        return "Auto Classification Processor"
+
+    def close(self) -> None:
+        """Nothing to close"""
+
+    @classmethod
+    @final
+    def create(
+        cls: Type[C],
+        config_dict: dict,
+        metadata: OpenMetadata,
+        pipeline_name: Optional[str] = None,
+    ) -> C:
+        config = parse_workflow_config_gracefully(config_dict)
+        return cls(config=config, metadata=metadata)
+
+    @final
+    def _run(self, record: SamplerResponse) -> Either[SamplerResponse]:
+        """
+        Main entrypoint for the processor.
+        """
+
+        # We don't always need to process
+        if not self.source_config.enableAutoClassification:
+            return Either(right=record, left=None)
+
+        column_tags = []
+
+        for idx, column in enumerate(record.table.columns):
+            try:
+                tags = self.create_column_tag_labels(
+                    column=column,
+                    sample_data=[row[idx] for row in record.sample_data.data.rows],
+                )
+                for tag in tags:
+                    column_tag = ColumnTag(
+                        column_fqn=column.fullyQualifiedName.root, tag_label=tag
+                    )
+                    column_tags.append(column_tag)
+            except Exception as err:
+                # TODO: Shouldn't we return a Left here?
+                self.status.failed(
+                    StackTraceError(
+                        name=record.table.fullyQualifiedName.root,
+                        error=f"Error in Processor {self.name} computing tags for [{column}] - [{err}]",
+                        stackTrace=traceback.format_exc(),
+                    )
+                )
+
+        record.column_tags = column_tags
+        return Either(right=record, left=None)

metadata/pii/constants.py

@@ -13,4 +13,12 @@ PII constants
 """
 
 PII = "PII"
+
+# Constants for Presidio
+PRESIDIO_LOGGER = "presidio-analyzer"
 SPACY_EN_MODEL = "en_core_web_md"
+
+# Supported language for Presidio.
+# Don't change this unless you know what you are doing.
+# We are doing some tricks to make Presidio work for our use case.
+SUPPORTED_LANG = "en"