rasa-pro 3.11.5__py3-none-any.whl → 3.12.0__py3-none-any.whl

rasa/core/lock.py

@@ -1,9 +1,8 @@
 import json
 import logging
-from collections import deque
-
 import time
-from typing import Text, Optional, Union, Deque, Dict, Any
+from collections import deque
+from typing import Any, Deque, Dict, Optional, Text, Union
 
 logger = logging.getLogger(__name__)
 

rasa/core/lock_store.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
+
 import asyncio
-from contextlib import asynccontextmanager
 import json
 import logging
 import os
-
+from contextlib import asynccontextmanager
 from typing import AsyncGenerator, Dict, Optional, Text, Union
 
-from rasa.shared.exceptions import RasaException, ConnectionException
 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.utils.endpoints import EndpointConfig
 
 logger = logging.getLogger(__name__)

rasa/core/migrate.py

@@ -1,28 +1,31 @@
 import copy
 import shutil
 from pathlib import Path
-from typing import List, Dict, Text, Any, Tuple, Optional, Union
+from typing import Any, Dict, List, Optional, Text, Tuple, Union
 
 from ruamel.yaml.scalarstring import DoubleQuotedScalarString
 
-import rasa.shared.utils.io
 import rasa.shared.utils.cli
-from rasa.shared.constants import REQUIRED_SLOTS_KEY, IGNORED_INTENTS
+import rasa.shared.utils.io
+from rasa.shared.constants import (
+    IGNORED_INTENTS,
+    LATEST_TRAINING_DATA_FORMAT_VERSION,
+    REQUIRED_SLOTS_KEY,
+)
 from rasa.shared.core.constants import (
     ACTIVE_LOOP,
+    KEY_MAPPING_TYPE,
     REQUESTED_SLOT,
-    SlotMappingType,
-    MAPPING_TYPE,
     SLOT_MAPPINGS,
+    SlotMappingType,
 )
-from rasa.shared.constants import LATEST_TRAINING_DATA_FORMAT_VERSION
-from rasa.shared.core.domain import KEY_ENTITIES, KEY_SLOTS, KEY_FORMS, Domain
+from rasa.shared.core.domain import KEY_ENTITIES, KEY_FORMS, KEY_SLOTS, Domain
 from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.yaml import (
     KEY_TRAINING_DATA_FORMAT_VERSION,
     read_yaml,
-    write_yaml,
     read_yaml_file,
+    write_yaml,
 )
 
 ORIGINAL_DOMAIN = "original_domain"  # not a default, fixed
@@ -40,7 +43,7 @@ def _create_back_up(domain_file: Path, backup_location: Path) -> Dict[Text, Any]
 def _get_updated_mapping_condition(
     condition: Dict[Text, Text], mapping: Dict[Text, Any], slot_name: Text
 ) -> Dict[Text, Text]:
-    if mapping.get(MAPPING_TYPE) not in [
+    if mapping.get(KEY_MAPPING_TYPE) not in [
         str(SlotMappingType.FROM_ENTITY),
         str(SlotMappingType.FROM_TRIGGER_INTENT),
     ]:

rasa/core/nlg/__init__.py

@@ -1,3 +1,3 @@
+from rasa.core.nlg.callback import CallbackNaturalLanguageGenerator  # noqa: F401
 from rasa.core.nlg.generator import NaturalLanguageGenerator  # noqa: F401
 from rasa.core.nlg.response import TemplatedNaturalLanguageGenerator  # noqa: F401
-from rasa.core.nlg.callback import CallbackNaturalLanguageGenerator  # noqa: F401

rasa/core/nlg/callback.py

@@ -1,6 +1,6 @@
 import json
 import logging
-from typing import List, Text, Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Text
 
 from rasa.core.constants import DEFAULT_REQUEST_TIMEOUT
 from rasa.core.nlg.generator import NaturalLanguageGenerator, ResponseVariationFilter
@@ -100,8 +100,7 @@ class CallbackNaturalLanguageGenerator(NaturalLanguageGenerator):
     @staticmethod
     def validate_response(content: Optional[Dict[Text, Any]]) -> bool:
         """Validate the NLG response. Raises exception on failure."""
-        from jsonschema import validate
-        from jsonschema import ValidationError
+        from jsonschema import ValidationError, validate
 
         try:
             if content is None or content == "":

rasa/core/nlg/contextual_response_rephraser.py

@@ -2,22 +2,31 @@ from typing import Any, Dict, Optional, Text
 
 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_CONFIG_KEY,
     MODEL_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
+    OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
     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.nlu.constants import (
+    KEY_COMPONENT_NAME,
+    KEY_LLM_RESPONSE_METADATA,
+    KEY_PROMPT_NAME,
+    KEY_USER_PROMPT,
+    PROMPTS,
+)
+from rasa.shared.providers.llm.llm_response import LLMResponse, measure_llm_latency
 from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_GENERATE_MODEL_NAME,
@@ -27,8 +36,6 @@ from rasa.shared.utils.llm import (
     get_prompt_template,
     llm_factory,
     resolve_model_client_config,
-)
-from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
 )
 from rasa.utils.endpoints import EndpointConfig
