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

rasa/dialogue_understanding/commands/handle_digressions_command.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+
+from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.patterns.cannot_handle import (
+    CannotHandlePatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.handle_digressions import (
+    HandleDigressionsPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import (
+    top_flow_frame,
+    user_flows_on_the_stack,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.steps import CollectInformationFlowStep
+from rasa.shared.core.flows.utils import ALL_LABEL
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.nlu.constants import HANDLE_DIGRESSIONS_COMMAND
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class HandleDigressionsCommand(Command):
+    """A command to handle digressions during an active flow."""
+
+    flow: str
+    """The interrupting flow."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return HANDLE_DIGRESSIONS_COMMAND
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> HandleDigressionsCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        try:
+            return HandleDigressionsCommand(flow=data["flow"])
+        except KeyError as e:
+            raise ValueError(
+                f"Missing parameter '{e}' while parsing HandleDigressionsCommand."
+            ) 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
+
+        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.push_cannot_handle.start_invalid_flow_id",
+                command=self,
+            )
+            stack.push(CannotHandlePatternFlowStackFrame())
+            return tracker.create_stack_updated_events(stack)
+
+        # this allows to include called user flows in the stack search
+        latest_user_frame = top_flow_frame(original_stack, ignore_call_frames=False)
+
+        if latest_user_frame is None:
+            structlogger.debug(
+                "command_executor.skip_command.no_top_flow", command=self
+            )
+            return []
+
+        original_top_flow = latest_user_frame.flow(all_flows)
+        current_step = original_top_flow.step_by_id(latest_user_frame.step_id)
+        if not isinstance(current_step, CollectInformationFlowStep):
+            structlogger.debug(
+                "command_executor.skip_command.not_at_a_collect_step", command=self
+            )
+            return []
+
+        ask_confirm_digressions = set(
+            current_step.ask_confirm_digressions
+            + original_top_flow.ask_confirm_digressions
+        )
+
+        block_digressions = set(
+            current_step.block_digressions + original_top_flow.block_digressions
+        )
+
+        if block_digressions:
+            if ALL_LABEL in block_digressions:
+                block_digressions.remove(ALL_LABEL)
+                block_digressions.add(self.flow)
+
+        if ask_confirm_digressions:
+            if ALL_LABEL in ask_confirm_digressions:
+                ask_confirm_digressions.remove(ALL_LABEL)
+                ask_confirm_digressions.add(self.flow)
+
+        structlogger.debug(
+            "command_executor.push_handle_digressions",
+            interrupting_flow_id=self.flow,
+            interrupted_flow_id=original_top_flow.id,
+            interrupted_step_id=current_step.id,
+            ask_confirm_digressions=ask_confirm_digressions,
+            block_digressions=block_digressions,
+        )
+        stack.push(
+            HandleDigressionsPatternFlowStackFrame(
+                interrupting_flow_id=self.flow,
+                interrupted_flow_id=original_top_flow.id,
+                interrupted_step_id=current_step.id,
+                ask_confirm_digressions=ask_confirm_digressions,
+                block_digressions=block_digressions,
+            )
+        )
+
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.flow)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, HandleDigressionsCommand):
+            return False
+
+        return other.flow == self.flow

rasa/dialogue_understanding/commands/human_handoff_command.py

@@ -7,6 +7,10 @@ from typing import Any, Dict, List
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.human_handoff import (
     HumanHandoffPatternFlowStackFrame,
 )
@@ -66,7 +70,14 @@ class HumanHandoffCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "hand over"
+        mapper = {
+            CommandSyntaxVersion.v1: "HumanHandoff()",
+            CommandSyntaxVersion.v2: "hand over",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> HumanHandoffCommand:
@@ -75,4 +86,11 @@ class HumanHandoffCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^hand over$"
+        mapper = {
+            CommandSyntaxVersion.v1: r"HumanHandoff\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*hand over$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -4,6 +4,10 @@ import re
 from dataclasses import dataclass
 from typing import Any, Dict, List
 
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
@@ -59,7 +63,14 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "provide info"
+        mapper = {
+            CommandSyntaxVersion.v1: "SearchAndReply()",
+            CommandSyntaxVersion.v2: "provide info",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> KnowledgeAnswerCommand:
@@ -68,4 +79,11 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^provide info$"
+        mapper = {
+            CommandSyntaxVersion.v1: r"SearchAndReply\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*provide info$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/prompt_command.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional, Protocol, runtime_checkable
+
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@runtime_checkable
+class PromptCommand(Protocol):
+    """
+    A protocol for commands predicted by the LLM model and incorporated into the prompt.
+    """
+
+    @classmethod
+    def command(cls) -> str:
+        """
+        Returns the command name.
+
+        This class method should be implemented to return the name of the command.
+        """
+        ...
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> PromptCommand:
+        """
+        Converts the dictionary to a command.
+
+        This class method should be implemented to create a command instance from the
+        given dictionary.
+        """
+        ...
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """
+        Runs the command on the tracker.
+
+        This method should be implemented to execute the command on the given tracker.
+        """
+        ...
+
+    def __hash__(self) -> int:
+        """
+        Returns the hash of the command.
+
+        This method should be implemented to return the hash of the command.
+        Useful for comparing commands and storing them in sets.
+        """
+        ...
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Compares the command with another object.
+
+        This method should be implemented to compare the command with another object.
+        """
+        ...
+
+    def to_dsl(self) -> str:
+        """
+        Converts the command to a DSL string.
+
+        This method should be implemented to convert the command to a DSL string.
+        A DSL string is a string representation of the command that is used in the
+        prompt.
+        """
+        ...
+
+    @classmethod
+    def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[PromptCommand]:
+        """
+        Converts the regex match to a command.
+
+        This class method should be implemented to create a command instance from the
+        given DSL string.
+        """
+        ...
+
+    @staticmethod
+    def regex_pattern() -> str:
+        """
+        Returns the regex pattern for the command.
+
+        This method should be implemented to return the regex pattern that matches the
+        command in the prompt.
+        """
+        ...

rasa/dialogue_understanding/commands/repeat_bot_messages_command.py

@@ -5,6 +5,10 @@ from dataclasses import dataclass
 from typing import Any, Dict, List
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.repeat import (
     RepeatBotMessagesPatternFlowStackFrame,
 )
@@ -60,7 +64,14 @@ class RepeatBotMessagesCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "repeat message"
+        mapper = {
+            CommandSyntaxVersion.v1: "RepeatLastBotMessages()",
+            CommandSyntaxVersion.v2: "repeat message",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> RepeatBotMessagesCommand:
@@ -69,4 +80,11 @@ class RepeatBotMessagesCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^repeat message$"
+        mapper = {
+            CommandSyntaxVersion.v1: r"RepeatLastBotMessages\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*repeat message$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/set_slot_command.py

@@ -2,12 +2,15 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any, Dict, List
 
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.commands.utils import (
     clean_extracted_value,
     get_nullable_slot_value,
@@ -19,6 +22,7 @@ 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.constants import SetSlotExtractor
 from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -27,17 +31,6 @@ 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]:
@@ -137,6 +130,7 @@ class SetSlotCommand(Command):
             in {
                 SetSlotExtractor.LLM.value,
                 SetSlotExtractor.COMMAND_PAYLOAD_READER.value,
+                SetSlotExtractor.NLU.value,
             }
         ):
             # Get the other predicted flows from the most recent message on the tracker.
@@ -154,7 +148,9 @@ class SetSlotCommand(Command):
                 return []
 
         structlogger.debug("command_executor.set_slot", command=self)
-        return [SlotSet(self.name, slot.coerce_value(self.value))]
+        return [
+            SlotSet(self.name, slot.coerce_value(self.value), filled_by=self.extractor)
+        ]
 
     def __hash__(self) -> int:
         return hash(self.value) + hash(self.name)
@@ -170,7 +166,14 @@ class SetSlotCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"set slot {self.name} {self.value}"
+        mapper = {
+            CommandSyntaxVersion.v1: f"SetSlot({self.name}, {self.value})",
+            CommandSyntaxVersion.v2: f"set slot {self.name} {self.value}",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SetSlotCommand:
@@ -181,4 +184,15 @@ class SetSlotCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"""^set slot ['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]? ['"]?(.+?)['"]?$"""
+        mapper = {
+            CommandSyntaxVersion.v1: (
+                r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
+            ),
+            CommandSyntaxVersion.v2: (
+                r"""^[^\w]*set slot ['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]? ['"]?(.+?)['"]?$"""  # noqa: E501
+            ),
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/skip_question_command.py

@@ -7,6 +7,10 @@ from typing import Any, Dict, List
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.skip_question import (
     SkipQuestionPatternFlowStackFrame,
 )
@@ -75,7 +79,14 @@ class SkipQuestionCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "skip"
+        mapper = {
+            CommandSyntaxVersion.v1: "SkipQuestion()",
+            CommandSyntaxVersion.v2: "skip question",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SkipQuestionCommand:
@@ -84,4 +95,11 @@ class SkipQuestionCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^skip$"
+        mapper = {
+            CommandSyntaxVersion.v1: r"SkipQuestion\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*skip question$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -7,6 +7,15 @@ from typing import Any, Dict, List, Optional
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
+from rasa.dialogue_understanding.patterns.clarify import FLOW_PATTERN_CLARIFICATION
+from rasa.dialogue_understanding.patterns.continue_interrupted import (
+    ContinueInterruptedPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     FlowStackFrameType,
     UserFlowStackFrame,
@@ -68,6 +77,10 @@ class StartFlowCommand(Command):
         applied_events: List[Event] = []
 
         if self.flow in user_flows_on_the_stack(stack):
+            top_frame = stack.top()
+            if top_frame is not None and top_frame.type() == FLOW_PATTERN_CLARIFICATION:
+                return self.change_flow_frame_position_in_the_stack(stack, tracker)
+
             structlogger.debug(
                 "command_executor.skip_command.already_started_flow", command=self
             )
@@ -110,7 +123,14 @@ class StartFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"start flow {self.flow}"
+        mapper = {
+            CommandSyntaxVersion.v1: f"StartFlow({self.flow})",
+            CommandSyntaxVersion.v2: f"start flow {self.flow}",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[StartFlowCommand]:
@@ -119,4 +139,43 @@ class StartFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^start flow ['\"]?([a-zA-Z0-9_-]+)['\"]?$"
+        mapper = {
+            CommandSyntaxVersion.v1: r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*start flow ['\"]?([a-zA-Z0-9_-]+)['\"]?",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
+
+    def change_flow_frame_position_in_the_stack(
+        self, stack: DialogueStack, tracker: DialogueStateTracker
+    ) -> List[Event]:
+        """Changes the position of the flow frame in the stack.
+
+        This is a special case when pattern clarification is the active flow and
+        the same flow is selected to start. In this case, the existing flow frame
+        should be moved up in the stack.
+        """
+        frames = stack.frames[:]
+
+        for idx, frame in enumerate(frames):
+            if isinstance(frame, UserFlowStackFrame) and frame.flow_id == self.flow:
+                structlogger.debug(
+                    "command_executor.change_flow_position_during_clarification",
+                    command=self,
+                    index=idx,
+                )
+                # pop the continue interrupted flow frame if it exists
+                next_frame = frames[idx + 1] if idx + 1 < len(frames) else None
+                if (
+                    isinstance(next_frame, ContinueInterruptedPatternFlowStackFrame)
+                    and next_frame.previous_flow_name == self.flow
+                ):
+                    stack.frames.pop(idx + 1)
+                # move up the existing flow from the stack
+                stack.frames.pop(idx)
+                stack.push(frame)
+                return tracker.create_stack_updated_events(stack)
+
+        return []