rasa-pro 3.11.0__py3-none-any.whl → 3.11.0a2__py3-none-any.whl

rasa/core/nlg/contextual_response_rephraser.py

@@ -1,11 +1,13 @@
 from typing import Any, Dict, Optional, Text
 
+import os
 import structlog
 from jinja2 import Template
+
 from rasa import telemetry
 from rasa.core.nlg.response import TemplatedNaturalLanguageGenerator
-from rasa.core.nlg.summarize import summarize_conversation
 from rasa.shared.constants import (
+    LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -13,25 +15,24 @@ from rasa.shared.constants import (
     PROVIDER_CONFIG_KEY,
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
-    MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.core.events import BotUttered, UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_GENERATE_MODEL_NAME,
     DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     USER,
     combine_custom_and_default_config,
     get_prompt_template,
+    llm_api_health_check,
     llm_factory,
-    resolve_model_client_config,
-)
-from rasa.shared.utils.llm import (
-    tracker_as_readable_transcript,
+    try_instantiate_llm_client,
 )
 from rasa.utils.endpoints import EndpointConfig
+
+from rasa.core.nlg.summarize import summarize_conversation
+
 from rasa.utils.log_utils import log_llm
 
 structlogger = structlog.get_logger()
@@ -40,11 +41,7 @@ RESPONSE_REPHRASING_KEY = "rephrase"
 
 RESPONSE_REPHRASING_TEMPLATE_KEY = "rephrase_prompt"
 
-RESPONSE_SUMMARISE_CONVERSATION_KEY = "summarize_conversation"
-
 DEFAULT_REPHRASE_ALL = False
-DEFAULT_SUMMARIZE_HISTORY = True
-DEFAULT_MAX_HISTORICAL_TURNS = 5
 
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
@@ -69,9 +66,7 @@ Suggested AI Response: {{suggested_response}}
 Rephrased AI Response:"""
 
 
-class ContextualResponseRephraser(
-    LLMHealthCheckMixin, TemplatedNaturalLanguageGenerator
-):
+class ContextualResponseRephraser(TemplatedNaturalLanguageGenerator):
     """Generates responses based on modified templates.
 
     The templates are filled with the entities and slots that are available in the
@@ -105,24 +100,18 @@ class ContextualResponseRephraser(
         self.trace_prompt_tokens = self.nlg_endpoint.kwargs.get(
             "trace_prompt_tokens", False
         )
-        self.summarize_history = self.nlg_endpoint.kwargs.get(
-            "summarize_history", DEFAULT_SUMMARIZE_HISTORY
-        )
-        self.max_historical_turns = self.nlg_endpoint.kwargs.get(
-            "max_historical_turns", DEFAULT_MAX_HISTORICAL_TURNS
-        )
-
-        self.llm_config = resolve_model_client_config(
+        llm_client = try_instantiate_llm_client(
             self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY),
-            ContextualResponseRephraser.__name__,
-        )
-
-        self.perform_llm_health_check(
-            self.llm_config,
             DEFAULT_LLM_CONFIG,
             "contextual_response_rephraser.init",
             ContextualResponseRephraser.__name__,
         )
+        if os.getenv(LLM_API_HEALTH_CHECK_ENV_VAR, "true").lower() == "true":
+            llm_api_health_check(
+                llm_client,
+                "contextual_response_rephraser.init",
+                ContextualResponseRephraser.__name__,
+            )
 
     def _last_message_if_human(self, tracker: DialogueStateTracker) -> Optional[str]:
         """Returns the latest message from the tracker.
@@ -151,7 +140,9 @@ class ContextualResponseRephraser(
         Returns:
             generated text
         """
-        llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
+        llm = llm_factory(
+            self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG
+        )
 
         try:
             llm_response = await llm.acompletion(prompt)
@@ -165,7 +156,7 @@ class ContextualResponseRephraser(
     def llm_property(self, prop: str) -> Optional[str]:
         """Returns a property of the LLM provider."""
         return combine_custom_and_default_config(
-            self.llm_config, DEFAULT_LLM_CONFIG
+            self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG
         ).get(prop)
 
     def custom_prompt_template(self, prompt_template: str) -> Optional[str]:
@@ -198,7 +189,9 @@ class ContextualResponseRephraser(
         Returns:
         The history for the prompt.
         """
-        llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
+        llm = llm_factory(
+            self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG
+        )
         return await summarize_conversation(tracker, llm, max_turns=5)
 
     async def rephrase(
@@ -219,24 +212,13 @@ class ContextualResponseRephraser(
         if not (response_text := response.get(KEY_RESPONSES_TEXT)):
             return response
 
-        prompt_template_text = self._template_for_response_rephrasing(response)
-
-        # Retrieve inputs for the dynamic prompt
         latest_message = self._last_message_if_human(tracker)
         current_input = f"{USER}: {latest_message}" if latest_message else ""
 
-        # Only summarise conversation history if flagged
-        if self.summarize_history:
-            history = await self._create_history(tracker)
-        else:
-            # make sure the transcript/history contains the last user utterance
-            max_turns = max(self.max_historical_turns, 1)
-            history = tracker_as_readable_transcript(tracker, max_turns=max_turns)
-            # the history already contains the current input
-            current_input = ""
+        prompt_template_text = self._template_for_response_rephrasing(response)
 
         prompt = Template(prompt_template_text).render(
-            history=history,
+            history=await self._create_history(tracker),
             suggested_response=response_text,
             current_input=current_input,
             slots=tracker.current_slot_values(),
@@ -253,7 +235,6 @@ class ContextualResponseRephraser(
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
         )
         if not (updated_text := await self._generate_llm_response(prompt)):
             # If the LLM fails to generate a response, we

rasa/core/persistor.py

@@ -4,19 +4,16 @@ import abc
 import os
 import shutil
 from enum import Enum
-from pathlib import Path
 from typing import TYPE_CHECKING, List, Optional, Text, Tuple, Union
 
 import structlog
 
-from rasa.exceptions import ModelNotFound
 import rasa.shared.utils.common
 import rasa.utils.common
 from rasa.constants import (
     HTTP_STATUS_FORBIDDEN,
     HTTP_STATUS_NOT_FOUND,
     MODEL_ARCHIVE_EXTENSION,
-    DEFAULT_BUCKET_NAME,
 )
 from rasa.env import (
     AWS_ENDPOINT_URL_ENV,
@@ -31,7 +28,6 @@ from rasa.shared.utils.io import raise_warning
 
 if TYPE_CHECKING:
     from azure.storage.blob import ContainerClient
-    from botocore.exceptions import ClientError
 
 structlogger = structlog.get_logger()
 
@@ -90,15 +86,14 @@ def get_persistor(storage: StorageType) -> Optional[Persistor]:
 
     if storage == RemoteStorageType.AWS.value:
         return AWSPersistor(
-            os.environ.get(BUCKET_NAME_ENV, DEFAULT_BUCKET_NAME),
-            os.environ.get(AWS_ENDPOINT_URL_ENV),
+            os.environ.get(BUCKET_NAME_ENV), os.environ.get(AWS_ENDPOINT_URL_ENV)
         )
     if storage == RemoteStorageType.GCS.value:
-        return GCSPersistor(os.environ.get(BUCKET_NAME_ENV, DEFAULT_BUCKET_NAME))
+        return GCSPersistor(os.environ.get(BUCKET_NAME_ENV))
 
     if storage == RemoteStorageType.AZURE.value:
         return AzurePersistor(
-            os.environ.get(AZURE_CONTAINER_ENV, DEFAULT_BUCKET_NAME),
+            os.environ.get(AZURE_CONTAINER_ENV),
             os.environ.get(AZURE_ACCOUNT_NAME_ENV),
             os.environ.get(AZURE_ACCOUNT_KEY_ENV),
         )
@@ -123,8 +118,7 @@ class Persistor(abc.ABC):
 
     def persist(self, trained_model: str) -> 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 = self._create_file_key(trained_model)
         self._persist_tar(file_key, trained_model)
 
     def retrieve(self, model_name: Text, target_path: Text) -> Text:
@@ -143,8 +137,7 @@ 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._retrieve_tar(tar_name)
         self._copy(os.path.basename(tar_name), target_path)
 
         if os.path.isdir(target_path):
@@ -152,36 +145,6 @@ class Persistor(abc.ABC):
 
         return target_path
 
-    def size_of_persisted_model(self, model_name: Text) -> int:
-        """Returns the size of the model that has been persisted to cloud storage.
-
-        Args:
-            model_name: The name of the model to retrieve.
-        """
-        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)
-
-    def _retrieve_tar_size(self, filename: Text) -> int:
-        """Returns the size of the model that has been persisted to cloud storage."""
-        structlogger.warning(
-            "persistor.retrieve_tar_size.not_implemented",
-            filename=filename,
-            event_info=(
-                "This method should be implemented in the persistor. "
-                "The default implementation will download the model "
-                "to calculate the size. Most persistors should override "
-                "this method to avoid downloading the model and get the "
-                "size directly from the cloud storage."
-            ),
-        )
-        self._retrieve_tar(filename)
-        return os.path.getsize(os.path.basename(filename))
-
     @abc.abstractmethod
     def _retrieve_tar(self, filename: Text) -> None:
         """Downloads a model previously persisted to cloud storage."""
@@ -218,7 +181,7 @@ class Persistor(abc.ABC):
 
     @staticmethod
     def _create_file_key(model_path: str) -> Text:
-        """Appends remote storage folders when provided to upload or retrieve file."""
+        """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,
@@ -230,7 +193,10 @@ class Persistor(abc.ABC):
                 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.",
+                "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)
@@ -263,13 +229,14 @@ class AWSPersistor(Persistor):
     def _ensure_bucket_exists(
         self, bucket_name: Text, region_name: Optional[Text] = None
     ) -> None:
-        from botocore import exceptions
+        import botocore
 
         # noinspection PyUnresolvedReferences
         try:
             self.s3.meta.client.head_bucket(Bucket=bucket_name)
-        except exceptions.ClientError as exc:
-            if self._error_code(exc) == HTTP_STATUS_FORBIDDEN:
+        except botocore.exceptions.ClientError as e:
+            error_code = int(e.response["Error"]["Code"])
+            if error_code == HTTP_STATUS_FORBIDDEN:
                 log = (
                     f"Access to the specified bucket '{bucket_name}' is forbidden. "
                     "Please make sure you have the necessary "
@@ -281,7 +248,7 @@ class AWSPersistor(Persistor):
                     event_info=log,
                 )
                 raise RasaException(log)
-            elif self._error_code(exc) == HTTP_STATUS_NOT_FOUND:
+            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."
@@ -293,57 +260,16 @@ class AWSPersistor(Persistor):
                 )
                 raise RasaException(log)
 
-    @staticmethod
-    def _error_code(e: "ClientError") -> int:
-        return int(e.response["Error"]["Code"])
-
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to s3."""
         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:
-        """Returns the size of the model that has been persisted to s3."""
-        try:
-            obj = self.s3.Object(self.bucket_name, model_path)
-            return obj.content_length
-        except Exception:
-            raise ModelNotFound()
-
-    def _retrieve_tar(self, target_filename: str) -> None:
+    def _retrieve_tar(self, model_path: Text) -> None:
         """Downloads a model that has previously been persisted to s3."""
-        from botocore import exceptions
-
-        log = (
-            f"Model '{target_filename}' not found in the specified bucket "
-            f"'{self.bucket_name}'. Please make sure the model exists "
-            f"in the bucket."
-        )
-
-        try:
-            with open(target_filename, "wb") as f:
-                self.bucket.download_fileobj(target_filename, f)
-
-            structlogger.debug(
-                "aws_persistor.retrieve_tar.object_found", object_key=target_filename
-            )
-        except exceptions.ClientError as exc:
-            if self._error_code(exc) == HTTP_STATUS_NOT_FOUND:
-                structlogger.error(
-                    "aws_persistor.retrieve_tar.model_not_found",
-                    bucket_name=self.bucket_name,
-                    target_filename=target_filename,
-                    event_info=log,
-                )
-                raise ModelNotFound() from exc
-        except exceptions.BotoCoreError as exc:
-            structlogger.error(
-                "aws_persistor.retrieve_tar.model_download_error",
-                bucket_name=self.bucket_name,
-                target_filename=target_filename,
-                event_info=log,
-            )
-            raise ModelNotFound() from exc
+        tar_name = os.path.basename(model_path)
+        with open(tar_name, "wb") as f:
+            self.bucket.download_fileobj(model_path, f)
 
 
 class GCSPersistor(Persistor):
@@ -368,95 +294,42 @@ class GCSPersistor(Persistor):
 
     def _ensure_bucket_exists(self, bucket_name: Text) -> None:
         from google.cloud import exceptions
-        from google.auth import exceptions as auth_exceptions
 
         try:
             self.storage_client.get_bucket(bucket_name)
-        except auth_exceptions.GoogleAuthError as exc:
+        except exceptions.NotFound:
             log = (
-                f"An error occurred while authenticating with Google Cloud "
-                f"Storage. Please make sure you have the necessary credentials "
-                f"to access the bucket '{bucket_name}'."
-            )
-            structlogger.error(
-                "gcp_persistor.ensure_bucket_exists.authentication_error",
-                bucket_name=bucket_name,
-                event_info=log,
-            )
-            raise RasaException(log) from exc
-        except exceptions.NotFound as exc:
-            log = (
-                f"The specified Google Cloud Storage bucket '{bucket_name}' "
-                f"does not exist. Please make sure to create the bucket first or "
-                f"provide an alternative valid bucket name."
+                f"The specified bucket '{bucket_name}' does not exist. "
+                "Please make sure to create the bucket first."
             )
             structlogger.error(
                 "gcp_persistor.ensure_bucket_exists.bucket_not_found",
                 bucket_name=bucket_name,
                 event_info=log,
             )
-            raise RasaException(log) from exc
-        except exceptions.Forbidden as exc:
+            raise RasaException(log)
+        except exceptions.Forbidden:
             log = (
-                f"Access to the specified Google Cloud storage bucket '{bucket_name}' "
-                f"is forbidden. Please make sure you have the necessary "
-                f"permissions to access the bucket. "
+                f"Access to the specified bucket '{bucket_name}' is forbidden. "
+                "Please make sure you have the necessary "
+                "permission to access the bucket. "
             )
             structlogger.error(
                 "gcp_persistor.ensure_bucket_exists.bucket_access_forbidden",
                 bucket_name=bucket_name,
                 event_info=log,
             )
-            raise RasaException(log) from exc
-        except ValueError as exc:
-            # bucket_name is None
-            log = (
-                "The specified Google Cloud Storage bucket name is None. Please "
-                "make sure to provide a valid bucket name."
-            )
-            structlogger.error(
-                "gcp_persistor.ensure_bucket_exists.bucket_name_none",
-                event_info=log,
-            )
-            raise RasaException(log) from exc
+            raise RasaException(log)
 
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to GCS."""
         blob = self.bucket.blob(file_key)
         blob.upload_from_filename(tar_path)
 
-    def _retrieve_tar_size(self, target_filename: Text) -> int:
-        """Returns the size of the model that has been persisted to GCS."""
-        try:
-            blob = self.bucket.blob(target_filename)
-            return blob.size
-        except Exception:
-            raise ModelNotFound()
-
     def _retrieve_tar(self, target_filename: Text) -> None:
         """Downloads a model that has previously been persisted to GCS."""
-        from google.api_core import exceptions
-
         blob = self.bucket.blob(target_filename)
-        try:
-            blob.download_to_filename(target_filename)
-
-            structlogger.debug(
-                "gcs_persistor.retrieve_tar.object_found", object_key=target_filename
-            )
-        except exceptions.NotFound as exc:
-            log = (
-                f"Model '{target_filename}' not found in the specified bucket "
-                f"'{self.bucket_name}'. Please make sure the model exists "
-                f"in the bucket."
-            )
-            structlogger.error(
-                "gcp_persistor.retrieve_tar.model_not_found",
-                bucket_name=self.bucket_name,
-                target_filename=target_filename,
-                event_info=log,
-            )
-            raise ModelNotFound() from exc
+        blob.download_to_filename(target_filename)
 
 
 class AzurePersistor(Persistor):
@@ -482,8 +355,7 @@ class AzurePersistor(Persistor):
         else:
             log = (
                 f"The specified container '{self.container_name}' does not exist."
-                "Please make sure to create the bucket first or "
-                f"provide an alternative valid bucket name."
+                "Please make sure to create the container first."
             )
             structlogger.error(
                 "azure_persistor.ensure_container_exists.container_not_found",
@@ -500,39 +372,10 @@ 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:
-        """Returns the size of the model that has been persisted to Azure."""
-        try:
-            blob_client = self._container_client().get_blob_client(target_filename)
-            properties = blob_client.get_blob_properties()
-            return properties.size
-        except Exception:
-            raise ModelNotFound()
-
     def _retrieve_tar(self, target_filename: Text) -> None:
         """Downloads a model that has previously been persisted to Azure."""
-        from azure.core.exceptions import AzureError
+        blob_client = self._container_client().get_blob_client(target_filename)
 
-        try:
-            with open(target_filename, "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())
-            structlogger.debug(
-                "azure_persistor.retrieve_tar.blob_found", blob_name=target_filename
-            )
-        except AzureError as exc:
-            log = (
-                f"An exception occurred while trying to download "
-                f"the model '{target_filename}' in the specified container "
-                f"'{self.container_name}'. Please make sure the model exists "
-                f"in the container."
-            )
-            structlogger.error(
-                "azure_persistor.retrieve_tar.model_download_error",
-                container_name=self.container_name,
-                target_filename=target_filename,
-                event_info=log,
-                exception=exc,
-            )
-            raise ModelNotFound() from exc
+        with open(target_filename, "wb") as blob:
+            download_stream = blob_client.download_blob()
+            blob.write(download_stream.readall())