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

rasa/core/lock_store.py

@@ -2,18 +2,27 @@ from __future__ import annotations
 
 import asyncio
 import json
-import logging
 import os
 from contextlib import asynccontextmanager
-from typing import AsyncGenerator, Dict, Optional, Text, Union
+from typing import Any, AsyncGenerator, Dict, Literal, Optional, Text, Union
+
+import structlog
+from pydantic import (
+    AnyUrl,
+    BaseModel,
+    Field,
+    NonNegativeInt,
+    model_validator,
+)
 
 import rasa.shared.utils.common
 from rasa.core.constants import DEFAULT_LOCK_LIFETIME
 from rasa.core.lock import TicketLock
 from rasa.shared.exceptions import ConnectionException, RasaException
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils.endpoints import EndpointConfig
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.getLogger(__name__)
 
 
 def _get_lock_lifetime() -> int:
@@ -76,7 +85,10 @@ class LockStore:
 
         Creates a new lock if none is found.
         """
-        logger.debug(f"Issuing ticket for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "lock_store.issue_ticket",
+            event_info=f"Issuing ticket for conversation '{conversation_id}'.",
+        )
         try:
             lock = self.get_or_create_lock(conversation_id)
             ticket = lock.issue_ticket(lock_lifetime)
@@ -109,7 +121,10 @@ class LockStore:
     async def _acquire_lock(
         self, conversation_id: Text, ticket: int, wait_time_in_seconds: float
     ) -> TicketLock:
-        logger.debug(f"Acquiring lock for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "lock_store._acquiring_lock_for_conversation",
+            event_info=f"Acquiring lock for conversation '{conversation_id}'.",
+        )
         while True:
             # fetch lock in every iteration because lock might no longer exist
             lock = self.get_lock(conversation_id)
@@ -120,16 +135,22 @@ class LockStore:
 
             # acquire lock if it isn't locked
             if not lock.is_locked(ticket):
-                logger.debug(f"Acquired lock for conversation '{conversation_id}'.")
+                structlogger.debug(
+                    "lock_store._acquired_lock_for_conversation",
+                    event_info=f"Acquired lock for conversation '{conversation_id}'.",
+                )
                 return lock
 
             items_before_this = ticket - (lock.now_serving or 0)
 
-            logger.debug(
-                f"Failed to acquire lock for conversation ID '{conversation_id}' "
-                f"because {items_before_this} other item(s) for this "
-                f"conversation ID have to be finished processing first. "
-                f"Retrying in {wait_time_in_seconds} seconds ..."
+            structlogger.debug(
+                "lock_store._retrying_lock_acquisition",
+                event_info=(
+                    f"Failed to acquire lock for conversation ID '{conversation_id}' "
+                    f"because {items_before_this} other item(s) for this "
+                    f"conversation ID have to be finished processing first. "
+                    f"Retrying in {wait_time_in_seconds} seconds ..."
+                ),
             )
 
             # sleep and update lock
@@ -186,9 +207,99 @@ class LockStore:
     @staticmethod
     def _log_deletion(conversation_id: Text, deletion_successful: bool) -> None:
         if deletion_successful:
-            logger.debug(f"Deleted lock for conversation '{conversation_id}'.")
+            structlogger.debug(
+                "lock_store._deleted_lock_for_conversation",
+                event_info=f"Deleted lock for conversation '{conversation_id}'.",
+            )
         else:
-            logger.debug(f"Could not delete lock for conversation '{conversation_id}'.")
+            structlogger.debug(
+                "lock_store._failed_to_delete_lock_for_conversation",
+                event_info=(
+                    f"Could not delete lock for conversation '{conversation_id}'."
+                ),
+            )
+
+
+class RedisLockStoreConfig(BaseModel):
+    host: Union[AnyUrl, Literal["localhost"]] = Field(
+        default="localhost", description="The host of the redis server."
+    )
+    port: NonNegativeInt = Field(
+        default=6379, ge=0, le=65535, description="The port of the redis server."
+    )
+    db: NonNegativeInt = Field(
+        default=0,
+        ge=0,
+        description="The name of the database within Redis "
+        "which should be used by Rasa",
+    )
+    username: Optional[str] = Field(
+        default=None,
+        description="The username which should be used for "
+        "authentication with the Redis database.",
+    )
+    password: Optional[str] = Field(
+        default=None,
+        description="The username which should be used for "
+        "authentication with the Redis database.",
+    )
+    use_ssl: bool = Field(
+        default=False,
+        serialization_alias="ssl",
+        description="True if SSL should be used for the connection to Redis.",
+    )
+    ssl_certfile: Optional[str] = Field(
+        default=None,
+        description="Path to the SSL certificate file.",
+    )
+    ssl_keyfile: Optional[str] = Field(
+        default=None, description="Path to the SSL private key file."
+    )
+    ssl_ca_certs: Optional[str] = Field(
+        default=None, description="Path to the SSL CA certificate file."
+    )
+    key_prefix: Optional[str] = Field(
+        default=None,
+        description="Prefix to prepend to all keys "
+        "used by the lock store. Must be alphanumeric.",
+    )
+    socket_timeout: float = Field(
+        default=DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
+        description="Timeout in seconds after which an exception "
+        "will be raised in case Redis doesn't respond "
+        "within `socket_timeout` seconds.",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_url_and_host_properties(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            if bool(data.get("url", None)) and bool(data.get("host", None)):
+                raise RasaException(
+                    "You cannot specify both 'url' and 'host' in the Redis lock store "
+                    "configuration. Please use only one of them."
+                )
+
+            if data.get("url", None):
+                raise_deprecation_warning(
+                    "The 'url' property in the redis lock store "
+                    "configuration is deprecated. Please use 'host' instead."
+                )
+                data["host"] = data.pop("url")
+        return data
+
+    @model_validator(mode="after")
+    def verify_username_password(self) -> RedisLockStoreConfig:
+        if bool(self.username) ^ bool(self.password):
+            raise ValueError(
+                f"Expected username and password. "
+                f"Found: username: {'<has value>' if self.username else '<N/A>'}, "
+                f"password: {'<has value>' if self.password else '<N/A>'}"
+            )
+        return self
+
+    def to_strict_redis(self) -> Dict[str, Any]:
+        return self.model_dump(by_alias=True, exclude={"key_prefix"})
 
 
 class RedisLockStore(LockStore):
@@ -196,57 +307,28 @@ class RedisLockStore(LockStore):
 
     def __init__(
         self,
-        host: Text = "localhost",
-        port: int = 6379,
-        db: int = 1,
-        username: Optional[Text] = None,
-        password: Optional[Text] = None,
-        use_ssl: bool = False,
-        ssl_certfile: Optional[Text] = None,
-        ssl_keyfile: Optional[Text] = None,
-        ssl_ca_certs: Optional[Text] = None,
-        key_prefix: Optional[Text] = None,
-        socket_timeout: float = DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
+        config: RedisLockStoreConfig = RedisLockStoreConfig(),
     ) -> None:
         """Create a lock store which uses Redis for persistence.
 
         Args:
-            host: The host of the redis server.
-            port: The port of the redis server.
-            db: The name of the database within Redis which should be used by Rasa
-                Open Source.
-            username: The username which should be used for authentication with the
-                Redis database.
-            password: The password which should be used for authentication with the
-                Redis database.
-            use_ssl: `True` if SSL should be used for the connection to Redis.
-            ssl_certfile: Path to the SSL certificate file.
-            ssl_keyfile: Path to the SSL private key file.
-            ssl_ca_certs: Path to the SSL CA certificate file.
-            key_prefix: prefix to prepend to all keys used by the lock store. Must be
-                alphanumeric.
-            socket_timeout: Timeout in seconds after which an exception will be raised
-                in case Redis doesn't respond within `socket_timeout` seconds.
+            config: Redis lock store configuration.
         """
         import redis
 
-        self.red = redis.StrictRedis(
-            host=host,
-            port=int(port),
-            db=int(db),
-            username=username,
-            password=password,
-            ssl=use_ssl,
-            ssl_certfile=ssl_certfile,
-            ssl_keyfile=ssl_keyfile,
-            ssl_ca_certs=ssl_ca_certs,
-            socket_timeout=socket_timeout,
-        )
+        self.config = config
+        self.red = redis.StrictRedis(**self.config.to_strict_redis())
 
         self.key_prefix = DEFAULT_REDIS_LOCK_STORE_KEY_PREFIX
-        if key_prefix:
-            logger.debug(f"Setting non-default redis key prefix: '{key_prefix}'.")
-            self._set_key_prefix(key_prefix)
+        if self.config.key_prefix:
+            structlogger.debug(
+                "redis_lock_store._set_key_prefix.non_default_key_prefix",
+                event_info=(
+                    f"Setting non-default "
+                    f"redis key prefix: '{self.config.key_prefix}'.",
+                ),
+            )
+            self._set_key_prefix(self.config.key_prefix)
 
         super().__init__()
 
@@ -254,9 +336,13 @@ class RedisLockStore(LockStore):
         if isinstance(key_prefix, str) and key_prefix.isalnum():
             self.key_prefix = key_prefix + ":" + DEFAULT_REDIS_LOCK_STORE_KEY_PREFIX
         else:
-            logger.warning(
-                f"Omitting provided non-alphanumeric redis key prefix: '{key_prefix}'. "
-                f"Using default '{self.key_prefix}' instead."
+            structlogger.warning(
+                "redis_lock_store._set_key_prefix.default_instead_of_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_lock(self, conversation_id: Text) -> Optional[TicketLock]:
@@ -313,7 +399,9 @@ def _create_from_endpoint_config(
 
         lock_store: LockStore = InMemoryLockStore()
     elif endpoint_config.type == "redis":
-        lock_store = RedisLockStore(host=endpoint_config.url, **endpoint_config.kwargs)
+        config = RedisLockStoreConfig.model_validate(endpoint_config.to_dict())
+
+        lock_store = RedisLockStore(config)
     elif endpoint_config.type == "concurrent_redis":
         from rasa.core.concurrent_lock_store import ConcurrentRedisLockStore
 
@@ -321,7 +409,10 @@ def _create_from_endpoint_config(
     else:
         lock_store = _load_from_module_name_in_endpoint_config(endpoint_config)
 
-    logger.debug(f"Connected to lock store '{lock_store.__class__.__name__}'.")
+    structlogger.debug(
+        "lock_store._create_from_endpoint_config.lock_store_connected",
+        event_info=f"Connected to lock store '{lock_store.__class__.__name__}'.",
+    )
 
     return lock_store
 

rasa/core/nlg/contextual_response_rephraser.py

@@ -17,6 +17,7 @@ from rasa.shared.constants import (
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
     TEMPERATURE_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
@@ -38,6 +39,7 @@ from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_GENERATE_MODEL_NAME,
     DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     USER,
+    check_prompt_config_keys_and_warn_if_deprecated,
     combine_custom_and_default_config,
     get_prompt_template,
     llm_factory,
@@ -110,8 +112,15 @@ class ContextualResponseRephraser(
         super().__init__(domain.responses)
 
         self.nlg_endpoint = endpoint_config
+
+        # Warn if the prompt config key is used to set the prompt template
+        check_prompt_config_keys_and_warn_if_deprecated(
+            self.nlg_endpoint.kwargs, "contextual_response_rephraser"
+        )
+
         self.prompt_template = get_prompt_template(
-            self.nlg_endpoint.kwargs.get(PROMPT_CONFIG_KEY),
+            self.nlg_endpoint.kwargs.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            or self.nlg_endpoint.kwargs.get(PROMPT_CONFIG_KEY),
             DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
             log_source_component=ContextualResponseRephraser.__name__,
             log_source_method=LOG_COMPONENT_SOURCE_METHOD_INIT,
@@ -215,10 +224,8 @@ class ContextualResponseRephraser(
 
     @measure_llm_latency
     async def _generate_llm_response(self, prompt: str) -> Optional[LLMResponse]:
-        """Use LLM to generate a response.
-
-        Returns an LLMResponse object containing both the generated text
-        (choices) and metadata.
+        """Use LLM to generate a response, returning an LLMResponse object
+        containing both the generated text (choices) and metadata.
 
         Args:
             prompt: The prompt to send to the LLM.
@@ -399,9 +406,12 @@ class ContextualResponseRephraser(
         Returns:
             The generated response.
         """
