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

rasa/shared/core/flows/flow.py

@@ -7,14 +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 (
@@ -43,6 +58,16 @@ 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."""
@@ -53,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)
@@ -71,6 +98,8 @@ class Flow:
     """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(
@@ -88,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"))
 
@@ -96,21 +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:
@@ -168,33 +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

@@ -288,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",
@@ -300,9 +328,6 @@
                 "always_include_in_prompt": {
                     "type": "boolean"
                 },
-                "name": {
-                    "type": "string"
-                },
                 "nlu_trigger": {
                     "$ref": "#/$defs/nlu_trigger"
                 },
@@ -320,6 +345,9 @@
                 },
                 "block_digressions": {
                     "$ref": "#/$defs/block_digressions"
+                },
+                "run_pattern_completed": {
+                    "type": "boolean"
                 }
             }
         },

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

@@ -10,42 +10,7 @@ from rasa.shared.core.constants import (
 )
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.flows.utils import extract_digression_prop
-
-
-@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.slots import SlotRejection
 
 
 @dataclass

rasa/shared/core/flows/utils.py

@@ -1,17 +1,21 @@
-from typing import Any, Dict, List, 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."
     )
@@ -53,3 +57,23 @@ def extract_digression_prop(prop: str, data: Dict[str, Any]) -> List[str]:
         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)
 

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