rasa-pro 3.12.0.dev11__py3-none-any.whl → 3.12.0.dev12__py3-none-any.whl

rasa/shared/core/slot_mappings.py

@@ -1,20 +1,15 @@
-from __future__ import annotations
-
-import copy
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, Union, cast
-
-from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, cast
 
 import rasa.shared.utils.io
 from rasa.shared.constants import DOCS_URL_NLU_BASED_SLOTS, IGNORED_INTENTS
 from rasa.shared.core.constants import (
+    ACTIVE_FLOW,
     ACTIVE_LOOP,
-    KEY_ACTION,
-    KEY_MAPPING_TYPE,
-    KEY_RUN_ACTION_EVERY_TURN,
     MAPPING_CONDITIONS,
+    MAPPING_TYPE,
     REQUESTED_SLOT,
+    SLOT_MAPPINGS,
     SlotMappingType,
 )
 from rasa.shared.core.slots import ListSlot, Slot
@@ -26,6 +21,7 @@ from rasa.shared.nlu.constants import (
     ENTITY_ATTRIBUTE_VALUE,
     INTENT,
     INTENT_NAME_KEY,
+    NOT_INTENT,
     TEXT,
 )
 
@@ -39,81 +35,11 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class SlotMappingCondition(BaseModel):
-    """Defines a condition for a slot mapping."""
-
-    active_loop: Optional[str]
-    requested_slot: Optional[str] = None
-    active_flow: Optional[str] = None
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> SlotMappingCondition:
-        # we allow None as a valid value for active_loop
-        # therefore we need to set a different default value
-        active_loop = data.pop(ACTIVE_LOOP, "")
-
-        return SlotMappingCondition(active_loop=active_loop, **data)
-
-    def as_dict(self) -> Dict[str, Any]:
-        return self.model_dump(exclude_none=True)
-
-
-class SlotMapping(BaseModel):
+class SlotMapping:
     """Defines functionality for the available slot mappings."""
 
-    type: SlotMappingType
-    conditions: List[SlotMappingCondition] = Field(default_factory=list)
-    entity: Optional[str] = None
-    intent: Optional[Union[str, List[str]]] = None
-    role: Optional[str] = None
-    group: Optional[str] = None
-    not_intent: Optional[Union[str, List[str]]] = None
-    value: Optional[Any] = None
-    allow_nlu_correction: Optional[bool] = None
-    run_action_every_turn: Optional[str] = None
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any], slot_name: str) -> SlotMapping:
-        data_copy = copy.deepcopy(data)
-        mapping_type = SlotMapping.validate_mapping(data_copy, slot_name)
-        conditions = [
-            SlotMappingCondition.from_dict(condition)
-            for condition in data_copy.pop(MAPPING_CONDITIONS, [])
-        ]
-
-        deprecated_action = data_copy.pop(KEY_ACTION, None)
-        if deprecated_action:
-            rasa.shared.utils.io.raise_deprecation_warning(
-                f"The `{KEY_ACTION}` key in slot mappings is deprecated and "
-                f"will be removed in Rasa Pro 4.0.0. "
-                f"Please use the `{KEY_RUN_ACTION_EVERY_TURN}` key instead.",
-            )
-            data_copy[KEY_RUN_ACTION_EVERY_TURN] = deprecated_action
-
-        run_action_every_turn = data_copy.pop(KEY_RUN_ACTION_EVERY_TURN, None)
-
-        return SlotMapping(
-            type=mapping_type,
-            conditions=conditions,
-            run_action_every_turn=run_action_every_turn,
-            **data_copy,
-        )
-
-    def as_dict(self) -> Dict[str, Any]:
-        data = self.model_dump(mode="json", exclude_none=True)
-        data[KEY_MAPPING_TYPE] = self.type.value
-
-        if self.conditions:
-            data[MAPPING_CONDITIONS] = [
-                condition.as_dict() for condition in self.conditions
-            ]
-        else:
-            data.pop(MAPPING_CONDITIONS, None)
-
-        return data
-
     @staticmethod