-        templated_response = await super().generate(
+        filled_slots = tracker.current_slot_values()
+        stack_context = tracker.stack.current_context()
+        templated_response = self.generate_from_slots(
             utter_action=utter_action,
-            tracker=tracker,
+            filled_slots=filled_slots,
+            stack_context=stack_context,
             output_channel=output_channel,
             **kwargs,
         )

rasa/core/nlg/generator.py

@@ -6,8 +6,6 @@ from pypred import Predicate
 
 import rasa.shared.utils.common
 import rasa.shared.utils.io
-from rasa.core.nlg.translate import has_translation
-from rasa.engine.language import Language
 from rasa.shared.constants import CHANNEL, RESPONSE_CONDITION
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -133,23 +131,11 @@ class ResponseVariationFilter:
 
         return True
 
-    def _filter_by_language(
-        self, responses: List[Dict[Text, Any]], language: Optional[Language] = None
-    ) -> List[Dict[Text, Any]]:
-        if not language:
-            return responses
-
-        if filtered := [r for r in responses if has_translation(r, language)]:
-            return filtered
-        # if no translation is found, return the original response variations
-        return responses
-
     def responses_for_utter_action(
         self,
         utter_action: Text,
         output_channel: Text,
         filled_slots: Dict[Text, Any],
-        language: Optional[Language] = None,
     ) -> List[Dict[Text, Any]]:
         """Returns array of responses that fit the channel, action and condition."""
         # filter responses without a condition
@@ -190,16 +176,16 @@ class ResponseVariationFilter:
         )
 
         if conditional_channel:
-            return self._filter_by_language(conditional_channel, language)
+            return conditional_channel
 
         if default_channel:
-            return self._filter_by_language(default_channel, language)
+            return default_channel
 
         if conditional_no_channel:
-            return self._filter_by_language(conditional_no_channel, language)
+            return conditional_no_channel
 
         if default_no_channel:
-            return self._filter_by_language(default_no_channel, language)
+            return default_no_channel
 
         # if there is no response variation selected,
         # return the internal error response to prevent
@@ -212,9 +198,7 @@ class ResponseVariationFilter:
             f"a default variation and that all the conditions are valid. "
             f"Returning the internal error response.",
         )
-        return self._filter_by_language(
-            self.responses.get("utter_internal_error_rasa", []), language
-        )
+        return self.responses.get("utter_internal_error_rasa", [])
 
     def get_response_variation_id(
         self,
@@ -308,7 +292,6 @@ def _evaluate_predicate(constraint: str, filled_slots: Dict[Text, Any]) -> bool:
         structlogger.error(
             "rasa.core.nlg.generator.evaluate_conditional_response_predicate.error",
             predicate=constraint,
-            document=document,
             error=str(e),
         )
         return False

rasa/core/nlg/interpolator.py

@@ -1,4 +1,3 @@
-import copy
 import logging
 import re
 from typing import Any, Dict, List, Text, Union
@@ -70,9 +69,9 @@ def interpolate_format_template(response: Text, values: Dict[Text, Text]) -> Tex
         )
         structlogger.exception(
             "interpolator.interpolate.text",
-            response=copy.deepcopy(response),
             placeholder_key=e.args[0],
             event_info=event_info,
+            error=str(e),
         )
         return response
 
@@ -98,9 +97,9 @@ def interpolate_jinja_template(response: Text, values: Dict[Text, Any]) -> Text:
         )
         structlogger.exception(
             "interpolator.interpolate.text",
-            response=copy.deepcopy(response),
             placeholder_key=e.args[0],
             event_info=event_info,
+            error=str(e),
         )
         return response
 

rasa/core/nlg/response.py

