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

rasa/shared/core/domain.py

@@ -46,10 +46,8 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTION_SHOULD_SEND_DOMAIN,
-    ACTIVE_LOOP,
+    KEY_MAPPING_TYPE,
     KNOWLEDGE_BASE_SLOT_NAMES,
-    MAPPING_CONDITIONS,
-    MAPPING_TYPE,
     SLOT_MAPPINGS,
     SlotMappingType,
 )
@@ -290,8 +288,6 @@ class Domain:
         responses = data.get(KEY_RESPONSES, {})
 
         domain_slots = data.get(KEY_SLOTS, {})
-        if domain_slots:
-            rasa.shared.core.slot_mappings.validate_slot_mappings(domain_slots)
         slots = cls.collect_slots(domain_slots)
         domain_actions = data.get(KEY_ACTIONS, [])
         actions = cls._collect_action_names(domain_actions)
@@ -596,7 +592,7 @@ class Domain:
                     ),
                 )
                 slot_dict[slot_name][SLOT_MAPPINGS] = [
-                    {MAPPING_TYPE: SlotMappingType.FROM_LLM.value}
+                    {KEY_MAPPING_TYPE: SlotMappingType.FROM_LLM.value}
                 ]
 
             slot = slot_class(slot_name, **slot_dict[slot_name])
@@ -1569,21 +1565,18 @@ class Domain:
                 matching_entities = []
 
                 for mapping in slot.mappings:
-                    mapping_conditions = mapping.get(MAPPING_CONDITIONS)
-                    if mapping[MAPPING_TYPE] != str(SlotMappingType.FROM_ENTITY) or (
+                    mapping_conditions = mapping.conditions
+                    if mapping.type != SlotMappingType.FROM_ENTITY or (
                         mapping_conditions
-                        and mapping_conditions[0].get(ACTIVE_LOOP) is not None
+                        and mapping_conditions[0].active_loop is not None
                     ):
                         continue
 
                     for entity in entities:
                         if (
-                            entity.get(ENTITY_ATTRIBUTE_TYPE)
-                            == mapping.get(ENTITY_ATTRIBUTE_TYPE)
-                            and entity.get(ENTITY_ATTRIBUTE_ROLE)
-                            == mapping.get(ENTITY_ATTRIBUTE_ROLE)
-                            and entity.get(ENTITY_ATTRIBUTE_GROUP)
-                            == mapping.get(ENTITY_ATTRIBUTE_GROUP)
+                            entity.get(ENTITY_ATTRIBUTE_TYPE) == mapping.entity
+                            and entity.get(ENTITY_ATTRIBUTE_ROLE) == mapping.role
+                            and entity.get(ENTITY_ATTRIBUTE_GROUP) == mapping.group
                         ):
                             matching_entities.append(entity.get("value"))
 
@@ -2015,19 +2008,19 @@ class Domain:
             is the total number of mappings which have conditions attached.
         """
         total_mappings = 0
-        custom_mappings = 0
+        controlled_mappings = 0
         conditional_mappings = 0
 
         for slot in self.slots:
             total_mappings += len(slot.mappings)
             for mapping in slot.mappings:
-                if mapping[MAPPING_TYPE] == str(SlotMappingType.CUSTOM):
-                    custom_mappings += 1
+                if mapping.type == SlotMappingType.CONTROLLED:
+                    controlled_mappings += 1
 
-                if MAPPING_CONDITIONS in mapping:
+                if mapping.conditions:
                     conditional_mappings += 1
 
-        return (total_mappings, custom_mappings, conditional_mappings)
+        return total_mappings, controlled_mappings, conditional_mappings
 
     def does_custom_action_explicitly_need_domain(self, action_name: Text) -> bool:
         """Assert if action has explicitly stated that it needs domain.

rasa/shared/core/events.py

@@ -1032,6 +1032,7 @@ class SlotSet(Event):
         value: Optional[Any] = None,
         timestamp: Optional[float] = None,
         metadata: Optional[Dict[Text, Any]] = None,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Creates event to set slot.
 
@@ -1043,6 +1044,7 @@ class SlotSet(Event):
         """
         self.key = key
         self.value = value
+        self._filled_by = filled_by
         super().__init__(timestamp, metadata)
 
     def __repr__(self) -> Text:
@@ -1060,6 +1062,14 @@ class SlotSet(Event):
 
         return (self.key, self.value) == (other.key, other.value)
 
+    @property
+    def filled_by(self) -> Optional[str]:
+        return self._filled_by
+
+    @filled_by.setter
+    def filled_by(self, value: str) -> None:
+        self._filled_by = value
+
     def as_story_string(self) -> Text:
         """Returns text representation of event."""
         props = json.dumps({self.key: self.value}, ensure_ascii=False)
@@ -1081,7 +1091,7 @@ class SlotSet(Event):
     def as_dict(self) -> Dict[Text, Any]:
         """Returns serialized event."""
         d = super().as_dict()
-        d.update({"name": self.key, "value": self.value})
+        d.update({"name": self.key, "value": self.value, "filled_by": self.filled_by})
         return d
 
     @classmethod
@@ -1092,13 +1102,14 @@ class SlotSet(Event):
                 parameters.get("value"),
                 parameters.get("timestamp"),
                 parameters.get("metadata"),
+                filled_by=parameters.get("filled_by"),
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse set slot event. {e}")
 
     def apply_to(self, tracker: "DialogueStateTracker") -> None:
         """Applies event to current conversation state."""
-        tracker._set_slot(self.key, self.value)
+        tracker._set_slot(self.key, self.value, self.filled_by)
 
 
 class Restarted(AlwaysEqualEventMixin):

rasa/shared/core/flows/flow.py

@@ -11,6 +11,10 @@ from pypred import Predicate
 
 import rasa.shared.utils.io
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.constants import (
+    KEY_ASK_CONFIRM_DIGRESSIONS,
+    KEY_BLOCK_DIGRESSIONS,
+)
 from rasa.shared.core.flows.flow_path import FlowPath, FlowPathsList, PathNode
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.flows.flow_step_links import (
@@ -33,6 +37,7 @@ from rasa.shared.core.flows.steps.constants import (
     START_STEP,
 )
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
+from rasa.shared.core.flows.utils import extract_digression_prop
 from rasa.shared.core.slots import Slot
 
 structlogger = structlog.get_logger()
@@ -62,6 +67,10 @@ class Flow:
     """The path to the file where the flow is stored."""
     persisted_slots: List[str] = field(default_factory=list)
     """The list of slots that should be persisted after the flow ends."""
+    ask_confirm_digressions: List[str] = field(default_factory=list)
+    """The flow ids for which the assistant should ask for confirmation."""
+    block_digressions: List[str] = field(default_factory=list)
+    """The flow ids that the assistant should block from digressing to."""
 
     @staticmethod
     def from_json(
@@ -98,6 +107,10 @@ class Flow:
             # data. When the model is trained, take the provided file_path.
             file_path=data.get("file_path") if "file_path" in data else file_path,
             persisted_slots=data.get("persisted_slots", []),
+            ask_confirm_digressions=extract_digression_prop(
+                KEY_ASK_CONFIRM_DIGRESSIONS, data
+            ),
+            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
         )
 
     def get_full_name(self) -> str:
@@ -172,6 +185,10 @@ class Flow:
             data["file_path"] = self.file_path
         if self.persisted_slots:
             data["persisted_slots"] = self.persisted_slots
+        if self.ask_confirm_digressions:
+            data[KEY_ASK_CONFIRM_DIGRESSIONS] = self.ask_confirm_digressions
+        if self.block_digressions:
+            data[KEY_BLOCK_DIGRESSIONS] = self.block_digressions
 
         return data
 

rasa/shared/core/flows/flows_yaml_schema.json

@@ -217,6 +217,12 @@
                             "reset_after_flow_ends": {
                                 "type": "boolean"
                             },
+                            "ask_confirm_digressions": {
+                                "$ref": "#/$defs/ask_confirm_digressions"
+                            },
+                            "block_digressions": {
+                                "$ref": "#/$defs/block_digressions"
+                            },
                             "utter": {
                                 "type": "string"
                             },
@@ -247,6 +253,32 @@
                 }
             }
         },
+        "ask_confirm_digressions": {
+            "oneOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            ]
+        },
+        "block_digressions": {
+            "oneOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            ]
+        },
         "flow": {
             "required": [
                 "steps",
@@ -282,6 +314,12 @@
                 },
                 "persisted_slots": {
                     "$ref": "#/$defs/persisted_slots"
+                },
+                "ask_confirm_digressions": {
+                    "$ref": "#/$defs/ask_confirm_digressions"
+                },
+                "block_digressions": {
+                    "$ref": "#/$defs/block_digressions"
                 }
             }
         },

rasa/shared/core/flows/steps/collect.py

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Dict, List, Set, Text
 
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
+from rasa.shared.core.constants import (
+    KEY_ASK_CONFIRM_DIGRESSIONS,
+    KEY_BLOCK_DIGRESSIONS,
+)
 from rasa.shared.core.flows.flow_step import FlowStep
+from rasa.shared.core.flows.utils import extract_digression_prop
 
 
 @dataclass
@@ -59,6 +64,10 @@ class CollectInformationFlowStep(FlowStep):
     """Whether to always ask the question even if the slot is already filled."""
     reset_after_flow_ends: bool = True
     """Whether to reset the slot value at the end of the flow."""
+    ask_confirm_digressions: List[str] = field(default_factory=list)
+    """The flow id digressions for which the assistant should ask for confirmation."""
+    block_digressions: List[str] = field(default_factory=list)
+    """The flow id digressions that should be blocked during the flow step."""
 
     @classmethod
     def from_json(
@@ -86,6 +95,10 @@ class CollectInformationFlowStep(FlowStep):
                 SlotRejection.from_dict(rejection)
                 for rejection in data.get("rejections", [])
             ],
+            ask_confirm_digressions=extract_digression_prop(
+                KEY_ASK_CONFIRM_DIGRESSIONS, data
+            ),
+            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
             **base.__dict__,
         )
 
@@ -101,6 +114,10 @@ class CollectInformationFlowStep(FlowStep):
         data["ask_before_filling"] = self.ask_before_filling
         data["reset_after_flow_ends"] = self.reset_after_flow_ends
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
+        data["ask_confirm_digressions"] = self.ask_confirm_digressions
+        data["block_digressions"] = (
+            self.block_digressions if self.block_digressions else False
+        )
 
         return data
 

rasa/shared/core/flows/utils.py

@@ -1,9 +1,10 @@
-from typing import Set
+from typing import Any, Dict, List, Set
 
 from rasa.shared.utils.io import raise_deprecation_warning
 
 RESET_PROPERTY_NAME = "reset_after_flow_ends"
 PERSIST_PROPERTY_NAME = "persisted_slots"
+ALL_LABEL = "ALL"
 
 
 def warn_deprecated_collect_step_config(flow_id: str, collect_step: str) -> None:
@@ -38,3 +39,17 @@ def get_invalid_slot_persistence_config_error_message(
         f"are neither used in a collect step nor a set_slot step of the flow. "
         f"Please remove such slots from the '{PERSIST_PROPERTY_NAME}' property."
     )
+
+
+def extract_digression_prop(prop: str, data: Dict[str, Any]) -> List[str]:
+    """Extracts the digression property from the data.
+
+    There can be two types of properties: ask_confirm_digressions and
+    block_digressions.
+    """
+    digression_property = data.get(prop, [])
+
+    if isinstance(digression_property, bool):
+        digression_property = [ALL_LABEL] if digression_property else []
+
+    return digression_property