-    def validate_mapping(mapping: Dict[str, Any], slot_name: str) -> SlotMappingType:
+    def validate(mapping: Dict[Text, Any], slot_name: Text) -> None:
         """Validates a slot mapping.
 
         Args:
@@ -132,22 +58,12 @@ class SlotMapping(BaseModel):
                 f"{DOCS_URL_NLU_BASED_SLOTS} for more information."
             )
 
-        mapping_raw = mapping.pop(KEY_MAPPING_TYPE, SlotMappingType.FROM_LLM.value)
-
-        if mapping_raw == "custom":
-            rasa.shared.utils.io.raise_deprecation_warning(
-                "The `custom` slot mapping type is deprecated and "
-                "will be removed in Rasa Pro 4.0.0. "
-                "Please use the `controlled` slot mapping type instead.",
-            )
-            mapping_raw = "controlled"
-
         try:
-            mapping_type = SlotMappingType(mapping_raw)
+            mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
         except ValueError:
             raise InvalidDomain(
                 f"Your domain uses an invalid slot mapping of type "
-                f"'{mapping_raw}' for slot '{slot_name}'. Please see "
+                f"'{mapping.get(MAPPING_TYPE)}' for slot '{slot_name}'. Please see "
                 f"{DOCS_URL_NLU_BASED_SLOTS} for more information."
             )
 
@@ -156,7 +72,7 @@ class SlotMapping(BaseModel):
             SlotMappingType.FROM_INTENT: ["value"],
             SlotMappingType.FROM_TRIGGER_INTENT: ["value"],
             SlotMappingType.FROM_TEXT: [],
-            SlotMappingType.CONTROLLED: [],
+            SlotMappingType.CUSTOM: [],
             SlotMappingType.FROM_LLM: [],
         }
 
@@ -170,18 +86,19 @@ class SlotMapping(BaseModel):
                     f"{DOCS_URL_NLU_BASED_SLOTS} for more information."
                 )
 
-        return mapping_type
-
+    @staticmethod
     def _get_active_loop_ignored_intents(
-        self, domain: "Domain", active_loop_name: Text
+        mapping: Dict[Text, Any], domain: "Domain", active_loop_name: Text
     ) -> List[Text]:
-        mapping_conditions = self.conditions
+        from rasa.shared.core.constants import ACTIVE_LOOP
+
+        mapping_conditions = mapping.get(MAPPING_CONDITIONS)
         active_loop_match = True
         ignored_intents = []
 
         if mapping_conditions:
             match_list = [
-                condition.active_loop == active_loop_name
+                condition.get(ACTIVE_LOOP) == active_loop_name
                 for condition in mapping_conditions
             ]
             active_loop_match = any(match_list)
@@ -194,21 +111,24 @@ class SlotMapping(BaseModel):
 
         return ignored_intents
 
+    @staticmethod
     def intent_is_desired(
-        self,
+        mapping: Dict[Text, Any],
         tracker: "DialogueStateTracker",
         domain: "Domain",
         message: Optional["Message"] = None,
     ) -> bool:
         """Checks whether user intent matches slot mapping intent specifications."""
-        mapping_intents = SlotMapping.to_list(self.intent)
-        mapping_not_intents = SlotMapping.to_list(self.not_intent)
+        mapping_intents = SlotMapping.to_list(mapping.get(INTENT, []))
+        mapping_not_intents = SlotMapping.to_list(mapping.get(NOT_INTENT, []))
 
         active_loop_name = tracker.active_loop_name
         if active_loop_name:
             mapping_not_intents = (
                 mapping_not_intents
-                + self._get_active_loop_ignored_intents(domain, active_loop_name)
+                + SlotMapping._get_active_loop_ignored_intents(
+                    mapping, domain, active_loop_name
+                )
             )
 
         if message is not None:
@@ -235,14 +155,16 @@ class SlotMapping(BaseModel):
 
         return x
 
+    @staticmethod
     def entity_is_desired(
-        self,
+        mapping: Dict[Text, Any],
         tracker: "DialogueStateTracker",
         message: Optional["Message"] = None,
     ) -> List[str]:
         """Checks whether slot should be filled by an entity in the input or not.
 
         Args:
+            mapping: Slot mapping.
             tracker: The tracker.
             message: The message being processed.
 
