rasa-pro 3.9.18__py3-none-any.whl → 3.10.4__py3-none-any.whl

rasa/nlu/persistor.py

@@ -1,13 +1,30 @@
+from __future__ import annotations
+
 import abc
-import structlog
 import os
 import shutil
-from typing import Optional, Text, Tuple, TYPE_CHECKING
+from enum import Enum
+from typing import TYPE_CHECKING, List, Optional, Text, Tuple, Union
 
-from rasa.shared.exceptions import RasaException
+import structlog
 
 import rasa.shared.utils.common
 import rasa.utils.common
+from rasa.constants import (
+    HTTP_STATUS_FORBIDDEN,
+    HTTP_STATUS_NOT_FOUND,
+    MODEL_ARCHIVE_EXTENSION,
+)
+from rasa.env import (
+    AWS_ENDPOINT_URL_ENV,
+    AZURE_ACCOUNT_KEY_ENV,
+    AZURE_ACCOUNT_NAME_ENV,
+    AZURE_CONTAINER_ENV,
+    BUCKET_NAME_ENV,
+    REMOTE_STORAGE_PATH_ENV,
+)
+from rasa.shared.exceptions import RasaException
+from rasa.shared.utils.io import raise_warning
 
 if TYPE_CHECKING:
     from azure.storage.blob import ContainerClient
@@ -15,34 +32,80 @@ if TYPE_CHECKING:
 structlogger = structlog.get_logger()
 
 
-def get_persistor(name: Text) -> Optional["Persistor"]:
+class RemoteStorageType(Enum):
+    """Enum for the different remote storage types."""
+
+    AWS = "aws"
+    GCS = "gcs"
+    AZURE = "azure"
+
+    @classmethod
+    def list(cls) -> List[str]:
+        """Returns a list of all available storage types."""
+        return [item.value for item in cls]
+
+
+"""Storage can be a built-in one or a module path to a custom persistor."""
+StorageType = Union[RemoteStorageType, str]
+
+
+def parse_remote_storage(value: str) -> StorageType:
+    try:
+        return RemoteStorageType(value)
+    except ValueError:
+        # if the value is not a valid storage type,
+        # but it is a string we assume it is a custom class
+        # and return it as is
+
+        supported_storages_help_text = (
+            f"Supported storages are: {RemoteStorageType.list()} "
+            "or path to a python class which implements `Persistor` interface."
+        )
+
+        if isinstance(value, str):
+            if value == "":
+                raise ValueError(
+                    f"The value can't be an empty string."
+                    f" {supported_storages_help_text}"
+                )
+
+            return value
+
+        raise ValueError(
+            f"Invalid storage type '{value}'. {supported_storages_help_text}"
+        )
+
+
+def get_persistor(storage: StorageType) -> Optional[Persistor]:
     """Returns an instance of the requested persistor.
 
     Currently, `aws`, `gcs`, `azure` and providing module paths are supported remote
     storages.
     """
-    if name == "aws":
+    if storage == RemoteStorageType.AWS.value:
         return AWSPersistor(
-            os.environ.get("BUCKET_NAME"), os.environ.get("AWS_ENDPOINT_URL")
+            os.environ.get(BUCKET_NAME_ENV), os.environ.get(AWS_ENDPOINT_URL_ENV)
         )
-    if name == "gcs":
-        return GCSPersistor(os.environ.get("BUCKET_NAME"))
+    if storage == RemoteStorageType.GCS.value:
+        return GCSPersistor(os.environ.get(BUCKET_NAME_ENV))
 
-    if name == "azure":
+    if storage == RemoteStorageType.AZURE.value:
         return AzurePersistor(
-            os.environ.get("AZURE_CONTAINER"),
-            os.environ.get("AZURE_ACCOUNT_NAME"),
-            os.environ.get("AZURE_ACCOUNT_KEY"),
+            os.environ.get(AZURE_CONTAINER_ENV),
+            os.environ.get(AZURE_ACCOUNT_NAME_ENV),
+            os.environ.get(AZURE_ACCOUNT_KEY_ENV),
         )
-    if name:
+    # If the persistor is not a built-in one, it is assumed to be a module path
+    # to a persistor implementation supplied by the user.
+    if storage:
         try:
