rasa-pro 3.12.0.dev12__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."""
 
@@ -41,6 +123,8 @@ class Slot(ABC):
         influence_conversation: bool = True,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
+        filled_by: Optional[str] = None,
+        validation: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Create a Slot.
 
@@ -57,9 +141,14 @@ class Slot(ABC):
                 such as `return_value`.
             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
+
         self.name = name
-        self.mappings = mappings
+        self.mappings = [SlotMapping.from_dict(mapping, name) for mapping in mappings]
         self._value = initial_value
         self.initial_value = initial_value
         self._value_reset_delay = value_reset_delay
@@ -67,6 +156,13 @@ class Slot(ABC):
         self._has_been_set = False
         self.is_builtin = is_builtin
         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.
@@ -132,6 +228,16 @@ class Slot(ABC):
         self._value = value
         self._has_been_set = True
 
+    @property
+    def filled_by(self) -> Optional[str]:
+        """Gets the slot's latest value extractor."""
+        return self._filled_by
+
+    @filled_by.setter
+    def filled_by(self, extractor: str) -> None:
+        """Sets the slot's latest value extractor."""
+        self._filled_by = extractor
+
     def has_same_coerced_value(self, other_value: Any) -> bool:
         """Checks if the coerced value of is the same as the slot value.
 
@@ -176,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": self.mappings,
+            "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.
@@ -198,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."""
@@ -215,6 +328,7 @@ class FloatSlot(Slot):
         influence_conversation: bool = True,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Creates a FloatSlot.
 
@@ -230,6 +344,7 @@ class FloatSlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
+            filled_by=filled_by,
         )
         self.max_value = max_value
         self.min_value = min_value
@@ -387,6 +502,7 @@ class CategoricalSlot(Slot):
         influence_conversation: bool = True,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Creates a `Categorical  Slot` (see parent class for detailed docstring)."""
         super().__init__(
@@ -397,6 +513,7 @@ class CategoricalSlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
+            filled_by=filled_by,
         )
         if values and None in values:
             rasa.shared.utils.io.raise_warning(
@@ -607,6 +724,7 @@ class AnySlot(Slot):
         influence_conversation: bool = False,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Creates an `Any  Slot` (see parent class for detailed docstring).
 
@@ -630,6 +748,7 @@ class AnySlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
+            filled_by=filled_by,
         )
 
     def __eq__(self, other: Any) -> bool:
@@ -652,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,
@@ -916,11 +920,13 @@ class DialogueStateTracker:
                 continue
             slot.reset()
 
-    def _set_slot(self, key: Text, value: Any) -> None:
+    def _set_slot(self, key: Text, value: Any, filled_by: Optional[str] = None) -> None:
         """Sets the value of a slot if that slot exists."""
         if key in self.slots:
             slot = self.slots[key]
             slot.value = value
+            if filled_by is not None:
+                slot.filled_by = filled_by
         else:
             logger.error(
                 f"Tried to set non existent slot '{key}'. Make sure you "
@@ -1095,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/constants.py

@@ -55,3 +55,4 @@ SPLIT_ENTITIES_BY_COMMA_DEFAULT_VALUE = True
 SINGLE_ENTITY_ALLOWED_INTERLEAVING_CHARSET = {".", ",", " ", ";"}
 
 SET_SLOT_COMMAND = "set slot"
+HANDLE_DIGRESSIONS_COMMAND = "handle digressions"

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"