rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/core/actions/action_clean_stack.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import structlog
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.dialogue_understanding.stack.frames import (
+    BaseFlowStackFrame,
+    UserFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import FlowStackFrameType
+from rasa.shared.core.constants import ACTION_CLEAN_STACK
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows.steps.constants import END_STEP
+from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+class ActionCleanStack(Action):
+    """Action which cancels a flow from the stack."""
+
+    def name(self) -> str:
+        """Return the flow name."""
+        return ACTION_CLEAN_STACK
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Clean the stack."""
+        structlogger.debug("action_clean_stack.run")
+        new_frames = []
+        # Set all frames to their end step, filter out any non-BaseFlowStackFrames
+        for frame in tracker.stack.frames:
+            if isinstance(frame, BaseFlowStackFrame):
+                structlogger.debug(
+                    "action_clean_stack.terminating_frame",
+                    frame_id=frame.frame_id,
+                    flow_id=frame.flow_id,
+                )
+                frame.step_id = ContinueFlowStep.continue_step_for_id(END_STEP)
+                if isinstance(frame, UserFlowStackFrame):
+                    # Making sure there are no "continue interrupts" triggered
+                    frame.frame_type = FlowStackFrameType.REGULAR
+                new_frames.append(frame)
+        new_stack = DialogueStack.from_dict([frame.as_dict() for frame in new_frames])
+
+        return tracker.create_stack_updated_events(new_stack)

rasa/core/actions/action_exceptions.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from rasa.shared.exceptions import RasaException
+
+
+class ActionExecutionRejection(RasaException):
+    """Raising this exception allows other policies to predict a different action."""
+
+    def __init__(self, action_name: str, message: Optional[str] = None) -> None:
+        """Create a new ActionExecutionRejection exception."""
+        self.action_name = action_name
+        self.message = message or "Custom action '{}' rejected to run".format(
+            action_name
+        )
+        super(ActionExecutionRejection, self).__init__()
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class DomainNotFound(Exception):
+    """Exception raised when domain is not found."""
+
+    pass

rasa/core/actions/action_hangup.py

@@ -0,0 +1,29 @@
+from typing import Optional, Dict, Any, List
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.shared.core.constants import ACTION_HANGUP
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, SessionEnded
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class ActionHangup(Action):
+    """Action which hangs up the call."""
+
+    def name(self) -> str:
+        """Return the name of the action."""
+        return ACTION_HANGUP
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Ask the output channel to hang up the call."""
+        await output_channel.hangup(tracker.sender_id)
+        return [SessionEnded(metadata={"_reason": "hangup"})]

rasa/core/actions/action_repeat_bot_messages.py

@@ -0,0 +1,89 @@
+from typing import Optional, Dict, Any, List
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.repeat import (
+    RepeatBotMessagesPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.user_silence import (
+    UserSilencePatternFlowStackFrame,
+)
+from rasa.shared.core.constants import ACTION_REPEAT_BOT_MESSAGES
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, BotUttered, UserUttered
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class ActionRepeatBotMessages(Action):
+    """Action to repeat bot messages"""
+
+    def name(self) -> str:
+        """Return the name of the action."""
+        return ACTION_REPEAT_BOT_MESSAGES
+
+    def _get_last_bot_events(self, tracker: DialogueStateTracker) -> List[Event]:
+        """Get the last consecutive bot events before the most recent user message.
+
+        This function scans the dialogue history in reverse to find the last sequence of
+        bot responses that occurred without any user interruption. It filters out all
+        non-utterance events and stops when it encounters a user message after finding
+        bot messages.
+
+        Args:
+            tracker: DialogueStateTracker containing the conversation events.
+
+        Returns:
+            List[Event]: A list of consecutive BotUttered events that occurred
+                most recently, in chronological order. Returns an empty list
+                if no bot messages are found or if the last message was from
+                the user.
+
+        Example:
+            For events: [User1, Bot1, Bot2, User2, Bot4, Bot5, User3]
+            Returns: [Bot4, Bot5] (the last two bot events)
+            The elif condition doesn't break when it sees User3 event.
+            But it does at User2 event.
+        """
+        # Skip action if we are in a collect information step whose
+        # default behavior is to repeat anyways
+        top_frame = tracker.stack.top(
+            lambda frame: isinstance(frame, RepeatBotMessagesPatternFlowStackFrame)
+            or isinstance(frame, UserSilencePatternFlowStackFrame)
+        )
+        if isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            return []
+        # filter user and bot events
+        filtered = [
+            e for e in tracker.events if isinstance(e, (BotUttered, UserUttered))
+        ]
+        bot_events: List[Event] = []
+
+        # find the last BotUttered events
+        for e in reversed(filtered):
+            if isinstance(e, BotUttered):
+                # insert instead of append because the list is reversed
+                bot_events.insert(0, e)
+
+            # stop if a UserUttered event is found
+            # only if we have collected some bot events already
+            # this condition skips the first N UserUttered events
+            elif bot_events:
+                break
+
+        return bot_events
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Send the last bot messages to the channel again"""
+        bot_events = self._get_last_bot_events(tracker)
+        return bot_events

rasa/core/actions/action_run_slot_rejections.py

@@ -0,0 +1,210 @@
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Union
+
+import structlog
+from jinja2 import Template
+from pypred import Predicate
+
+from rasa.core.actions.action import Action, create_bot_utterance
+from rasa.core.utils import add_bot_utterance_metadata
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.shared.core.constants import ACTION_RUN_SLOT_REJECTIONS_NAME
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.flows.steps.collect import SlotRejection
+from rasa.shared.core.slots import (
+    BooleanSlot,
+    CategoricalSlot,
+    FloatSlot,
+    Slot,
+)
+
+if TYPE_CHECKING:
+    from rasa.core.nlg import NaturalLanguageGenerator
+    from rasa.core.channels.channel import OutputChannel
+    from rasa.shared.core.domain import Domain
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+UTTERANCE_NOT_DEFINED_BY_USER = "TO.UPDATE.VALUE.BUT.MISSING.UTTERANCE"
+
+
+def utterance_for_slot_type(slot: Slot) -> Optional[str]:
+    """Return the utterance to use for the slot type."""
+    if isinstance(slot, BooleanSlot):
+        return "utter_boolean_slot_rejection"
+    elif isinstance(slot, FloatSlot):
+        return "utter_float_slot_rejection"
+    elif isinstance(slot, CategoricalSlot):
+        return "utter_categorical_slot_rejection"
+    return None
+
+
+def coerce_slot_value(
+    slot_value: str, slot_name: str, tracker: "DialogueStateTracker"
+) -> Union[str, bool, float, None]:
+    """Coerce the slot value to the correct type.
+
+    Tries to coerce the slot value to the correct type. If the
+    conversion fails, `None` is returned.
+
+    Args:
+        slot_value: The value to coerce.
+        slot_name: The name of the slot.
+        tracker: The tracker containing the current state of the conversation.
+
+    Returns:
+        The coerced value or `None` if the conversion failed.
+    """
+    if slot_name not in tracker.slots:
+        return slot_value
+
+    slot = tracker.slots[slot_name]
+
+    if not slot.is_valid_value(slot_value):
+        structlogger.debug(
+            "run.rejection.slot_value_not_valid",
+            rejection=slot_value,
+        )
+        return None
+
+    return slot.coerce_value(slot_value)
+
+
+def run_rejections(
+    slot_value: Union[str, bool, float, None],
+    slot_name: str,
+    rejections: List[SlotRejection],
+) -> Optional[str]:
+    """Run the predicate checks under rejections."""
+    violation = False
+    internal_error = False
+    current_context = {"slots": {slot_name: slot_value}}
+
+    structlogger.debug("run.predicate.context", context=current_context)
+    document = current_context.copy()
+
+    for rejection in rejections:
+        condition = rejection.if_
+        utterance = rejection.utter
+
+        try:
+            rendered_template = Template(condition).render(current_context)
+            predicate = Predicate(rendered_template)
+            violation = predicate.evaluate(document)
+            structlogger.debug(
+                "run.predicate.result",
+                predicate=predicate.description(),
+                violation=violation,
+            )
+        except (TypeError, Exception) as e:
+            structlogger.error(
+                "run.predicate.error",
+                predicate=condition,
+                document=document,
+                error=str(e),
+            )
+            violation = True
+            internal_error = True
+
+        if violation:
+            break
+
+    if not violation:
+        return None
+    if internal_error:
+        utterance = "utter_internal_error_rasa"
+    if not isinstance(utterance, str):
+        utterance = UTTERANCE_NOT_DEFINED_BY_USER
+    return utterance
+
+
+class ActionRunSlotRejections(Action):
+    """Action which evaluates the predicate checks under rejections."""
+
+    def name(self) -> Text:
+        """Return the name of the action."""
+        return ACTION_RUN_SLOT_REJECTIONS_NAME
+
+    async def run(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        """Run the predicate checks."""
+        utterance = None
+        top_frame = tracker.stack.top()
+        if not isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            return []
+
+        slot_name = top_frame.collect
+        slot_instance = tracker.slots.get(slot_name)
+        if slot_instance and not slot_instance.has_been_set:
+            # this is the first time the assistant asks for the slot value,
+            # therefore we skip the predicate validation because the slot
+            # value has not been provided
+            structlogger.debug(
+                "first.collect.slot.not.set",
+                slot_name=slot_name,
+                slot_value=slot_instance.value,
+            )
+            return []
+
+        slot_value = tracker.get_slot(slot_name)
+
+        if slot_instance and slot_instance.has_been_set and slot_value is None:
+            return []
+
+        typed_slot_value = coerce_slot_value(slot_value, slot_name, tracker)
+        if typed_slot_value is None:
+            # the slot value could not be coerced to the correct type
+            utterance = utterance_for_slot_type(slot_instance)
+        elif top_frame.rejections:
+            # run the predicate checks under rejections
+            utterance = run_rejections(
+                typed_slot_value, slot_name, top_frame.rejections
+            )
+
+        events: List[Event] = []
+        if utterance:
+            # the slot value has been rejected
+            events.append(SlotSet(slot_name, None))
+        elif slot_value != typed_slot_value or type(slot_value) != type(
+            typed_slot_value
+        ):
+            # the slot value has been coerced to the correct type
+            return [SlotSet(slot_name, typed_slot_value)]
+        elif slot_value == typed_slot_value:
+            # the slot value has not changed and no utterance present
+            return []
+
+        if utterance == UTTERANCE_NOT_DEFINED_BY_USER:
+            structlogger.error(
+                "run.rejection.missing.utter",
+                utterance=None,
+            )
+            return events
+
+        message = await nlg.generate(
+            utterance,
+            tracker,
+            output_channel.name(),
+            value=slot_value,
+        )
+
+        if message is None:
+            structlogger.error(
+                "run.rejection.failed.finding.utter",
+                utterance=utterance,
+            )
+        else:
+            message = add_bot_utterance_metadata(
+                message, utterance, nlg, domain, tracker
+            )
+            events.append(create_bot_utterance(message))
+
+        return events

rasa/core/actions/action_trigger_chitchat.py

@@ -0,0 +1,31 @@
+from typing import Optional, Dict, Any, List
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.stack.frames import ChitChatStackFrame
+from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class ActionTriggerChitchat(Action):
+    """Action which triggers a chitchat answer."""
+
+    def name(self) -> str:
+        """Return the name of the action."""
+        return ACTION_TRIGGER_CHITCHAT
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Run the predicate checks."""
+        stack = tracker.stack
+        stack.push(ChitChatStackFrame())
+        return tracker.create_stack_updated_events(stack)

rasa/core/actions/action_trigger_flow.py

@@ -0,0 +1,109 @@
+from typing import Any, Dict, Optional, Text, List
+
+import structlog
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+from rasa.core.actions import action
+from rasa.core.channels import OutputChannel
+from rasa.shared.constants import FLOW_PREFIX
+
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import (
+    ActiveLoop,
+    Event,
+    FlowInterrupted,
+    SlotSet,
+)
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger(__name__)
+
+
+class ActionTriggerFlow(action.Action):
+    """Action which triggers a flow by putting it on the dialogue stack."""
+
+    def __init__(self, flow_action_name: Text) -> None:
+        """Creates a `ActionTriggerFlow`.
+
+        Args:
+            flow_action_name: Name of the flow.
+        """
+        super().__init__()
+
+        if not flow_action_name.startswith(FLOW_PREFIX):
+            raise ValueError(
+                f"Flow action name '{flow_action_name}' needs to start with "
+                f"'{FLOW_PREFIX}'."
+            )
+
+        self._flow_name = flow_action_name[len(FLOW_PREFIX) :]
+        self._flow_action_name = flow_action_name
+
+    def name(self) -> Text:
+        """Return the flow name."""
+        return self._flow_action_name
+
+    def create_events_to_start_flow(self, tracker: DialogueStateTracker) -> List[Event]:
+        """Create events to start the flow.
+
+        Args:
+            tracker: The tracker to start the flow on.
+
+        Returns:
+            The event to start the flow."""
+        stack = tracker.stack
+        events: List[Event] = []
+
+        frame_type = FlowStackFrameType.REGULAR
+
+        if not stack.is_empty():
+            frame_type = FlowStackFrameType.INTERRUPT
+            top_user_frame = top_user_flow_frame(stack)
+            if top_user_frame is not None:
+                events.append(
+                    FlowInterrupted(top_user_frame.flow_id, top_user_frame.step_id)
+                )
+
+        stack.push(
+            UserFlowStackFrame(
+                flow_id=self._flow_name,
+                frame_type=frame_type,
+            )
+        )
+        return events + tracker.create_stack_updated_events(stack)
+
+    def create_events_to_set_flow_slots(self, metadata: Dict[str, Any]) -> List[Event]:
+        """Create events to set the flow slots.
+
+        Set additional slots to prefill information for the flow.
+
+        Args:
+            metadata: The metadata to set the slots from.
+
+        Returns:
+            The events to set the flow slots.
+        """
+        slots_to_be_set = metadata.get("slots", {}) if metadata else {}
+        return [SlotSet(key, value) for key, value in slots_to_be_set.items()]
+
+    async def run(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        """Trigger the flow."""
+        events: List[Event] = self.create_events_to_start_flow(tracker)
+        events.extend(self.create_events_to_set_flow_slots(metadata))
+
+        if tracker.active_loop_name:
+            # end any active loop to ensure we are progressing the started flow
+            events.append(ActiveLoop(None))
+
+        return events

rasa/core/actions/action_trigger_search.py

@@ -0,0 +1,31 @@
+from typing import Optional, Dict, Any, List
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.stack.frames import SearchStackFrame
+from rasa.shared.core.constants import ACTION_TRIGGER_SEARCH
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class ActionTriggerSearch(Action):
+    """Action which triggers a search"""
+
+    def name(self) -> str:
+        """Return the name of the action."""
+        return ACTION_TRIGGER_SEARCH
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Run the predicate checks."""
+        stack = tracker.stack
+        stack.push(SearchStackFrame())
+        return tracker.create_stack_updated_events(stack)

rasa/core/actions/constants.py

@@ -0,0 +1,5 @@
+DEFAULT_SELECTIVE_DOMAIN = False
+SELECTIVE_DOMAIN = "enable_selective_domain"
+
+SSL_CLIENT_CERT_FIELD = "ssl_client_cert"
+SSL_CLIENT_KEY_FIELD = "ssl_client_key"