rasa-pro 3.11.5__py3-none-any.whl → 3.12.0__py3-none-any.whl

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -1,10 +1,21 @@
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 import structlog
-from rasa.dialogue_understanding.commands import Command
+
+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,
@@ -66,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
             )
@@ -105,3 +120,64 @@ class StartFlowCommand(Command):
             return False
 
         return other.flow == self.flow
+
+    def to_dsl(self) -> str:
+        """Converts the command to a DSL string."""
+        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]:
+        """Converts the DSL string to a command."""
+        return StartFlowCommand(flow=str(match.group(1).strip()))
+
+    @staticmethod
+    def regex_pattern() -> str:
+        mapper = {
+            CommandSyntaxVersion.v1: r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)",
+            CommandSyntaxVersion.v2: (
+                r"""^[\s\W\d]*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 []

rasa/dialogue_understanding/commands/user_silence_command.py

@@ -2,7 +2,8 @@ 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.commands.command import Command
 from rasa.dialogue_understanding.patterns.user_silence import (
     UserSilencePatternFlowStackFrame,
 )
@@ -53,7 +54,4 @@ class UserSilenceCommand(Command):
         return hash(self.command())
 
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, UserSilenceCommand):
-            return False
-
-        return True
+        return isinstance(other, UserSilenceCommand)

rasa/dialogue_understanding/commands/utils.py

@@ -1,45 +1,128 @@
-from typing import Dict, Type
-
-from rasa.dialogue_understanding.commands import (
-    CancelFlowCommand,
-    CannotHandleCommand,
-    ChitChatAnswerCommand,
-    Command,
-    HumanHandoffCommand,
-    KnowledgeAnswerCommand,
-    SessionStartCommand,
-    SkipQuestionCommand,
-    RestartCommand,
-)
-from rasa.dialogue_understanding.commands.user_silence_command import UserSilenceCommand
-from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
-from rasa.dialogue_understanding.patterns.cannot_handle import (
-    CannotHandlePatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.chitchat import ChitchatPatternFlowStackFrame
-from rasa.dialogue_understanding.patterns.human_handoff import (
-    HumanHandoffPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.restart import RestartPatternFlowStackFrame
-from rasa.dialogue_understanding.patterns.search import SearchPatternFlowStackFrame
-from rasa.dialogue_understanding.patterns.session_start import (
-    SessionStartPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.skip_question import (
-    SkipQuestionPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.user_silence import (
-    UserSilencePatternFlowStackFrame,
+from typing import TYPE_CHECKING, List, Optional, Tuple, Union
+
+import structlog
+
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
 )
+from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.slots import Slot
+from rasa.shared.core.trackers import DialogueStateTracker
+
+if TYPE_CHECKING:
+    from rasa.dialogue_understanding.commands import StartFlowCommand
+    from rasa.shared.core.flows import FlowsList
+
+structlogger = structlog.get_logger()
+
+
+def start_flow_by_name(
+    flow_name: str, flows: "FlowsList"
+) -> Optional["StartFlowCommand"]:
+    from rasa.dialogue_understanding.commands import StartFlowCommand
+
+    if flow_name in flows.user_flow_ids:
+        return StartFlowCommand(flow=flow_name)
+    else:
+        structlogger.debug(
+            "command_parser.start_flow_by_name.invalid_flow_id", flow=flow_name
+        )
+        return None
+
+
+def extract_cleaned_options(options_str: str) -> List[str]:
+    """Extract and clean options from a string."""
+    delimiters = [",", " "]
+
+    for delimiter in delimiters:
+        options_str = options_str.replace(delimiter, " ")
+
+    return sorted(
+        opt.strip().strip('"').strip("'") for opt in options_str.split() if opt.strip()
+    )
+
+
+def is_none_value(value: str) -> bool:
+    """Check if the value is a none value."""
+    if not value:
+        return True
+    return value in {
+        "[missing information]",
+        "[missing]",
+        "None",
+        "undefined",
+        "null",
+    }
+
+
+def clean_extracted_value(value: str) -> str:
+    """Clean up the extracted value from the llm."""
+    # replace any combination of single quotes, double quotes, and spaces
+    # from the beginning and end of the string
+    return value.strip("'\" ")
+
+
+def get_nullable_slot_value(slot_value: str) -> Union[str, None]:
+    """Get the slot value or None if the value is a none value.
+
+    Args:
+        slot_value: the value to coerce
+
+    Returns:
+        The slot value or None if the value is a none value.
+    """
+    return slot_value if not is_none_value(slot_value) else None
+
+
+def initialize_pattern_validate_slot(
+    slot: Slot,
+) -> Optional[ValidateSlotPatternFlowStackFrame]:
+    """Initialize the pattern to validate a slot value."""
+    if not slot.requires_validation():
+        return None
+
+    validation = slot.validation
+    slot_name = slot.name
+    return ValidateSlotPatternFlowStackFrame(
+        validate=slot_name,
+        refill_utter=validation.refill_utter or f"{UTTER_ASK_PREFIX}{slot_name}",  # type: ignore[union-attr]
+        refill_action=f"{ACTION_ASK_PREFIX}{slot_name}",
+        rejections=validation.rejections,  # type: ignore[union-attr]
+    )
+
+
+def create_validate_frames_from_slot_set_events(
+    tracker: DialogueStateTracker,
+    events: List[Event],
+    validate_frames: List[ValidateSlotPatternFlowStackFrame] = [],
+    should_break: bool = False,
+) -> Tuple[DialogueStateTracker, List[ValidateSlotPatternFlowStackFrame]]:
+    """Process SlotSet events and create validation frames.
+
+    Args:
+        tracker: The dialogue state tracker.
+        events: List of events to process.
+        should_break:  whether or not to break after the first non-SlotSet event.
+            if True, break out of the event loop as soon as the first non-SlotSet
+            event is encountered.
+            if False, continue processing the events until the end.
+
+    Returns:
+        Tuple of (updated tracker, list of validation frames).
+    """
+    for event in events:
+        if not isinstance(event, SlotSet):
+            if should_break:
+                # we want to only process the most recent SlotSet events
+                # so we break once we encounter a different event
+                break
+            continue
+
+        slot = tracker.slots.get(event.key)
+        frame = initialize_pattern_validate_slot(slot)
+
+        if frame:
+            validate_frames.append(frame)
 
-triggerable_pattern_to_command_class: Dict[str, Type[Command]] = {
-    SessionStartPatternFlowStackFrame.flow_id: SessionStartCommand,
-    UserSilencePatternFlowStackFrame.flow_id: UserSilenceCommand,
-    CancelPatternFlowStackFrame.flow_id: CancelFlowCommand,
-    ChitchatPatternFlowStackFrame.flow_id: ChitChatAnswerCommand,
-    HumanHandoffPatternFlowStackFrame.flow_id: HumanHandoffCommand,
-    SearchPatternFlowStackFrame.flow_id: KnowledgeAnswerCommand,
-    SkipQuestionPatternFlowStackFrame.flow_id: SkipQuestionCommand,
-    CannotHandlePatternFlowStackFrame.flow_id: CannotHandleCommand,
-    RestartPatternFlowStackFrame.flow_id: RestartCommand,
-}
+    return tracker, validate_frames

rasa/dialogue_understanding/constants.py

@@ -0,0 +1,2 @@
+RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME = "RASA_RECORD_COMMANDS_AND_PROMPTS"
+KEY_MINIMIZE_NUM_CALLS = "minimize_num_calls"

rasa/dialogue_understanding/generator/__init__.py

@@ -9,6 +9,7 @@ from rasa.dialogue_understanding.generator.multi_step.multi_step_llm_command_gen
     MultiStepLLMCommandGenerator,
 )
 from rasa.dialogue_understanding.generator.single_step.single_step_llm_command_generator import (  # noqa: E501
+    CompactLLMCommandGenerator,
     SingleStepLLMCommandGenerator,
 )
 
@@ -18,4 +19,5 @@ __all__ = [
     "LLMCommandGenerator",
     "MultiStepLLMCommandGenerator",
     "SingleStepLLMCommandGenerator",
+    "CompactLLMCommandGenerator",
 ]

rasa/dialogue_understanding/generator/command_generator.py

@@ -1,27 +1,31 @@
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict, List, Optional, Set, Text, Tuple
 
 import structlog
 
 from rasa.dialogue_understanding.commands import (
     Command,
+    CorrectSlotsCommand,
+    ErrorCommand,
     SetSlotCommand,
     StartFlowCommand,
-    ErrorCommand,
 )
-from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
-from rasa.shared.core.constants import SlotMappingType
+from rasa.dialogue_understanding.utils import (
+    _handle_via_nlu_in_coexistence,
+)
+from rasa.shared.constants import (
+    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
+    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
+)
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.slot_mappings import SlotFillingManager
 from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.nlu.constants import (
+    COMMANDS,
+    TEXT,
+)
 from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.nlu.constants import COMMANDS, TEXT
 from rasa.shared.utils.llm import DEFAULT_MAX_USER_INPUT_CHARACTERS
-from rasa.shared.constants import (
-    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
-    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
-)
 
 structlogger = structlog.get_logger()
 
@@ -89,9 +93,9 @@ class CommandGenerator:
         )
 
         for message in messages:
-            if message.get(COMMANDS):
-                # do not overwrite commands if they are already present
-                # i.e. another command generator already predicted commands
+            if _handle_via_nlu_in_coexistence(tracker, message):
+                # Skip running the CALM pipeline if the message should
+                # be handled by the NLU-based system in a coexistence mode.
                 continue
 
             commands = await self._evaluate_and_predict(
@@ -103,9 +107,6 @@ class CommandGenerator:
             commands = self._check_commands_against_startable_flows(
                 commands, startable_flows
             )
-            commands = self._check_commands_against_slot_mappings(
-                commands, tracker, domain
-            )
             commands_dicts = [command.as_dict() for command in commands]
             message.set(COMMANDS, commands_dicts, add_to_output=True)
 
@@ -193,11 +194,100 @@ class CommandGenerator:
             flows: The flows to use for command prediction.
             tracker: The tracker containing the conversation history up to now.
             **kwargs: Keyword arguments for forward compatibility.
+
         Returns:
         The predicted commands.
         """
         raise NotImplementedError()
 
+    def _check_commands_overlap(
+        self, prior_commands: List[Command], commands: List[Command]
+    ) -> List[Command]:
+        """Check if there is overlap between the prior commands and the current ones.
+
+        Args:
+            prior_commands: The prior commands.
+            commands: The commands to check.
+
+        Returns:
+            The final commands.
+        """
+        if not prior_commands:
+            return commands
+
+        prior_commands, commands = self._check_slot_command_overlap(
+            prior_commands, commands
+        )
+
+        prior_start_flow_names = {
+            command.flow
+            for command in prior_commands
+            if isinstance(command, StartFlowCommand)
+        }
+        current_start_flow_names = {
+            command.flow
+            for command in commands
+            if isinstance(command, StartFlowCommand)
+        }
+
+        return self._check_start_flow_command_overlap(
+            prior_commands,
+            commands,
+            prior_start_flow_names,
+            current_start_flow_names,
+        )
+
+    def _check_start_flow_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        prior_start_flow_names: Set[str],
+        current_start_flow_names: Set[str],
+    ) -> List[Command]:
+        """Get the final commands.
+
+        Args:
+            prior_commands: The prior commands.
+            commands: The currently predicted commands to check.
+            prior_start_flow_names: The names of the flows from the prior commands.
+            current_start_flow_names: The names of the flows from the current commands.
+
+        Returns:
+            The final commands.
+        """
+        raise NotImplementedError()
+
+    def _check_slot_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Check if the current commands overlap with the prior commands."""
+        prior_slot_names = gather_slot_names(prior_commands)
+        current_slot_names = gather_slot_names(commands)
+        overlapping_slot_names = prior_slot_names.intersection(current_slot_names)
+
+        structlogger.debug(
+            "command_generator.check_slot_command_overlap",
+            overlapping_slot_names=overlapping_slot_names,
+        )
+
+        if not overlapping_slot_names:
+            return prior_commands, commands
+
+        return self._filter_slot_commands(
+            prior_commands, commands, overlapping_slot_names
+        )
+
+    def _filter_slot_commands(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        overlapping_slot_names: Set[str],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Filter out the overlapping slot commands."""
+        raise NotImplementedError()
+
     def _check_commands_against_startable_flows(
         self, commands: List[Command], startable_flows: FlowsList
     ) -> List[Command]:
@@ -274,70 +364,21 @@ class CommandGenerator:
         return len(message.get(TEXT, "").strip()) == 0
 
     @staticmethod
-    def _check_commands_against_slot_mappings(
-        commands: List[Command],
-        tracker: DialogueStateTracker,
-        domain: Optional[Domain] = None,
-    ) -> List[Command]:
-        """Check if the LLM-issued slot commands are fillable.
-
-        The LLM-issued slot commands are fillable if the slot
-        mappings are satisfied.
-        """
-        if not domain:
-            return commands
-
-        llm_fillable_slot_names = [
-            command.name
-            for command in commands
-            if isinstance(command, SetSlotCommand)
-            and command.extractor == SetSlotExtractor.LLM.value
+    def _get_prior_commands(message: Message) -> List[Command]:
+        """Get the prior commands from the tracker."""
+        return [
+            Command.command_from_json(command) for command in message.get(COMMANDS, [])
         ]
 
-        if not llm_fillable_slot_names:
-            return commands
 
-        llm_fillable_slots = [
-            slot for slot in domain.slots if slot.name in llm_fillable_slot_names
-        ]
-
-        slot_filling_manager = SlotFillingManager(domain, tracker)
-        slots_to_be_removed = []
-
-        structlogger.debug(
-            "command_processor.check_commands_against_slot_mappings.active_flow",
-            active_flow=tracker.active_flow,
-        )
-
-        for slot in llm_fillable_slots:
-            should_fill_slot = False
-            for mapping in slot.mappings:
-                mapping_type = SlotMappingType(mapping.get("type"))
-
-                should_fill_slot = slot_filling_manager.should_fill_slot(
-                    slot.name, mapping_type, mapping
-                )
-
-                if should_fill_slot:
-                    break
-
-            if not should_fill_slot:
-                structlogger.debug(
-                    "command_processor.check_commands_against_slot_mappings.slot_not_fillable",
-                    slot_name=slot.name,
-                )
-                slots_to_be_removed.append(slot.name)
-
-        if not slots_to_be_removed:
-            return commands
-
-        filtered_commands = [
-            command
-            for command in commands
-            if not (
-                isinstance(command, SetSlotCommand)
-                and command.name in slots_to_be_removed
-            )
-        ]
+def gather_slot_names(commands: List[Command]) -> Set[str]:
+    """Gather all slot names from the commands."""
+    slot_names = set()
+    for command in commands:
+        if isinstance(command, SetSlotCommand):
+            slot_names.add(command.name)
+        if isinstance(command, CorrectSlotsCommand):
+            for slot in command.corrected_slots:
+                slot_names.add(slot.name)
 
-        return filtered_commands
+    return slot_names