rasa-pro 3.8.16__py3-none-any.whl

rasa/dialogue_understanding/generator/nlu_command_adapter.py

@@ -0,0 +1,157 @@
+from typing import Dict, Text, Any, Optional, List
+
+import structlog
+
+from rasa.dialogue_understanding.commands import (
+    Command,
+    StartFlowCommand,
+    SetSlotCommand,
+)
+from rasa.dialogue_understanding.generator import CommandGenerator
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.recipes.default_recipe import DefaultV1Recipe
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.core.flows.flows_list import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.nlu.constants import INTENT
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.training_data.training_data import TrainingData
+
+structlogger = structlog.get_logger()
+
+
+@DefaultV1Recipe.register(
+    [
+        DefaultV1Recipe.ComponentType.COMMAND_GENERATOR,
+    ],
+    is_trainable=False,
+)
+class NLUCommandAdapter(GraphComponent, CommandGenerator):
+    """An NLU-based command generator."""
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> None:
+        super().__init__(config)
+        self.config = {**self.get_default_config(), **config}
+        self._model_storage = model_storage
+        self._resource = resource
+        self._execution_context = execution_context
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> "NLUCommandAdapter":
+        """Creates a new untrained component (see parent class for full docstring)."""
+        return cls(config, model_storage, resource, execution_context)
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        **kwargs: Any,
+    ) -> "NLUCommandAdapter":
+        """Loads trained component (see parent class for full docstring)."""
+        return cls(config, model_storage, resource, execution_context)
+
+    def train(self, training_data: TrainingData) -> Resource:
+        """Trains the NLU command adapter."""
+        return self._resource
+
+    async def predict_commands(
+        self,
+        message: Message,
+        flows: FlowsList,
+        tracker: Optional[DialogueStateTracker] = None,
+    ) -> List[Command]:
+        """Creates commands using the predicted intents.
+
+        Args:
+            message: The message from the user.
+            flows: The flows available to the user.
+            tracker: The tracker containing the current state of the conversation.
+
+        Returns:
+            The commands triggered by NLU.
+        """
+        if tracker is None or flows.is_empty():
+            # cannot do anything if there are no flows or no tracker
+            return []
+
+        commands = self.convert_nlu_to_commands(message, tracker, flows)
+
+        if commands and len(commands) >= 1 and tracker.has_coexistence_routing_slot:
+            # if the nlu command adapter will start a flow and the coexistence feature
+            # is used, make sure to set the routing slot
+            commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True)]
+
+        # TODO:
+        #    (May 30th, 2024)
+        #    This code within the can be removed once the cleaning process
+        #    is applied by default for every instance of the command generator
+        #    class.
+        #    Ticket: https://rasahq.atlassian.net/browse/ENG-1076
+        from rasa.dialogue_understanding.processor.command_processor import (
+            clean_up_commands,
+        )
+
+        structlogger.info("nlu_command_adapter.cleaning_commands", commands=commands)
+        if commands:
+            commands = clean_up_commands(
+                commands, tracker, flows, self._execution_context
+            )
+            structlogger.info(
+                "nlu_command_adapter.clean_commands", clean_commands=commands
+            )
+
+        return commands
+
+    @staticmethod
+    def convert_nlu_to_commands(
+        message: Message, tracker: DialogueStateTracker, flows: FlowsList
+    ) -> List[Command]:
+        """Converts the predicted intent to a command."""
+        if tracker is None or flows.is_empty():
+            # cannot do anything if there are no flows or no tracker
+            return []
+
+        if not message.get(INTENT) or not message.get(INTENT)["name"]:
+            # if the message does not have an intent set,
+            # no commands can be predicted
+            return []
+
+        commands: List[Command] = []
+
+        for flow in flows:
+            if flow.nlu_triggers and flow.nlu_triggers.is_triggered(message):
+                commands.append(StartFlowCommand(flow.id))
+
+        structlogger.info("nlu_command_adapter.predict_commands", commands=commands)
+
+        # there should be just one flow that can be triggered by the predicted intent
+        # this is checked when loading the flows
+        # however we just doublecheck here and return the first command if there are
+        # multiple flows triggered by the intent
+        if len(commands) > 1:
+            structlogger.warning(
+                "nlu_command_adapter.predict_commands",
+                messag=f"Two many flows found that are triggered by the "
+                f"intent '{message.get(INTENT)['name']}'. Take the first one.",
+                commands=commands,
+            )
+            commands = [commands[0]]
+
+        return commands

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"],
+        )