@@ -254,16 +176,19 @@ class SlotMapping(BaseModel):
             matching_values = [
                 cast(Text, entity[ENTITY_ATTRIBUTE_VALUE])
                 for entity in extracted_entities
-                if entity.get(ENTITY_ATTRIBUTE_TYPE) == self.entity
-                and entity.get(ENTITY_ATTRIBUTE_GROUP) == self.group
-                and entity.get(ENTITY_ATTRIBUTE_ROLE) == self.role
+                if entity.get(ENTITY_ATTRIBUTE_TYPE)
+                == mapping.get(ENTITY_ATTRIBUTE_TYPE)
+                and entity.get(ENTITY_ATTRIBUTE_GROUP)
+                == mapping.get(ENTITY_ATTRIBUTE_GROUP)
+                and entity.get(ENTITY_ATTRIBUTE_ROLE)
+                == mapping.get(ENTITY_ATTRIBUTE_ROLE)
             ]
         elif tracker.latest_message and tracker.latest_message.text is not None:
             matching_values = list(
                 tracker.get_latest_entity_values(
-                    self.entity,
-                    self.role,
-                    self.group,
+                    mapping.get(ENTITY_ATTRIBUTE_TYPE),
+                    mapping.get(ENTITY_ATTRIBUTE_ROLE),
+                    mapping.get(ENTITY_ATTRIBUTE_GROUP),
                 )
             )
         else:
@@ -271,38 +196,45 @@ class SlotMapping(BaseModel):
 
         return matching_values
 
+    @staticmethod
     def check_mapping_validity(
-        self,
         slot_name: Text,
+        mapping_type: SlotMappingType,
+        mapping: Dict[Text, Any],
         domain: "Domain",
     ) -> bool:
         """Checks the mapping for validity.
 
         Args:
             slot_name: The name of the slot to be validated.
+            mapping_type: The type of the slot mapping.
+            mapping: Slot mapping.
             domain: The domain to check against.
 
         Returns:
             True, if intent and entity specified in a mapping exist in domain.
         """
         if (
-            self.type == SlotMappingType.FROM_ENTITY
-            and self.entity not in domain.entities
+            mapping_type == SlotMappingType.FROM_ENTITY
+            and mapping.get(ENTITY_ATTRIBUTE_TYPE) not in domain.entities
         ):
             rasa.shared.utils.io.raise_warning(
                 f"Slot '{slot_name}' uses a 'from_entity' mapping "
-                f"for a non-existent entity '{self.entity}'. "
+                f"for a non-existent entity '{mapping.get(ENTITY_ATTRIBUTE_TYPE)}'. "
                 f"Skipping slot extraction because of invalid mapping."
             )
             return False
 
-        if self.type == SlotMappingType.FROM_INTENT and self.intent is not None:
-            intent_list = SlotMapping.to_list(self.intent)
+        if (
+            mapping_type == SlotMappingType.FROM_INTENT
+            and mapping.get(INTENT) is not None
+        ):
+            intent_list = SlotMapping.to_list(mapping.get(INTENT))
             for intent in intent_list:
                 if intent and intent not in domain.intents:
                     rasa.shared.utils.io.raise_warning(
                         f"Slot '{slot_name}' uses a 'from_intent' mapping for "
-                        f"a non-existent intent '{intent}'. "
+                        f"a non-existent intent '{mapping.get('intent')}'. "
                         f"Skipping slot extraction because of invalid mapping."
                     )
                     return False
@@ -310,6 +242,22 @@ class SlotMapping(BaseModel):
         return True
 
 
+def validate_slot_mappings(domain_slots: Dict[Text, Any]) -> None:
+    """Raises InvalidDomain exception if slot mappings are invalid."""
+    rasa.shared.utils.io.raise_warning(
+        f"Slot auto-fill has been removed in 3.0 and replaced with a "
+        f"new explicit mechanism to set slots. "
+        f"Please refer to {DOCS_URL_NLU_BASED_SLOTS} to learn more.",
+        UserWarning,
+    )
+
+    for slot_name, properties in domain_slots.items():
+        mappings = properties.get(SLOT_MAPPINGS, [])
+
+        for slot_mapping in mappings:
+            SlotMapping.validate(slot_mapping, slot_name)
+
+
 class SlotFillingManager:
     """Manages slot filling based on conversation context."""
 
@@ -328,34 +276,41 @@ class SlotFillingManager:
     def is_slot_mapping_valid(
         self,
         slot_name: str,
-        mapping: SlotMapping,
+        mapping_type: SlotMappingType,
+        mapping: Dict[str, Any],
     ) -> bool:
         """Check if a slot mapping is valid."""
