rasa-pro 3.12.0.dev13__py3-none-any.whl → 3.12.0rc1__py3-none-any.whl

rasa/shared/core/slots.py

@@ -1,7 +1,12 @@
+from __future__ import annotations
+
 import logging
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Text, Type
 
+from pydantic import BaseModel, Field
+
 import rasa.shared.core.constants
 import rasa.shared.utils.common
 import rasa.shared.utils.io
@@ -9,6 +14,9 @@ from rasa.shared.constants import (
     DOCS_URL_CATEGORICAL_SLOTS,
     DOCS_URL_NLU_BASED_SLOTS,
     DOCS_URL_SLOTS,
+    REFILL_UTTER,
+    REJECTIONS,
+    UTTER_ASK_PREFIX,
 )
 from rasa.shared.exceptions import RasaException
 
@@ -23,6 +31,80 @@ class InvalidSlotConfigError(RasaException, ValueError):
     """Raised if a slot's config is invalid."""
 
 
+@dataclass
+class SlotRejection:
+    """A pair of validation condition and an utterance for the case of failure."""
+
+    if_: str
+    """The condition that should be checked."""
+    utter: str
+    """The utterance that should be executed if the condition is met."""
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SlotRejection:
+        """Create a SlotRejection object from serialized data.
+
+        Args:
+            data: data for a SlotRejection object in a serialized format
+
+        Returns:
+            A SlotRejection object
+        """
+        return SlotRejection(
+            if_=data["if"],
+            utter=data["utter"],
+        )
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Serialize the SlotRejection object.
+
+        Returns:
+            the SlotRejection object as serialized data
+        """
+        return {
+            "if": self.if_,
+            "utter": self.utter,
+        }
+
+
+class SlotValidation(BaseModel):
+    rejections: List[SlotRejection] = Field(alias=REJECTIONS)
+    """how the slot value is validated using predicate evaluation."""
+    refill_utter: str = Field(alias=REFILL_UTTER)
+    """The utterance that the assistant uses to ask for the slot."""
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SlotValidation:
+        """Creates a SlotValidation object from serialised data.
+
+        Args:
+            data: data for a SlotValidation object in a serialized format
+
+        Returns:
+            A SlotValidation object
+        """
+        rejections = data.get(REJECTIONS)
+        if rejections is not None:
+            rejections = [
+                SlotRejection.from_dict(rejection) for rejection in rejections
+            ]
+
+        return SlotValidation(
+            rejections=rejections, refill_utter=data.get(REFILL_UTTER)
+        )
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Serialize the SlotValidation object.
+
+        Returns:
+            the SlotValidation object as serialized data
+        """
+        return {
+            REJECTIONS: [rejection.as_dict() for rejection in self.rejections],
+            REFILL_UTTER: self.refill_utter,
+        }
+
+
 class Slot(ABC):
     """Key-value store for storing information during a conversation."""
 
@@ -42,6 +124,7 @@ class Slot(ABC):
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
         filled_by: Optional[str] = None,
+        validation: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Create a Slot.
 
@@ -59,6 +142,8 @@ class Slot(ABC):
             shared_for_coexistence: If `True` the slot is not forgotten after either
                 dm1 or CALM finishes.
             filled_by: The name of the extractor that fills the slot.
+            validation: The validation rules that should be used to validate
+                slot values.
         """
         from rasa.shared.core.slot_mappings import SlotMapping
 
@@ -73,6 +158,12 @@ class Slot(ABC):
         self.shared_for_coexistence = shared_for_coexistence
         self._filled_by = filled_by
 
+        if validation:
+            validation.setdefault(REFILL_UTTER, f"{UTTER_ASK_PREFIX}{self.name}")
+        self.validation = (
+            SlotValidation.from_dict(validation) if validation else validation
+        )
+
     def feature_dimensionality(self) -> int:
         """How many features this single slot creates.
 
@@ -191,12 +282,15 @@ class Slot(ABC):
 
     def persistence_info(self) -> Dict[str, Any]:
         """Returns relevant information to persist this slot."""
