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

rasa/shared/core/slot_mappings.py

@@ -1,23 +1,40 @@
 from __future__ import annotations
 
 import copy
-import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, Union, cast
+from enum import Enum
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Text,
+    Tuple,
+    Union,
+    cast,
+)
 
+import structlog
 from pydantic import BaseModel, Field
 
 import rasa.shared.utils.io
 from rasa.shared.constants import DOCS_URL_NLU_BASED_SLOTS, IGNORED_INTENTS
 from rasa.shared.core.constants import (
+    ACTION_EXTRACT_SLOTS,
+    ACTION_VALIDATE_SLOT_MAPPINGS,
     ACTIVE_LOOP,
     KEY_ACTION,
+    KEY_COEXISTENCE_SYSTEM,
     KEY_MAPPING_TYPE,
     KEY_RUN_ACTION_EVERY_TURN,
     MAPPING_CONDITIONS,
     REQUESTED_SLOT,
     SlotMappingType,
 )
+from rasa.shared.core.events import BotUttered, Event, SlotSet
 from rasa.shared.core.slots import ListSlot, Slot
+from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.constants import (
     ENTITIES,
     ENTITY_ATTRIBUTE_GROUP,
@@ -30,13 +47,14 @@ from rasa.shared.nlu.constants import (
 )
 
 if TYPE_CHECKING:
+    from rasa.core.channels.channel import OutputChannel
+    from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.domain import Domain
     from rasa.shared.core.trackers import DialogueStateTracker
     from rasa.shared.nlu.training_data.message import Message
     from rasa.utils.endpoints import EndpointConfig
 
-
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 class SlotMappingCondition(BaseModel):
@@ -58,6 +76,12 @@ class SlotMappingCondition(BaseModel):
         return self.model_dump(exclude_none=True)
 
 
+class CoexistenceSystemType(Enum):
+    NLU = "NLU"
+    CALM = "CALM"
+    SHARED = "SHARED"
+
+
 class SlotMapping(BaseModel):
     """Defines functionality for the available slot mappings."""
 
@@ -71,6 +95,7 @@ class SlotMapping(BaseModel):
     value: Optional[Any] = None
     allow_nlu_correction: Optional[bool] = None
     run_action_every_turn: Optional[str] = None
+    coexistence_system: Optional[CoexistenceSystemType] = None
 
     @staticmethod
     def from_dict(data: Dict[str, Any], slot_name: str) -> SlotMapping:
@@ -92,10 +117,16 @@ class SlotMapping(BaseModel):
 
         run_action_every_turn = data_copy.pop(KEY_RUN_ACTION_EVERY_TURN, None)
 
+        coexistence_system = data_copy.pop(KEY_COEXISTENCE_SYSTEM, None)
+        coexistence_system_type = (
+            CoexistenceSystemType(coexistence_system) if coexistence_system else None
+        )
+
         return SlotMapping(
             type=mapping_type,
             conditions=conditions,
             run_action_every_turn=run_action_every_turn,
+            coexistence_system=coexistence_system_type,
             **data_copy,
         )
 
@@ -324,6 +355,7 @@ class SlotFillingManager:
         self.tracker = tracker
         self.message = message
         self._action_endpoint = action_endpoint
+        self.executed_custom_actions: Set[str] = set()
 
     def is_slot_mapping_valid(
         self,
@@ -524,6 +556,173 @@ class SlotFillingManager:
 
         return True
 
+    @staticmethod
+    def should_fill_slot_in_coexistence(
+        is_calm_system: bool,
+        slot: Slot,
+        calm_slot_names: Set[str],
+    ) -> bool:
+        """Check if a slot should be filled in a coexistence assistant."""
+        if slot.shared_for_coexistence:
+            return True
+
+        coexistence_systems = [
+            mapping.coexistence_system
+            for mapping in slot.mappings
+            if mapping.type == SlotMappingType.CONTROLLED
+        ]
+
+        if not is_calm_system and (
+            slot.name in calm_slot_names
+            or CoexistenceSystemType.CALM in coexistence_systems
+        ):
+            return False
+
+        if is_calm_system and (
+            slot.name not in calm_slot_names
+            or CoexistenceSystemType.NLU in coexistence_systems
+        ):
+            return False
+
+        return True
+
+    async def run_action_at_every_turn(
+        self,
+        slot: Slot,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+    ) -> List[Event]:
+        """Runs a custom action at every turn to fill a slot.
+
+        This executes only if the slot has a controlled mapping type
+        with the `run_action_every_turn` key set.
+        """
+        slot_events: List[Event] = []
+        for mapping in slot.mappings:
+            should_fill_controlled_slot = mapping.type == SlotMappingType.CONTROLLED
+
+            if not should_fill_controlled_slot:
+                continue
+
+            custom_events = await self._execute_custom_action(
+                mapping,
+                output_channel,
+                nlg,
+            )
+            slot_events.extend(custom_events)
+
+        return slot_events
+
+    async def _execute_custom_action(
+        self,
+        mapping: "SlotMapping",
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+    ) -> List[Event]:
+        custom_action = mapping.run_action_every_turn
+
+        if not custom_action or custom_action in self.executed_custom_actions:
+            return []
+
+        slot_events = await self._run_custom_action(custom_action, output_channel, nlg)
+
+        self.executed_custom_actions.add(custom_action)
+
+        return slot_events
+
+    async def _run_custom_action(
+        self,
+        custom_action: str,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        recreate_tracker: bool = False,
+    ) -> List[Event]:
+        from rasa.core.actions.action import RemoteAction
+        from rasa.shared.core.trackers import DialogueStateTracker
+        from rasa.utils.endpoints import ClientResponseError
+
+        slot_events: List[Event] = []
+        remote_action = RemoteAction(custom_action, self._action_endpoint)
+        disallowed_types = set()
+
+        tracker = (
+            DialogueStateTracker.from_events(
+                self.tracker.sender_id,
+                self.tracker.events_after_latest_restart() + slot_events,
+                slots=self.domain.slots,
+            )
+            if recreate_tracker
+            else self.tracker
+        )
+
+        try:
+            custom_events = await remote_action.run(
+                output_channel, nlg, tracker, self.domain
+            )
+            for event in custom_events:
+                if isinstance(event, SlotSet):
+                    slot_events.append(event)
+                elif isinstance(event, BotUttered):
+                    slot_events.append(event)
+                else:
+                    disallowed_types.add(event.type_name)
+        except (RasaException, ClientResponseError) as e:
+            structlogger.warning(
+                "slot_filling_manager.run_custom_action_failed",
+                failed_custom_action=custom_action,
+                event_info=f"Failed to execute custom action '{custom_action}' "
+                f"as a result of error '{e!s}'. The default action "
+                f"'{ACTION_EXTRACT_SLOTS}' failed to fill slots with custom "
+                f"mappings.",
+            )
+
+        for type_name in disallowed_types:
+            structlogger.info(
+                "slot_filling_manager.run_custom_action_disallowed_event",
+                custom_action_name=custom_action,
+                disallowed_evet_type=type_name,
+                event_info=f"Running custom action '{custom_action}' has resulted "
+                f"in an event of type '{type_name}'. This is "
+                f"disallowed and the tracker will not be "
+                f"updated with this event.",
+            )
+
+        return slot_events
+
+    async def execute_validation_action(
+        self,
+        extraction_events: List[Event],
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+    ) -> List[Event]:
+        slot_events: List[SlotSet] = [
+            event for event in extraction_events if isinstance(event, SlotSet)
+        ]
+
+        slot_candidates = "\n".join([e.key for e in slot_events])
+        structlogger.debug(
+            "slot_filling_manager.execute_validation_action",
+            slot_candidates=slot_candidates,
+            event_info=f"Validating extracted slots: {slot_candidates}",
+        )
+
+        if ACTION_VALIDATE_SLOT_MAPPINGS not in self.domain.user_actions:
+            return cast(List[Event], slot_events)
+
+        validate_events = await self._run_custom_action(
+            ACTION_VALIDATE_SLOT_MAPPINGS, output_channel, nlg, recreate_tracker=True
+        )
+        validated_slot_names = [
+            event.key for event in validate_events if isinstance(event, SlotSet)
+        ]
+
+        # If the custom action doesn't return a SlotSet event for an extracted slot
+        # candidate we assume that it was valid. The custom action has to return a
+        # SlotSet(slot_name, None) event to mark a Slot as invalid.
+        return validate_events + [
+            event for event in slot_events if event.key not in validated_slot_names
+        ]
+
 
 def extract_slot_value(
     slot: Slot, slot_filling_manager: SlotFillingManager
@@ -554,7 +753,11 @@ def extract_slot_value(
                 value is not None
                 or slot_filling_manager.tracker.get_slot(slot.name) is not None
             ):
-                logger.debug(f"Extracted value '{value}' for slot '{slot.name}'.")
+                structlogger.debug(
+                    "slot_filling_manager.extract_slot_value",
+                    slot_name=slot.name,
+                    event_info=f"Extracted value '{value}' for slot '{slot.name}'.",
+                )
 
                 is_extracted = True
                 return value, is_extracted

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."""
@@ -231,6 +329,7 @@ class FloatSlot(Slot):
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
         filled_by: Optional[str] = None,
+        validation: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Creates a FloatSlot.
 
@@ -247,6 +346,7 @@ class FloatSlot(Slot):
             is_builtin,
             shared_for_coexistence,
             filled_by=filled_by,
+            validation=validation,
         )
         self.max_value = max_value
         self.min_value = min_value
@@ -405,6 +505,7 @@ class CategoricalSlot(Slot):
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
         filled_by: Optional[str] = None,
+        validation: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Creates a `Categorical  Slot` (see parent class for detailed docstring)."""
         super().__init__(
@@ -416,6 +517,7 @@ class CategoricalSlot(Slot):
             is_builtin,
             shared_for_coexistence,
             filled_by=filled_by,
+            validation=validation,
         )
         if values and None in values:
             rasa.shared.utils.io.raise_warning(
@@ -627,6 +729,7 @@ class AnySlot(Slot):
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
         filled_by: Optional[str] = None,
+        validation: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Creates an `Any  Slot` (see parent class for detailed docstring).
 
@@ -651,6 +754,7 @@ class AnySlot(Slot):
             is_builtin,
             shared_for_coexistence,
             filled_by=filled_by,
+            validation=validation,
         )
 
     def __eq__(self, other: Any) -> bool:
@@ -673,3 +777,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."""