-        return mapping.check_mapping_validity(
+        return SlotMapping.check_mapping_validity(
             slot_name=slot_name,
+            mapping_type=mapping_type,
+            mapping=mapping,
             domain=self.domain,
         )
 
-    def is_intent_desired(self, mapping: SlotMapping) -> bool:
+    def is_intent_desired(self, mapping: Dict[str, Any]) -> bool:
         """Check if the intent matches the one indicated in the slot mapping."""
-        return mapping.intent_is_desired(
+        return SlotMapping.intent_is_desired(
+            mapping=mapping,
             tracker=self.tracker,
             domain=self.domain,
             message=self.message,
         )
 
-    def _verify_mapping_conditions(self, mapping: SlotMapping, slot_name: Text) -> bool:
-        if mapping.conditions and mapping.type != str(
+    def _verify_mapping_conditions(
+        self, mapping: Dict[Text, Any], slot_name: Text
+    ) -> bool:
+        if mapping.get(MAPPING_CONDITIONS) and mapping[MAPPING_TYPE] != str(
             SlotMappingType.FROM_TRIGGER_INTENT
         ):
-            return self._matches_mapping_conditions(mapping, slot_name)
+            if not self._matches_mapping_conditions(mapping, slot_name):
+                return False
 
         return True
 
     def _matches_mapping_conditions(
-        self, mapping: SlotMapping, slot_name: Text
+        self, mapping: Dict[Text, Any], slot_name: Text
     ) -> bool:
-        slot_mapping_conditions = mapping.conditions
+        slot_mapping_conditions = mapping.get(MAPPING_CONDITIONS)
 
         if not slot_mapping_conditions:
             return True
@@ -373,20 +328,20 @@ class SlotFillingManager:
     @staticmethod
     def _mapping_conditions_match_flow(
         active_flow: str,
-        slot_mapping_conditions: List[SlotMappingCondition],
+        slot_mapping_conditions: List[Dict[str, str]],
     ) -> bool:
         active_flow_conditions = list(
-            filter(lambda x: x.active_flow is not None, slot_mapping_conditions)
+            filter(lambda x: x.get(ACTIVE_FLOW) is not None, slot_mapping_conditions)
         )
         return any(
             [
-                condition.active_flow == active_flow
+                condition.get(ACTIVE_FLOW) == active_flow
                 for condition in active_flow_conditions
             ]
         )
 
     def _mapping_conditions_match_form(
-        self, slot_name: str, slot_mapping_conditions: List[SlotMappingCondition]
+        self, slot_name: str, slot_mapping_conditions: List[Dict[str, str]]
     ) -> bool:
         if (
             self.tracker.is_active_loop_rejected
@@ -396,10 +351,12 @@ class SlotFillingManager:
 
         # check if found mapping conditions matches form
         for condition in slot_mapping_conditions:
-            active_loop = condition.active_loop
+            # we allow None as a valid value for active_loop
+            # therefore we need to set a different default value
+            active_loop = condition.get(ACTIVE_LOOP, "")
 
             if active_loop and active_loop == self.tracker.active_loop_name:
-                condition_requested_slot = condition.requested_slot
+                condition_requested_slot = condition.get(REQUESTED_SLOT)
                 if not condition_requested_slot:
                     return True
                 if condition_requested_slot == self.tracker.get_slot(REQUESTED_SLOT):
@@ -413,11 +370,11 @@ class SlotFillingManager:
     def _fails_unique_entity_mapping_check(
         self,
         slot_name: Text,
-        mapping: SlotMapping,
+        mapping: Dict[Text, Any],
     ) -> bool:
         from rasa.core.actions.forms import FormAction
 
-        if mapping.type != SlotMappingType.FROM_ENTITY:
+        if mapping[MAPPING_TYPE] != str(SlotMappingType.FROM_ENTITY):
             return False
 
         form_name = self.tracker.active_loop_name
@@ -438,9 +395,12 @@ class SlotFillingManager:
 
         return True
 
-    def _is_trigger_intent_mapping_condition_met(self, mapping: SlotMapping) -> bool:
+    def _is_trigger_intent_mapping_condition_met(
+        self, mapping: Dict[Text, Any]
+    ) -> bool:
         active_loops_in_mapping_conditions = [
-            condition.active_loop for condition in mapping.conditions
+            condition.get(ACTIVE_LOOP)
+            for condition in mapping.get(MAPPING_CONDITIONS, [])
         ]
 
         trigger_mapping_condition_met = True
@@ -461,7 +421,7 @@ class SlotFillingManager:
     def extract_slot_value_from_predefined_mapping(
         self,
         mapping_type: SlotMappingType,
-        mapping: SlotMapping,
+        mapping: Dict[Text, Any],
     ) -> List[Any]:
         """Extracts slot value if slot has an applicable predefined mapping."""
         if (
@@ -494,9 +454,9 @@ class SlotFillingManager:
         value: List[Any] = []
 
         if should_fill_entity_slot:
-            value = mapping.entity_is_desired(self.tracker, self.message)
+            value = SlotMapping.entity_is_desired(mapping, self.tracker, self.message)
         elif should_fill_intent_slot or should_fill_trigger_slot:
-            value = [mapping.value]
+            value = [mapping.get("value")]
         elif should_fill_text_slot:
             value = [self.message.get(TEXT)] if self.message is not None else []
             if not value:
@@ -508,9 +468,11 @@ class SlotFillingManager:
 
         return value
 
-    def should_fill_slot(self, slot_name: str, mapping: SlotMapping) -> bool:
+    def should_fill_slot(
+        self, slot_name: str, mapping_type: SlotMappingType, mapping: Dict[Text, Any]
+    ) -> bool:
         """Checks if a slot should be filled based on the conversation context."""
-        if not self.is_slot_mapping_valid(slot_name, mapping):
+        if not self.is_slot_mapping_valid(slot_name, mapping_type, mapping):
             return False
 
         if not self.is_intent_desired(mapping):
@@ -532,12 +494,14 @@ def extract_slot_value(
     is_extracted = False
 
     for mapping in slot.mappings:
-        mapping_type = mapping.type
+        mapping_type = SlotMappingType(
+            mapping.get(MAPPING_TYPE, SlotMappingType.FROM_LLM.value)
+        )
 
-        if mapping_type in [SlotMappingType.FROM_LLM, SlotMappingType.CONTROLLED]:
+        if mapping_type in [SlotMappingType.FROM_LLM, SlotMappingType.CUSTOM]:
             continue
 
-        if not slot_filling_manager.should_fill_slot(slot.name, mapping):
+        if not slot_filling_manager.should_fill_slot(slot.name, mapping_type, mapping):
             continue
 
         value: List[Any] = (

rasa/shared/core/slots.py

@@ -41,7 +41,6 @@ class Slot(ABC):
         influence_conversation: bool = True,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
-        filled_by: Optional[str] = None,
     ) -> None:
         """Create a Slot.
 
@@ -58,12 +57,9 @@ 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.
         """
-        from rasa.shared.core.slot_mappings import SlotMapping
-
         self.name = name
-        self.mappings = [SlotMapping.from_dict(mapping, name) for mapping in mappings]
+        self.mappings = mappings
         self._value = initial_value
         self.initial_value = initial_value
         self._value_reset_delay = value_reset_delay
@@ -71,7 +67,6 @@ 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
 
     def feature_dimensionality(self) -> int:
         """How many features this single slot creates.
@@ -137,16 +132,6 @@ 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.
 
@@ -195,7 +180,7 @@ class Slot(ABC):
             "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],
+            "mappings": self.mappings,
         }
 
     def fingerprint(self) -> Text:
@@ -230,7 +215,6 @@ 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.
 
@@ -246,7 +230,6 @@ class FloatSlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
-            filled_by=filled_by,
         )
         self.max_value = max_value
         self.min_value = min_value
@@ -404,7 +387,6 @@ 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__(
@@ -415,7 +397,6 @@ 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(
@@ -626,7 +607,6 @@ 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).
 
@@ -650,7 +630,6 @@ class AnySlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
-            filled_by=filled_by,
         )
 
     def __eq__(self, other: Any) -> bool:

rasa/shared/core/trackers.py

@@ -916,13 +916,11 @@ class DialogueStateTracker:
                 continue
             slot.reset()
 
-    def _set_slot(self, key: Text, value: Any, filled_by: Optional[str] = None) -> None:
+    def _set_slot(self, key: Text, value: Any) -> 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 "

rasa/shared/nlu/constants.py

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

rasa/shared/utils/llm.py

@@ -680,7 +680,7 @@ def allowed_values_for_slot(slot: Slot) -> Union[str, None]:
     if isinstance(slot, BooleanSlot):
         return str([True, False])
     if isinstance(slot, CategoricalSlot):
-        return str([v for v in slot.values if v != "__other__"])
+        return str([v for v in slot.values if v != "__other__"] + ["other"])
     else:
         return None
 

rasa/shared/utils/schemas/domain.yml

@@ -78,6 +78,7 @@ mapping:
           mappings:
            type: "seq"
            required: False
+           allowempty: False
            sequence:
               - type: "map"
                 allowempty: True