-        return {
+        persistence_info_dict = {
             "type": rasa.shared.utils.common.module_path_from_instance(self),
             "initial_value": self.initial_value,
             "influence_conversation": self.influence_conversation,
             "mappings": [mapping.as_dict() for mapping in self.mappings],
         }
+        if self.validation:
+            persistence_info_dict["validation"] = self.validation.as_dict()  # type: ignore
+        return persistence_info_dict
 
     def fingerprint(self) -> Text:
         """Returns a unique hash for the slot which is stable across python runs.
@@ -213,6 +307,10 @@ class Slot(ABC):
             return False
         return self.name == other.name and self.value == other.value
 
+    def requires_validation(self) -> bool:
+        """Indicates if the slot requires validation."""
+        return True if self.validation else False
+
 
 class FloatSlot(Slot):
     """A slot storing a float value."""
@@ -673,3 +771,35 @@ class AnySlot(Slot):
             f"implement a custom slot type by subclassing '{Slot.__name__}'. "
             f"See the documentation for more information: {DOCS_URL_NLU_BASED_SLOTS}"
         )
+
+
+class StrictCategoricalSlot(CategoricalSlot):
+    """A categorical slot that strictly enforces allowed values."""
+
+    type_name = "strict_categorical"
+
+    def coerce_value(self, value: Any) -> Any:
+        """Coerce the value to one of the allowed ones or raise an error if invalid."""
+        if value is None:
+            return value
+
+        for allowed_value in self.values:
+            # Allowed values are always stored as strings, so we can use casefold().
+            if value.casefold() == allowed_value.casefold():
+                return allowed_value
+
+        raise InvalidSlotConfigError(
+            f"Value '{value}' is not allowed for the slot '{self.name}'. "
+            f"Allowed values are: {self.values}"
+        )
+
+    @Slot.value.setter  # type: ignore[attr-defined,misc]
+    def value(self, value: Any) -> None:
+        """Set the slot's value using strict coercion."""
+        coerced_value = self.coerce_value(value)
+        super(StrictCategoricalSlot, self.__class__).value.fset(self, coerced_value)
+
+    def add_default_value(self) -> None:
+        # StrictCategoricalSlot enforces validation against a specified set of values,
+        # so default values should not be automatically added.
+        pass

rasa/shared/core/trackers.py

@@ -6,6 +6,7 @@ import os
 import time
 from collections import deque
 from enum import Enum
+from functools import cached_property
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -26,6 +27,7 @@ from typing import (
 )
 
 import rasa.shared.utils.io
+from rasa.engine.language import Language
 from rasa.shared.constants import (
     ASSISTANT_ID_KEY,
     DEFAULT_SENDER_ID,
@@ -37,6 +39,7 @@ from rasa.shared.core.constants import (
     ACTION_SESSION_START_NAME,
     ACTIVE_LOOP,
     FOLLOWUP_ACTION,
+    LANGUAGE_SLOT,
     LOOP_NAME,
     PREVIOUS_ACTION,
     SHOULD_NOT_BE_SET,
@@ -61,7 +64,8 @@ from rasa.shared.core.events import (
     UserUttered,
 )
 from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.slots import AnySlot, Slot
+from rasa.shared.core.slots import AnySlot, Slot, StrictCategoricalSlot
+from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.constants import (
     ACTION_NAME,
     ACTION_TEXT,
@@ -1097,6 +1101,75 @@ class DialogueStateTracker:
 
         return FlowsList(active_flows)
 
+    @cached_property
+    def supported_languages(self) -> List[Language]:
+        """Returns the supported languages for this model configuration
+
+        Returns:
+            A list of supported languages.
+        """
+        if LANGUAGE_SLOT not in self.slots:
+            raise RasaException(
+                f"The required slot '{LANGUAGE_SLOT}' is missing from the tracker. "
+                f"Please ensure that a slot named '{LANGUAGE_SLOT}' exists."
+            )
+
+        language_slot = self.slots[LANGUAGE_SLOT]
+
+        if not isinstance(language_slot, StrictCategoricalSlot):
+            raise RasaException(
+                f"The slot '{LANGUAGE_SLOT}' must be of type "
+                f"'{StrictCategoricalSlot.type_name}'. "
+                f"Please update the slot configuration accordingly."
+            )
+
+        return [
+            Language.from_language_code(language_code)
+            for language_code in language_slot.values
+        ]
+
+    @property
+    def current_language(self) -> Optional[Language]:
+        """Get the language of the current conversation.
+
+        Returns:
+            The language of the current conversation or `None` if not set.
+        """
+        language_code = self.get_slot("language")
+        if not language_code:
+            return None
+
+        supported_languages = self.supported_languages or []
+        matching_language = (
+            language
+            for language in supported_languages
+            if language.code == language_code
+        )
+        return next(matching_language, None)
+
+    @property
+    def default_language(self) -> Language:
+        """Get the assistant's default language.
+
+        Returns:
+            The assistant's default language.
+
+        Raises:
+            RasaException: If no default language is defined in the config.
+        """
+        supported_languages = self.supported_languages or []
+        matching_language = (
+            language for language in supported_languages if language.is_default is True
+        )
+        try:
+            return next(matching_language)
+        except StopIteration:
+            raise RasaException(
+                "No default language configured. "
+                "Please configure the `language` parameter in config.yml file. "
+                "Example: `language: en`."
+            )
+
 
 class TrackerEventDiffEngine:
     """Computes event difference of two trackers."""

rasa/shared/importers/importer.py

@@ -20,16 +20,19 @@ import rasa.shared.constants
 import rasa.shared.core.constants
 import rasa.shared.utils.common
 import rasa.shared.utils.io
+from rasa.shared.constants import CONFIG_ADDITIONAL_LANGUAGES_KEY, CONFIG_LANGUAGE_KEY
 from rasa.shared.core.domain import (
     IS_RETRIEVAL_INTENT_KEY,
     KEY_ACTIONS,
     KEY_E2E_ACTIONS,
     KEY_INTENTS,
     KEY_RESPONSES,
+    KEY_SLOTS,
     Domain,
 )
 from rasa.shared.core.events import ActionExecuted, UserUttered
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.slots import StrictCategoricalSlot
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.nlu.constants import ACTION_NAME, ENTITIES
 from rasa.shared.nlu.training_data.message import Message
@@ -202,8 +205,10 @@ class TrainingDataImporter(ABC):
                 )
             ]
 
-        return E2EImporter(
-            FlowSyncImporter(ResponsesSyncImporter(CombinedDataImporter(importers)))
+        return LanguageImporter(
+            E2EImporter(
+                FlowSyncImporter(ResponsesSyncImporter(CombinedDataImporter(importers)))
+            )
         )
 
     @staticmethod
@@ -522,6 +527,49 @@ class FlowSyncImporter(PassThroughImporter):
         return self._importer.get_domain()
 
 
+class LanguageImporter(PassThroughImporter):
+    """Importer that configures the language settings in the domain."""
+
+    @cached_method
+    def get_domain(self) -> Domain:
+        domain = self._importer.get_domain()
+        if domain.is_empty():
+            return domain
+
+        config = self._importer.get_config()
+        language = config.get(CONFIG_LANGUAGE_KEY)
+        additional_languages = config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY) or []
+
+        values = additional_languages.copy()
+        if language and language not in values:
+            values.append(language)
+
+        # Prepare the serialized representation of the language slot
+        slot_name = rasa.shared.core.constants.LANGUAGE_SLOT
+        serialized_slot: Dict[Text, Any] = {
+            "type": StrictCategoricalSlot.type_name,
+            "initial_value": language,
+            "values": values,
+            "mappings": [],
+            "is_builtin": True,
+        }
+
+        domain_with_language_slot = Domain.from_dict(
+            {KEY_SLOTS: {slot_name: serialized_slot}}
+        )
+        return domain.merge(domain_with_language_slot)
+
+    @cached_method
+    def get_user_domain(self) -> Domain:
+        """Delegate to the underlying importer to get the user domain."""
+        return self._importer.get_user_domain()
+
+    @cached_method
+    def get_user_flows(self) -> FlowsList:
+        """Delegate to the underlying importer to get user flows."""
+        return self._importer.get_user_flows()
+
+
 class ResponsesSyncImporter(PassThroughImporter):
     """Importer that syncs `responses` between Domain and NLU training data.
 

rasa/shared/nlu/training_data/schemas/responses.yml

@@ -17,6 +17,12 @@ schema;responses:
             required: False
           text:
             type: "str"
+          translation:
+            type: "map"
+            allowempty: True
+            mapping:
+              regex;(.*):
+                type: "str"
           image:
             type: "str"
           custom:
@@ -32,6 +38,18 @@ schema;responses:
                   type: "str"
                 payload:
                   type: "str"
+                translation:
+                  type: "map"
+                  allowempty: True
+                  mapping:
+                    regex;(.*):
+                      type: "map"
+                      allowempty: True
+                      mapping:
+                        title:
+                          type: "str"
+                        payload:
+                          type: "str"
           button_type:
             type: "str"
           quick_replies:
@@ -57,15 +75,4 @@ schema;responses:
           metadata:
             type: "any"
           condition:
-            type: "seq"
-            sequence:
-              - type: "map"
-                allowempty: False
-                mapping:
-                  type:
-                    type: "str"
-                    enum: ['slot']
-                  name:
-                    type: "str"
-                  value:
-                    type: "any"
+            type: "any"