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

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import copy
 import re
 from dataclasses import dataclass
 from typing import Any, Dict, List
@@ -9,11 +8,8 @@ import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
-from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
-from rasa.dialogue_understanding.stack.frames import (
-    UserFlowStackFrame,
-)
+from rasa.dialogue_understanding.stack.frames import UserFlowStackFrame
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import FlowStackFrameType
 from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
 from rasa.shared.core.events import Event, FlowCancelled
@@ -93,8 +89,7 @@ class CancelFlowCommand(Command):
         original_stack = original_tracker.stack
 
         applied_events: List[Event] = []
-        # capture the top frame before we push new frames onto the stack
-        initial_top_frame = stack.top()
+
         user_frame = top_user_flow_frame(original_stack)
         current_flow = user_frame.flow(all_flows) if user_frame else None
 
@@ -119,21 +114,6 @@ class CancelFlowCommand(Command):
         if user_frame:
             applied_events.append(FlowCancelled(user_frame.flow_id, user_frame.step_id))
 
-        if initial_top_frame and isinstance(
-            initial_top_frame, ClarifyPatternFlowStackFrame
-        ):
-            structlogger.debug(
-                "command_executor.cancel_flow.cancel_clarification_options",
-                clarification_options=initial_top_frame.clarification_options,
-            )
-            applied_events += cancel_all_pending_clarification_options(
-                initial_top_frame,
-                original_stack,
-                canceled_frames,
-                all_flows,
-                stack,
-            )
-
         return applied_events + tracker.create_stack_updated_events(stack)
 
     def __hash__(self) -> int:
@@ -144,7 +124,7 @@ class CancelFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "CancelFlow()"
+        return "cancel flow"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> CancelFlowCommand:
@@ -153,42 +133,4 @@ class CancelFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"CancelFlow\(\)"
-
-
-def cancel_all_pending_clarification_options(
-    initial_top_frame: ClarifyPatternFlowStackFrame,
-    original_stack: DialogueStack,
-    canceled_frames: List[str],
-    all_flows: FlowsList,
-    stack: DialogueStack,
-) -> List[FlowCancelled]:
-    """Cancel all pending clarification options.
-
-    This is a special case when the assistant asks the user to clarify
-    which pending digression flow to start after the completion of an active flow.
-    If the user chooses to cancel all options, this function takes care of
-    updating the stack by removing all pending flow stack frames
-    listed as clarification options.
-    """
-    clarification_names = set(initial_top_frame.names)
-    to_be_canceled_frames = []
-    applied_events = []
-    for frame in reversed(original_stack.frames):
-        if frame.frame_id in canceled_frames:
-            continue
-
-        to_be_canceled_frames.append(frame.frame_id)
-        if isinstance(frame, UserFlowStackFrame):
-            readable_flow_name = frame.flow(all_flows).readable_name()
-            if readable_flow_name in clarification_names:
-                stack.push(
-                    CancelPatternFlowStackFrame(
-                        canceled_name=readable_flow_name,
-                        canceled_frames=copy.deepcopy(to_be_canceled_frames),
-                    )
-                )
-                applied_events.append(FlowCancelled(frame.flow_id, frame.step_id))
-                to_be_canceled_frames.clear()
-
-    return applied_events
+        return r"^cancel flow$"

rasa/dialogue_understanding/commands/change_flow_command.py

@@ -48,7 +48,7 @@ class ChangeFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "ChangeFlow()"
+        return "change"
 
     @staticmethod
     def from_dsl(match: re.Match, **kwargs: Any) -> ChangeFlowCommand:
@@ -57,4 +57,4 @@ class ChangeFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"ChangeFlow\(\)"
+        return r"^change"

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -59,7 +59,7 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "ChitChat()"
+        return "offtopic reply"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> ChitChatAnswerCommand:
@@ -68,4 +68,4 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"ChitChat\(\)"
+        return r"^offtopic reply$"

rasa/dialogue_understanding/commands/clarify_command.py

@@ -89,7 +89,7 @@ class ClarifyCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"Clarify({', '.join(self.options)})"
+        return f"disambiguate flows {' '.join(self.options)}"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[ClarifyCommand]:
@@ -99,4 +99,4 @@ class ClarifyCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"Clarify\(([\"\'a-zA-Z0-9_, ]*)\)"
+        return r"^disambiguate flows([\"\'a-zA-Z0-9_, ]*)$"

rasa/dialogue_understanding/commands/correct_slots_command.py

@@ -31,7 +31,6 @@ class CorrectedSlot:
 
     name: str
     value: Any
-    filled_by: Optional[str] = None
 
 
 @dataclass
@@ -55,9 +54,7 @@ class CorrectSlotsCommand(Command):
         try:
             return CorrectSlotsCommand(
                 corrected_slots=[
-                    CorrectedSlot(
-                        s["name"], value=s["value"], filled_by=s.get("filled_by", None)
-                    )
+                    CorrectedSlot(s["name"], value=s["value"])
                     for s in data["corrected_slots"]
                 ]
             )
@@ -138,10 +135,7 @@ class CorrectSlotsCommand(Command):
         proposed_slots = {}
         for corrected_slot in self.corrected_slots:
             if tracker.get_slot(corrected_slot.name) != corrected_slot.value:
