rasa-pro 3.9.18__py3-none-any.whl

rasa/dialogue_understanding/patterns/cancel.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+import structlog
+from rasa.core.actions import action
+from rasa.core.channels.channel import OutputChannel
+from rasa.core.nlg.generator import NaturalLanguageGenerator
+from rasa.dialogue_understanding.stack.frames import (
+    BaseFlowStackFrame,
+    PatternFlowStackFrame,
+)
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.constants import ACTION_CANCEL_FLOW
+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()
+
+FLOW_PATTERN_CANCEL = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "cancel_flow"
+
+
+@dataclass
+class CancelPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame which cancels a flow.
+
+    The frame contains the information about the stack frames that should
+    be canceled."""
+
+    flow_id: str = FLOW_PATTERN_CANCEL
+    """The ID of the flow."""
+    canceled_name: str = ""
+    """The name of the flow that should be canceled."""
+    canceled_frames: List[str] = field(default_factory=list)
+    """The stack frames that should be canceled. These can be multiple
+    frames since the user frame that is getting canceled might have
+    created patterns that should be canceled as well."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_CANCEL
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> CancelPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return CancelPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            canceled_name=data["canceled_name"],
+            canceled_frames=data["canceled_frames"],
+        )
+
+
+class ActionCancelFlow(action.Action):
+    """Action which cancels a flow from the stack."""
+
+    def __init__(self) -> None:
+        """Creates a `ActionCancelFlow`."""
+        super().__init__()
+
+    def name(self) -> str:
+        """Return the flow name."""
+        return ACTION_CANCEL_FLOW
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Cancel the flow."""
+        stack = tracker.stack
+        if not (top := stack.top()):
+            structlogger.warning("action.cancel_flow.no_active_flow")
+            return []
+
+        if not isinstance(top, CancelPatternFlowStackFrame):
+            structlogger.warning("action.cancel_flow.no_cancel_frame", top=top)
+            return []
+
+        for canceled_frame_id in top.canceled_frames:
+            for frame in stack.frames:
+                if frame.frame_id == canceled_frame_id and isinstance(
+                    frame, BaseFlowStackFrame
+                ):
+                    # Setting the stack frame to the end step so it is properly
+                    # wrapped up by the flow policy
+                    frame.step_id = ContinueFlowStep.continue_step_for_id(END_STEP)
+                    break
+            else:
+                structlogger.warning(
+                    "action.cancel_flow.frame_not_found",
+                    dialogue_stack=stack,
+                    frame_id=canceled_frame_id,
+                )
+
+        return tracker.create_stack_updated_events(stack)

rasa/dialogue_understanding/patterns/cannot_handle.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Text
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import (
+    RASA_DEFAULT_FLOW_PATTERN_PREFIX,
+    RASA_PATTERN_CANNOT_HANDLE_DEFAULT,
+)
+
+FLOW_PATTERN_CANNOT_HANDLE = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "cannot_handle"
+
+
+@dataclass
+class CannotHandlePatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame that gets added when that the
+    bot can't handle the user's input."""
+
+    flow_id: str = FLOW_PATTERN_CANNOT_HANDLE
+    """The ID of the flow."""
+
+    reason: Optional[Text] = RASA_PATTERN_CANNOT_HANDLE_DEFAULT
+    """Reason for cannot handle used in switch-case of the
+    cannot handle pattern flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_CANNOT_HANDLE
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> CannotHandlePatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return CannotHandlePatternFlowStackFrame(
+            frame_id=data["frame_id"], step_id=data["step_id"], reason=data["reason"]
+        )

rasa/dialogue_understanding/patterns/chitchat.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_CHITCHAT = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "chitchat"
+
+
+@dataclass
+class ChitchatPatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that gets added to respond to Chitchat."""
+
+    flow_id: str = FLOW_PATTERN_CHITCHAT
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_CHITCHAT
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> ChitchatPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return ChitchatPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/clarify.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+import structlog
+from rasa.core.actions import action
+from rasa.core.channels.channel import OutputChannel
+from rasa.core.nlg.generator import NaturalLanguageGenerator
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.constants import ACTION_CLARIFY_FLOWS
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+structlogger = structlog.get_logger()
+
+FLOW_PATTERN_CLARIFICATION = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "clarification"
+
+
+@dataclass
+class ClarifyPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame which helps the user clarify their action."""
+
+    flow_id: str = FLOW_PATTERN_CLARIFICATION
+    """The ID of the flow."""
+    names: List[str] = field(default_factory=list)
+    """The names of the flows that the user can choose from."""
+    clarification_options: str = ""
+    """The options that the user can choose from as a string."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_CLARIFICATION
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> ClarifyPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return ClarifyPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            names=data["names"],
+            clarification_options=data["clarification_options"],
+        )
+
+
+class ActionClarifyFlows(action.Action):
+    """Action which clarifies which flow to start."""
+
+    def name(self) -> str:
+        """Return the flow name."""
+        return ACTION_CLARIFY_FLOWS
+
+    @staticmethod
+    def assemble_options_string(names: List[str]) -> str:
+        """Concatenate options to a human-readable string."""
+        clarification_message = ""
+        for i, name in enumerate(names):
+            if i == 0:
+                clarification_message += name
+            elif i == len(names) - 1:
+                clarification_message += f" or {name}"
+            else:
+                clarification_message += f", {name}"
+        return clarification_message
+
+    async def run(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Correct the slots."""
+        stack = tracker.stack
+        if not (top := stack.top()):
+            structlogger.warning("action.clarify_flows.no_active_flow")
+            return []
+
+        if not isinstance(top, ClarifyPatternFlowStackFrame):
+            structlogger.warning("action.clarify_flows.no_clarification_frame", top=top)
+            return []
+
+        options_string = self.assemble_options_string(top.names)
+        top.clarification_options = options_string
+        # since we modified the stack frame, we need to update the stack
+        return tracker.create_stack_updated_events(stack)

rasa/dialogue_understanding/patterns/code_change.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+import structlog
+from rasa.dialogue_understanding.stack.frames import (
+    PatternFlowStackFrame,
+)
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+structlogger = structlog.get_logger()
+
+FLOW_PATTERN_CODE_CHANGE_ID = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "code_change"
+
+
+@dataclass
+class CodeChangeFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame which cleans the stack after a bot update."""
+
+    flow_id: str = FLOW_PATTERN_CODE_CHANGE_ID
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_CODE_CHANGE_ID
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> CodeChangeFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return CodeChangeFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/collect_information.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.flows.steps.collect import SlotRejection
+
+
+FLOW_PATTERN_COLLECT_INFORMATION = (
+    RASA_DEFAULT_FLOW_PATTERN_PREFIX + "collect_information"
+)
+
+
+@dataclass
+class CollectInformationPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame which collects information from the user."""
+
+    flow_id: str = FLOW_PATTERN_COLLECT_INFORMATION
+    """The ID of the flow."""
+    collect: str = ""
+    """The information that should be collected from the user.
+    this corresponds to the slot that will be filled."""
+    utter: str = ""
+    """The utter action that should be executed to ask the user for the
+    information."""
+    collect_action: str = ""
+    """The action that should be executed to ask the user for the
+    information."""
+    rejections: Optional[List[SlotRejection]] = None
+    """The predicate check that should be applied to the collected information.
+    If a predicate check fails, its `utter` action indicated under rejections
+    will be executed.
+    """
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return "pattern_collect_information"
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> CollectInformationPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        rejections = data.get("rejections")
+        if rejections is not None:
+            rejections = [
+                SlotRejection.from_dict(rejection) for rejection in rejections
+            ]
+
+        return CollectInformationPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            collect=data["collect"],
+            collect_action=data["collect_action"],
+            utter=data["utter"],
+            rejections=rejections,
+        )
+
+    def context_as_dict(
+        self, underlying_frames: List[DialogueStackFrame]
+    ) -> Dict[str, Any]:
+        """Returns the context of the frame as a dictionary.
+
+        The collect information frame needs a special implementation as
+        it includes the context of the underlying frame in its context.
+
+        This corresponds to the user expectation when e.g. using templates
+        in a collect information node.
+        """
+        context = super().context_as_dict(underlying_frames)
+
+        if underlying_frames:
+            underlying_context = underlying_frames[-1].context_as_dict(
+                underlying_frames[:-1]
+            )
+        else:
+            underlying_context = {}
+
+        # the collect information frame is a special case, as it is not
+        # a regular frame, but a frame that is used to collect information
+
+        context.update(underlying_context)
+        return context

rasa/dialogue_understanding/patterns/completed.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_COMPLETED = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "completed"
+
+
+@dataclass
+class CompletedPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame which gets added if all prior flows are completed."""
+
+    flow_id: str = FLOW_PATTERN_COMPLETED
+    """The ID of the flow."""
+    previous_flow_name: str = ""
+    """The name of the last flow that was completed."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_COMPLETED
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> CompletedPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return CompletedPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            previous_flow_name=data["previous_flow_name"],
+        )

rasa/dialogue_understanding/patterns/continue_interrupted.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_CONTINUE_INTERRUPTED = (
+    RASA_DEFAULT_FLOW_PATTERN_PREFIX + "continue_interrupted"
+)
+
+
+@dataclass
+class ContinueInterruptedPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame that gets added if an interruption is completed."""
+
+    flow_id: str = FLOW_PATTERN_CONTINUE_INTERRUPTED
+    """The ID of the flow."""
+    previous_flow_name: str = ""
+    """The name of the flow that was interrupted."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_CONTINUE_INTERRUPTED
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> ContinueInterruptedPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return ContinueInterruptedPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            previous_flow_name=data["previous_flow_name"],
+        )