@@ -57,7 +64,7 @@ DEFAULT_LLM_CONFIG = {
 DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE = """The following is a conversation with
 an AI assistant. The assistant is helpful, creative, clever, and very friendly.
 Rephrase the suggested AI response staying close to the original message and retaining
-its meaning. Use simple english.
+its meaning. Use simple {{language}}.
 
 Context / previous conversation with the user:
 {{history}}
@@ -124,6 +131,55 @@ class ContextualResponseRephraser(
             ContextualResponseRephraser.__name__,
         )
 
+    @classmethod
+    def _add_prompt_and_llm_metadata_to_response(
+        cls,
+        response: Dict[str, Any],
+        prompt_name: str,
+        user_prompt: str,
+        llm_response: Optional["LLMResponse"] = None,
+    ) -> Dict[str, Any]:
+        """Stores the prompt and LLMResponse metadata to response.
+
+        Args:
+            response: The response to add the prompt and LLMResponse metadata to.
+            prompt_name: A name identifying prompt usage.
+            user_prompt: The user prompt that was sent to the LLM.
+            llm_response: The response object from the LLM (None if no response).
+        """
+        from rasa.dialogue_understanding.utils import record_commands_and_prompts
+
+        if not record_commands_and_prompts:
+            return response
+
+        prompt_data: Dict[Text, Any] = {
+            KEY_COMPONENT_NAME: cls.__name__,
+            KEY_PROMPT_NAME: prompt_name,
+            KEY_USER_PROMPT: user_prompt,
+            KEY_LLM_RESPONSE_METADATA: llm_response.to_dict() if llm_response else None,
+        }
+
+        prompts = response.get(PROMPTS, [])
+        prompts.append(prompt_data)
+        response[PROMPTS] = prompts
+        return response
+
+    @staticmethod
+    def get_language_label(tracker: DialogueStateTracker) -> str:
+        """Fetches the label of the language to be used for the rephraser.
+
+        Args:
+            tracker: The tracker to get the language from.
+
+        Returns:
+            The label of the current language, or "English" if no language is set.
+        """
+        return (
+            tracker.current_language.label
+            if tracker.current_language
+            else tracker.default_language.label
+        )
+
     def _last_message_if_human(self, tracker: DialogueStateTracker) -> Optional[str]:
         """Returns the latest message from the tracker.
 
@@ -142,20 +198,21 @@ class ContextualResponseRephraser(
                 return None
         return None
 
-    async def _generate_llm_response(self, prompt: str) -> Optional[str]:
-        """Use LLM to generate a response.
+    @measure_llm_latency
+    async def _generate_llm_response(self, prompt: str) -> Optional[LLMResponse]:
+        """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
+            prompt: The prompt to send to the LLM.
 
         Returns:
-            generated text
+            An LLMResponse object if successful, otherwise None.
         """
         llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
 
         try:
-            llm_response = await llm.acompletion(prompt)
-            return llm_response.choices[0]
+            return await llm.acompletion(prompt)
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here
@@ -240,6 +297,7 @@ class ContextualResponseRephraser(
             suggested_response=response_text,
             current_input=current_input,
             slots=tracker.current_slot_values(),
+            language=self.get_language_label(tracker),
         )
         log_llm(
             logger=structlogger,
@@ -255,11 +313,21 @@ class ContextualResponseRephraser(
             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
-            # return the original response.
+        llm_response = await self._generate_llm_response(prompt)
+        llm_response = LLMResponse.ensure_llm_response(llm_response)
+
+        response = self._add_prompt_and_llm_metadata_to_response(
+            response=response,
+            prompt_name="rephrase_prompt",
+            user_prompt=prompt,
+            llm_response=llm_response,
+        )
+
+        if not (llm_response and llm_response.choices and llm_response.choices[0]):
+            # If the LLM fails to generate a response, return the original response.
             return response
 
+        updated_text = llm_response.choices[0]
         structlogger.debug(
             "nlg.rewrite.complete",
             response_text=response_text,

rasa/core/nlg/generator.py

@@ -1,14 +1,17 @@
-import logging
-from typing import List, Optional, Union, Text, Any, Dict
+from typing import Any, Dict, List, Optional, Text, Union
+
+import structlog
+from jinja2 import Template
+from pypred import Predicate
 
 import rasa.shared.utils.common
 import rasa.shared.utils.io
 from rasa.shared.constants import CHANNEL, RESPONSE_CONDITION
 from rasa.shared.core.domain import Domain
-from rasa.utils.endpoints import EndpointConfig
 from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.utils.endpoints import EndpointConfig
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 class NaturalLanguageGenerator:
@@ -74,7 +77,11 @@ def _create_from_endpoint_config(
     else:
         nlg = _load_from_module_name_in_endpoint_config(endpoint_config, domain)
 
-    logger.debug(f"Instantiated NLG to '{nlg.__class__.__name__}'.")
+    structlogger.debug(
+        "rasa.core.nlg.generator.create",
+        nlg_class_name=nlg.__class__.__name__,
+        event_info=f"Instantiated NLG to '{nlg.__class__.__name__}'.",
+    )
     return nlg
 
 
@@ -112,18 +119,15 @@ class ResponseVariationFilter:
     ) -> bool:
         """Checks if the conditional response variation matches the filled slots."""
         constraints = response.get(RESPONSE_CONDITION, [])
-        for constraint in constraints:
-            name = constraint["name"]
-            value = constraint["value"]
-            filled_slots_value = filled_slots.get(name)
-            if isinstance(filled_slots_value, str) and isinstance(value, str):
-                if filled_slots_value.casefold() != value.casefold():
+        if isinstance(constraints, str) and not _evaluate_predicate(
+            constraints, filled_slots
+        ):
+            return False
+
+        elif isinstance(constraints, list):
+            for constraint in constraints:
+                if not _evaluate_and_deprecate_condition(constraint, filled_slots):
                     return False
-            # slot values can be of different data types
-            # such as int, float, bool, etc. hence, this check
-            # executes when slot values are not strings
-            elif filled_slots_value != value:
-                return False
 
         return True
 
@@ -180,7 +184,21 @@ class ResponseVariationFilter:
         if conditional_no_channel:
             return conditional_no_channel
 
-        return default_no_channel
+        if default_no_channel:
+            return default_no_channel
+
+        # if there is no response variation selected,
+        # return the internal error response to prevent
+        # the bot from staying silent
+        structlogger.error(
+            "rasa.core.nlg.generator.responses_for_utter_action.no_response",
+            utter_action=utter_action,
+            event_info=f"No response variation selected for the predicted "
+            f"utterance {utter_action}. Please check you have provided "
+            f"a default variation and that all the conditions are valid. "
+            f"Returning the internal error response.",
+        )
+        return self.responses.get("utter_internal_error_rasa", [])
 
     def get_response_variation_id(
         self,
@@ -228,3 +246,53 @@ class ResponseVariationFilter:
             response_ids.add(response_variation_id)
 
         return True
+
+
+def _evaluate_and_deprecate_condition(
+    constraint: Dict[Text, Any], filled_slots: Dict[Text, Any]
+) -> bool:
+    """Evaluates the condition of a response variation."""
+    rasa.shared.utils.io.raise_deprecation_warning(
+        "Using a dictionary as a condition in a response variation is deprecated. "
+        "Please use a pypred string predicate instead. "
+        "Dictionary conditions will be removed in Rasa Open Source 4.0.0 .",
+        warn_until_version="4.0.0",
+    )
+
+    name = constraint["name"]
+    value = constraint["value"]
+    filled_slots_value = filled_slots.get(name)
+    if isinstance(filled_slots_value, str) and isinstance(value, str):
+        if filled_slots_value.casefold() != value.casefold():
+            return False
+    # slot values can be of different data types
+    # such as int, float, bool, etc. hence, this check
+    # executes when slot values are not strings
+    elif filled_slots_value != value:
+        return False
+
+    return True
+
+
+def _evaluate_predicate(constraint: str, filled_slots: Dict[Text, Any]) -> bool:
+    """Evaluates the condition of a response variation."""
+    context = {"slots": filled_slots}
+    document = context.copy()
+    try:
+        rendered_template = Template(constraint).render(context)
+        predicate = Predicate(rendered_template)
+        result = predicate.evaluate(document)
+        structlogger.debug(
+            "rasa.core.nlg.generator.evaluate_conditional_response_predicate",
+            predicate=predicate.description(),
+            result=result,
+        )
+        return result
+    except (TypeError, Exception) as e:
+        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,10 +1,11 @@
 import copy
-import re
 import logging
-from jinja2 import Template
+import re
+from typing import Any, Dict, List, Text, Union
+
 import jinja2
 import structlog
-from typing import Text, Dict, Union, Any, List
+from jinja2 import Template
 
 from rasa.core.constants import JINJA2_TEMPLATE_ENGINE, RASA_FORMAT_TEMPLATE_ENGINE
 

rasa/core/nlg/response.py

@@ -1,14 +1,13 @@
 import copy
 import logging
-from rasa.core.constants import DEFAULT_TEMPLATE_ENGINE, TEMPLATE_ENGINE_CONFIG_KEY
-
-from rasa.shared.core.trackers import DialogueStateTracker
-from typing import Text, Any, Dict, Optional, List
+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.shared.constants import RESPONSE_CONDITION
 from rasa.shared.core.domain import RESPONSE_KEYS_TO_INTERPOLATE
+from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import METADATA
 
 logger = logging.getLogger(__name__)
@@ -50,9 +49,12 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
                 selected_response = np.random.choice(suitable_responses)
                 condition = selected_response.get(RESPONSE_CONDITION)
                 if condition:
-                    formatted_response_conditions = self._format_response_conditions(
-                        condition
-                    )
+                    if isinstance(condition, list):
+                        formatted_response_conditions = (
+                            self._format_response_conditions(condition)
+                        )
+                    else:
+                        formatted_response_conditions = condition
                     logger.debug(
                         "Selecting response variation with conditions:"
                         f"{formatted_response_conditions}"

rasa/core/nlg/summarize.py

@@ -2,6 +2,7 @@ from typing import Optional
 
 import structlog
 from jinja2 import Template
+
 from rasa.core.tracker_store import DialogueStateTracker
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.utils.llm import (

rasa/core/nlg/translate.py

@@ -0,0 +1,55 @@
+from typing import Any, Dict, List, Optional, Text
+
+from rasa.engine.language import Language
+from rasa.shared.core.flows.constants import KEY_TRANSLATION
+
+
+def get_translated_text(
+    text: Optional[Text],
+    translation: Dict[Text, Any],
+    language: Optional[Language] = None,
+) -> Optional[Text]:
+    """Get the translated text from the message.
+
+    Args:
+        text: The default text to use if no translation is found.
+        translation: The translations for the text.
+        language: The language to use for the translation.
+
+    Returns:
+        The translated text if found, otherwise the default text.
+    """
+    language_code = language.code if language else None
+    return translation.get(language_code, text)
+
+
+def get_translated_buttons(
+    buttons: Optional[List[Dict[Text, Any]]], language: Optional[Language] = None
+) -> Optional[List[Dict[Text, Any]]]:
+    """Get the translated buttons from the message.
+
+    Args:
+        buttons: The default buttons to use if no translation is found.
+        language: The language to use for the translation.
+
+    Returns:
+        The translated buttons if found; otherwise, the default buttons.
+    """
+    if buttons is None:
+        return None
+
+    language_code = language.code if language else None
+    translated_buttons = []
+    for button in buttons:
+        translation = button.get(KEY_TRANSLATION, {})
+        language_translation = translation.get(language_code, {})
+
+        # Maintain the original key order to ensure
+        # accurate comparisons of BotUtter events.
+        translated_button = {
+            key: language_translation.get(key, button.get(key))
+            for key, value in button.items()
+            if key != KEY_TRANSLATION
+        }
+        translated_buttons.append(translated_button)
+    return translated_buttons

rasa/core/persistor.py

@@ -9,14 +9,13 @@ 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 (
+    DEFAULT_BUCKET_NAME,
     HTTP_STATUS_FORBIDDEN,
     HTTP_STATUS_NOT_FOUND,
     MODEL_ARCHIVE_EXTENSION,
-    DEFAULT_BUCKET_NAME,
 )
 from rasa.env import (
     AWS_ENDPOINT_URL_ENV,
@@ -26,6 +25,7 @@ from rasa.env import (
     BUCKET_NAME_ENV,
     REMOTE_STORAGE_PATH_ENV,
 )
+from rasa.exceptions import ModelNotFound
 from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.io import raise_warning
 
@@ -367,8 +367,8 @@ class GCSPersistor(Persistor):
         self.bucket = self.storage_client.bucket(bucket_name)
 
     def _ensure_bucket_exists(self, bucket_name: Text) -> None:
-        from google.cloud import exceptions
         from google.auth import exceptions as auth_exceptions
+        from google.cloud import exceptions
 
         try:
             self.storage_client.get_bucket(bucket_name)

rasa/core/policies/ensemble.py

@@ -1,22 +1,23 @@
 from __future__ import annotations
-from abc import abstractmethod, ABC
-from typing import Optional, Text, List, Dict, Any
+
 import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Text
 
+from rasa.core.policies.policy import PolicyPrediction
 from rasa.engine.graph import GraphComponent
-from rasa.engine.storage.storage import ModelStorage
-from rasa.engine.storage.resource import Resource
 from rasa.engine.runner.interface import ExecutionContext
-from rasa.core.policies.policy import PolicyPrediction
-from rasa.shared.exceptions import RasaException, InvalidConfigException
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import (
-    ActionExecutionRejected,
     ActionExecuted,
+    ActionExecutionRejected,
     DefinePrevUserUtteredFeaturization,
 )
 from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import InvalidConfigException, RasaException
 
 logger = logging.getLogger(__name__)
 
@@ -34,11 +35,11 @@ def is_not_in_training_data(
         `False` if and only if an action was predicted (i.e. `max_confidence` > 0) by
         a `MemoizationPolicy`
     """
-    from rasa.core.policies.rule_policy import RulePolicy
     from rasa.core.policies.memoization import (
-        MemoizationPolicy,
         AugmentedMemoizationPolicy,
+        MemoizationPolicy,
     )
+    from rasa.core.policies.rule_policy import RulePolicy
 
     if not policy_name:
         return True