-                proposed_slots[corrected_slot.name] = {
-                    "value": corrected_slot.value,
-                    "filled_by": corrected_slot.filled_by,
-                }
+                proposed_slots[corrected_slot.name] = corrected_slot.value
             else:
                 structlogger.debug(
                     "command_executor.skip_correction.slot_already_set", command=self
@@ -246,9 +240,6 @@ class CorrectSlotsCommand(Command):
             corrected_slots=proposed_slots,
             reset_flow_id=earliest_collect.flow_id if earliest_collect else None,
             reset_step_id=earliest_collect.step.id if earliest_collect else None,
-            new_slot_values=[
-                value.get("value") for slot, value in proposed_slots.items()
-            ],
         )
 
     def run_command_on_tracker(

rasa/dialogue_understanding/commands/human_handoff_command.py

@@ -66,7 +66,7 @@ class HumanHandoffCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "HumanHandoff()"
+        return "hand over"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> HumanHandoffCommand:
@@ -75,4 +75,4 @@ class HumanHandoffCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"HumanHandoff\(\)"
+        return r"^hand over$"

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -59,7 +59,7 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "SearchAndReply()"
+        return "provide info"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> KnowledgeAnswerCommand:
@@ -68,4 +68,4 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"SearchAndReply\(\)"
+        return r"^provide info$"

rasa/dialogue_understanding/commands/repeat_bot_messages_command.py

@@ -60,7 +60,7 @@ class RepeatBotMessagesCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "RepeatLastBotMessages()"
+        return "repeat message"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> RepeatBotMessagesCommand:
@@ -69,4 +69,4 @@ class RepeatBotMessagesCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"RepeatLastBotMessages\(\)"
+        return r"^repeat message$"

rasa/dialogue_understanding/commands/set_slot_command.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any, Dict, List
 
 import structlog
@@ -18,7 +19,6 @@ 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,6 +27,17 @@ 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]:
@@ -126,7 +137,6 @@ 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.
@@ -144,9 +154,7 @@ class SetSlotCommand(Command):
                 return []
 
         structlogger.debug("command_executor.set_slot", command=self)
-        return [
-            SlotSet(self.name, slot.coerce_value(self.value), filled_by=self.extractor)
-        ]
+        return [SlotSet(self.name, slot.coerce_value(self.value))]
 
     def __hash__(self) -> int:
         return hash(self.value) + hash(self.name)
@@ -162,7 +170,7 @@ class SetSlotCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"SetSlot({self.name}, {self.value})"
+        return f"set slot {self.name} {self.value}"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SetSlotCommand:
@@ -173,4 +181,4 @@ class SetSlotCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
+        return r"""^set slot ['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]? ['"]?(.+?)['"]?$"""

rasa/dialogue_understanding/commands/skip_question_command.py

@@ -75,7 +75,7 @@ class SkipQuestionCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "SkipQuestion()"
+        return "skip"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SkipQuestionCommand:
@@ -84,4 +84,4 @@ class SkipQuestionCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"SkipQuestion\(\)"
+        return r"^skip$"

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -7,11 +7,6 @@ from typing import Any, Dict, List, Optional
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
-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,
@@ -73,10 +68,6 @@ 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
             )
@@ -119,7 +110,7 @@ class StartFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"StartFlow({self.flow})"
+        return f"start flow {self.flow}"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[StartFlowCommand]:
@@ -128,36 +119,4 @@ class StartFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)"
-
-    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 []
+        return r"^start flow ['\"]?([a-zA-Z0-9_-]+)['\"]?$"

rasa/dialogue_understanding/commands/utils.py

@@ -27,7 +27,7 @@ def extract_cleaned_options(options_str: str) -> List[str]:
     """Extract and clean options from a string."""
     return sorted(
         opt.strip().strip('"').strip("'")
-        for opt in options_str.split(",")
+        for opt in options_str.split(" ")
         if opt.strip()
     )
 

rasa/dialogue_understanding/constants.py

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

rasa/dialogue_understanding/generator/command_generator.py

@@ -1,24 +1,23 @@
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Set, Text, Tuple
+from typing import Any, Dict, List, Optional, Text
 
 import structlog
 
 from rasa.dialogue_understanding.commands import (
     Command,
-    CorrectSlotsCommand,
     ErrorCommand,
     SetSlotCommand,
     StartFlowCommand,
 )
-from rasa.dialogue_understanding.utils import (
-    _handle_via_nlu_in_coexistence,
-)
+from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
 from rasa.shared.constants import (
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
 )
+from rasa.shared.core.constants import SlotMappingType
 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,
@@ -93,9 +92,9 @@ class CommandGenerator:
         )
 
         for message in messages:
-            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.
+            if message.get(COMMANDS):
+                # do not overwrite commands if they are already present
+                # i.e. another command generator already predicted commands
                 continue
 
             commands = await self._evaluate_and_predict(
@@ -107,6 +106,9 @@ 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)
 
@@ -200,94 +202,6 @@ class CommandGenerator:
         """
         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]:
@@ -364,21 +278,70 @@ class CommandGenerator:
         return len(message.get(TEXT, "").strip()) == 0
 
     @staticmethod
-    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, [])
+    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
+        ]
+
+        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 = []
 
-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)
+        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
+            )
+        ]
 
-    return slot_names
+        return filtered_commands

rasa/dialogue_understanding/generator/command_parser.py

@@ -125,7 +125,7 @@ def _parse_standard_commands(
     commands: List[Command] = []
     for command_clz in standard_commands:
         pattern = _get_compiled_pattern(command_clz.regex_pattern())
-        if match := pattern.search(action):
+        if match := pattern.search(action.strip()):
             parsed_command = command_clz.from_dsl(match, **kwargs)
             if _additional_parsing_fn := _get_additional_parsing_logic(command_clz):
                 parsed_command = _additional_parsing_fn(parsed_command, flows, **kwargs)