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

rasa/shared/core/slots.py

@@ -1,16 +1,24 @@
+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
-from rasa.shared.exceptions import RasaException
 import rasa.shared.utils.common
 import rasa.shared.utils.io
 from rasa.shared.constants import (
-    DOCS_URL_SLOTS,
-    DOCS_URL_NLU_BASED_SLOTS,
     DOCS_URL_CATEGORICAL_SLOTS,
+    DOCS_URL_NLU_BASED_SLOTS,
+    DOCS_URL_SLOTS,
+    REFILL_UTTER,
+    REJECTIONS,
+    UTTER_ASK_PREFIX,
 )
+from rasa.shared.exceptions import RasaException
 
 logger = logging.getLogger(__name__)
 
@@ -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,8 @@ class FloatSlot(Slot):
         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:
         """Creates a FloatSlot.
 
@@ -230,6 +345,8 @@ class FloatSlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
+            filled_by=filled_by,
+            validation=validation,
         )
         self.max_value = max_value
         self.min_value = min_value
@@ -387,6 +504,8 @@ class CategoricalSlot(Slot):
         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:
         """Creates a `Categorical  Slot` (see parent class for detailed docstring)."""
         super().__init__(
@@ -397,6 +516,8 @@ class CategoricalSlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
+            filled_by=filled_by,
+            validation=validation,
         )
         if values and None in values:
             rasa.shared.utils.io.raise_warning(
@@ -607,6 +728,8 @@ class AnySlot(Slot):
         influence_conversation: bool = False,
         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).
 
@@ -630,6 +753,8 @@ class AnySlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
+            filled_by=filled_by,
+            validation=validation,
         )
 
     def __eq__(self, other: Any) -> bool:
@@ -652,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,26 +6,28 @@ import os
 import time
 from collections import deque
 from enum import Enum
+from functools import cached_property
 from typing import (
-    Dict,
-    Text,
+    TYPE_CHECKING,
     Any,
-    Optional,
-    Iterator,
+    Deque,
+    Dict,
+    FrozenSet,
     Generator,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Text,
+    Tuple,
     Type,
     TypeVar,
-    List,
-    Deque,
-    Iterable,
     Union,
-    FrozenSet,
-    Tuple,
-    TYPE_CHECKING,
     cast,
 )
 
 import rasa.shared.utils.io
+from rasa.engine.language import Language
 from rasa.shared.constants import (
     ASSISTANT_ID_KEY,
     DEFAULT_SENDER_ID,
@@ -34,50 +36,52 @@ from rasa.shared.constants import (
 from rasa.shared.core import events
 from rasa.shared.core.constants import (
     ACTION_LISTEN_NAME,
-    LOOP_NAME,
-    SHOULD_NOT_BE_SET,
-    PREVIOUS_ACTION,
-    ACTIVE_LOOP,
     ACTION_SESSION_START_NAME,
+    ACTIVE_LOOP,
     FOLLOWUP_ACTION,
+    LANGUAGE_SLOT,
+    LOOP_NAME,
+    PREVIOUS_ACTION,
+    SHOULD_NOT_BE_SET,
 )
 from rasa.shared.core.conversation import Dialogue
 from rasa.shared.core.domain import Domain, State
 from rasa.shared.core.events import (
-    DialogueStackUpdated,
-    RoutingSessionEnded,
-    SlotSet,
-    UserUttered,
     ActionExecuted,
-    Event,
-    Restarted,
+    ActionExecutionRejected,
     ActionReverted,
-    UserUtteranceReverted,
-    BotUttered,
     ActiveLoop,
-    SessionStarted,
-    ActionExecutionRejected,
+    BotUttered,
     DefinePrevUserUtteredFeaturization,
+    DialogueStackUpdated,
+    Event,
     FlowStarted,
+    Restarted,
+    RoutingSessionEnded,
+    SessionStarted,
+    SlotSet,
+    UserUtteranceReverted,
+    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 (
-    ENTITY_ATTRIBUTE_VALUE,
-    ENTITY_ATTRIBUTE_TYPE,
-    ENTITY_ATTRIBUTE_GROUP,
-    ENTITY_ATTRIBUTE_ROLE,
-    ACTION_TEXT,
     ACTION_NAME,
+    ACTION_TEXT,
     ENTITIES,
+    ENTITY_ATTRIBUTE_GROUP,
+    ENTITY_ATTRIBUTE_ROLE,
+    ENTITY_ATTRIBUTE_TYPE,
+    ENTITY_ATTRIBUTE_VALUE,
     METADATA_MODEL_ID,
 )
 
 if TYPE_CHECKING:
+    from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
     from rasa.shared.core.events import NLUPredictionData
-    from rasa.shared.core.training_data.structures import Story
     from rasa.shared.core.training_data.story_writer.story_writer import StoryWriter
-    from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+    from rasa.shared.core.training_data.structures import Story
 
     EventTypeAlias = TypeVar("EventTypeAlias", bound=Event)
 
@@ -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/core/training_data/loading.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from typing import Text, Optional, List, Union
+from typing import List, Optional, Text, Union
 
 import rasa.shared.data
 import rasa.shared.utils.io

rasa/shared/core/training_data/story_reader/story_reader.py

@@ -1,14 +1,14 @@
 import logging
 from pathlib import Path
-from typing import Optional, Dict, Text, List, Any, Union
+from typing import Any, Dict, List, Optional, Text, Union
 
 from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import SlotSet, ActionExecuted, Event
-from rasa.shared.exceptions import RasaCoreException
+from rasa.shared.core.events import ActionExecuted, Event, SlotSet
 from rasa.shared.core.training_data.story_reader.story_step_builder import (
     StoryStepBuilder,
 )
 from rasa.shared.core.training_data.structures import StoryStep
+from rasa.shared.exceptions import RasaCoreException
 
 logger = logging.getLogger(__name__)
 

rasa/shared/core/training_data/story_reader/story_step_builder.py

@@ -1,17 +1,17 @@
 import logging
-from typing import Text, Optional, Dict, Any, List
+from typing import Any, Dict, List, Optional, Text
 
 import rasa.shared.core.training_data.structures
 import rasa.shared.utils.io
 from rasa.shared.constants import DOCS_URL_STORIES
-from rasa.shared.core.events import UserUttered, Event
+from rasa.shared.core.events import Event, UserUttered
 from rasa.shared.core.training_data.structures import (
-    Checkpoint,
     GENERATED_CHECKPOINT_PREFIX,
     GENERATED_HASH_LENGTH,
     STORY_START,
-    StoryStep,
+    Checkpoint,
     RuleStep,
+    StoryStep,
 )
 
 logger = logging.getLogger(__name__)

rasa/shared/core/training_data/story_reader/yaml_story_reader.py

@@ -1,60 +1,58 @@
 import copy
 import functools
 import json
-from json import JSONDecodeError
 import logging
-import structlog
-from pathlib import Path
 import re
+from json import JSONDecodeError
+from pathlib import Path
 from re import Match, Pattern
-from typing import Dict, Text, List, Any, Optional, Union, Tuple
+from typing import Any, Dict, List, Optional, Text, Tuple, Union
+
+import structlog
 
-from rasa.shared.core.domain import Domain
 import rasa.shared.data
-from rasa.shared.core.slots import TextSlot, ListSlot
-from rasa.shared.exceptions import YamlException
 import rasa.shared.utils.io
-from rasa.shared.core.constants import LOOP_NAME
+from rasa.shared.constants import (
+    DOCS_URL_RULES,
+    DOCS_URL_SLOTS,
+    DOCS_URL_STORIES,
+    INTENT_MESSAGE_PREFIX,
+    TEST_STORIES_FILE_PREFIX,
+)
+from rasa.shared.core.constants import LOOP_NAME, RULE_SNIPPET_ACTION_NAME
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import (
+    ActiveLoop,
+    DialogueStackUpdated,
+    SlotSet,
+    UserUttered,
+)
+from rasa.shared.core.slots import ListSlot, TextSlot
+from rasa.shared.core.training_data.story_reader.story_reader import StoryReader
+from rasa.shared.core.training_data.structures import StoryStep
+from rasa.shared.exceptions import YamlException
 from rasa.shared.nlu.constants import (
+    ACTION_TEXT,
     ENTITIES,
     ENTITY_ATTRIBUTE_END,
     ENTITY_ATTRIBUTE_START,
     ENTITY_ATTRIBUTE_TYPE,
     ENTITY_ATTRIBUTE_VALUE,
+    EXTRACTOR,
+    FULL_RETRIEVAL_INTENT_NAME_KEY,
     INTENT,
     INTENT_NAME_KEY,
     INTENT_RANKING_KEY,
     PREDICTED_CONFIDENCE_KEY,
-    FULL_RETRIEVAL_INTENT_NAME_KEY,
-    ACTION_TEXT,
     TEXT,
-    EXTRACTOR,
 )
 from rasa.shared.nlu.training_data import entities_parser
-
-from rasa.shared.constants import (
-    INTENT_MESSAGE_PREFIX,
-    DOCS_URL_STORIES,
-    TEST_STORIES_FILE_PREFIX,
-    DOCS_URL_RULES,
-    DOCS_URL_SLOTS,
-)
-
-from rasa.shared.core.constants import RULE_SNIPPET_ACTION_NAME
-from rasa.shared.core.events import (
-    UserUttered,
-    SlotSet,
-    ActiveLoop,
-    DialogueStackUpdated,
-)
-from rasa.shared.core.training_data.story_reader.story_reader import StoryReader
-from rasa.shared.core.training_data.structures import StoryStep
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.utils.yaml import (
-    validate_raw_yaml_using_schema_file,
+    is_key_in_yaml,
     read_yaml,
+    validate_raw_yaml_using_schema_file,
     validate_training_data_format_version,
-    is_key_in_yaml,
 )
 
 logger = logging.getLogger(__name__)

rasa/shared/core/training_data/story_writer/yaml_story_writer.py

@@ -1,55 +1,53 @@
+import json
 from collections import OrderedDict
 from pathlib import Path
-from typing import Any, Dict, List, Text, Union, Optional
+from typing import Any, Dict, List, Optional, Text, Union
 
 from ruamel import yaml
-import json
 from ruamel.yaml.comments import CommentedMap
 from ruamel.yaml.scalarstring import DoubleQuotedScalarString, LiteralScalarString
 
-import rasa.shared.utils.io
 import rasa.shared.core.constants
-from rasa.shared.constants import LATEST_TRAINING_DATA_FORMAT_VERSION
 import rasa.shared.core.events
+import rasa.shared.utils.io
+from rasa.shared.constants import LATEST_TRAINING_DATA_FORMAT_VERSION
 from rasa.shared.core.constants import FLOW_HASHES_SLOT
 from rasa.shared.core.events import (
-    UserUttered,
     ActionExecuted,
-    SlotSet,
     ActiveLoop,
-    Event,
     DialogueStackUpdated,
+    Event,
+    SlotSet,
+    UserUttered,
 )
-
 from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
-    KEY_STORIES,
-    KEY_STORY_NAME,
-    KEY_USER_INTENT,
-    KEY_ENTITIES,
     KEY_ACTION,
-    KEY_STEPS,
+    KEY_ACTIVE_LOOP,
+    KEY_BOT_END_TO_END_MESSAGE,
     KEY_CHECKPOINT,
-    KEY_SLOT_NAME,
     KEY_CHECKPOINT_SLOTS,
+    KEY_COMMANDS,
+    KEY_ENTITIES,
     KEY_OR,
-    KEY_USER_MESSAGE,
-    KEY_ACTIVE_LOOP,
-    KEY_BOT_END_TO_END_MESSAGE,
-    KEY_RULES,
-    KEY_RULE_FOR_CONVERSATION_START,
-    KEY_WAIT_FOR_USER_INPUT_AFTER_RULE,
     KEY_RULE_CONDITION,
+    KEY_RULE_FOR_CONVERSATION_START,
     KEY_RULE_NAME,
+    KEY_RULES,
+    KEY_SLOT_NAME,
     KEY_STACK_UPDATE,
-    KEY_COMMANDS,
+    KEY_STEPS,
+    KEY_STORIES,
+    KEY_STORY_NAME,
+    KEY_USER_INTENT,
+    KEY_USER_MESSAGE,
+    KEY_WAIT_FOR_USER_INPUT_AFTER_RULE,
 )
-
 from rasa.shared.core.training_data.story_writer.story_writer import StoryWriter
 from rasa.shared.core.training_data.structures import (
-    StoryStep,
-    Checkpoint,
     STORY_START,
+    Checkpoint,
     RuleStep,
+    StoryStep,
 )
 from rasa.shared.utils.yaml import write_yaml