-            persistor = rasa.shared.utils.common.class_from_module_path(name)
+            persistor = rasa.shared.utils.common.class_from_module_path(storage)
             return persistor()
         except ImportError:
             raise ImportError(
-                f"Unknown model persistor {name}. Please make sure to "
-                "either use an included model persistor (`aws`, `gcs` "
-                "or `azure`) or specify the module path to an external "
+                f"Unknown model persistor {storage}. Please make sure to "
+                f"either use an included model persistor ({RemoteStorageType.list()}) "
+                f"or specify the module path to an external "
                 "model persistor."
             )
     return None
@@ -51,25 +114,35 @@ def get_persistor(name: Text) -> Optional["Persistor"]:
 class Persistor(abc.ABC):
     """Store models in cloud and fetch them when needed."""
 
-    def persist(self, model_directory: Text, model_name: Text) -> None:
-        """Uploads a model persisted in the `target_dir` to cloud storage."""
-        if not os.path.isdir(model_directory):
-            raise ValueError(f"Target directory '{model_directory}' not found.")
+    def persist(self, trained_model: str) -> None:
+        """Uploads a trained model persisted in the `target_dir` to cloud storage."""
+        file_key = self._create_file_key(trained_model)
+        self._persist_tar(file_key, trained_model)
 
-        file_key, tar_path = self._compress(model_directory, model_name)
-        self._persist_tar(file_key, tar_path)
+    def retrieve(self, model_name: Text, target_path: Text) -> Text:
+        """Downloads a model that has been persisted to cloud storage.
 
-    def retrieve(self, model_name: Text, target_path: Text) -> None:
-        """Downloads a model that has been persisted to cloud storage."""
-        tar_name = model_name
+        Downloaded model will be saved to the `target_path`.
+        If `target_path` is a directory, the model will be saved to that directory.
+        If `target_path` is a file, the model will be saved to that file.
 
-        if not model_name.endswith("tar.gz"):
+        Args:
+            model_name: The name of the model to retrieve.
+            target_path: The path to which the model should be saved.
+        """
+        tar_name = model_name
+        if not model_name.endswith(MODEL_ARCHIVE_EXTENSION):
             # ensure backward compatibility
             tar_name = self._tar_name(model_name)
-
+        tar_name = self._create_file_key(tar_name)
         self._retrieve_tar(tar_name)
         self._copy(os.path.basename(tar_name), target_path)
 
+        if os.path.isdir(target_path):
+            return os.path.join(target_path, model_name)
+
+        return target_path
+
     @abc.abstractmethod
     def _retrieve_tar(self, filename: Text) -> None:
         """Downloads a model previously persisted to cloud storage."""
@@ -97,13 +170,37 @@ class Persistor(abc.ABC):
 
     @staticmethod
     def _tar_name(model_name: Text, include_extension: bool = True) -> Text:
-        ext = ".tar.gz" if include_extension else ""
+        ext = f".{MODEL_ARCHIVE_EXTENSION}" if include_extension else ""
         return f"{model_name}{ext}"
 
     @staticmethod
     def _copy(compressed_path: Text, target_path: Text) -> None:
         shutil.copy2(compressed_path, target_path)
 
