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

rasa/dialogue_understanding/commands/utils.py

@@ -1,7 +1,18 @@
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, Any, 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
@@ -25,10 +36,13 @@ def start_flow_by_name(
 
 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()
+        opt.strip().strip('"').strip("'") for opt in options_str.split() if opt.strip()
     )
 
 
@@ -62,3 +76,83 @@ def get_nullable_slot_value(slot_value: str) -> Union[str, None]:
         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,
+    update_corrected_slots: 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.
+        update_corrected_slots: whether or not corrected slots in the last
+            correction frame need to be updated.
+
+    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)
+            if update_corrected_slots:
+                tracker = update_corrected_slots_in_correction_frame(
+                    tracker, event.key, event.value
+                )
+
+    return tracker, validate_frames
+
+
+def update_corrected_slots_in_correction_frame(
+    tracker: DialogueStateTracker, slot_name: str, slot_value: Any
+) -> DialogueStateTracker:
+    """Update the corrected_slots and new_slot_values of the
+    CorrectionPatternFlowStackFrame with only valid values.
+    """
+    stack = tracker.stack
+    top_frame = stack.top()
+    del top_frame.corrected_slots[slot_name]  # type: ignore[union-attr]
+    top_frame.new_slot_values.remove(slot_value)  # type: ignore[union-attr]
+
+    # since we can't directly modify a stack we have to pop first
+    # and then push back the updated frame
+    stack.pop()
+    stack.push(top_frame)
+    new_events = tracker.create_stack_updated_events(stack)
+    tracker.update_with_events(new_events)
+    return tracker

rasa/dialogue_understanding/constants.py

@@ -1 +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,23 +1,24 @@
 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,
 )
-from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
+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.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,
@@ -92,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(
@@ -106,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)
 
@@ -202,6 +200,94 @@ 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]:
@@ -278,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
-        ]
-
-        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
+    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, [])
         ]
 
-        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

rasa/dialogue_understanding/generator/command_parser.py

@@ -16,6 +16,7 @@ from rasa.dialogue_understanding.commands import (
     SkipQuestionCommand,
     StartFlowCommand,
 )
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.dialogue_understanding.commands.utils import start_flow_by_name
 from rasa.shared.core.flows import FlowsList
 
@@ -41,8 +42,8 @@ def _get_compiled_pattern(pattern_str: str) -> re.Pattern:
 
 
 def _create_default_commands(
-    default_commands_to_remove: Union[List[Type[Command]], List[str]],
-) -> List[Type[Command]]:
+    default_commands_to_remove: Union[List[Type[PromptCommand]], List[str]],
+) -> List[Type[PromptCommand]]:
     """Return an updated list of default commands after removing the provided commands.
 
     Args:
@@ -64,11 +65,11 @@ def _create_default_commands(
 
 
 def _get_additional_parsing_logic(
-    command_clz: Type[Command],
-) -> Optional[Callable[[Command, FlowsList], Optional[Command]]]:
+    command_clz: Type[PromptCommand],
+) -> Optional[Callable[[PromptCommand, FlowsList], Optional[PromptCommand]]]:
     """Get additional parsing logic for a command."""
     command_to_parsing_fn_mapper: Dict[
-        Type[Command], Callable[..., Optional[Command]]
+        Type[PromptCommand], Callable[..., Optional[PromptCommand]]
     ] = {
         ClarifyCommand: _parse_clarify_command,
         SetSlotCommand: _parse_set_slot_command,
@@ -81,8 +82,10 @@ def parse_commands(
     actions: Optional[str],
     flows: FlowsList,
     is_handle_flows_prompt: bool = False,
-    additional_commands: Optional[List[Type[Command]]] = None,
-    default_commands_to_remove: Optional[Union[List[Type[Command]], List[str]]] = None,
+    additional_commands: Optional[List[Type[PromptCommand]]] = None,
+    default_commands_to_remove: Optional[
+        Union[List[Type[PromptCommand]], List[str]]
+    ] = None,
     **kwargs: Any,
 ) -> List[Command]:
     """Parse a list of action commands."""
@@ -116,7 +119,7 @@ def parse_commands(
 
 
 def _parse_standard_commands(
-    standard_commands: List[Type[Command]],
+    standard_commands: List[Type[PromptCommand]],
     action: str,
     flows: FlowsList,
     **kwargs: Any,
@@ -125,7 +128,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.strip()):
+        if match := pattern.search(action):
             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)
@@ -135,7 +138,7 @@ def _parse_standard_commands(
 
 
 def _parse_custom_commands(
-    custom_commands: List[Type[Command]],
+    custom_commands: List[Type[PromptCommand]],
     action: str,
     flows: FlowsList,
     **kwargs: Any,
@@ -152,7 +155,7 @@ def _parse_custom_commands(
 
 def _parse_set_slot_command(
     parsed_command: Optional[SetSlotCommand], flows: FlowsList, **kwargs: Any
-) -> Optional[Command]:
+) -> Optional[PromptCommand]:
     """Additional parsing logic for the SetSlotCommand."""
     if not parsed_command:
         return None
@@ -164,7 +167,7 @@ def _parse_set_slot_command(
 
 def _parse_clarify_command(
     parsed_command: Optional[ClarifyCommand], flows: FlowsList, **kwargs: Any
-) -> Optional[Command]:
+) -> Optional[PromptCommand]:
     """Additional parsing logic for the ClarifyCommand."""
     if not parsed_command:
         return None
@@ -194,7 +197,7 @@ def _parse_clarify_command(
 
 def _parse_start_flow_command(
     parsed_command: Optional[StartFlowCommand], flows: FlowsList, **kwargs: Any
-) -> Optional[Command]:
+) -> Optional[PromptCommand]:
     """Additional parsing logic for the StartFlowCommand."""
     if not parsed_command:
         return None

rasa/dialogue_understanding/generator/constants.py

@@ -25,3 +25,6 @@ FLOW_RETRIEVAL_ACTIVE_KEY = "active"
 FLOW_RETRIEVAL_EMBEDDINGS_CONFIG_KEY = "embeddings"
 
 FLOW_RETRIEVAL_FLOW_THRESHOLD = 20
+
+COMMAND_PROMPT_FILE_NAME = "command_prompt.jinja2"
+LLM_BASED_COMMAND_GENERATOR_CONFIG_FILE = "config.json"