@@ -5,11 +5,8 @@ from typing import Any, Dict, List, Optional, Text
 from rasa.core.constants import DEFAULT_TEMPLATE_ENGINE, TEMPLATE_ENGINE_CONFIG_KEY
 from rasa.core.nlg import interpolator
 from rasa.core.nlg.generator import NaturalLanguageGenerator, ResponseVariationFilter
-from rasa.core.nlg.translate import get_translated_buttons, get_translated_text
-from rasa.engine.language import Language
-from rasa.shared.constants import BUTTONS, RESPONSE_CONDITION, TEXT
+from rasa.shared.constants import RESPONSE_CONDITION
 from rasa.shared.core.domain import RESPONSE_KEYS_TO_INTERPOLATE
-from rasa.shared.core.flows.constants import KEY_TRANSLATION
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import METADATA
 
@@ -33,11 +30,7 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
 
     # noinspection PyUnusedLocal
     def _random_response_for(
-        self,
-        utter_action: Text,
-        output_channel: Text,
-        filled_slots: Dict[Text, Any],
-        language: Optional[Language] = None,
+        self, utter_action: Text, output_channel: Text, filled_slots: Dict[Text, Any]
     ) -> Optional[Dict[Text, Any]]:
         """Select random response for the utter action from available ones.
 
@@ -49,7 +42,7 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
         if utter_action in self.responses:
             response_filter = ResponseVariationFilter(self.responses)
             suitable_responses = response_filter.responses_for_utter_action(
-                utter_action, output_channel, filled_slots, language
+                utter_action, output_channel, filled_slots
             )
 
             if suitable_responses:
@@ -82,36 +75,9 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
         """Generate a response for the requested utter action."""
         filled_slots = tracker.current_slot_values()
         stack_context = tracker.stack.current_context()
-        response = self.generate_from_slots(
-            utter_action,
-            filled_slots,
-            stack_context,
-            output_channel,
-            tracker.current_language,
-            **kwargs,
+        return self.generate_from_slots(
+            utter_action, filled_slots, stack_context, output_channel, **kwargs
         )
-        if response is not None:
-            return self.translate_response(response, tracker.current_language)
-        return None
-
-    def translate_response(
-        self, response: Dict[Text, Any], language: Optional[Language] = None
-    ) -> Dict[Text, Any]:
-        message_copy = copy.deepcopy(response)
-
-        text = get_translated_text(
-            text=message_copy.pop(TEXT, None),
-            translation=message_copy.pop(KEY_TRANSLATION, {}),
-            language=language,
-        )
-
-        buttons = get_translated_buttons(
-            buttons=message_copy.pop(BUTTONS, None), language=language
-        )
-        message_copy[TEXT] = text
-        if buttons:
-            message_copy[BUTTONS] = buttons
-        return message_copy
 
     def generate_from_slots(
         self,
@@ -119,15 +85,12 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
         filled_slots: Dict[Text, Any],
         stack_context: Dict[Text, Any],
         output_channel: Text,
-        language: Optional[Language] = None,
         **kwargs: Any,
     ) -> Optional[Dict[Text, Any]]:
         """Generate a response for the requested utter action."""
         # Fetching a random response for the passed utter action
         r = copy.deepcopy(
-            self._random_response_for(
-                utter_action, output_channel, filled_slots, language
-            )
+            self._random_response_for(utter_action, output_channel, filled_slots)
         )
         # Filling the slots in the response with placeholders and returning the response
         if r is not None:

rasa/core/nlg/summarize.py

@@ -4,7 +4,7 @@ from typing import Callable, List, Optional
 import structlog
 from jinja2 import Template
 
-from rasa.core.tracker_store import DialogueStateTracker
+from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,

rasa/core/nlg/translate.py

@@ -23,14 +23,6 @@ def get_translated_text(
     return translation.get(language_code, text)
 
 
-def has_translation(
-    message: Dict[Text, Any], language: Optional[Language] = None
-) -> bool:
-    """Check if the message has a translation for the given language."""
-    language_code = language.code if language else None
-    return language_code in message.get(KEY_TRANSLATION, {})
-
-
 def get_translated_buttons(
     buttons: Optional[List[Dict[Text, Any]]], language: Optional[Language] = None
 ) -> Optional[List[Dict[Text, Any]]]: