rasa-pro 3.12.0.dev12__py3-none-any.whl → 3.12.0rc1__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/constants.py

@@ -0,0 +1,11 @@
+KEY_ID = "id"
+KEY_STEPS = "steps"
+KEY_NAME = "name"
+KEY_DESCRIPTION = "description"
+KEY_IF = "if"
+KEY_ALWAYS_INCLUDE_IN_PROMPT = "always_include_in_prompt"
+KEY_NLU_TRIGGER = "nlu_trigger"
+KEY_FILE_PATH = "file_path"
+KEY_PERSISTED_SLOTS = "persisted_slots"
+KEY_RUN_PATTERN_COMPLETED = "run_pattern_completed"
+KEY_TRANSLATION = "translation"

rasa/shared/core/flows/flow.py

@@ -7,10 +7,29 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, Text, Union
 
 import structlog
+from pydantic import BaseModel
 from pypred import Predicate
 
 import rasa.shared.utils.io
+from rasa.engine.language import Language
 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.constants import (
+    KEY_ALWAYS_INCLUDE_IN_PROMPT,
+    KEY_DESCRIPTION,
+    KEY_FILE_PATH,
+    KEY_ID,
+    KEY_IF,
+    KEY_NAME,
+    KEY_NLU_TRIGGER,
+    KEY_PERSISTED_SLOTS,
+    KEY_RUN_PATTERN_COMPLETED,
+    KEY_STEPS,
+    KEY_TRANSLATION,
+)
 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,11 +52,22 @@ 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()
 
 
+class FlowLanguageTranslation(BaseModel):
+    """Represents the translation of the flow properties in a specific language."""
+
+    name: str
+    """The human-readable name of the flow."""
+
+    class Config:
+        extra = "ignore"
+
+
 @dataclass
 class Flow:
     """Represents the configuration of a flow."""
@@ -48,6 +78,8 @@ class Flow:
     """The human-readable name of the flow."""
     description: Optional[Text] = None
     """The description of the flow."""
+    translation: Dict[Text, FlowLanguageTranslation] = field(default_factory=dict)
+    """The translation of the flow properties in different languages."""
     guard_condition: Optional[Text] = None
     """The condition that needs to be fulfilled for the flow to be startable."""
     step_sequence: FlowStepSequence = field(default_factory=FlowStepSequence.empty)
@@ -62,6 +94,12 @@ 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."""
+    run_pattern_completed: bool = True
+    """Whether the pattern_completed flow should be run after the flow ends."""
 
     @staticmethod
     def from_json(
@@ -79,6 +117,8 @@ class Flow:
         Returns:
             A Flow object.
         """
+        from rasa.shared.core.flows.utils import extract_translations
+
         step_sequence = FlowStepSequence.from_json(flow_id, data.get("steps"))
         nlu_triggers = NLUTriggers.from_json(data.get("nlu_trigger"))
 
@@ -87,17 +127,25 @@ class Flow:
 
         return Flow(
             id=flow_id,
-            custom_name=data.get("name"),
-            description=data.get("description"),
-            always_include_in_prompt=data.get("always_include_in_prompt"),
-            # str or bool are permitted in the flow schema but internally we want a str
-            guard_condition=str(data["if"]) if "if" in data else None,
+            custom_name=data.get(KEY_NAME),
+            description=data.get(KEY_DESCRIPTION),
+            always_include_in_prompt=data.get(KEY_ALWAYS_INCLUDE_IN_PROMPT),
+            # str or bool are permitted in the flow schema, but internally we want a str
+            guard_condition=str(data[KEY_IF]) if KEY_IF in data else None,
             step_sequence=Flow.resolve_default_ids(step_sequence),
             nlu_triggers=nlu_triggers,
             # If we are reading the flows in after training the file_path is part of
             # 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", []),
+            file_path=data.get(KEY_FILE_PATH) if KEY_FILE_PATH in data else file_path,
+            persisted_slots=data.get(KEY_PERSISTED_SLOTS, []),
+            ask_confirm_digressions=extract_digression_prop(
+                KEY_ASK_CONFIRM_DIGRESSIONS, data
+            ),
+            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
+            run_pattern_completed=data.get(KEY_RUN_PATTERN_COMPLETED, True),
+            translation=extract_translations(
+                translation_data=data.get(KEY_TRANSLATION, {})
+            ),
         )
 
     def get_full_name(self) -> str:
@@ -155,29 +203,62 @@ class Flow:
             The Flow object as serialized data.
         """
         data: Dict[Text, Any] = {
-            "id": self.id,
-            "steps": self.step_sequence.as_json(),
+            KEY_ID: self.id,
+            KEY_STEPS: self.step_sequence.as_json(),
         }
         if self.custom_name is not None:
-            data["name"] = self.custom_name
+            data[KEY_NAME] = self.custom_name
         if self.description is not None:
-            data["description"] = self.description
+            data[KEY_DESCRIPTION] = self.description
         if self.guard_condition is not None:
-            data["if"] = self.guard_condition
+            data[KEY_IF] = self.guard_condition
         if self.always_include_in_prompt is not None:
-            data["always_include_in_prompt"] = self.always_include_in_prompt
+            data[KEY_ALWAYS_INCLUDE_IN_PROMPT] = self.always_include_in_prompt
         if self.nlu_triggers:
-            data["nlu_trigger"] = self.nlu_triggers.as_json()
+            data[KEY_NLU_TRIGGER] = self.nlu_triggers.as_json()
         if self.file_path:
-            data["file_path"] = self.file_path
+            data[KEY_FILE_PATH] = self.file_path
         if self.persisted_slots:
-            data["persisted_slots"] = self.persisted_slots
+            data[KEY_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
+        if self.run_pattern_completed is not None:
+            data["run_pattern_completed"] = self.run_pattern_completed
+        if self.translation:
+            data[KEY_TRANSLATION] = {
+                language_code: translation.dict()
+                for language_code, translation in self.translation.items()
+            }
 
         return data
 
-    def readable_name(self) -> str:
-        """Returns the name of the flow or its id if no name is set."""
-        return self.name or self.id
+    def localized_name(self, language: Optional[Language] = None) -> Optional[Text]:
+        """Returns the language specific flow name or None.
+
+        Args:
+            language: Preferred language code.
+
+        Returns:
+            Flow name in the specified language or None.
+        """
+        language_code = language.code if language else None
+        translation = self.translation.get(language_code)
+        return translation.name if translation else None
+
+    def readable_name(self, language: Optional[Language] = None) -> str:
+        """
+        Returns the flow's name in the specified language if available; otherwise
+        falls back to the flow's name, and finally the flow's ID.
+
+        Args:
+            language: Preferred language code.
+
+        Returns:
+            string: the localized name, the default name, or the flow's ID.
+        """
+        return self.localized_name(language) or self.name or self.id
 
     def step_by_id(self, step_id: Optional[Text]) -> Optional[FlowStep]:
         """Returns the step with the given id."""

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",
@@ -256,9 +288,37 @@
             "additionalProperties": false,
             "schema_name": "dictionary with flow properties",
             "properties": {
+                "name": {
+                    "type": "string"
+                },
                 "description": {
                     "type": "string"
                 },
+                "translation": {
+                    "type": "object",
+                    "schema_name": "flow translation mapping",
+                    "properties": {
+                        "metadata": {
+                            "type": "object"
+                        }
+                    },
+                    "patternProperties": {
+                        "^(?!metadata$).+": {
+                            "type": "object",
+                            "additionalProperties": false,
+                            "required": [
+                                "name"
+                            ],
+                            "properties": {
+                                "name": {
+                                    "type": "string"
+                                },
+                                "metadata": {}
+                            }
+                        }
+                    },
+                    "additionalProperties": false
+                },
                 "if": {
                     "type": [
                         "string",
@@ -268,9 +328,6 @@
                 "always_include_in_prompt": {
                     "type": "boolean"
                 },
-                "name": {
-                    "type": "string"
-                },
                 "nlu_trigger": {
                     "$ref": "#/$defs/nlu_trigger"
                 },
@@ -282,6 +339,15 @@
                 },
                 "persisted_slots": {
                     "$ref": "#/$defs/persisted_slots"
+                },
+                "ask_confirm_digressions": {
+                    "$ref": "#/$defs/ask_confirm_digressions"
+                },
+                "block_digressions": {
+                    "$ref": "#/$defs/block_digressions"
+                },
+                "run_pattern_completed": {
+                    "type": "boolean"
                 }
             }
         },

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

@@ -1,46 +1,16 @@
 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
-
-
-@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,
-        }
+from rasa.shared.core.flows.utils import extract_digression_prop
+from rasa.shared.core.slots import SlotRejection
 
 
 @dataclass
@@ -59,6 +29,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 +60,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 +79,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,16 +1,21 @@
-from typing import Set
+from typing import TYPE_CHECKING, Any, Dict, List, Set, Text
 
 from rasa.shared.utils.io import raise_deprecation_warning
 
+if TYPE_CHECKING:
+    from rasa.shared.core.flows.flow import FlowLanguageTranslation
+
+
 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:
+def warn_deprecated_collect_step_config() -> None:
     """Warns about deprecated reset_after_flow_ends usage in collect steps."""
     raise_deprecation_warning(
-        f"Configuring '{RESET_PROPERTY_NAME}' in collect step '{collect_step}' is "
-        f"deprecated and will be removed in Rasa Pro 4.0.0. In flow id '{flow_id}', "
+        f"Configuring '{RESET_PROPERTY_NAME}' in collect steps is "
+        f"deprecated and will be removed in Rasa Pro 4.0.0. In the parent flow, "
         f"please use the '{PERSIST_PROPERTY_NAME}' "
         "property at the flow level instead."
     )
@@ -38,3 +43,37 @@ 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
+
+
+def extract_translations(
+    translation_data: Dict[Text, Any],
+) -> Dict[Text, "FlowLanguageTranslation"]:
+    """Extracts translations from a dictionary.
+
+    Args:
+        translation_data: The dictionary containing the translations.
+
+    Returns:
+        A dictionary containing the extracted translations.
+    """
+    from rasa.shared.core.flows.flow import FlowLanguageTranslation
+
+    return {
+        language_code: FlowLanguageTranslation.parse_obj({**data})
+        for language_code, data in translation_data.items()
+        if language_code != "metadata"
+    }

rasa/shared/core/flows/validation.py

@@ -723,7 +723,7 @@ def validate_slot_persistence_configuration(flow: Flow) -> None:
             flow_slots.add(step.collect)
             if not step.reset_after_flow_ends:
                 collect_step = step.collect
-                warn_deprecated_collect_step_config(flow_id, collect_step)
+                warn_deprecated_collect_step_config()
                 if has_flow_level_persistence:
                     raise DuplicateSlotPersistConfigException(flow_id, collect_step)