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

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import FreeFormAnswerCommand
+from rasa.dialogue_understanding.patterns.search import SearchPatternFlowStackFrame
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class KnowledgeAnswerCommand(FreeFormAnswerCommand):
+    """A command to indicate a knowledge-based free-form answer by the bot."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "knowledge"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> KnowledgeAnswerCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return KnowledgeAnswerCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        stack.push(SearchPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, KnowledgeAnswerCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/noop_command.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class NoopCommand(Command):
+    """A command to indicate that nothing needs to be done."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "noop"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> NoopCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return NoopCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        return []
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, NoopCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/repeat_bot_messages_command.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.repeat import (
+    RepeatBotMessagesPatternFlowStackFrame,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class RepeatBotMessagesCommand(Command):
+    """A command to indicate that the bot should repeat its last messages."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "repeat"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> RepeatBotMessagesCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return RepeatBotMessagesCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+        Get all the bot utterances until last user utterance and repeat them.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        stack.push(RepeatBotMessagesPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RepeatBotMessagesCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/restart_command.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.restart import RestartPatternFlowStackFrame
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class RestartCommand(Command):
+    """A command to restart a session."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "restart"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> RestartCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return RestartCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        stack.push(RestartPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RestartCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/session_end_command.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.shared.core.events import Event, SessionEnded
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class SessionEndCommand(Command):
+    """A command to indicate the end of a session."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "session end"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SessionEndCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return SessionEndCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        metadata = {"_reason": "user disconnected"}
+
+        # Add metadata sent by the channel connector, if available
+        if tracker.latest_message:
+            user_metadata = tracker.latest_message.metadata or {}
+            metadata.update(user_metadata)
+
+        return [SessionEnded(metadata=metadata)]
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SessionEndCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/session_start_command.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.session_start import (
+    SessionStartPatternFlowStackFrame,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class SessionStartCommand(Command):
+    """A command to indicate the start of a session."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "session start"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SessionStartCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return SessionStartCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        stack.push(SessionStartPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SessionStartCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/set_slot_command.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List
+
+import structlog
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import (
+    get_collect_steps_excluding_ask_before_filling_for_active_flow,
+)
+from rasa.shared.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.nlu.constants import SET_SLOT_COMMAND
+
+structlogger = structlog.get_logger()
+
+
+class SetSlotExtractor(Enum):
+    """The extractors that can set a slot."""
+
+    LLM = "LLM"
+    COMMAND_PAYLOAD_READER = "CommandPayloadReader"
+    NLU = "NLU"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+def get_flows_predicted_to_start_from_tracker(
+    tracker: DialogueStateTracker,
+) -> List[str]:
+    """Returns the flows that are predicted to start from the current state.
+
+    Args:
+        tracker: The tracker to use.
+
+    Returns:
+        The flows that are predicted to start from the current state.
+    """
+    from rasa.dialogue_understanding.processor.command_processor import (
+        get_commands_from_tracker,
+        filter_start_flow_commands,
+    )
+
+    commands = get_commands_from_tracker(tracker)
+    return filter_start_flow_commands(commands)
+
+
+@dataclass
+class SetSlotCommand(Command):
+    """A command to set a slot."""
+
+    name: str
+    value: Any
+    extractor: str = SetSlotExtractor.LLM.value
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return SET_SLOT_COMMAND
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SetSlotCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        try:
+            return SetSlotCommand(
+                name=data["name"],
+                value=data["value"],
+                extractor=data.get("extractor", SetSlotExtractor.LLM.value),
+            )
+        except KeyError as e:
+            raise ValueError(f"Missing key when parsing SetSlotCommand: {e}") from e
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        slot = tracker.slots.get(self.name)
+        if slot is None:
+            structlogger.debug(
+                "command_executor.skip_command.slot_not_in_domain", command=self
+            )
+            return []
+
+        if slot.has_same_coerced_value(self.value):
+            # value hasn't changed, skip this one
+            structlogger.debug(
+                "command_executor.skip_command.slot_already_set", command=self
+            )
+            return []
+
+        # Get slots of the active flow
+        slots_of_active_flow = (
+            get_collect_steps_excluding_ask_before_filling_for_active_flow(
+                tracker.stack, all_flows
+            )
+        )
+
+        # Add slots that are asked in the current collect step. This is needed
+        # to include slots that has ask_before_filling set to True.
+        top_frame = tracker.stack.top()
+        if isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            slots_of_active_flow.add(top_frame.collect)
+
+        if (
+            self.name not in slots_of_active_flow
+            and self.name != ROUTE_TO_CALM_SLOT
+            and self.extractor
+            in {
+                SetSlotExtractor.LLM.value,
+                SetSlotExtractor.COMMAND_PAYLOAD_READER.value,
+            }
+        ):
+            # Get the other predicted flows from the most recent message on the tracker.
+            predicted_flows = get_flows_predicted_to_start_from_tracker(tracker)
+            use_slot_fill = any(
+                step.collect == self.name and not step.ask_before_filling
+                for flow in all_flows.underlying_flows
+                if flow.id in predicted_flows
+                for step in flow.get_collect_steps()
+            )
+            if not use_slot_fill:
+                structlogger.debug(
+                    "command_executor.skip_command.slot_not_asked_for", command=self
+                )
+                return []
+
+        structlogger.debug("command_executor.set_slot", command=self)
+        return [SlotSet(self.name, slot.coerce_value(self.value))]
+
+    def __hash__(self) -> int:
+        return hash(self.value) + hash(self.name)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SetSlotCommand):
+            return False
+
+        return other.value == self.value and other.name == self.name

rasa/dialogue_understanding/commands/skip_question_command.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.skip_question import (
+    SkipQuestionPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows.flows_list import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class SkipQuestionCommand(Command):
+    """A command that registers the user intent to skip the current question / step in
+    the flow.
+    """
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "skip question"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SkipQuestionCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return SkipQuestionCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        user_frame = top_user_flow_frame(original_tracker.stack)
+        current_flow = user_frame.flow(all_flows) if user_frame else None
+
+        if not current_flow:
+            structlogger.debug(
+                "command_executor.skip_question.no_active_flow", command=self
+            )
+            return []
+
+        stack.push(SkipQuestionPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SkipQuestionCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import (
+    top_user_flow_frame,
+    user_flows_on_the_stack,
+)
+from rasa.shared.core.events import Event, FlowInterrupted
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class StartFlowCommand(Command):
+    """A command to start a flow."""
+
+    flow: str
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "start flow"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> StartFlowCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        try:
+            return StartFlowCommand(flow=data["flow"])
+        except KeyError as e:
+            raise ValueError(
+                f"Missing parameter '{e}' while parsing StartFlowCommand."
+            ) from e
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        original_stack = original_tracker.stack
+        applied_events: List[Event] = []
+
+        if self.flow in user_flows_on_the_stack(stack):
+            structlogger.debug(
+                "command_executor.skip_command.already_started_flow", command=self
+            )
+            return []
+        elif self.flow not in all_flows.flow_ids:
+            structlogger.debug(
+                "command_executor.skip_command.start_invalid_flow_id", command=self
+            )
+            return []
+
+        original_user_frame = top_user_flow_frame(original_stack)
+        original_top_flow = (
+            original_user_frame.flow(all_flows) if original_user_frame else None
+        )
+
+        frame_type = FlowStackFrameType.REGULAR
+
+        if original_top_flow:
+            frame_type = FlowStackFrameType.INTERRUPT
+
+            if original_user_frame is not None:
+                applied_events.append(
+                    FlowInterrupted(
+                        original_user_frame.flow_id, original_user_frame.step_id
+                    )
+                )
+
+        structlogger.debug("command_executor.start_flow", command=self)
+        stack.push(UserFlowStackFrame(flow_id=self.flow, frame_type=frame_type))
+        return applied_events + tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.flow)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, StartFlowCommand):
+            return False
+
+        return other.flow == self.flow