+    @staticmethod
+    def _create_file_key(model_path: str) -> Text:
+        """Appends remote storage folders when provided to upload or retrieve file"""
+        bucket_object_path = os.environ.get(REMOTE_STORAGE_PATH_ENV)
+
+        # To keep the backward compatibility, if REMOTE_STORAGE_PATH is not provided,
+        # the model_name (which might be a complete path) will be returned as it is.
+        if bucket_object_path is None:
+            return str(model_path)
+        else:
+            raise_warning(
+                f"{REMOTE_STORAGE_PATH_ENV} is deprecated and will be "
+                "removed in future versions. "
+                "Please use the -m path/to/model.tar.gz option to "
+                "specify the model path when loading a model."
+                "Or use --output and --fixed-model-name to specify the "
+                "output directory and the model name when saving a "
+                "trained model to remote storage.",
+            )
+
+        file_key = os.path.basename(model_path)
+        file_key = os.path.join(bucket_object_path, file_key)
+        return file_key
+
 
 class AWSPersistor(Persistor):
     """Store models on S3.
@@ -137,7 +234,7 @@ class AWSPersistor(Persistor):
             self.s3.meta.client.head_bucket(Bucket=bucket_name)
         except botocore.exceptions.ClientError as e:
             error_code = int(e.response["Error"]["Code"])
-            if error_code == 403:
+            if error_code == HTTP_STATUS_FORBIDDEN:
                 log = (
                     f"Access to the specified bucket '{bucket_name}' is forbidden. "
                     "Please make sure you have the necessary "
@@ -149,7 +246,7 @@ class AWSPersistor(Persistor):
                     event_info=log,
                 )
                 raise RasaException(log)
-            elif error_code == 404:
+            elif error_code == HTTP_STATUS_NOT_FOUND:
                 log = (
                     f"The specified bucket '{bucket_name}' does not exist. "
                     "Please make sure to create the bucket first."
@@ -183,7 +280,7 @@ class GCSPersistor(Persistor):
         """Initialise class with client and bucket."""
         # there are no type hints in this repo for now
         # https://github.com/googleapis/python-storage/issues/393
-        from google.cloud import storage  # type: ignore[attr-defined]
+        from google.cloud import storage
 
         super().__init__()
 

rasa/server.py

@@ -11,17 +11,17 @@ from http import HTTPStatus
 from inspect import isawaitable
 from pathlib import Path
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
+    Coroutine,
     DefaultDict,
+    Dict,
     List,
+    NoReturn,
     Optional,
     Text,
     Union,
-    Dict,
-    TYPE_CHECKING,
-    NoReturn,
-    Coroutine,
 )
 
 import aiohttp
@@ -54,15 +54,16 @@ from rasa.core.test import test
 from rasa.core.utils import AvailableEndpoints
 from rasa.nlu.emulators.emulator import Emulator
 from rasa.nlu.emulators.no_emulator import NoEmulator
+from rasa.nlu.persistor import parse_remote_storage
 from rasa.nlu.test import CVEvaluationResult
 from rasa.shared.constants import (
-    DOCS_URL_TRAINING_DATA,
-    DOCS_BASE_URL,
-    DEFAULT_SENDER_ID,
     DEFAULT_MODELS_PATH,
+    DEFAULT_SENDER_ID,
+    DOCS_BASE_URL,
+    DOCS_URL_TRAINING_DATA,
     TEST_STORIES_FILE_PREFIX,
 )
-from rasa.shared.core.domain import InvalidDomain, Domain
+from rasa.shared.core.domain import Domain, InvalidDomain
 from rasa.shared.core.events import Event
 from rasa.shared.core.trackers import (
     DialogueStateTracker,
@@ -80,8 +81,10 @@ from rasa.utils.endpoints import EndpointConfig
 
 if TYPE_CHECKING:
     from ssl import SSLContext
+
+    from mypy_extensions import Arg, KwArg, VarArg
+
     from rasa.core.processor import MessageProcessor
-    from mypy_extensions import Arg, VarArg, KwArg
 
     SanicResponse = Union[
         response.HTTPResponse, Coroutine[Any, Any, response.HTTPResponse]
@@ -532,6 +535,32 @@ def add_root_route(app: Sanic) -> None:
         """
         return response.html(html_content)
 
+    @app.get("/license")
+    async def license(request: Request) -> HTTPResponse:
+        """Respond with the license expiration date."""
+        from rasa.utils.licensing import (
+            get_license_expiration_date,
+            property_of_active_license,
+        )
+
+        body = {
+            "id": property_of_active_license(lambda active_license: active_license.jti),
+            "company": property_of_active_license(
+                lambda active_license: active_license.company
+            ),
+            "scope": property_of_active_license(
+                lambda active_license: active_license.scope
+            ),
+            "email": property_of_active_license(
+                lambda active_license: active_license.email
+            ),
+            "expires": get_license_expiration_date(),
+        }
+        return response.json(
+            body=body,
+            headers={"Content-Type": "application/json"},
+        )
+
 
 def async_if_callback_url(f: Callable[..., Coroutine]) -> Callable:
     """Decorator to enable async request handling.
@@ -1351,7 +1380,13 @@ def create_app(
 
         model_path = request.json.get("model_file", None)
         model_server = request.json.get("model_server", None)
-        remote_storage = request.json.get("remote_storage", None)
+
+        remote_storage_argument = request.json.get("remote_storage", None)
+        remote_storage = (
+            parse_remote_storage(remote_storage_argument)
+            if remote_storage_argument
+            else None
+        )
 
         if model_server:
             try:

rasa/shared/constants.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import List, Text
 
+from rasa.shared.engine.caching import get_local_cache_location
 
 DOCS_BASE_URL = "https://rasa.com/docs/rasa-pro"
 DOCS_URL_CONCEPTS = DOCS_BASE_URL + "/concepts"
@@ -51,6 +52,8 @@ MODEL_CONFIG_SCHEMA_FILE = "shared/utils/schemas/model_config.yml"
 CONFIG_SCHEMA_FILE = "shared/utils/schemas/config.yml"
 RESPONSES_SCHEMA_FILE = "shared/nlu/training_data/schemas/responses.yml"
 SCHEMA_EXTENSIONS_FILE = "shared/utils/pykwalify_extensions.py"
+ASSERTIONS_SCHEMA_FILE = "e2e_test/assertions_schema.yml"
+ASSERTIONS_SCHEMA_EXTENSIONS_FILE = "e2e_test/pykwalify_extensions.py"
 LATEST_TRAINING_DATA_FORMAT_VERSION = "3.1"
 
 DOMAIN_SCHEMA_FILE = "shared/utils/schemas/domain.yml"
@@ -83,6 +86,8 @@ ENV_LOG_LEVEL_LLM_MODULE_NAMES = {
     "EnterpriseSearchPolicy": "LOG_LEVEL_LLM_ENTERPRISE_SEARCH",
     "IntentlessPolicy": "LOG_LEVEL_LLM_INTENTLESS_POLICY",
     "ContextualResponseRephraser": "LOG_LEVEL_LLM_REPHRASER",
+    "NLUCommandAdapter": "LOG_LEVEL_NLU_COMMAND_ADAPTER",
+    "LLMBasedRouter": "LOG_LEVEL_LLM_BASED_ROUTER",
 }
 TCP_PROTOCOL = "TCP"
 
@@ -137,34 +142,82 @@ DIAGNOSTIC_DATA = "diagnostic_data"
 RESPONSE_CONDITION = "condition"
 CHANNEL = "channel"
 
+API_KEY = "api_key"
+
+AZURE_API_KEY_ENV_VAR = "AZURE_API_KEY"
+AZURE_AD_TOKEN_ENV_VAR = "AZURE_AD_TOKEN"
+AZURE_API_BASE_ENV_VAR = "AZURE_API_BASE"
+AZURE_API_VERSION_ENV_VAR = "AZURE_API_VERSION"
+AZURE_API_TYPE_ENV_VAR = "AZURE_API_TYPE"
+
 OPENAI_API_KEY_ENV_VAR = "OPENAI_API_KEY"
 OPENAI_API_TYPE_ENV_VAR = "OPENAI_API_TYPE"
 OPENAI_API_VERSION_ENV_VAR = "OPENAI_API_VERSION"
 OPENAI_API_BASE_ENV_VAR = "OPENAI_API_BASE"
 
+OPENAI_API_BASE_CONFIG_KEY = "openai_api_base"
 OPENAI_API_TYPE_CONFIG_KEY = "openai_api_type"
-OPENAI_API_TYPE_NO_PREFIX_CONFIG_KEY = "api_type"
-
 OPENAI_API_VERSION_CONFIG_KEY = "openai_api_version"
-OPENAI_API_VERSION_NO_PREFIX_CONFIG_KEY = "api_version"
 
-OPENAI_API_BASE_CONFIG_KEY = "openai_api_base"
-OPENAI_API_BASE_NO_PREFIX_CONFIG_KEY = "api_base"
+API_BASE_CONFIG_KEY = "api_base"
+API_TYPE_CONFIG_KEY = "api_type"
+API_VERSION_CONFIG_KEY = "api_version"
+LANGCHAIN_TYPE_CONFIG_KEY = "_type"
+RASA_TYPE_CONFIG_KEY = "type"
+PROVIDER_CONFIG_KEY = "provider"
 
-OPENAI_DEPLOYMENT_NAME_CONFIG_KEY = "deployment_name"
-OPENAI_DEPLOYMENT_CONFIG_KEY = "deployment"
-OPENAI_ENGINE_CONFIG_KEY = "engine"
+REQUEST_TIMEOUT_CONFIG_KEY = "request_timeout"  # deprecated
+TIMEOUT_CONFIG_KEY = "timeout"
 
-RASA_TYPE_CONFIG_KEY = "type"
-LANGCHAIN_TYPE_CONFIG_KEY = "_type"
+DEPLOYMENT_NAME_CONFIG_KEY = "deployment_name"
+DEPLOYMENT_CONFIG_KEY = "deployment"
+EMBEDDINGS_CONFIG_KEY = "embeddings"
+ENGINE_CONFIG_KEY = "engine"
+LLM_CONFIG_KEY = "llm"
+MODEL_CONFIG_KEY = "model"
+MODEL_NAME_CONFIG_KEY = "model_name"
+PROMPT_CONFIG_KEY = "prompt"
+PROMPT_TEMPLATE_CONFIG_KEY = "prompt_template"
+
+STREAM_CONFIG_KEY = "stream"
+N_REPHRASES_CONFIG_KEY = "n"
+
+AZURE_API_KEY_ENV_VAR = "AZURE_API_KEY"
+AZURE_AD_TOKEN_ENV_VAR = "AZURE_AD_TOKEN"
+AZURE_API_BASE_ENV_VAR = "AZURE_API_BASE"
+AZURE_API_VERSION_ENV_VAR = "AZURE_API_VERSION"
+AZURE_API_TYPE_ENV_VAR = "AZURE_API_TYPE"
+
+HUGGINGFACE_MULTIPROCESS_CONFIG_KEY = "multi_process"
+HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY = "cache_folder"
+HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY = "show_progress"
+HUGGINGFACE_MODEL_KWARGS_CONFIG_KEY = "model_kwargs"
+HUGGINGFACE_ENCODE_KWARGS_CONFIG_KEY = "encode_kwargs"
+HUGGINGFACE_LOCAL_EMBEDDING_CACHING_FOLDER = (
+    get_local_cache_location() / "huggingface_local_embeddings"
+)
 
 REQUESTS_CA_BUNDLE_ENV_VAR = "REQUESTS_CA_BUNDLE"
 REQUESTS_SSL_CONTEXT_PURPOSE_ENV_VAR = "REQUESTS_SSL_CONTEXT_PURPOSE"
+RASA_CA_BUNDLE_ENV_VAR = "RASA_CA_BUNDLE"  # used in verify
+RASA_SSL_CERTIFICATE_ENV_VAR = "RASA_SSL_CERTIFICATE"  # used in cert (client side)
+LITELLM_SSL_VERIFY_ENV_VAR = "SSL_VERIFY"
+LITELLM_SSL_CERTIFICATE_ENV_VAR = "SSL_CERTIFICATE"
+
+OPENAI_PROVIDER = "openai"
+AZURE_OPENAI_PROVIDER = "azure"
+SELF_HOSTED_PROVIDER = "self-hosted"
+HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER = "huggingface_local"
 
+AZURE_API_TYPE = "azure"
+OPENAI_API_TYPE = "openai"
 
 RASA_DEFAULT_FLOW_PATTERN_PREFIX = "pattern_"
 CONTEXT = "context"
 
+RASA_PATTERN_INTERNAL_ERROR = "pattern_internal_error"
+RASA_PATTERN_HUMAN_HANDOFF = "pattern_human_handoff"
+
 RASA_INTERNAL_ERROR_PREFIX = "rasa_internal_error_"
 RASA_PATTERN_INTERNAL_ERROR_DEFAULT = RASA_INTERNAL_ERROR_PREFIX + "default"
 RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG = (
@@ -185,8 +238,3 @@ RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT = (
 )
 
 ROUTE_TO_CALM_SLOT = "route_session_to_calm"
-EMBEDDINGS_CONFIG_KEY = "embeddings"
-MODEL_CONFIG_KEY = "model"
-MODEL_NAME_CONFIG_KEY = "model_name"
-PROMPT_CONFIG_KEY = "prompt"
-PROMPT_TEMPLATE_CONFIG_KEY = "prompt_template"

rasa/shared/core/domain.py

@@ -11,7 +11,6 @@ from typing import (
     Dict,
     Iterable,
     List,
-    MutableMapping,
     NamedTuple,
     NoReturn,
     Optional,
@@ -20,6 +19,7 @@ from typing import (
     Tuple,
     Union,
     cast,
+    MutableMapping,
 )
 
 import structlog
@@ -51,11 +51,11 @@ from rasa.shared.core.constants import (
 )
 from rasa.shared.core.events import SlotSet, UserUttered
 from rasa.shared.core.slots import (
-    AnySlot,
-    CategoricalSlot,
-    ListSlot,
     Slot,
+    CategoricalSlot,
     TextSlot,
+    AnySlot,
+    ListSlot,
 )
 from rasa.shared.exceptions import (
     RasaException,
@@ -63,21 +63,21 @@ from rasa.shared.exceptions import (
     YamlSyntaxException,
 )
 from rasa.shared.nlu.constants import (
-    ENTITIES,
-    ENTITY_ATTRIBUTE_GROUP,
-    ENTITY_ATTRIBUTE_ROLE,
     ENTITY_ATTRIBUTE_TYPE,
-    INTENT_NAME_KEY,
+    ENTITY_ATTRIBUTE_ROLE,
+    ENTITY_ATTRIBUTE_GROUP,
     RESPONSE_IDENTIFIER_DELIMITER,
+    INTENT_NAME_KEY,
+    ENTITIES,
 )
 from rasa.shared.utils.cli import print_error_and_exit
 from rasa.shared.utils.yaml import (
     KEY_TRAINING_DATA_FORMAT_VERSION,
-    dump_obj_as_yaml_to_string,
     read_yaml,
+    validate_training_data_format_version,
     read_yaml_file,
+    dump_obj_as_yaml_to_string,
     validate_raw_yaml_using_schema_file_with_responses,
-    validate_training_data_format_version,
 )
 
 if TYPE_CHECKING:
@@ -271,8 +271,8 @@ class Domain:
 
         additional_arguments = {
             **data.get("config", {}),
-            "actions_which_explicitly_need_domain": cls._collect_actions_which_explicitly_need_domain(  # noqa: E501
-                domain_actions
+            "actions_which_explicitly_need_domain": (
+                cls._collect_actions_which_explicitly_need_domain(domain_actions)
             ),
         }
         session_config = cls._get_session_config(data.get(SESSION_CONFIG_KEY, {}))
@@ -2047,6 +2047,9 @@ class Domain:
 
         return action_names
 
+    def is_custom_action(self, action_name: str) -> bool:
+        return action_name in self._custom_actions
+
 
 def warn_about_duplicates_found_during_domain_merging(
     duplicates: Dict[Text, List[Text]],

rasa/shared/core/events.py

@@ -930,16 +930,42 @@ class BotUttered(SkipEventInMDStoryMixin):
 
         return self.__members() == other.__members()
 
+    def _clean_up_metadata(self) -> Dict[str, Any]:
+        """Removes search_results metadata key from the metadata.
+
+        This is intended to prevent increasing the string representation
+        character length of the bot event.
+        """
+        from rasa.core.policies.enterprise_search_policy import (
+            SEARCH_RESULTS_METADATA_KEY,
+        )
+
+        metadata = copy.deepcopy(self.metadata)
+
+        if SEARCH_RESULTS_METADATA_KEY in self.metadata:
+            metadata.pop(SEARCH_RESULTS_METADATA_KEY)
+            structlogger.debug(
+                "search_results.metadata.removed",
+                event_info="Removed search_results metadata key only "
+                "from the string representation of the bot event.",
+            )
+
+        return metadata
+
     def __str__(self) -> Text:
         """Returns text representation of event."""
+        metadata = self._clean_up_metadata()
+
         return "BotUttered(text: {}, data: {}, metadata: {})".format(
-            self.text, json.dumps(self.data), json.dumps(self.metadata)
+            self.text, json.dumps(self.data), json.dumps(metadata)
         )
 
     def __repr__(self) -> Text:
         """Returns text representation of event for debugging."""
+        metadata = self._clean_up_metadata()
+
         return "BotUttered('{}', {}, {}, {})".format(
-            self.text, json.dumps(self.data), json.dumps(self.metadata), self.timestamp
+            self.text, json.dumps(self.data), json.dumps(metadata), self.timestamp
         )
 
     def apply_to(self, tracker: "DialogueStateTracker") -> None: