rasa-pro 3.12.22__py3-none-any.whl → 3.13.0__py3-none-any.whl

rasa/core/tracker_store.py

@@ -1,1792 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-import itertools
-import json
-import os
-from inspect import isawaitable, iscoroutinefunction
-from time import sleep
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    Generic,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Text,
-    TypeVar,
-    Union,
-)
-
-import sqlalchemy as sa
-import structlog
-from boto3.dynamodb.conditions import Key
-from pymongo.collection import Collection
-
-import rasa.shared.utils.cli
-import rasa.shared.utils.common
-import rasa.shared.utils.io
-import rasa.utils.json_utils
-from rasa.constants import DEFAULT_SANIC_WORKERS, ENV_SANIC_WORKERS
-from rasa.core.brokers.broker import EventBroker
-from rasa.core.constants import (
-    POSTGRESQL_MAX_OVERFLOW,
-    POSTGRESQL_POOL_SIZE,
-    POSTGRESQL_SCHEMA,
-)
-from rasa.plugin import plugin_manager
-from rasa.shared.core.constants import ACTION_LISTEN_NAME
-from rasa.shared.core.conversation import Dialogue
-from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import Event, SessionStarted
-from rasa.shared.core.trackers import (
-    ActionExecuted,
-    DialogueStateTracker,
-    EventVerbosity,
-    TrackerEventDiffEngine,
-)
-from rasa.shared.exceptions import ConnectionException, RasaException
-from rasa.shared.nlu.constants import INTENT_NAME_KEY
-from rasa.utils.endpoints import EndpointConfig
-
-if TYPE_CHECKING:
-    import boto3.resources.factory.dynamodb.Table
-    from sqlalchemy import Sequence
-    from sqlalchemy.engine.base import Engine
-    from sqlalchemy.engine.url import URL
-    from sqlalchemy.orm import Query, Session
-
-structlogger = structlog.get_logger(__name__)
-
-# default values of PostgreSQL pool size and max overflow
-POSTGRESQL_DEFAULT_MAX_OVERFLOW = 100
-POSTGRESQL_DEFAULT_POOL_SIZE = 50
-
-# default value for key prefix in RedisTrackerStore
-DEFAULT_REDIS_TRACKER_STORE_KEY_PREFIX = "tracker:"
-
-
-def check_if_tracker_store_async(tracker_store: TrackerStore) -> bool:
-    """Evaluates if a tracker store object is async based on implementation of methods.
-
-    :param tracker_store: tracker store object we're evaluating
-    :return: if the tracker store correctly implements all async methods
-    """
-    return all(
-        iscoroutinefunction(getattr(tracker_store, method))
-        for method in _get_async_tracker_store_methods()
-    )
-
-
-def _get_async_tracker_store_methods() -> List[str]:
-    return [
-        attribute
-        for attribute in dir(TrackerStore)
-        if iscoroutinefunction(getattr(TrackerStore, attribute))
-    ]
-
-
-class TrackerDeserialisationException(RasaException):
-    """Raised when an error is encountered while deserialising a tracker."""
-
-
-SerializationType = TypeVar("SerializationType")
-
-
-class SerializedTrackerRepresentation(Generic[SerializationType]):
-    """Mixin class for specifying different serialization methods per tracker store."""
-
-    @staticmethod
-    def serialise_tracker(tracker: DialogueStateTracker) -> SerializationType:
-        """Requires implementation to return representation of tracker."""
-        raise NotImplementedError()
-
-
-class SerializedTrackerAsText(SerializedTrackerRepresentation[Text]):
-    """Mixin class that returns the serialized tracker as string."""
-
-    @staticmethod
-    def serialise_tracker(tracker: DialogueStateTracker) -> Text:
-        """Serializes the tracker, returns representation of the tracker."""
-        dialogue = tracker.as_dialogue()
-
-        return json.dumps(dialogue.as_dict())
-
-
-class SerializedTrackerAsDict(SerializedTrackerRepresentation[Dict]):
-    """Mixin class that returns the serialized tracker as dictionary."""
-
-    @staticmethod
-    def serialise_tracker(tracker: DialogueStateTracker) -> Dict:
-        """Serializes the tracker, returns representation of the tracker."""
-        d = tracker.as_dialogue().as_dict()
-        d.update({"sender_id": tracker.sender_id})
-        return d
-
-
-class TrackerStore:
-    """Represents common behavior and interface for all `TrackerStore`s."""
-
-    def __init__(
-        self,
-        domain: Optional[Domain],
-        event_broker: Optional[EventBroker] = None,
-        **kwargs: Dict[Text, Any],
-    ) -> None:
-        """Create a TrackerStore.
-
-        Args:
-            domain: The `Domain` to initialize the `DialogueStateTracker`.
-            event_broker: An event broker to publish any new events to another
-                destination.
-            kwargs: Additional kwargs.
-        """
-        self._domain = domain or Domain.empty()
-        self.event_broker = event_broker
-        self.max_event_history: Optional[int] = None
-
-    @staticmethod
-    def create(
-        obj: Union[TrackerStore, EndpointConfig, None],
-        domain: Optional[Domain] = None,
-        event_broker: Optional[EventBroker] = None,
-    ) -> TrackerStore:
-        """Factory to create a tracker store."""
-        if isinstance(obj, TrackerStore):
-            return obj
-
-        import pymongo.errors
-        import sqlalchemy.exc
-        from botocore.exceptions import BotoCoreError
-
-        try:
-            _tracker_store = plugin_manager().hook.create_tracker_store(
-                endpoint_config=obj,
-                domain=domain,
-                event_broker=event_broker,
-            )
-
-            tracker_store = (
-                _tracker_store
-                if _tracker_store
-                else create_tracker_store(obj, domain, event_broker)
-            )
-
-            return tracker_store
-        except (
-            BotoCoreError,
-            pymongo.errors.ConnectionFailure,
-            sqlalchemy.exc.OperationalError,
-            ConnectionError,
-            pymongo.errors.OperationFailure,
-        ) as error:
-            raise ConnectionException(
-                "Cannot connect to tracker store." + str(error)
-            ) from error
-
-    async def get_or_create_tracker(
-        self,
-        sender_id: Text,
-        max_event_history: Optional[int] = None,
-        append_action_listen: bool = True,
-    ) -> "DialogueStateTracker":
-        """Returns tracker or creates one if the retrieval returns None.
-
-        Args:
-            sender_id: Conversation ID associated with the requested tracker.
-            max_event_history: Value to update the tracker store's max event history to.
-            append_action_listen: Whether or not to append an initial `action_listen`.
-        """
-        self.max_event_history = max_event_history
-
-        tracker = await self.retrieve(sender_id)
-
-        if tracker is None:
-            tracker = await self.create_tracker(
-                sender_id, append_action_listen=append_action_listen
-            )
-
-        return tracker
-
-    def init_tracker(self, sender_id: Text) -> "DialogueStateTracker":
-        """Returns a Dialogue State Tracker."""
-        return DialogueStateTracker(
-            sender_id,
-            self.domain.slots,
-            max_event_history=self.max_event_history,
-        )
-
-    async def create_tracker(
-        self, sender_id: Text, append_action_listen: bool = True
-    ) -> DialogueStateTracker:
-        """Creates a new tracker for `sender_id`.
-
-        The tracker begins with a `SessionStarted` event and is initially listening.
-
-        Args:
-            sender_id: Conversation ID associated with the tracker.
-            append_action_listen: Whether or not to append an initial `action_listen`.
-
-        Returns:
-            The newly created tracker for `sender_id`.
-        """
-        tracker = self.init_tracker(sender_id)
-
-        if append_action_listen:
-            tracker.update(ActionExecuted(ACTION_LISTEN_NAME))
-
-        await self.save(tracker)
-
-        return tracker
-
-    async def save(self, tracker: DialogueStateTracker) -> None:
-        """Save method that will be overridden by specific tracker."""
-        raise NotImplementedError()
-
-    async def exists(self, conversation_id: Text) -> bool:
-        """Checks if tracker exists for the specified ID.
-
-        This method may be overridden by the specific tracker store for
-        faster implementations.
-
-        Args:
-            conversation_id: Conversation ID to check if the tracker exists.
-
-        Returns:
-            `True` if the tracker exists, `False` otherwise.
-        """
-        return await self.retrieve(conversation_id) is not None
-
-    async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
-        """Retrieves tracker for the latest conversation session.
-
-        This method will be overridden by the specific tracker store.
-
-        Args:
-            sender_id: Conversation ID to fetch the tracker for.
-
-        Returns:
-            Tracker containing events from the latest conversation sessions.
-        """
-        raise NotImplementedError()
-
-    async def retrieve_full_tracker(
-        self, conversation_id: Text
-    ) -> Optional[DialogueStateTracker]:
-        """Retrieve method for fetching all tracker events.
-
-        Fetches events across conversation sessions. The default implementation
-        uses `self.retrieve()`.
-
-        Args:
-            conversation_id: The conversation ID to retrieve the tracker for.
-
-        Returns:
-            The fetch tracker containing all events across session starts.
-        """
-        return await self.retrieve(conversation_id)
-
-    async def get_or_create_full_tracker(
-        self,
-        sender_id: Text,
-        append_action_listen: bool = True,
-    ) -> "DialogueStateTracker":
-        """Returns tracker or creates one if the retrieval returns None.
-
-        Args:
-            sender_id: Conversation ID associated with the requested tracker.
-            append_action_listen: Whether to append an initial `action_listen`.
-
-        Returns:
-            The tracker for the conversation ID.
-        """
-        tracker = await self.retrieve_full_tracker(sender_id)
-
-        if tracker is None:
-            tracker = await self.create_tracker(
-                sender_id, append_action_listen=append_action_listen
-            )
-
-        return tracker
-
-    async def stream_events(self, tracker: DialogueStateTracker) -> None:
-        """Streams events to a message broker."""
-        if self.event_broker is None:
-            structlogger.debug(
-                "tracker_store.stream_events.no_broker_configured",
-                event_info="No event broker configured. Skipping streaming events.",
-            )
-            return None
-
-        old_tracker = await self.retrieve(tracker.sender_id)
-        new_events = TrackerEventDiffEngine.event_difference(old_tracker, tracker)
-
-        await self._stream_new_events(self.event_broker, new_events, tracker.sender_id)
-
-    async def _stream_new_events(
-        self,
-        event_broker: EventBroker,
-        new_events: List[Event],
-        sender_id: Text,
-    ) -> None:
-        """Publishes new tracker events to a message broker."""
-        for event in new_events:
-            body = {"sender_id": sender_id}
-            body.update(event.as_dict())
-            event_broker.publish(body)
-
-    async def keys(self) -> Iterable[Text]:
-        """Returns the set of values for the tracker store's primary key."""
-        raise NotImplementedError()
-
-    async def count_conversations(self, after_timestamp: float = 0.0) -> int:
-        """Returns the number of conversations that have occurred after a timestamp.
-
-        By default, this method returns the number of conversations that
-        have occurred after the Unix epoch (i.e. timestamp 0). A conversation
-        is considered to have occurred after a timestamp if at least one event
-        happened after that timestamp.
-        """
-        tracker_keys = await self.keys()
-
-        conversation_count = 0
-        for key in tracker_keys:
-            tracker = await self.retrieve(key)
-            if tracker is None or not tracker.events:
-                continue
-
-            last_event = tracker.events[-1]
-            if last_event.timestamp >= after_timestamp:
-                conversation_count += 1
-
-        return conversation_count
-
-    def deserialise_tracker(
-        self, sender_id: Text, serialised_tracker: Union[Text, bytes]
-    ) -> Optional[DialogueStateTracker]:
-        """Deserializes the tracker and returns it."""
-        tracker = self.init_tracker(sender_id)
-
-        try:
-            dialogue = Dialogue.from_parameters(json.loads(serialised_tracker))
-        except UnicodeDecodeError as e:
-            raise TrackerDeserialisationException(
-                "Tracker cannot be deserialised. "
-                "Trackers must be serialised as json. "
-                "Support for deserialising pickled trackers has been removed."
-            ) from e
-
-        tracker.recreate_from_dialogue(dialogue)
-
-        return tracker
-
-    @property
-    def domain(self) -> Domain:
-        """Returns the domain of the tracker store."""
-        return self._domain
-
-    @domain.setter
-    def domain(self, domain: Optional[Domain]) -> None:
-        self._domain = domain or Domain.empty()
-
-
-class InMemoryTrackerStore(TrackerStore, SerializedTrackerAsText):
-    """Stores conversation history in memory."""
-
-    def __init__(
-        self,
-        domain: Domain,
-        event_broker: Optional[EventBroker] = None,
-        **kwargs: Dict[Text, Any],
-    ) -> None:
-        """Initializes the tracker store."""
-        self.store: Dict[Text, Text] = {}
-        super().__init__(domain, event_broker, **kwargs)
-
-    async def save(self, tracker: DialogueStateTracker) -> None:
-        """Updates and saves the current conversation state."""
-        await self.stream_events(tracker)
-        serialised = InMemoryTrackerStore.serialise_tracker(tracker)
-        self.store[tracker.sender_id] = serialised
-
-    async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
-        """Returns tracker matching sender_id."""
-        return await self._retrieve(sender_id, fetch_all_sessions=False)
-
-    async def keys(self) -> Iterable[Text]:
-        """Returns sender_ids of the Tracker Store in memory."""
-        return self.store.keys()
-
-    async def retrieve_full_tracker(
-        self, sender_id: Text
-    ) -> Optional[DialogueStateTracker]:
-        """Returns tracker matching sender_id.
-
-        Args:
-            sender_id: Conversation ID to fetch the tracker for.
-        """
-        return await self._retrieve(sender_id, fetch_all_sessions=True)
-
-    async def _retrieve(
-        self, sender_id: Text, fetch_all_sessions: bool
-    ) -> Optional[DialogueStateTracker]:
-        """Returns tracker matching sender_id.
-
-        Args:
-            sender_id: Conversation ID to fetch the tracker for.
-            fetch_all_sessions: Whether to fetch all sessions or only the last one.
-        """
-        if sender_id not in self.store:
-            structlogger.debug(
-                "in_memory_tracker_store.retrieve.no_tracker_for_sender_id",
-                event_info=f"Could not find tracker for conversation ID '{sender_id}'.",
-            )
-            return None
-
-        tracker = self.deserialise_tracker(sender_id, self.store[sender_id])
-
-        if not tracker:
-            structlogger.debug(
-                "in_memory_tracker_store.retrieve.failed_to_deserialize_tracker",
-                event_info=(
-                    f"Could not deserialize tracker "
-                    f"for conversation ID '{sender_id}'.",
-                ),
-            )
-            return None
-
-        if fetch_all_sessions:
-            return tracker
-
-        # only return the last session
-        multiple_tracker_sessions = (
-            rasa.shared.core.trackers.get_trackers_for_conversation_sessions(tracker)
-        )
-
-        if 0 <= len(multiple_tracker_sessions) <= 1:
-            return tracker
-
-        return multiple_tracker_sessions[-1]
-
-
-class RedisTrackerStore(TrackerStore, SerializedTrackerAsText):
-    """Stores conversation history in Redis."""
-
-    def __init__(
-        self,
-        domain: Domain,
-        host: Text = "localhost",
-        port: int = 6379,
-        db: int = 0,
-        username: Optional[Text] = None,
-        password: Optional[Text] = None,
-        event_broker: Optional[EventBroker] = None,
-        record_exp: Optional[float] = None,
-        key_prefix: Optional[Text] = None,
-        use_ssl: bool = False,
-        ssl_keyfile: Optional[Text] = None,
-        ssl_certfile: Optional[Text] = None,
-        ssl_ca_certs: Optional[Text] = None,
-        **kwargs: Dict[Text, Any],
-    ) -> None:
-        """Initializes the tracker store."""
-        import redis
-
-        self.red = redis.StrictRedis(
-            host=host,
-            port=port,
-            db=db,
-            username=username,
-            password=password,
-            ssl=use_ssl,
-            ssl_keyfile=ssl_keyfile,
-            ssl_certfile=ssl_certfile,
-            ssl_ca_certs=ssl_ca_certs,
-            decode_responses=True,
-        )
-        self.record_exp = record_exp
-
-        self.key_prefix = DEFAULT_REDIS_TRACKER_STORE_KEY_PREFIX
-        if key_prefix:
-            structlogger.debug(
-                "redis_tracker_store.init.custom_key_prefix",
-                event_info=f"Setting non-default redis key prefix: '{key_prefix}'.",
-            )
-            self._set_key_prefix(key_prefix)
-
-        super().__init__(domain, event_broker, **kwargs)
-
-    def _set_key_prefix(self, key_prefix: Text) -> None:
-        if isinstance(key_prefix, str) and key_prefix.isalnum():
-            self.key_prefix = key_prefix + ":" + DEFAULT_REDIS_TRACKER_STORE_KEY_PREFIX
-        else:
-            structlogger.warning(
-                "redis_tracker_store.init.invalid_key_prefix",
-                event_info=(
-                    f"Omitting provided non-alphanumeric "
-                    f"redis key prefix: '{key_prefix}'. "
-                    f"Using default '{self.key_prefix}' instead."
-                ),
-            )
-
-    def _get_key_prefix(self) -> Text:
-        return self.key_prefix
-
-    async def save(
-        self, tracker: DialogueStateTracker, timeout: Optional[float] = None
-    ) -> None:
-        """Saves the current conversation state."""
-        await self.stream_events(tracker)
-
-        if not timeout and self.record_exp:
-            timeout = self.record_exp
-
-        stored = self.red.get(self.key_prefix + tracker.sender_id)
-
-        if stored is not None:
-            prior_tracker = self.deserialise_tracker(tracker.sender_id, stored)
-
-            tracker = self._merge_trackers(prior_tracker, tracker)
-
-        serialised_tracker = self.serialise_tracker(tracker)
-        self.red.set(
-            self.key_prefix + tracker.sender_id, serialised_tracker, ex=timeout
-        )
-
-    async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
-        """Retrieves tracker for the latest conversation session.
-
-        The Redis key is formed by appending a prefix to sender_id.
-
-        Args:
-            sender_id: Conversation ID to fetch the tracker for.
-
-        Returns:
-            Tracker containing events from the latest conversation sessions.
-        """
-        return await self._retrieve(sender_id, fetch_all_sessions=False)
-
-    async def retrieve_full_tracker(
-        self, sender_id: Text
-    ) -> Optional[DialogueStateTracker]:
-        """Retrieves tracker for all conversation sessions.
-
-        The Redis key is formed by appending a prefix to sender_id.
-
-        Args:
-            sender_id: Conversation ID to fetch the tracker for.
-
-        Returns:
-            Tracker containing events from all conversation sessions.
-        """
-        return await self._retrieve(sender_id, fetch_all_sessions=True)
-
-    async def _retrieve(
-        self, sender_id: Text, fetch_all_sessions: bool
-    ) -> Optional[DialogueStateTracker]:
-        """Returns tracker matching sender_id.
-
-        Args:
-            sender_id: Conversation ID to fetch the tracker for.
-            fetch_all_sessions: Whether to fetch all sessions or only the last one.
-        """
-        stored = self.red.get(self.key_prefix + sender_id)
-        if stored is None:
-            structlogger.debug(
-                "redis_tracker_store.retrieve.no_tracker_for_sender_id",
-                event_info=f"Could not find tracker for conversation ID '{sender_id}'.",
-            )
-            return None
-
-        tracker = self.deserialise_tracker(sender_id, stored)
-        if fetch_all_sessions:
-            return tracker
-
-        # only return the last session
-        multiple_tracker_sessions = (
-            rasa.shared.core.trackers.get_trackers_for_conversation_sessions(tracker)
-        )
-
-        if 0 <= len(multiple_tracker_sessions) <= 1:
-            return tracker
-
-        return multiple_tracker_sessions[-1]
-
-    async def keys(self) -> Iterable[Text]:
-        """Returns keys of the Redis Tracker Store."""
-        return self.red.keys(self.key_prefix + "*")
-
-    @staticmethod
-    def _merge_trackers(
-        prior_tracker: DialogueStateTracker, tracker: DialogueStateTracker
-    ) -> DialogueStateTracker:
-        """Merges two trackers.
-
-        Args:
-            prior_tracker: Tracker containing events from the previous conversation
-                sessions.
-            tracker: Tracker containing events from the current conversation session.
-        """
-        if not prior_tracker.events:
-            return tracker
-
-        last_event_timestamp = prior_tracker.events[-1].timestamp
-        past_tracker = tracker.travel_back_in_time(target_time=last_event_timestamp)
-
-        if past_tracker.events == prior_tracker.events:
-            return tracker
-
-        merged = tracker.init_copy()
-        merged.update_with_events(list(prior_tracker.events), override_timestamp=False)
-
-        for new_event in tracker.events:
-            # Event subclasses implement `__eq__` method that make it difficult
-            # to compare events. We use `as_dict` to compare events.
-            if all(
-                [
-                    new_event.as_dict() != existing_event.as_dict()
-                    for existing_event in merged.events
-                ]
-            ):
-                merged.update(new_event)
-
-        return merged
-
-
-class DynamoTrackerStore(TrackerStore, SerializedTrackerAsDict):
-    """Stores conversation history in DynamoDB."""
-
-    def __init__(
-        self,
-        domain: Domain,
-        table_name: Text = "states",
-        region: Text = "us-east-1",
-        event_broker: Optional[EndpointConfig] = None,
-        **kwargs: Dict[Text, Any],
-    ) -> None:
-        """Initialize `DynamoTrackerStore`.
-
-        Args:
-            domain: Domain associated with this tracker store.
-            table_name: The name of the DynamoDB table, does not need to be present a
-                priori.
-            region: The name of the region associated with the client.
-                A client is associated with a single region.
-            event_broker: An event broker used to publish events.
-            kwargs: Additional kwargs.
-        """
-        import boto3
-
-        self.client = boto3.client("dynamodb", region_name=region)
-        self.region = region
-        self.table_name = table_name
-        self.db = self.get_or_create_table(table_name)
-        super().__init__(domain, event_broker, **kwargs)
-
-    def get_or_create_table(
-        self, table_name: Text
-    ) -> "boto3.resources.factory.dynamodb.Table":
-        """Returns table or creates one if the table name is not in the table list."""
-        import boto3
-
-        dynamo = boto3.resource("dynamodb", region_name=self.region)
-        try:
-            self.client.describe_table(TableName=table_name)
-        except self.client.exceptions.ResourceNotFoundException:
-            sanic_workers_count = int(
-                os.environ.get(ENV_SANIC_WORKERS, DEFAULT_SANIC_WORKERS)
-            )
-
-            if sanic_workers_count > 1:
-                structlogger.error(
-                    "dynamo_tracker_store.table_creation_not_supported_in_multi_worker_mode",
-                    event_info=(
-                        "DynamoDB table creation is not "
-                        "supported in multi-worker mode. "
-                        "Table should already exist.",
-                    ),
-                )
-                raise RasaException(
-                    "DynamoDB table creation is not supported in "
-                    "case of multiple sanic workers. To create the table either "
-                    "run Rasa with a single worker or create the table manually."
-                    "Here are the defaults which can be used to "
-                    "create the table manually: "
-                    f"Table name: {table_name}, Primary key: sender_id, "
-                    f"key type `HASH`, attribute type `S` (String), "
-                    "Provisioned throughput: Read capacity units: 5, "
-                    "Write capacity units: 5"
-                )
-
-            table = dynamo.create_table(
-                TableName=self.table_name,
-                KeySchema=[{"AttributeName": "sender_id", "KeyType": "HASH"}],
-                AttributeDefinitions=[
-                    {"AttributeName": "sender_id", "AttributeType": "S"}
-                ],
-                ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
-            )
-
-            # Wait until the table exists.
-            table.meta.client.get_waiter("table_exists").wait(TableName=table_name)
-        else:
-            table = dynamo.Table(table_name)
-
-        return table
-
-    async def save(self, tracker: DialogueStateTracker) -> None:
-        """Saves the current conversation state."""
-        await self.stream_events(tracker)
-        serialized = self.serialise_tracker(tracker)
-
-        self.db.put_item(Item=serialized)
-
-    @staticmethod
-    def serialise_tracker(
-        tracker: "DialogueStateTracker",
-    ) -> Dict:
-        """Serializes the tracker, returns object with decimal types.
-
-        DynamoDB cannot store `float`s, so we'll convert them to `Decimal`s.
-        """
-        return rasa.utils.json_utils.replace_floats_with_decimals(
-            SerializedTrackerAsDict.serialise_tracker(tracker)
-        )
-
-    async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
-        """Retrieve dialogues for a sender_id in reverse-chronological order.
-
-        Based on the session_date sort key.
-        """
-        return await self._retrieve(sender_id, fetch_all_sessions=False)
-
-    async def retrieve_full_tracker(
-        self, sender_id: Text
-    ) -> Optional[DialogueStateTracker]:
-        """Retrieves tracker for all conversation sessions.
-
-        Args:
-            sender_id: Conversation ID to fetch the tracker for.
-        """
-        return await self._retrieve(sender_id, fetch_all_sessions=True)
-
-    async def _retrieve(
-        self, sender_id: Text, fetch_all_sessions: bool
-    ) -> Optional[DialogueStateTracker]:
-        """Returns tracker matching sender_id.
-
-        Args:
-            sender_id: Conversation ID to fetch the tracker for.
-            fetch_all_sessions: Whether to fetch all sessions or only the last one.
-        """
-        dialogues = self.db.query(
-            KeyConditionExpression=Key("sender_id").eq(sender_id),
-            ScanIndexForward=False,
-        )["Items"]
-
-        if not dialogues:
-            return None
-
-        if fetch_all_sessions:
-            events_with_floats = []
-            for dialogue in dialogues:
-                if dialogue.get("events"):
-                    events = rasa.utils.json_utils.replace_decimals_with_floats(
-                        dialogue["events"]
-                    )
-                    events_with_floats += events
-        else:
-            events = dialogues[0].get("events", [])
-            # `float`s are stored as `Decimal` objects - we need to convert them back
-            events_with_floats = rasa.utils.json_utils.replace_decimals_with_floats(
-                events
-            )
-
-        if self.domain is None:
-            slots = []
-        else:
-            slots = self.domain.slots
-
-        return DialogueStateTracker.from_dict(sender_id, events_with_floats, slots)
-
-    async def keys(self) -> Iterable[Text]:
-        """Returns sender_ids of the `DynamoTrackerStore`."""
-        response = self.db.scan(ProjectionExpression="sender_id")
-        sender_ids = [i["sender_id"] for i in response["Items"]]
-
-        while response.get("LastEvaluatedKey"):
-            response = self.db.scan(
-                ProjectionExpression="sender_id",
-                ExclusiveStartKey=response["LastEvaluatedKey"],
-            )
-            sender_ids.extend([i["sender_id"] for i in response["Items"]])
-
-        return sender_ids
-
-
-class MongoTrackerStore(TrackerStore, SerializedTrackerAsText):
-    """Stores conversation history in Mongo.
-
-    Property methods:
-        conversations: returns the current conversation
-    """
-
-    def __init__(
-        self,
-        domain: Domain,
-        host: Optional[Text] = "mongodb://localhost:27017",
-        db: Optional[Text] = "rasa",
-        username: Optional[Text] = None,
-        password: Optional[Text] = None,
-        auth_source: Optional[Text] = "admin",
-        collection: Text = "conversations",
-        event_broker: Optional[EventBroker] = None,
-        **kwargs: Dict[Text, Any],
-    ) -> None:
-        from pymongo import MongoClient
-        from pymongo.database import Database
-
-        self.client: MongoClient = MongoClient(
-            host,
-            username=username,
-            password=password,
-            authSource=auth_source,
-            # delay connect until process forking is done
-            connect=False,
-        )
-
-        self.db = Database(self.client, db)
-        self.collection = collection
-        super().__init__(domain, event_broker, **kwargs)
-
-        self._ensure_indices()
-
-    @property
-    def conversations(self) -> Collection:
-        """Returns the current conversation."""
-        return self.db[self.collection]
-
-    def _ensure_indices(self) -> None:
-        """Create an index on the sender_id."""
-        self.conversations.create_index("sender_id")
-
-    @staticmethod
-    def _current_tracker_state_without_events(tracker: DialogueStateTracker) -> Dict:
-        # get current tracker state and remove `events` key from state
-        # since events are pushed separately in the `update_one()` operation
-        state = tracker.current_state(EventVerbosity.ALL)
-        state.pop("events", None)
-
-        return state
-
-    async def save(self, tracker: DialogueStateTracker) -> None:
-        """Saves the current conversation state."""
-        await self.stream_events(tracker)
-
-        additional_events = self._additional_events(tracker)
-
-        self.conversations.update_one(
-            {"sender_id": tracker.sender_id},
-            {
-                "$set": self._current_tracker_state_without_events(tracker),
-                "$push": {
-                    "events": {"$each": [e.as_dict() for e in additional_events]}
-                },
-            },
-            upsert=True,
-        )
-
-    def _additional_events(self, tracker: DialogueStateTracker) -> Iterator:
-        """Return events from the tracker which aren't currently stored.
-
-        Args:
-            tracker: Tracker to inspect.
-
-        Returns:
-            List of serialised events that aren't currently stored.
-
-        """
-        stored = self.conversations.find_one({"sender_id": tracker.sender_id}) or {}
-        all_events = self._events_from_serialized_tracker(stored)
-
-        number_events_since_last_session = len(
-            self._events_since_last_session_start(all_events)
-        )
-
-        return itertools.islice(
-            tracker.events, number_events_since_last_session, len(tracker.events)
-        )
-
-    @staticmethod
-    def _events_from_serialized_tracker(serialised: Dict) -> List[Dict]:
-        return serialised.get("events", [])
-
-    @staticmethod
-    def _events_since_last_session_start(events: List[Dict]) -> List[Dict]:
-        """Retrieve events since and including the latest `SessionStart` event.
-
-        Args:
-            events: All events for a conversation ID.
-
-        Returns:
-            List of serialised events since and including the latest `SessionStarted`
-            event. Returns all events if no such event is found.
-
-        """
-        events_after_session_start = []
-        for event in reversed(events):
-            events_after_session_start.append(event)
-            if event["event"] == SessionStarted.type_name:
-                break
-
-        return list(reversed(events_after_session_start))
-
-    async def _retrieve(
-        self, sender_id: Text, fetch_events_from_all_sessions: bool
-    ) -> Optional[List[Dict[Text, Any]]]:
-        stored = self.conversations.find_one({"sender_id": sender_id})
-
-        # look for conversations which have used an `int` sender_id in the past
-        # and update them.
-        if not stored and sender_id.isdigit():
-            from pymongo import ReturnDocument
-
-            stored = self.conversations.find_one_and_update(
-                {"sender_id": int(sender_id)},
-                {"$set": {"sender_id": str(sender_id)}},
-                return_document=ReturnDocument.AFTER,
-            )
-
-        if not stored:
-            return None
-
-        events = self._events_from_serialized_tracker(stored)
-
-        if not fetch_events_from_all_sessions:
-            events = self._events_since_last_session_start(events)
-
-        return events
-
-    async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
-        """Retrieves tracker for the latest conversation session."""
-        events = await self._retrieve(sender_id, fetch_events_from_all_sessions=False)
-
-        if not events:
-            return None
-
-        return DialogueStateTracker.from_dict(sender_id, events, self.domain.slots)
-
-    async def retrieve_full_tracker(
-        self, conversation_id: Text
-    ) -> Optional[DialogueStateTracker]:
-        """Fetching all tracker events across conversation sessions."""
-        events = await self._retrieve(
-            conversation_id, fetch_events_from_all_sessions=True
-        )
-
-        if not events:
-            return None
-
-        return DialogueStateTracker.from_dict(
-            conversation_id, events, self.domain.slots
-        )
-
-    async def keys(self) -> Iterable[Text]:
-        """Returns sender_ids of the Mongo Tracker Store."""
-        return [c["sender_id"] for c in self.conversations.find()]
-
-
-def _create_sequence(table_name: Text) -> "Sequence":
-    """Creates a sequence object for a specific table name.
-
-    If using Oracle you will need to create a sequence in your database,
-    as described here: https://rasa.com/docs/rasa-pro/production/tracker-stores#sqltrackerstore
-    Args:
-        table_name: The name of the table, which gets a Sequence assigned
-
-    Returns: A `Sequence` object
-    """
-    from sqlalchemy.orm import declarative_base
-
-    sequence_name = f"{table_name}_seq"
-    Base = declarative_base()
-    return sa.Sequence(sequence_name, metadata=Base.metadata, optional=True)
-
-
-def is_postgresql_url(url: Union[Text, "URL"]) -> bool:
-    """Determine whether `url` configures a PostgreSQL connection.
-
-    Args:
-        url: SQL connection URL.
-
-    Returns:
-        `True` if `url` is a PostgreSQL connection URL.
-    """
-    if isinstance(url, str):
-        return "postgresql" in url
-
-    return url.drivername == "postgresql"
-
-
-def create_engine_kwargs(url: Union[Text, "URL"]) -> Dict[Text, Any]:
-    """Get `sqlalchemy.create_engine()` kwargs.
-
-    Args:
-        url: SQL connection URL.
-
-    Returns:
-        kwargs to be passed into `sqlalchemy.create_engine()`.
-    """
-    if not is_postgresql_url(url):
-        return {}
-
-    kwargs: Dict[Text, Any] = {}
-
-    schema_name = os.environ.get(POSTGRESQL_SCHEMA)
-
-    if schema_name:
-        structlogger.debug(
-            "postgresql_tracker_store.schema_name",
-            event_inf=f"Using PostgreSQL schema '{schema_name}'.",
-        )
-        kwargs["connect_args"] = {"options": f"-csearch_path={schema_name}"}
-
-    # pool_size and max_overflow can be set to control the number of
-    # connections that are kept in the connection pool. Not available
-    # for SQLite, and only  tested for PostgreSQL. See
-    # https://docs.sqlalchemy.org/en/13/core/pooling.html#sqlalchemy.pool.QueuePool
-    kwargs["pool_size"] = int(
-        os.environ.get(POSTGRESQL_POOL_SIZE, POSTGRESQL_DEFAULT_POOL_SIZE)
-    )
-    kwargs["max_overflow"] = int(
-        os.environ.get(POSTGRESQL_MAX_OVERFLOW, POSTGRESQL_DEFAULT_MAX_OVERFLOW)
-    )
-
-    return kwargs
-
-
-def ensure_schema_exists(session: "Session") -> None:
-    """Ensure that the requested PostgreSQL schema exists in the database.
-
-    Args:
-        session: Session used to inspect the database.
-
-    Raises:
-        `ValueError` if the requested schema does not exist.
-        RasaException if no engine can be obtained from session.
-    """
-    schema_name = os.environ.get(POSTGRESQL_SCHEMA)
-
-    if not schema_name:
-        return
-
-    engine = session.get_bind()
-
-    if not isinstance(engine, sa.engine.base.Engine):
-        # The "bind" is usually an instance of Engine, except in the case
-        # where the session has been explicitly bound directly to a connection.
-        raise RasaException("Cannot ensure schema exists as no engine exists.")
-
-    if is_postgresql_url(engine.url):
-        query = sa.exists(
-            sa.select(sa.text("schema_name"))
-            .select_from(sa.text("information_schema.schemata"))
-            .where(sa.text(f"schema_name = '{schema_name}'"))
-        )
-        if not session.query(query).scalar():
-            raise ValueError(schema_name)
-
-
-def validate_port(port: Any) -> Optional[int]:
-    """Ensure that port can be converted to integer.
-
-    Raises:
-        RasaException if port cannot be cast to integer.
-    """
-    if port is not None and not isinstance(port, int):
-        try:
-            port = int(port)
-        except ValueError as e:
-            raise RasaException(f"The port '{port}' cannot be cast to integer.") from e
-
-    return port
-
-
-class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
-    """Store which can save and retrieve trackers from an SQL database."""
-
-    from sqlalchemy.orm import DeclarativeBase
-
-    class Base(DeclarativeBase):
-        """Base class for all tracker store tables."""
-
-        pass
-
-    class SQLEvent(Base):
-        """Represents an event in the SQL Tracker Store."""
-
-        __tablename__ = "events"
-
-        # `create_sequence` is needed to create a sequence for databases that
-        # don't autoincrement Integer primary keys (e.g. Oracle)
-        id = sa.Column(sa.Integer, _create_sequence(__tablename__), primary_key=True)
-        sender_id = sa.Column(sa.String(255), nullable=False, index=True)
-        type_name = sa.Column(sa.String(255), nullable=False)
-        timestamp = sa.Column(sa.Float)
-        intent_name = sa.Column(sa.String(255))
-        action_name = sa.Column(sa.String(255))
-        data = sa.Column(sa.Text)
-
-    def __init__(
-        self,
-        domain: Optional[Domain] = None,
-        dialect: Text = "sqlite",
-        host: Optional[Text] = None,
-        port: Optional[int] = None,
-        db: Text = "rasa.db",
-        username: Optional[Text] = None,
-        password: Optional[Text] = None,
-        event_broker: Optional[EventBroker] = None,
-        login_db: Optional[Text] = None,
-        query: Optional[Dict] = None,
-        **kwargs: Dict[Text, Any],
-    ) -> None:
-        import sqlalchemy.exc
-
-        port = validate_port(port)
-
-        engine_url = self.get_db_url(
-            dialect, host, port, db, username, password, login_db, query
-        )
-
-        self.engine = sa.create_engine(engine_url, **create_engine_kwargs(engine_url))
-
-        structlogger.debug(
-            "sql_tracker_store.connect_to_sql_database",
-            event_info=f"Attempting to connect to database via '{self.engine.url!r}'.",
-        )
-
-        # Database might take a while to come up
-        while True:
-            try:
-                # if `login_db` has been provided, use current channel with
-                # that database to create working database `db`
-                if login_db:
-                    self._create_database_and_update_engine(db, engine_url)
-
-                try:
-                    self.Base.metadata.create_all(self.engine)
-                except (
-                    sqlalchemy.exc.OperationalError,
-                    sqlalchemy.exc.ProgrammingError,
-                ) as e:
-                    # Several Rasa services started in parallel may attempt to
-                    # create tables at the same time. That is okay so long as
-                    # the first services finishes the table creation.
-                    structlogger.error(
-                        "sql_tracker_store.create_tables_failed",
-                        event_info="Could not create tables",
-                        exec_info=e,
-                    )
-
-                self.sessionmaker = sa.orm.session.sessionmaker(bind=self.engine)
-                break
-            except (
-                sqlalchemy.exc.OperationalError,
-                sqlalchemy.exc.IntegrityError,
-            ) as error:
-                structlogger.warning(
-                    "sql_tracker_store.initialisation_error",
-                    event_info="Failed to establish a connection to the SQL database. ",
-                    exc_info=error,
-                )
-                sleep(5)
-
-        structlogger.debug(
-            "sql_tracker_store.connected_to_sql_database",
-            event_info=f"Connection to SQL database '{db}' successful.",
-        )
-
-        super().__init__(domain, event_broker, **kwargs)
-
-    @staticmethod
-    def get_db_url(
-        dialect: Text = "sqlite",
-        host: Optional[Text] = None,
-        port: Optional[int] = None,
-        db: Text = "rasa.db",
-        username: Optional[Text] = None,
-        password: Optional[Text] = None,
-        login_db: Optional[Text] = None,
-        query: Optional[Dict] = None,
-    ) -> Union[Text, "URL"]:
-        """Build an SQLAlchemy `URL` object.
-
-        The URL object represents the parameters needed to connect to an
-        SQL database.
-
-        Args:
-            dialect: SQL database type.
-            host: Database network host.
-            port: Database network port.
-            db: Database name.
-            username: User name to use when connecting to the database.
-            password: Password for database user.
-            login_db: Alternative database name to which initially connect, and create
-                the database specified by `db` (PostgreSQL only).
-            query: Dictionary of options to be passed to the dialect and/or the
-                DBAPI upon connect.
-
-        Returns:
-            URL ready to be used with an SQLAlchemy `Engine` object.
-        """
-        from urllib import parse
-
-        # Users might specify a url in the host
-        if host and "://" in host:
-            # assumes this is a complete database host name including
-            # e.g. `postgres://...`
-            return host
-        elif host:
-            # add fake scheme to properly parse components
-            parsed = parse.urlsplit(f"scheme://{host}")
-
-            # users might include the port in the url
-            port = parsed.port or port
-            host = parsed.hostname or host
-
-        if not query:
-            # query needs to be set in order to create a URL
-            query = {}
-
-        return sa.engine.url.URL(
-            dialect,
-            username,
-            password,
-            host,
-            port,
-            database=login_db if login_db else db,
-            query=query,
-        )
-
-    def _create_database_and_update_engine(self, db: Text, engine_url: "URL") -> None:
-        """Creates database `db` and updates engine accordingly."""
-        from sqlalchemy import create_engine
-
-        if self.engine.dialect.name != "postgresql":
-            rasa.shared.utils.io.raise_warning(
-                "The parameter 'login_db' can only be used with a postgres database."
-            )
-            return
-
-        self._create_database(self.engine, db)
-        self.engine.dispose()
-        engine_url = sa.engine.url.URL(
-            drivername=engine_url.drivername,
-            username=engine_url.username,
-            password=engine_url.password,
-            host=engine_url.host,
-            port=engine_url.port,
-            database=db,
-            query=engine_url.query,
-        )
-        self.engine = create_engine(engine_url)
-
-    @staticmethod
-    def _create_database(engine: "Engine", database_name: Text) -> None:
-        """Create database `db` on `engine` if it does not exist."""
-        import sqlalchemy.exc
-
-        with engine.connect() as connection:
-            connection.execution_options(isolation_level="AUTOCOMMIT")
-            matching_rows = connection.execute(
-                sa.text(
-                    f"SELECT 1 FROM pg_catalog.pg_database "
-                    f"WHERE datname = '{database_name}'"
-                )
-            ).rowcount
-
-            if not matching_rows:
-                try:
-                    connection.execute(sa.text(f"CREATE DATABASE {database_name}"))
-                except (
-                    sqlalchemy.exc.ProgrammingError,
-                    sqlalchemy.exc.IntegrityError,
-                ) as e:
-                    structlogger.error(
-                        "sql_tracker_store.create_database_failed",
-                        event_info=f"Could not create database '{database_name}'",
-                        exec_info=e,
-                    )
-
-    @contextlib.contextmanager
-    def session_scope(self) -> Generator["Session", None, None]:
-        """Provide a transactional scope around a series of operations."""
-        session = self.sessionmaker()
-        try:
-            ensure_schema_exists(session)
-            yield session
-        except ValueError as e:
-            rasa.shared.utils.cli.print_error_and_exit(
-                f"Requested PostgreSQL schema '{e}' was not found in the database. To "
-                f"continue, please create the schema by running 'CREATE DATABASE {e};' "
-                f"or unset the '{POSTGRESQL_SCHEMA}' environment variable in order to "
-                f"use the default schema. Exiting application."
-            )
-        finally:
-            session.close()
-
-    async def keys(self) -> Iterable[Text]:
-        """Returns sender_ids of the SQLTrackerStore."""
-        with self.session_scope() as session:
-            sender_ids = session.query(self.SQLEvent.sender_id).distinct().all()
-            return [sender_id for (sender_id,) in sender_ids]
-
-    async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
-        """Retrieves tracker for the latest conversation session."""
-        return await self._retrieve(sender_id, fetch_events_from_all_sessions=False)
-
-    async def retrieve_full_tracker(
-        self, conversation_id: Text
-    ) -> Optional[DialogueStateTracker]:
-        """Fetching all tracker events across conversation sessions."""
-        return await self._retrieve(
-            conversation_id, fetch_events_from_all_sessions=True
-        )
-
-    async def count_conversations(self, after_timestamp: float = 0.0) -> int:
-        """Returns the number of conversations that have occurred after a timestamp.
-
-        By default, this method returns the number of conversations that
-        have occurred after the Unix epoch (i.e. timestamp 0).
-        """
-        with self.session_scope() as session:
-            query = (
-                session.query(self.SQLEvent.sender_id)
-                .distinct()
-                .filter(self.SQLEvent.timestamp >= after_timestamp)
-            )
-            return query.count()
-
-    async def _retrieve(
-        self, sender_id: Text, fetch_events_from_all_sessions: bool
-    ) -> Optional[DialogueStateTracker]:
-        with self.session_scope() as session:
-            serialised_events = self._event_query(
-                session,
-                sender_id,
-                fetch_events_from_all_sessions=fetch_events_from_all_sessions,
-            ).all()
-
-            events = [json.loads(event.data) for event in serialised_events]
-
-            if self.domain and len(events) > 0:
-                structlogger.debug(
-                    "sql_tracker_store.recreating_tracker",
-                    event_info=f"Recreating tracker from sender id '{sender_id}'",
-                )
-                return DialogueStateTracker.from_dict(
-                    sender_id, events, self.domain.slots
-                )
-            else:
-                structlogger.debug(
-                    "sql_tracker_store._retrieve.no_tracker_for_sender_id",
-                    event_info=(
-                        f"Can't retrieve tracker matching "
-                        f"sender id '{sender_id}' from SQL storage. "
-                        f"Returning `None` instead.",
-                    ),
-                )
-                return None
-
-    def _event_query(
-        self, session: "Session", sender_id: Text, fetch_events_from_all_sessions: bool
-    ) -> "Query":
-        """Provide the query to retrieve the conversation events for a specific sender.
-
-        The events are ordered by ID to ensure correct sequence of events.
-        As `timestamp` is not guaranteed to be unique and low-precision (float), it
-        cannot be used to order the events.
-
-        Args:
-            session: Current database session.
-            sender_id: Sender id whose conversation events should be retrieved.
-            fetch_events_from_all_sessions: Whether to fetch events from all
-                conversation sessions. If `False`, only fetch events from the
-                latest conversation session.
-
-        Returns:
-            Query to get the conversation events.
-        """
-        # Subquery to find the timestamp of the latest `SessionStarted` event
-        session_start_sub_query = (
-            session.query(sa.func.max(self.SQLEvent.timestamp).label("session_start"))
-            .filter(
-                self.SQLEvent.sender_id == sender_id,
-                self.SQLEvent.type_name == SessionStarted.type_name,
-            )
-            .subquery()
-        )
-
-        event_query = session.query(self.SQLEvent).filter(
-            self.SQLEvent.sender_id == sender_id
-        )
-        if not fetch_events_from_all_sessions:
-            event_query = event_query.filter(
-                # Find events after the latest `SessionStarted` event or return all
-                # events
-                sa.or_(
-                    self.SQLEvent.timestamp >= session_start_sub_query.c.session_start,
-                    session_start_sub_query.c.session_start.is_(None),
-                )
-            )
-
-        return event_query.order_by(self.SQLEvent.id)
-
-    async def save(self, tracker: DialogueStateTracker) -> None:
-        """Update database with events from the current conversation."""
-        await self.stream_events(tracker)
-
-        with self.session_scope() as session:
-            # only store recent events
-            events = self._additional_events(session, tracker)
-
-            for event in events:
-                data = event.as_dict()
-                intent = (
-                    data.get("parse_data", {}).get("intent", {}).get(INTENT_NAME_KEY)
-                )
-                action = data.get("name")
-                timestamp = data.get("timestamp")
-
-                # noinspection PyArgumentList
-                session.add(
-                    self.SQLEvent(
-                        sender_id=tracker.sender_id,
-                        type_name=event.type_name,
-                        timestamp=timestamp,
-                        intent_name=intent,
-                        action_name=action,
-                        data=json.dumps(data),
-                    )
-                )
-            session.commit()
-
-        structlogger.debug(
-            "sql_tracker_store.save_tracker",
-            event_info=(
-                f"Tracker with sender_id " f"'{tracker.sender_id}' stored to database",
-            ),
-        )
-
-    def _additional_events(
-        self, session: "Session", tracker: DialogueStateTracker
-    ) -> Iterator:
-        """Return events from the tracker which aren't currently stored."""
-        number_of_events_since_last_session = self._event_query(
-            session, tracker.sender_id, fetch_events_from_all_sessions=False
-        ).count()
-
-        return itertools.islice(
-            tracker.events, number_of_events_since_last_session, len(tracker.events)
-        )
-
-
-class FailSafeTrackerStore(TrackerStore):
-    """Tracker store wrapper.
-
-    Allows a fallback to a different tracker store in case of errors.
-    """
-
-    def __init__(
-        self,
-        tracker_store: TrackerStore,
-        on_tracker_store_error: Optional[Callable[[Exception], None]] = None,
-        fallback_tracker_store: Optional[TrackerStore] = None,
-    ) -> None:
-        """Create a `FailSafeTrackerStore`.
-
-        Args:
-            tracker_store: Primary tracker store.
-            on_tracker_store_error: Callback which is called when there is an error
-                in the primary tracker store.
-            fallback_tracker_store: Fallback tracker store.
-        """
-        self._fallback_tracker_store: Optional[TrackerStore] = fallback_tracker_store
-        self._tracker_store = tracker_store
-        self._on_tracker_store_error = on_tracker_store_error
-
-        super().__init__(tracker_store.domain, tracker_store.event_broker)
-
-    @property
-    def domain(self) -> Domain:
-        """Returns the domain of the primary tracker store."""
-        return self._tracker_store.domain
-
-    @domain.setter
-    def domain(self, domain: Domain) -> None:
-        self._tracker_store.domain = domain
-
-        if self._fallback_tracker_store:
-            self._fallback_tracker_store.domain = domain
-
-    @property
-    def fallback_tracker_store(self) -> TrackerStore:
-        """Returns the fallback tracker store."""
-        if not self._fallback_tracker_store:
-            self._fallback_tracker_store = InMemoryTrackerStore(
-                self._tracker_store.domain, self._tracker_store.event_broker
-            )
-
-        return self._fallback_tracker_store
-
-    def on_tracker_store_error(self, error: Exception) -> None:
-        """Calls the callback when there is an error in the primary tracker store."""
-        if self._on_tracker_store_error:
-            self._on_tracker_store_error(error)
-        else:
-            structlogger.error(
-                "fail_safe_tracker_store.tracker_store_error",
-                event_info=(
-                    f"Error happened when trying to save conversation tracker to "
-                    f"'{self._tracker_store.__class__.__name__}'. Falling back to use "
-                    f"the '{InMemoryTrackerStore.__name__}'. Please "
-                    f"investigate the following error: {error}."
-                ),
-            )
-
-    async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
-        """Calls `retrieve` method of primary tracker store."""
-        try:
-            return await self._tracker_store.retrieve(sender_id)
-        except Exception as e:
-            self.on_tracker_store_retrieve_error(e)
-            return None
-
-    async def keys(self) -> Iterable[Text]:
-        """Calls `keys` method of primary tracker store."""
-        try:
-            return await self._tracker_store.keys()
-        except Exception as e:
-            self.on_tracker_store_error(e)
-            return []
-
-    async def save(self, tracker: DialogueStateTracker) -> None:
-        """Calls `save` method of primary tracker store."""
-        try:
-            await self._tracker_store.save(tracker)
-        except Exception as e:
-            self.on_tracker_store_error(e)
-            await self.fallback_tracker_store.save(tracker)
-
-    async def retrieve_full_tracker(
-        self, sender_id: Text
-    ) -> Optional[DialogueStateTracker]:
-        """Calls `retrieve_full_tracker` method of primary tracker store.
-
-        Args:
-            sender_id: The sender id of the tracker to retrieve.
-        """
-        try:
-            return await self._tracker_store.retrieve_full_tracker(sender_id)
-        except Exception as e:
-            self.on_tracker_store_retrieve_error(e)
-            return None
-
-    def on_tracker_store_retrieve_error(self, error: Exception) -> None:
-        """Calls `_on_tracker_store_error` callable attribute if set.
-
-        Otherwise, logs the error.
-
-        Args:
-            error: The error that occurred.
-        """
-        if self._on_tracker_store_error:
-            self._on_tracker_store_error(error)
-        else:
-            structlogger.error(
-                "fail_safe_tracker_store.tracker_store_retrieve_error",
-                event_info=(
-                    f"Error happened when trying to retrieve conversation tracker from "
-                    f"'{self._tracker_store.__class__.__name__}'. Falling back to use "
-                    f"the '{InMemoryTrackerStore.__name__}'."
-                ),
-                exec_info=error,
-            )
-
-
-def _create_from_endpoint_config(
-    endpoint_config: Optional[EndpointConfig] = None,
-    domain: Optional[Domain] = None,
-    event_broker: Optional[EventBroker] = None,
-) -> TrackerStore:
-    """Given an endpoint configuration, create a proper tracker store object."""
-    domain = domain or Domain.empty()
-
-    if endpoint_config is None or endpoint_config.type is None:
-        # default tracker store if no type is set
-        tracker_store: TrackerStore = InMemoryTrackerStore(domain, event_broker)
-    elif endpoint_config.type.lower() == "redis":
-        tracker_store = RedisTrackerStore(
-            domain=domain,
-            host=endpoint_config.url,
-            event_broker=event_broker,
-            **endpoint_config.kwargs,
-        )
-    elif endpoint_config.type.lower() == "mongod":
-        tracker_store = MongoTrackerStore(
-            domain=domain,
-            host=endpoint_config.url,
-            event_broker=event_broker,
-            **endpoint_config.kwargs,
-        )
-    elif endpoint_config.type.lower() == "sql":
-        tracker_store = SQLTrackerStore(
-            domain=domain,
-            host=endpoint_config.url,
-            event_broker=event_broker,
-            **endpoint_config.kwargs,
-        )
-    elif endpoint_config.type.lower() == "dynamo":
-        tracker_store = DynamoTrackerStore(
-            domain=domain, event_broker=event_broker, **endpoint_config.kwargs
-        )
-    else:
-        tracker_store = _load_from_module_name_in_endpoint_config(
-            domain, endpoint_config, event_broker
-        )
-
-    structlogger.debug(
-        "tracker_store.create_tracker_store_from_endpoint_config",
-        eventi_info=f"Connected to {tracker_store.__class__.__name__}.",
-    )
-
-    return tracker_store
-
-
-def _load_from_module_name_in_endpoint_config(
-    domain: Domain, store: EndpointConfig, event_broker: Optional[EventBroker] = None
-) -> TrackerStore:
-    """Initializes a custom tracker.
-
-    Defaults to the InMemoryTrackerStore if the module path can not be found.
-
-    Args:
-        domain: defines the universe in which the assistant operates
-        store: the specific tracker store
-        event_broker: an event broker to publish events
-
-    Returns:
-        a tracker store from a specified type in a stores endpoint configuration
-    """
-    try:
-        tracker_store_class = rasa.shared.utils.common.class_from_module_path(
-            store.type
-        )
-
-        return tracker_store_class(
-            host=store.url, domain=domain, event_broker=event_broker, **store.kwargs
-        )
-    except (AttributeError, ImportError):
-        rasa.shared.utils.io.raise_warning(
-            f"Tracker store with type '{store.type}' not found. "
-            f"Using `InMemoryTrackerStore` instead."
-        )
-        return InMemoryTrackerStore(domain)
-
-
-def create_tracker_store(
-    endpoint_config: Optional[EndpointConfig],
-    domain: Optional[Domain] = None,
-    event_broker: Optional[EventBroker] = None,
-) -> TrackerStore:
-    """Creates a tracker store based on the current configuration."""
-    tracker_store = _create_from_endpoint_config(endpoint_config, domain, event_broker)
-
-    if not check_if_tracker_store_async(tracker_store):
-        rasa.shared.utils.io.raise_deprecation_warning(
-            f"Tracker store implementation "
-            f"{tracker_store.__class__.__name__} "
-            f"is not asynchronous. Non-asynchronous tracker stores "
-            f"are currently deprecated and will be removed in 4.0. "
-            f"Please make the following methods async: "
-            f"{_get_async_tracker_store_methods()}"
-        )
-        tracker_store = AwaitableTrackerStore(tracker_store)
-
-    return tracker_store
-
-
-class AwaitableTrackerStore(TrackerStore):
-    """Wraps a tracker store so it can be implemented with async overrides."""
-
-    def __init__(
-        self,
-        tracker_store: TrackerStore,
-    ) -> None:
-        """Create a `AwaitableTrackerStore`.
-
-        Args:
-            tracker_store: the wrapped tracker store.
-        """
-        self._tracker_store = tracker_store
-
-        super().__init__(tracker_store.domain, tracker_store.event_broker)
-
-    @property
-    def domain(self) -> Domain:
-        """Returns the domain of the primary tracker store."""
-        return self._tracker_store.domain
-
-    @domain.setter
-    def domain(self, domain: Optional[Domain]) -> None:
-        """Setter method to modify the wrapped tracker store's domain field."""
-        self._tracker_store.domain = domain or Domain.empty()
-
-    @staticmethod
-    def create(
-        obj: Union[TrackerStore, EndpointConfig, None],
-        domain: Optional[Domain] = None,
-        event_broker: Optional[EventBroker] = None,
-    ) -> TrackerStore:
-        """Wrapper to call `create` method of primary tracker store."""
-        if isinstance(obj, TrackerStore):
-            return AwaitableTrackerStore(obj)
-        elif isinstance(obj, EndpointConfig):
-            return AwaitableTrackerStore(_create_from_endpoint_config(obj))
-        else:
-            raise ValueError(
-                f"{type(obj).__name__} supplied "
-                f"but expected object of type {TrackerStore.__name__} or "
-                f"of type {EndpointConfig.__name__}."
-            )
-
-    async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
-        """Wrapper to call `retrieve` method of primary tracker store."""
-        result = self._tracker_store.retrieve(sender_id)
-        return (
-            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
-        )
-
-    async def keys(self) -> Iterable[Text]:
-        """Wrapper to call `keys` method of primary tracker store."""
-        result = self._tracker_store.keys()
-        return await result if isawaitable(result) else result
-
-    async def save(self, tracker: DialogueStateTracker) -> None:
-        """Wrapper to call `save` method of primary tracker store."""
-        result = self._tracker_store.save(tracker)
-        return await result if isawaitable(result) else result
-
-    async def retrieve_full_tracker(
-        self, conversation_id: Text
-    ) -> Optional[DialogueStateTracker]:
-        """Wrapper to call `retrieve_full_tracker` method of primary tracker store."""
-        result = self._tracker_store.retrieve_full_tracker(conversation_id)
-        return (
-            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
-        )