rasa-pro 3.13.0.dev3__py3-none-any.whl → 3.13.0.dev7__py3-none-any.whl

rasa/core/persistor.py

@@ -121,10 +121,12 @@ def get_persistor(storage: StorageType) -> Optional[Persistor]:
 class Persistor(abc.ABC):
     """Store models in cloud and fetch them when needed."""
 
-    def persist(self, trained_model: str) -> None:
+    def persist(self, trained_model: str, remote_root_only: bool = False) -> None:
         """Uploads a trained model persisted in the `target_dir` to cloud storage."""
         absolute_file_key = self._create_file_key(trained_model)
-        file_key = Path(absolute_file_key).name
+        file_key = (
+            Path(absolute_file_key).name if remote_root_only else absolute_file_key
+        )
         self._persist_tar(file_key, trained_model)
 
     def retrieve(self, model_name: Text, target_path: Text) -> Text:
@@ -143,30 +145,32 @@ class Persistor(abc.ABC):
             # ensure backward compatibility
             tar_name = self._tar_name(model_name)
         tar_name = self._create_file_key(tar_name)
-        target_filename = os.path.basename(tar_name)
-        self._retrieve_tar(target_filename)
-        self._copy(os.path.basename(tar_name), target_path)
+        self._retrieve_tar(tar_name, target_path)
 
         if os.path.isdir(target_path):
             return os.path.join(target_path, model_name)
 
         return target_path
 
-    def size_of_persisted_model(self, model_name: Text) -> int:
+    def size_of_persisted_model(
+        self, model_name: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to cloud storage.
 
         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)
-        target_filename = os.path.basename(tar_name)
-        return self._retrieve_tar_size(target_filename)
+        return self._retrieve_tar_size(tar_name, target_path)
 
-    def _retrieve_tar_size(self, filename: Text) -> int:
+    def _retrieve_tar_size(
+        self, filename: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to cloud storage."""
         structlogger.warning(
             "persistor.retrieve_tar_size.not_implemented",
@@ -179,11 +183,11 @@ class Persistor(abc.ABC):
                 "size directly from the cloud storage."
             ),
         )
-        self._retrieve_tar(filename)
+        self._retrieve_tar(filename, target_path)
         return os.path.getsize(os.path.basename(filename))
 
     @abc.abstractmethod
-    def _retrieve_tar(self, filename: Text) -> None:
+    def _retrieve_tar(self, filename: str, target_path: Optional[str] = None) -> None:
         """Downloads a model previously persisted to cloud storage."""
         raise NotImplementedError
 
@@ -302,7 +306,9 @@ class AWSPersistor(Persistor):
         with open(tar_path, "rb") as f:
             self.s3.Object(self.bucket_name, file_key).put(Body=f)
 
-    def _retrieve_tar_size(self, model_path: Text) -> int:
+    def _retrieve_tar_size(
+        self, model_path: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to s3."""
         try:
             obj = self.s3.Object(self.bucket_name, model_path)
@@ -310,7 +316,9 @@ class AWSPersistor(Persistor):
         except Exception:
             raise ModelNotFound()
 
-    def _retrieve_tar(self, target_filename: str) -> None:
+    def _retrieve_tar(
+        self, target_filename: str, target_path: Optional[str] = None
+    ) -> None:
         """Downloads a model that has previously been persisted to s3."""
         from botocore import exceptions
 
@@ -320,8 +328,14 @@ class AWSPersistor(Persistor):
             f"in the bucket."
         )
 
+        tar_name = (
+            os.path.join(target_path, os.path.basename(target_filename))
+            if target_path
+            else os.path.basename(target_filename)
+        )
+
         try:
-            with open(target_filename, "wb") as f:
+            with open(tar_name, "wb") as f:
                 self.bucket.download_fileobj(target_filename, f)
 
             structlogger.debug(
@@ -425,7 +439,9 @@ class GCSPersistor(Persistor):
         blob = self.bucket.blob(file_key)
         blob.upload_from_filename(tar_path)
 
-    def _retrieve_tar_size(self, target_filename: Text) -> int:
+    def _retrieve_tar_size(
+        self, target_filename: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to GCS."""
         try:
             blob = self.bucket.blob(target_filename)
@@ -433,13 +449,22 @@ class GCSPersistor(Persistor):
         except Exception:
             raise ModelNotFound()
 
-    def _retrieve_tar(self, target_filename: Text) -> None:
+    def _retrieve_tar(
+        self, target_filename: str, target_path: Optional[str] = None
+    ) -> None:
         """Downloads a model that has previously been persisted to GCS."""
         from google.api_core import exceptions
 
         blob = self.bucket.blob(target_filename)
+
+        destination = (
+            os.path.join(target_path, os.path.basename(target_filename))
+            if target_path
+            else target_filename
+        )
+
         try:
-            blob.download_to_filename(target_filename)
+            blob.download_to_filename(destination)
 
             structlogger.debug(
                 "gcs_persistor.retrieve_tar.object_found", object_key=target_filename
@@ -500,7 +525,9 @@ class AzurePersistor(Persistor):
         with open(tar_path, "rb") as data:
             self._container_client().upload_blob(name=file_key, data=data)
 
-    def _retrieve_tar_size(self, target_filename: Text) -> int:
+    def _retrieve_tar_size(
+        self, target_filename: Text, target_path: Optional[str] = None
+    ) -> int:
         """Returns the size of the model that has been persisted to Azure."""
         try:
             blob_client = self._container_client().get_blob_client(target_filename)
@@ -509,12 +536,20 @@ class AzurePersistor(Persistor):
         except Exception:
             raise ModelNotFound()
 
-    def _retrieve_tar(self, target_filename: Text) -> None:
+    def _retrieve_tar(
+        self, target_filename: Text, target_path: Optional[str] = None
+    ) -> None:
         """Downloads a model that has previously been persisted to Azure."""
         from azure.core.exceptions import AzureError
 
+        destination = (
+            os.path.join(target_path, os.path.basename(target_filename))
+            if target_path
+            else target_filename
+        )
+
         try:
-            with open(target_filename, "wb") as model_file:
+            with open(destination, "wb") as model_file:
                 blob_client = self._container_client().get_blob_client(target_filename)
                 download_stream = blob_client.download_blob()
                 model_file.write(download_stream.readall())

rasa/core/policies/enterprise_search_policy.py

@@ -46,12 +46,15 @@ from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
+    MAX_RETRIES_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
+    TEMPERATURE_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.constants import (
@@ -135,14 +138,14 @@ DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME,
     TIMEOUT_CONFIG_KEY: 10,
-    "temperature": 0.0,
-    "max_tokens": 256,
-    "max_retries": 1,
+    TEMPERATURE_CONFIG_KEY: 0.0,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY: 256,
+    MAX_RETRIES_CONFIG_KEY: 1,
 }
 
 DEFAULT_EMBEDDINGS_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
-    "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
 }
 
 ENTERPRISE_SEARCH_PROMPT_FILE_NAME = "enterprise_search_policy_prompt.jinja2"

rasa/core/policies/intentless_policy.py

@@ -31,12 +31,14 @@ from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
     LLM_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
+    TEMPERATURE_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
@@ -111,14 +113,14 @@ NLU_ABSTENTION_THRESHOLD = "nlu_abstention_threshold"
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME,
-    "temperature": 0.0,
-    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TEMPERATURE_CONFIG_KEY: 0.0,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY: DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     TIMEOUT_CONFIG_KEY: 5,
 }
 
 DEFAULT_EMBEDDINGS_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
-    "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
 }
 
 DEFAULT_INTENTLESS_PROMPT_TEMPLATE = importlib.resources.open_text(
@@ -344,8 +346,6 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             # ensures that the policy will not override a deterministic policy
             # which utilizes the nlu predictions confidence (e.g. Memoization).
             NLU_ABSTENTION_THRESHOLD: 0.9,
-            LLM_CONFIG_KEY: DEFAULT_LLM_CONFIG,
-            EMBEDDINGS_CONFIG_KEY: DEFAULT_EMBEDDINGS_CONFIG,
             PROMPT_CONFIG_KEY: DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
         }
 
@@ -381,13 +381,19 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         super().__init__(config, model_storage, resource, execution_context, featurizer)
 
         # Resolve LLM config
-        self.config[LLM_CONFIG_KEY] = resolve_model_client_config(
-            self.config.get(LLM_CONFIG_KEY), IntentlessPolicy.__name__
+        self.config[LLM_CONFIG_KEY] = combine_custom_and_default_config(
+            resolve_model_client_config(
+                self.config.get(LLM_CONFIG_KEY), IntentlessPolicy.__name__
+            ),
+            DEFAULT_LLM_CONFIG,
         )
 
         # Resolve embeddings config
-        self.config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
-            self.config.get(EMBEDDINGS_CONFIG_KEY), IntentlessPolicy.__name__
+        self.config[EMBEDDINGS_CONFIG_KEY] = combine_custom_and_default_config(
+            resolve_model_client_config(
+                self.config.get(EMBEDDINGS_CONFIG_KEY), IntentlessPolicy.__name__
+            ),
+            DEFAULT_EMBEDDINGS_CONFIG,
         )
 
         self.nlu_abstention_threshold: float = self.config[NLU_ABSTENTION_THRESHOLD]

rasa/core/processor.py

@@ -12,7 +12,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, Union
 import structlog
 
 import rasa.core.actions.action
-import rasa.core.tracker_store
+import rasa.core.tracker_stores.tracker_store
 import rasa.core.utils
 import rasa.shared.core.trackers
 import rasa.shared.utils.io
@@ -126,7 +126,7 @@ class MessageProcessor:
     def __init__(
         self,
         model_path: Union[Text, Path],
-        tracker_store: rasa.core.tracker_store.TrackerStore,
+        tracker_store: rasa.core.tracker_stores.tracker_store.TrackerStore,
         lock_store: LockStore,
         generator: NaturalLanguageGenerator,
         action_endpoint: Optional[EndpointConfig] = None,

rasa/core/run.py

@@ -86,13 +86,15 @@ def _create_single_channel(channel: Text, credentials: Dict[Text, Any]) -> Any:
             )
 
 
-def _create_app_without_api(cors: Optional[Union[Text, List[Text]]] = None) -> Sanic:
+def _create_app_without_api(
+    cors: Optional[Union[Text, List[Text]]] = None, is_inspector_enabled: bool = False
+) -> Sanic:
     app = Sanic("rasa_core_no_api", configure_logging=False)
 
     # Reset Sanic warnings filter that allows the triggering of Sanic warnings
     warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"sanic.*")
 
-    server.add_root_route(app)
+    server.add_root_route(app, is_inspector_enabled)
     server.configure_cors(app, cors)
     return app
 
@@ -127,6 +129,7 @@ def configure_app(
     server_listeners: Optional[List[Tuple[Callable, Text]]] = None,
     use_uvloop: Optional[bool] = True,
     keep_alive_timeout: int = constants.DEFAULT_KEEP_ALIVE_TIMEOUT,
+    is_inspector_enabled: bool = False,
 ) -> Sanic:
     """Run the agent."""
     rasa.core.utils.configure_file_logging(
@@ -144,6 +147,7 @@ def configure_app(
                 jwt_private_key=jwt_private_key,
                 jwt_method=jwt_method,
                 endpoints=endpoints,
+                is_inspector_enabled=is_inspector_enabled,
             )
         )
     else:
@@ -259,6 +263,7 @@ def serve_application(
         syslog_protocol=syslog_protocol,
         request_timeout=request_timeout,
         server_listeners=server_listeners,
+        is_inspector_enabled=inspect,
     )
 
     ssl_context = server.create_ssl_context(

rasa/core/{auth_retry_tracker_store.py → tracker_stores/auth_retry_tracker_store.py}

@@ -3,7 +3,7 @@ from typing import Iterable, Optional, Text
 
 from rasa.core.brokers.broker import EventBroker
 from rasa.core.secrets_manager.secret_manager import EndpointResolver
-from rasa.core.tracker_store import TrackerStore, create_tracker_store
+from rasa.core.tracker_stores.tracker_store import TrackerStore, create_tracker_store
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig
@@ -119,3 +119,7 @@ class AuthRetryTrackerStore(TrackerStore):
         """Recreate tracker store with updated credentials."""
         endpoint_config = EndpointResolver.update_config(self.endpoint_config)
         return create_tracker_store(endpoint_config, domain, event_broker)
+
+    async def delete(self, sender_id: Text) -> None:
+        """Delete tracker for the given sender_id."""
+        await self._tracker_store.delete(sender_id)

rasa/core/tracker_stores/dynamo_tracker_store.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Text
+
+import structlog
+from boto3.dynamodb.conditions import Key
+
+import rasa.utils
+from rasa.constants import DEFAULT_SANIC_WORKERS, ENV_SANIC_WORKERS
+from rasa.core.tracker_stores.tracker_store import (
+    SerializedTrackerAsDict,
+    TrackerStore,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
+
+structlogger = structlog.get_logger(__name__)
+
+if TYPE_CHECKING:
+    import boto3.resources.factory.dynamodb.Table
+
+
+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)
+
+    async def delete(self, sender_id: Text) -> None:
+        """Delete tracker for the given sender_id."""
+        if not await self.exists(sender_id):
+            structlogger.info(
+                "dynamo_tracker_store.delete.no_tracker_for_sender_id",
+                event_info=f"Could not find tracker for conversation ID '{sender_id}'.",
+            )
+            return None
+
+        self.db.delete_item(
+            Key={"sender_id": sender_id},
+            ConditionExpression="attribute_exists(sender_id)",
+        )
+        structlogger.info(
+            "dynamo_tracker_store.delete.deleted_tracker",
+            sender_id=sender_id,
+        )
+
+    @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
+
+        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
+
+        if self.domain is None:
+            slots = []
+        else:
+            slots = self.domain.slots
+
+        tracker = DialogueStateTracker.from_dict(sender_id, events_with_floats, slots)
+
+        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 len(multiple_tracker_sessions) <= 1:
+            return tracker
+
+        return multiple_tracker_sessions[-1]
+
+    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