rasa-pro 3.13.0.dev5__py3-none-any.whl → 3.13.0.dev8__py3-none-any.whl

rasa/llm_fine_tuning/paraphrasing_module.py

@@ -1,11 +1,9 @@
-from typing import Any, Dict, List, Tuple, Type
+from typing import Any, Dict, List, Tuple
 
 import structlog
 from tqdm import tqdm
 
-from rasa.dialogue_understanding.generator.llm_based_command_generator import (
-    LLMBasedCommandGenerator,
-)
+from rasa.core.agent import Agent
 from rasa.llm_fine_tuning.conversations import Conversation
 from rasa.llm_fine_tuning.paraphrasing.conversation_rephraser import (
     ConversationRephraser,
@@ -28,8 +26,7 @@ async def create_paraphrased_conversations(
     rephrase_config: Dict[str, Any],
     num_rephrases: int,
     flows: FlowsList,
-    llm_command_generator: Type[LLMBasedCommandGenerator],
-    llm_command_generator_config: Dict[str, Any],
+    agent: Agent,
     storage_context: StorageContext,
 ) -> Tuple[List[Conversation], Dict[str, Any]]:
     """Create paraphrased conversations.
@@ -42,7 +39,7 @@ async def create_paraphrased_conversations(
         rephrase_config: The path to the rephrase configuration file.
         num_rephrases: The number of rephrases to produce per user message.
         flows: All flows.
-        llm_command_generator_config: The configuration of the trained model.
+        agent: The Rasa agent.
         storage_context: The storage context.
 
     Returns:
@@ -50,7 +47,7 @@ async def create_paraphrased_conversations(
         rephrasing.
     """
     rephraser = ConversationRephraser(rephrase_config)
-    validator = RephraseValidator(llm_command_generator_config, flows)
+    validator = RephraseValidator(flows)
 
     if num_rephrases <= 0:
         structlogger.info(
@@ -64,18 +61,19 @@ async def create_paraphrased_conversations(
     rephrased_conversations: List[Conversation] = []
     for i in tqdm(range(len(conversations))):
         current_conversation = conversations[i]
-
         try:
             # rephrase all user messages even if rephrase=False is set
             # to not confuse the LLM and get valid output
             rephrasings = await rephraser.rephrase_conversation(
-                conversations[i], num_rephrases
+                current_conversation, num_rephrases
             )
             # filter out the rephrasings for user messages that have rephrase=False set
-            rephrasings = _filter_rephrasings(rephrasings, conversations[i])
+            rephrasings = _filter_rephrasings(rephrasings, current_conversation)
             # check if the rephrasings are still producing the same commands
             rephrasings = await validator.validate_rephrasings(
-                rephrasings, current_conversation, llm_command_generator
+                agent,
+                rephrasings,
+                current_conversation,
             )
         except ProviderClientAPIException as e:
             structlogger.error(

rasa/llm_fine_tuning/storage.py

@@ -96,9 +96,9 @@ class FileStorageStrategy(StorageStrategy):
         file_path = self._get_file_path(storage_location)
         self._create_output_dir(file_path)
 
-        with open(str(file_path), "w") as outfile:
+        with open(str(file_path), "w", encoding="utf-8") as outfile:
             for example in llm_data:
-                json.dump(example.as_dict(), outfile)
+                json.dump(example.as_dict(), outfile, ensure_ascii=False)
                 outfile.write("\n")
 
     def write_formatted_finetuning_data(
@@ -110,9 +110,9 @@ class FileStorageStrategy(StorageStrategy):
         file_path = self._get_file_path(module_storage_location, file_name)
         self._create_output_dir(file_path)
 
-        with open(str(file_path), "w") as file:
+        with open(str(file_path), "w", encoding="utf-8") as file:
             for example in formatted_data:
-                json.dump(example.as_dict(), file)
+                json.dump(example.as_dict(), file, ensure_ascii=False)
                 file.write("\n")
 
     def write_e2e_test_suite_to_yaml_file(

rasa/llm_fine_tuning/utils.py

@@ -1,7 +1,69 @@
-from typing import List
+from contextlib import contextmanager
+from datetime import datetime
+from typing import Callable, Generator, List, Union
+
+import structlog
 
 from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
+from rasa.dialogue_understanding.generator import LLMBasedCommandGenerator
+from rasa.shared.providers.llm.llm_response import LLMResponse
+
+structlogger = structlog.get_logger()
 
 
 def commands_as_string(commands: List[PromptCommand], delimiter: str = "\n") -> str:
     return delimiter.join([command.to_dsl() for command in commands])
+
+
+def make_mock_invoke_llm(commands: str) -> Callable:
+    """Capture the `commands` in a closure so the resulting async function
+    can use it as its response.
+
+    Args:
+        commands: The commands to return from the mock LLM call.
+    """
+
+    async def _mock_invoke_llm(
+        self: LLMBasedCommandGenerator, prompt: Union[List[dict], List[str], str]
+    ) -> LLMResponse:
+        structlogger.debug(
+            f"LLM call intercepted, response mocked. "
+            f"Responding with the following commands: '{commands}' "
+            f"to the prompt: {prompt}"
+        )
+        fake_response_dict = {
+            "id": "",
+            "choices": [commands],
+            "created": int(datetime.now().timestamp()),
+            "model": "mocked-llm",
+        }
+        return LLMResponse.from_dict(fake_response_dict)
+
+    return _mock_invoke_llm
+
+
+@contextmanager
+def patch_invoke_llm_in_generators(mock_impl: Callable) -> Generator:
+    """Replace CommandGenerator.invoke_llm in the base class AND in all
+    current subclasses (recursively).  Everything is restored on exit.
+    """
+    originals = {}
+
+    def collect(cls: type[LLMBasedCommandGenerator]) -> None:
+        # store current attribute, then recurse
+        originals[cls] = cls.invoke_llm
+        for sub in cls.__subclasses__():
+            collect(sub)
+
+    # collect every existing subclass of CommandGenerator
+    collect(LLMBasedCommandGenerator)  # type: ignore[type-abstract]
+
+    try:
+        # apply the monkey-patch everywhere
+        for cls in originals:
+            cls.invoke_llm = mock_impl  # type: ignore[assignment]
+        yield
+    finally:
+        # restore originals (even if an exception happened)
+        for cls, orig in originals.items():
+            cls.invoke_llm = orig  # type: ignore[assignment]

rasa/model_manager/config.py

@@ -1,6 +1,8 @@
 import os
 import sys
 
+from rasa.constants import RASA_REMOTE_STORAGE_ENV_VAR_NAME
+
 DEFAULT_SERVER_BASE_WORKING_DIRECTORY = "working-data"
 
 SERVER_BASE_WORKING_DIRECTORY = os.environ.get(
@@ -12,7 +14,7 @@ SERVER_PORT = os.environ.get("RASA_MODEL_SERVER_PORT", 8000)
 SERVER_BASE_URL = os.environ.get("RASA_MODEL_SERVER_BASE_URL", None)
 
 # defaults to storing on the local hard drive
-SERVER_MODEL_REMOTE_STORAGE = os.environ.get("RASA_REMOTE_STORAGE", None)
+SERVER_MODEL_REMOTE_STORAGE = os.environ.get(RASA_REMOTE_STORAGE_ENV_VAR_NAME, None)
 
 # The path to the python executable that is running this script
 # we will use the same python to run training / bots

rasa/model_manager/model_api.py

@@ -7,12 +7,16 @@ from typing import Any, Callable, Dict, Optional, Union
 import dotenv
 import psutil
 import structlog
+from ruamel.yaml import YAMLError
 from sanic import Blueprint, Sanic, response
 from sanic.exceptions import NotFound
 from sanic.request import Request
 from sanic.response import json
 from socketio import AsyncServer
 
+import rasa
+from rasa.cli.project_templates.defaults import get_rasa_defaults
+from rasa.cli.scaffold import ProjectTemplateName, scaffold_path
 from rasa.constants import MODEL_ARCHIVE_EXTENSION
 from rasa.exceptions import ModelNotFound
 from rasa.model_manager import config
@@ -45,6 +49,10 @@ from rasa.model_manager.warm_rasa_process import (
     initialize_warm_rasa_process,
     shutdown_warm_rasa_processes,
 )
+from rasa.server import ErrorResponse
+from rasa.shared.exceptions import InvalidConfigException
+from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
+from rasa.studio.upload import build_calm_import_parts
 
 dotenv.load_dotenv()
 
@@ -476,6 +484,86 @@ def internal_blueprint() -> Blueprint:
         except ModelNotFound:
             return response.raw(b"", status=404)
 
+    @bp.post("/defaults")
+    async def get_defaults(request: Request) -> response.HTTPResponse:
+        """Returns the system defaults like prompts, patterns, etc."""
+        body = request.json or {}
+        config_yaml = body.get("config")
+        if config_yaml is None:
+            exc = ErrorResponse(
+                HTTPStatus.BAD_REQUEST,
+                "BadRequest",
+                "Missing `config` key in request body.",
+            )
+            return response.json(exc.error_info, status=exc.status)
+
+        endpoints_yaml = body.get("endpoints")
+        if endpoints_yaml is None:
+            exc = ErrorResponse(
+                HTTPStatus.BAD_REQUEST,
+                "BadRequest",
+                "Missing `endpoints` key in request body.",
+            )
+            return response.json(exc.error_info, status=exc.status)
+
+        try:
+            defaults = get_rasa_defaults(config_yaml, endpoints_yaml)
+        except (YAMLError, InvalidConfigException) as e:
+            exc = ErrorResponse(
+                HTTPStatus.INTERNAL_SERVER_ERROR,
+                "InitDataError",
+                f"Failed to load defaults. Error: {e!s}",
+            )
+            return response.json(exc.error_info, status=exc.status)
+        return response.json(defaults.model_dump(exclude_none=True))
+
+    @bp.get("/project_template")
+    async def get_project_template(request: Request) -> response.HTTPResponse:
+        """Return initial project template data."""
+        template = request.args.get("template", ProjectTemplateName.DEFAULT.value)
+
+        try:
+            template_enum = ProjectTemplateName(template)
+        except ValueError:
+            valid_templates = ", ".join([t.value for t in ProjectTemplateName])
+            exc = ErrorResponse(
+                HTTPStatus.BAD_REQUEST,
+                "BadRequest",
+                f"Unknown template '{template}'. Valid templates: "
+                f"{valid_templates}",
+            )
+            return response.json(exc.error_info, status=exc.status)
+
+        template_dir = scaffold_path(template_enum)
+        if not os.path.isdir(template_dir):
+            exc = ErrorResponse(
+                HTTPStatus.INTERNAL_SERVER_ERROR,
+                "InitDataError",
+                f"Template directory '{template_dir}' not found.",
+            )
+            return response.json(exc.error_info, status=exc.status)
+
+        assistant_name, parts = build_calm_import_parts(
+            data_path=f"{template_dir}/data",
+            domain_path=f"{template_dir}/domain",
+            config_path=f"{template_dir}/config.yml",
+            endpoints_path=f"{template_dir}/endpoints.yml",
+            assistant_name=template_enum.value,
+        )
+
+        defaults = get_rasa_defaults(
+            config_yaml=dump_obj_as_yaml_to_string(parts.config),
+            endpoints_yaml=dump_obj_as_yaml_to_string(parts.endpoints),
+        )
+        return response.json(
+            {
+                **parts.model_dump(exclude_none=True),
+                "assistantName": assistant_name,
+                "defaults": defaults.model_dump(exclude_none=True),
+                "version": rasa.__version__,
+            }
+        )
+
     return bp
 
 
@@ -532,8 +620,7 @@ def size_of_model(model_name: str) -> Optional[int]:
             model_name=model_file_name,
         )
         return fetch_size_of_remote_model(
-            model_file_name,
-            config.SERVER_MODEL_REMOTE_STORAGE,
+            model_file_name, config.SERVER_MODEL_REMOTE_STORAGE, model_path
         )
     raise ModelNotFound("Model not found.")
 

rasa/model_manager/runner_service.py

@@ -166,13 +166,13 @@ def fetch_remote_model_to_dir(
 ) -> str:
     """Fetch the model from remote storage.
 
-    Returns the path to the model diretory.
+    Returns the path to the model directory.
     """
     from rasa.core.persistor import get_persistor
 
     persistor = get_persistor(storage_type)
 
-    # we now there must be a persistor, because the config is set
+    # we know there must be a persistor, because the config is set
     # this is here to please the type checker for the call below
     assert persistor is not None
 
@@ -182,7 +182,9 @@ def fetch_remote_model_to_dir(
         raise ModelNotFound() from e
 
 
-def fetch_size_of_remote_model(model_name: str, storage_type: str) -> int:
+def fetch_size_of_remote_model(
+    model_name: str, storage_type: str, model_path: str
+) -> int:
     """Fetch the size of the model from remote storage."""
     from rasa.core.persistor import get_persistor
 
@@ -192,7 +194,9 @@ def fetch_size_of_remote_model(model_name: str, storage_type: str) -> int:
     # this is here to please the type checker for the call below
     assert persistor is not None
 
-    return persistor.size_of_persisted_model(model_name=model_name)
+    return persistor.size_of_persisted_model(
+        model_name=model_name, target_path=model_path
+    )
 
 
 def start_bot_process(

rasa/model_manager/trainer_service.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, Optional
 import structlog
 from pydantic import BaseModel, ConfigDict
 
-from rasa.constants import MODEL_ARCHIVE_EXTENSION
+from rasa.constants import MODEL_ARCHIVE_EXTENSION, RASA_DIR_NAME
 from rasa.model_manager import config
 from rasa.model_manager.utils import (
     ensure_base_directory_exists,
@@ -171,7 +171,7 @@ def seed_training_directory_with_rasa_cache(
             training_base_path=training_base_path,
         )
         # copy the cache to the training directory
-        shutil.copytree(src=cache_path, dst=subpath(training_base_path, ".rasa"))
+        shutil.copytree(src=cache_path, dst=subpath(training_base_path, RASA_DIR_NAME))
 
 
 def persist_rasa_cache(assistant_id: str, training_base_path: str) -> None:
@@ -184,12 +184,12 @@ def persist_rasa_cache(assistant_id: str, training_base_path: str) -> None:
     cache_path = cache_for_assistant_path(assistant_id)
 
     # if the training failed and didn't create a cache, skip this step
-    if not os.path.exists(subpath(training_base_path, ".rasa")):
+    if not os.path.exists(subpath(training_base_path, RASA_DIR_NAME)):
         return
 
     # clean up the cache directory first
     shutil.rmtree(cache_path, ignore_errors=True)
-    shutil.copytree(src=subpath(training_base_path, ".rasa"), dst=cache_path)
+    shutil.copytree(src=subpath(training_base_path, RASA_DIR_NAME), dst=cache_path)
 
 
 def write_training_data_to_files(
@@ -278,6 +278,7 @@ def start_training_process(
                 "--keep-local-model-copy",
                 "--remote-storage",
                 config.SERVER_MODEL_REMOTE_STORAGE,
+                "--remote-root-only",
             ]
         )
 

rasa/model_training.py

@@ -160,6 +160,7 @@ async def train(
     remote_storage: Optional[StorageType] = None,
     file_importer: Optional[TrainingDataImporter] = None,
     keep_local_model_copy: bool = False,
+    remote_root_only: bool = False,
 ) -> TrainingResult:
     """Trains a Rasa model (Core and NLU).
 
@@ -187,6 +188,8 @@ async def train(
             If it is not provided, a new instance will be created.
         keep_local_model_copy: If `True` the model will be stored locally even if
             remote storage is configured.
+        remote_root_only: If `True`, the model will be stored in the root of the
+            remote model storage.
 
     Returns:
         An instance of `TrainingResult`.
@@ -269,6 +272,7 @@ async def train(
             dry_run=dry_run,
             remote_storage=remote_storage,
             keep_local_model_copy=keep_local_model_copy,
+            remote_root_only=remote_root_only,
             **(core_additional_arguments or {}),
             **(nlu_additional_arguments or {}),
         )
@@ -284,6 +288,7 @@ async def _train_graph(
     dry_run: bool = False,
     remote_storage: Optional[StorageType] = None,
     keep_local_model_copy: bool = False,
+    remote_root_only: bool = False,
     **kwargs: Any,
 ) -> TrainingResult:
     if model_to_finetune:
@@ -363,7 +368,9 @@ async def _train_graph(
             is_finetuning=is_finetuning,
         )
         if remote_storage:
-            push_model_to_remote_storage(full_model_path, remote_storage)
+            push_model_to_remote_storage(
+                full_model_path, remote_storage, remote_root_only
+            )
             if not keep_local_model_copy:
                 full_model_path.unlink()
             structlogger.info(
@@ -581,14 +588,16 @@ async def train_nlu(
     ).model
 
 
-def push_model_to_remote_storage(model_path: Path, remote_storage: StorageType) -> None:
+def push_model_to_remote_storage(
+    model_path: Path, remote_storage: StorageType, remote_root_only: bool = False
+) -> None:
     """Push model to remote storage."""
     from rasa.core.persistor import get_persistor
 
     persistor = get_persistor(remote_storage)
 
     if persistor is not None:
-        persistor.persist(str(model_path))
+        persistor.persist(str(model_path), remote_root_only)
 
     else:
         raise RasaException(

rasa/nlu/extractors/crf_entity_extractor.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import logging
+import shutil
 import typing
 from collections import OrderedDict
 from enum import Enum
+from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Type
 
 import numpy as np
@@ -43,6 +45,10 @@ if typing.TYPE_CHECKING:
 
 CONFIG_FEATURES = "features"
 
+TAGGERS_DIR = "taggers"
+CRFSUITE_MODEL_FILE_NAME = "model.crfsuite"
+PLAIN_CRF_MODEL_FILE_NAME = "model.txt"
+
 
 class CRFToken:
     def __init__(
@@ -419,19 +425,11 @@ class CRFEntityExtractor(GraphComponent, EntityExtractorMixin):
         """Loads trained component (see parent class for full docstring)."""
         try:
             with model_storage.read_from(resource) as model_dir:
-                dataset = rasa.shared.utils.io.read_json_file(
-                    model_dir / "crf_dataset.json"
-                )
                 crf_order = rasa.shared.utils.io.read_json_file(
                     model_dir / "crf_order.json"
                 )
 
-                dataset = [
-                    [CRFToken.create_from_dict(token_data) for token_data in sub_list]
-                    for sub_list in dataset
-                ]
-
-                entity_taggers = cls.train_model(dataset, config, crf_order)
+                entity_taggers = cls._load_taggers(model_dir, config)
 
                 entity_extractor = cls(config, model_storage, resource, entity_taggers)
                 entity_extractor.crf_order = crf_order
@@ -443,19 +441,71 @@ class CRFEntityExtractor(GraphComponent, EntityExtractorMixin):
             )
             return cls(config, model_storage, resource)
 
+    @classmethod
+    def _load_taggers(
+        cls, model_dir: Path, config: Dict[Text, Any]
+    ) -> Dict[str, "CRF"]:
+        """
+        Load taggers from model directory that persists trained binary
+        `model.crfsuite` files.
+        """
+
+        import pycrfsuite
+        import sklearn_crfsuite
+
+        # Get tagger directories
+        taggers_base = model_dir / TAGGERS_DIR
+        if not taggers_base.exists():
+            return {}
+
+        taggers_dirs = [
+            directory for directory in taggers_base.iterdir() if directory.is_dir()
+        ]
+
+        entity_taggers: Dict[str, "CRF"] = {}
+
+        for tagger_dir in taggers_dirs:
+            # Instantiate sklearns CRF wrapper for the pycrfsuite's Tagger
+            entity_tagger = sklearn_crfsuite.CRF(
+                algorithm="lbfgs",
+                # coefficient for L1 penalty
+                c1=config["L1_c"],
+                # coefficient for L2 penalty
+                c2=config["L2_c"],
+                # stop earlier
+                max_iterations=config["max_iterations"],
+                # include transitions that are possible, but not observed
+                all_possible_transitions=True,
+            )
+
+            # Load pycrfsuite tagger from the persisted binary model.crfsuite file
+            entity_tagger._tagger = pycrfsuite.Tagger()
+            entity_tagger._tagger.open(str(tagger_dir / CRFSUITE_MODEL_FILE_NAME))
+
+            entity_taggers[tagger_dir.name] = entity_tagger
+
+        return entity_taggers
+
     def persist(self, dataset: List[List[CRFToken]]) -> None:
         """Persist this model into the passed directory."""
         with self._model_storage.write_to(self._resource) as model_dir:
-            data_to_store = [
-                [token.to_dict() for token in sub_list] for sub_list in dataset
-            ]
-
-            rasa.shared.utils.io.dump_obj_as_json_to_file(
-                model_dir / "crf_dataset.json", data_to_store
-            )
             rasa.shared.utils.io.dump_obj_as_json_to_file(
                 model_dir / "crf_order.json", self.crf_order
             )
+            if self.entity_taggers is not None:
+                for tag_name, entity_tagger in self.entity_taggers.items():
+                    # Create the directories for storing the CRF model
+                    tagger_dir = model_dir / TAGGERS_DIR / tag_name
+                    tagger_dir.mkdir(parents=True, exist_ok=True)
+                    # Create a plain text version of the CRF model
+                    entity_tagger.tagger_.dump(
+                        str(tagger_dir / PLAIN_CRF_MODEL_FILE_NAME)
+                    )
+                    # Persist binary version of the model.crfsuite
+                    shutil.copy2(
+                        src=entity_tagger.modelfile.name,
+                        dst=tagger_dir / CRFSUITE_MODEL_FILE_NAME,
+                    )
 
     @classmethod
     def _crf_tokens_to_features(

rasa/plugin.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import argparse
 import functools
 import sys
-from typing import TYPE_CHECKING, Any, List, Optional, Text, Union
+from typing import TYPE_CHECKING, List, Optional, Text, Union
 
 import pluggy
 
@@ -11,7 +11,7 @@ from rasa.cli import SubParsersAction
 
 if TYPE_CHECKING:
     from rasa.core.brokers.broker import EventBroker
-    from rasa.core.tracker_store import TrackerStore
+    from rasa.core.tracker_stores.tracker_store import TrackerStore
     from rasa.shared.core.domain import Domain
     from rasa.shared.core.trackers import DialogueStateTracker
     from rasa.utils.endpoints import EndpointConfig
@@ -69,16 +69,6 @@ def create_tracker_store(  # type: ignore[empty-body]
     """Hook specification for wrapping with AuthRetryTrackerStore."""
 
 
-@hookspec(firstresult=True)  # type: ignore[misc]
-def init_anonymization_pipeline(endpoints_file: Optional[Text]) -> None:
-    """Hook specification for initialising the anonymization pipeline."""
-
-
-@hookspec(firstresult=True)  # type: ignore[misc]
-def get_anonymization_pipeline() -> Optional[Any]:
-    """Hook specification for getting the anonymization pipeline."""
-
-
 @hookspec  # type: ignore[misc]
 def after_server_stop() -> None:
     """Hook specification for stopping the server.

rasa/privacy/constants.py

@@ -0,0 +1,83 @@
+PRIVACY_CONFIG_SCHEMA = "privacy/privacy_config_schema.json"
+REDACTION_CHAR_KEY = "redaction_char"
+KEEP_LEFT_KEY = "keep_left"
+KEEP_RIGHT_KEY = "keep_right"
+DELETION_KEY = "deletion"
+ANONYMIZATION_KEY = "anonymization"
+TRACKER_STORE_SETTINGS = "tracker_store_settings"
+SLOT_KEY = "slot"
+TEXT_KEY = "text"
+ENTITIES_KEY = "entities"
+VALUE_KEY = "value"
+ENTITY_LABEL_KEY = "label"
+
+USER_CHAT_INACTIVITY_IN_MINUTES_ENV_VAR_NAME = "USER_CHAT_INACTIVITY_IN_MINUTES"
+GLINER_MODEL_PATH_ENV_VAR_NAME = "GLINER_MODEL_PATH"
+HUGGINGFACE_CACHE_DIR_ENV_VAR_NAME = "HUGGINGFACE_HUB_CACHE_DIR"
+
+DEFAULT_PII_MODEL = "urchade/gliner_multi_pii-v1"
+GLINER_LABELS = [
+    "person",
+    "organization",
+    "company",
+    "phone number",
+    "address",
+    "full address",
+    "postcode",
+    "zip code",
+    "passport number",
+    "email",
+    "credit card number",
+    "social security number",
+    "health insurance id number",
+    "date of birth",
+    "mobile phone number",
+    "bank account number",
+    "medication",
+    "cpf",
+    "driver's license number",
+    "tax identification number",
+    "medical condition",
+    "identity card number",
+    "national id number",
+    "ip address",
+    "email address",
+    "iban",
+    "credit card expiration date",
+    "username",
+    "health insurance number",
+    "registration number",
+    "student id number",
+    "insurance number",
+    "membership number",
+    "booking number",
+    "landline phone number",
+    "blood type",
+    "cvv",
+    "reservation number",
+    "digital signature",
+    "social media handle",
+    "license plate number",
+    "cnpj",
+    "postal code",
+    "passport_number",
+    "serial number",
+    "vehicle registration number",
+    "fax number",
+    "visa number",
+    "insurance company",
+    "identity document number",
+    "transaction number",
+    "national health insurance number",
+    "cvc",
+    "birth certificate number",
+    "train ticket number",
+    "passport expiration date",
+    "social_security_number",
+    "personally identifiable information",
+    "banking routing number",
+    "sort code",
+    "routing number",
+    "tax number",
+    "swift code",
+]