rasa-pro 3.13.1a18__py3-none-any.whl → 3.13.1a20__py3-none-any.whl

rasa/dialogue_understanding/commands/correct_slots_command.py

@@ -232,16 +232,6 @@ class CorrectSlotsCommand(Command):
             proposed_slots, all_flows, tracker
         )
 
-        if not earliest_collect and not is_reset_only:
-            # if we could not find any step in the flow, where the slots were
-            # previously set, and we also don't want to reset the slots, do
-            # not correct the slots.
-            structlogger.debug(
-                "correct_slots_command.skip_correction",
-                is_reset_only=is_reset_only,
-            )
-            return None
-
         return CorrectionPatternFlowStackFrame(
             is_reset_only=is_reset_only,
             corrected_slots=proposed_slots,
@@ -279,6 +269,20 @@ class CorrectSlotsCommand(Command):
             return []
 
         structlogger.debug("correct_slots_command", command=self)
+
+        # check if the correct slot is referring to a slot of a flow on the stack
+        # the slot also needs to be part of a collect step in any of those flows
+        # if this is not the case, we don't want to correct the slot
+        for slot in self.corrected_slots:
+            if not self.should_correct_slot(slot, tracker, all_flows):
+                structlogger.warning(
+                    "correct_slots_command.skip_correct_slot",
+                    correct_slot=slot,
+                    reason="The slot is not part of a collect step in any of the flows "
+                    "on the stack. Skipping correction.",
+                )
+                return []
+
         proposed_slots = self.corrected_slots_dict(tracker)
 
         correction_frame = self.create_correction_frame(
@@ -303,3 +307,27 @@ class CorrectSlotsCommand(Command):
             return False
 
         return True
+
+    def should_correct_slot(
+        self, slot: CorrectedSlot, tracker: DialogueStateTracker, all_flows: FlowsList
+    ) -> bool:
+        """Checks if the slot should be corrected.
+
+        Args:
+            slot: The slot to check.
+            tracker: The tracker.
+            all_flows: All flows in the assistant.
+        """
+        # get all flows on the stack
+        flows_on_stack = utils.user_flows_on_the_stack(tracker.stack)
+
+        # check if the slot is part of a collect step in any of the flows on the stack
+        for flow_id in flows_on_stack:
+            flow = all_flows.flow_by_id(flow_id)
+            if flow is None:
+                continue
+            for collect_step in flow.get_collect_steps():
+                if collect_step.collect == slot.name:
+                    return True
+
+        return False

rasa/dialogue_understanding/generator/command_generator.py

@@ -114,7 +114,7 @@ class CommandGenerator:
             # slot asked by the active collect step.
             # Or return a CannotHandleCommand if no matching command is found.
             commands = self._filter_commands_during_force_slot_filling(
-                commands, available_flows, tracker
+                commands, flows, tracker
             )
 
             commands_dicts = [command.as_dict() for command in commands]
@@ -385,14 +385,14 @@ class CommandGenerator:
     @staticmethod
     def _filter_commands_during_force_slot_filling(
         commands: List[Command],
-        available_flows: FlowsList,
+        flows: FlowsList,
         tracker: Optional[DialogueStateTracker] = None,
     ) -> List[Command]:
         """Filter commands during a collect step that has set `force_slot_filling`.
 
         Args:
             commands: The commands to filter.
-            available_flows: The available flows.
+            flows: All flows.
             tracker: The tracker.
 
         Returns:
@@ -409,7 +409,7 @@ class CommandGenerator:
             )
             return commands
 
-        updated_flows = find_updated_flows(tracker, available_flows)
+        updated_flows = find_updated_flows(tracker, flows)
         if updated_flows:
             structlogger.debug(
                 "command_generator.filter_commands_during_force_slot_filling.running_flows_were_updated",
@@ -418,7 +418,7 @@ class CommandGenerator:
             return [HandleCodeChangeCommand()]
 
         stack = tracker.stack
-        step = get_current_collect_step(stack, available_flows)
+        step = get_current_collect_step(stack, flows)
 
         if step is None or not step.force_slot_filling:
             return commands

rasa/dialogue_understanding/generator/command_parser.py

@@ -1,5 +1,4 @@
 import re
-import sys
 from functools import lru_cache
 from typing import Any, Callable, Dict, List, Optional, Type, Union
 
@@ -19,6 +18,7 @@ from rasa.dialogue_understanding.commands import (
 )
 from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.dialogue_understanding.commands.utils import start_flow_by_name
+from rasa.exceptions import ValidationError
 from rasa.shared.core.flows import FlowsList
 
 structlogger = structlog.get_logger()
@@ -87,16 +87,13 @@ def validate_custom_commands(command_classes: List[Type[PromptCommand]]) -> None
     ]
 
     if clz_not_inheriting_from_command_clz:
-        structlogger.error(
-            "command_parser.validate_custom_commands.invalid_command",
+        raise ValidationError(
+            code="command_parser.validate_custom_commands.invalid_command",
+            event_info="The additional command classes must be a subclass of the "
+            "'Command' class. Please refer to the class in "
+            "`rasa.dialogue_understanding.commands.command.Command`",
             invalid_commands=clz_not_inheriting_from_command_clz,
-            event_info=(
-                "The additional command classes must be a subclass of the 'Command' "
-                "class. Please refer to the class in "
-                "`rasa.dialogue_understanding.commands.command.Command`"
-            ),
         )
-        sys.exit(1)
 
     clz_not_adhering_to_prompt_command_protocol = [
         command_clz.__name__
@@ -105,16 +102,15 @@ def validate_custom_commands(command_classes: List[Type[PromptCommand]]) -> None
     ]
 
     if clz_not_adhering_to_prompt_command_protocol:
-        structlogger.error(
-            "command_parser.validate_custom_commands.invalid_command",
-            invalid_commands=clz_not_adhering_to_prompt_command_protocol,
+        raise ValidationError(
+            code="command_parser.validate_custom_commands.invalid_command",
             event_info=(
                 "The additional command classes must adhere to the 'PromptCommand' "
                 "protocol. Please refer to the protocol in "
                 "`rasa.dialogue_understanding.commands.prompt_command.PromptCommand`"
             ),
+            invalid_commands=clz_not_adhering_to_prompt_command_protocol,
         )
-        sys.exit(1)
 
 
 def parse_commands(

rasa/dialogue_understanding/processor/command_processor.py

@@ -37,7 +37,6 @@ from rasa.dialogue_understanding.stack.frames import (
     BaseFlowStackFrame,
 )
 from rasa.dialogue_understanding.stack.utils import (
-    filled_slots_for_active_flow,
     top_flow_frame,
     top_user_flow_frame,
 )
@@ -125,7 +124,8 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     # check that there is only at max one cancel flow command
     if sum(isinstance(c, CancelFlowCommand) for c in commands) > 1:
         structlogger.error(
-            "command_processor.validate_state_of_commands.multiple_cancel_flow_commands",
+            "command_processor.validate_state_of_commands."
+            "multiple_cancel_flow_commands",
             commands=[command.__class__.__name__ for command in commands],
         )
         raise ValueError("There can only be one cancel flow command.")
@@ -136,7 +136,8 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     ]
     if free_form_answer_commands != commands[: len(free_form_answer_commands)]:
         structlogger.error(
-            "command_processor.validate_state_of_commands.free_form_answer_commands_not_at_beginning",
+            "command_processor.validate_state_of_commands."
+            "free_form_answer_commands_not_at_beginning",
             commands=[command.__class__.__name__ for command in commands],
         )
         raise ValueError(
@@ -146,7 +147,8 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     # check that there is at max only one correctslots command
     if sum(isinstance(c, CorrectSlotsCommand) for c in commands) > 1:
         structlogger.error(
-            "command_processor.validate_state_of_commands.multiple_correct_slots_commands",
+            "command_processor.validate_state_of_commands."
+            "multiple_correct_slots_commands",
             commands=[command.__class__.__name__ for command in commands],
         )
         raise ValueError("There can only be one correct slots command.")
@@ -230,11 +232,9 @@ def execute_commands(
 
     events: List[Event] = flow_hash_events
 
-    # commands need to be reversed to make sure they end up in the right order
-    # on the stack. e.g. if there multiple start flow commands, the first one
-    # should be on top of the stack. this is achieved by reversing the list
-    # and then pushing the commands onto the stack in the reversed order.
-    reversed_commands = list(reversed(commands))
+    # reorder commands: in case there is no active flow, we want to make sure to
+    # run the start flow commands first.
+    final_commands = reorder_commands(commands, tracker)
 
     # we need to keep track of the ValidateSlotPatternFlowStackFrame that
     # should be pushed onto the stack before executing the StartFlowCommands.
@@ -245,7 +245,7 @@ def execute_commands(
 
     validate_state_of_commands(commands)
 
-    for command in reversed_commands:
+    for command in final_commands:
         new_events = command.run_command_on_tracker(
             tracker, all_flows, original_tracker
         )
@@ -398,14 +398,12 @@ def clean_up_commands(
     """
     domain = domain if domain else Domain.empty()
 
-    slots_so_far, active_flow = filled_slots_for_active_flow(tracker, all_flows)
-
     clean_commands: List[Command] = []
 
     for command in commands:
         if isinstance(command, SetSlotCommand):
             clean_commands = clean_up_slot_command(
-                clean_commands, command, tracker, all_flows, slots_so_far
+                clean_commands, command, tracker, all_flows
             )
 
         elif isinstance(command, CancelFlowCommand) and contains_command(
@@ -439,7 +437,8 @@ def clean_up_commands(
                 # drop a start flow command if the starting flow is equal
                 # to the currently active flow
                 structlogger.debug(
-                    "command_processor.clean_up_commands.skip_command_flow_already_active",
+                    "command_processor.clean_up_commands."
+                    "skip_command_flow_already_active",
                     command=command,
                 )
                 continue
@@ -470,7 +469,8 @@ def clean_up_commands(
             clean_commands = clean_up_clarify_command(clean_commands, commands, command)
             if command not in clean_commands:
                 structlogger.debug(
-                    "command_processor.clean_up_commands.drop_clarify_given_other_commands",
+                    "command_processor.clean_up_commands."
+                    "drop_clarify_given_other_commands",
                     command=command,
                 )
         else:
@@ -494,6 +494,25 @@ def clean_up_commands(
     return clean_commands
 
 
+def _get_slots_eligible_for_correction(tracker: DialogueStateTracker) -> Set[str]:
+    """Get all slots that are eligible for correction.
+
+    # We consider all slots, which are not None, that were set in the tracker
+    # eligible for correction.
+    # In the correct_slot_command we will check if a slot should actually be
+    # corrected.
+    """
+    # get all slots that were set in the tracker
+    slots_so_far = set(
+        [event.key for event in tracker.events if isinstance(event, SlotSet)]
+    )
+
+    # filter out slots that are set to None (None = empty value)
+    slots_so_far = {slot for slot in slots_so_far if tracker.get_slot(slot) is not None}
+
+    return slots_so_far
+
+
 def ensure_max_number_of_command_type(
     commands: List[Command], command_type: Type[Command], n: int
 ) -> List[Command]:
@@ -553,7 +572,6 @@ def clean_up_slot_command(
     command: SetSlotCommand,
     tracker: DialogueStateTracker,
     all_flows: FlowsList,
-    slots_so_far: Set[str],
 ) -> List[Command]:
     """Clean up a slot command.
 
@@ -566,16 +584,15 @@ def clean_up_slot_command(
         command: The command to clean up.
         tracker: The dialogue state tracker.
         all_flows: All flows.
-        slots_so_far: The slots that have been filled so far.
 
     Returns:
         The cleaned up commands.
     """
     stack = tracker.stack
-
     resulting_commands = commands_so_far[:]
-
     slot = tracker.slots.get(command.name)
+
+    # if the slot is not in the domain, we cannot set it
     if slot is None:
         structlogger.debug(
             "command_processor.clean_up_slot_command.skip_command_slot_not_in_domain",
@@ -588,6 +605,7 @@ def clean_up_slot_command(
         )
         return resulting_commands
 
+    # check if the slot should be set by the command
     if not should_slot_be_set(slot, command, resulting_commands):
         structlogger.debug(
             "command_processor.clean_up_slot_command.skip_command.extractor_"
@@ -613,6 +631,7 @@ def clean_up_slot_command(
 
         return resulting_commands
 
+    # check if the slot can be corrected by the LLM
     if (
         slot.filled_by == SetSlotExtractor.NLU.value
         and command.extractor == SetSlotExtractor.LLM.value
@@ -633,7 +652,13 @@ def clean_up_slot_command(
             )
             return resulting_commands
 
-    if command.name in slots_so_far and command.name != ROUTE_TO_CALM_SLOT:
+    # get all slots that were set in the tracker and are eligible for correction
+    slots_eligible_for_correction = _get_slots_eligible_for_correction(tracker)
+
+    if (
+        command.name in slots_eligible_for_correction
+        and command.name != ROUTE_TO_CALM_SLOT
+    ):
         current_collect_info = get_current_collect_step(stack, all_flows)
 
         if current_collect_info and current_collect_info.collect == command.name:
@@ -641,49 +666,71 @@ def clean_up_slot_command(
             resulting_commands.append(command)
             return resulting_commands
 
-        if (slot := tracker.slots.get(command.name)) is not None and str(
-            slot.value
-        ) == str(command.value):
-            # the slot is already set, we don't need to set it again
-            structlogger.debug(
-                "command_processor.clean_up_slot_command.skip_command_slot_already_set",
-                command=command,
-            )
+        if should_slot_be_corrected(command, tracker, stack, all_flows):
+            # if the slot was already set before, we need to convert it into
+            # a correction
+            return convert_set_slot_to_correction(command, resulting_commands)
+        else:
             return resulting_commands
 
-        top = top_flow_frame(stack)
-        if isinstance(top, CorrectionPatternFlowStackFrame):
-            already_corrected_slots = top.corrected_slots
-        else:
-            already_corrected_slots = {}
+    resulting_commands.append(command)
+    return resulting_commands
 
-        if command.name in already_corrected_slots and str(
-            already_corrected_slots[command.name]
-        ) == str(command.value):
-            structlogger.debug(
-                "command_processor.clean_up_slot_command"
-                ".skip_command_slot_already_corrected",
-                command=command,
-            )
-            return resulting_commands
 
+def should_slot_be_corrected(
+    command: SetSlotCommand,
+    tracker: DialogueStateTracker,
+    stack: DialogueStack,
+    all_flows: FlowsList,
+) -> bool:
+    """Check if a slot should be corrected."""
+    if (slot := tracker.slots.get(command.name)) is not None and str(slot.value) == str(
+        command.value
+    ):
+        # the slot is already set to the same value, we don't need to set it again
         structlogger.debug(
-            "command_processor.clean_up_slot_command.convert_command_to_correction",
+            "command_processor.clean_up_slot_command.skip_command_slot_already_set",
             command=command,
         )
+        return False
 
-        # Group all corrections into one command
-        corrected_slot = CorrectedSlot(command.name, command.value, command.extractor)
-        for c in resulting_commands:
-            if isinstance(c, CorrectSlotsCommand):
-                c.corrected_slots.append(corrected_slot)
-                break
-        else:
-            resulting_commands.append(
-                CorrectSlotsCommand(corrected_slots=[corrected_slot])
-            )
+    top = top_flow_frame(stack)
+    if isinstance(top, CorrectionPatternFlowStackFrame):
+        already_corrected_slots = top.corrected_slots
     else:
-        resulting_commands.append(command)
+        already_corrected_slots = {}
+
+    if command.name in already_corrected_slots and str(
+        already_corrected_slots[command.name]
+    ) == str(command.value):
+        structlogger.debug(
+            "command_processor.clean_up_slot_command"
+            ".skip_command_slot_already_corrected",
+            command=command,
+        )
+        return False
+
+    return True
+
+
+def convert_set_slot_to_correction(
+    command: SetSlotCommand,
+    resulting_commands: List[Command],
+) -> List[Command]:
+    """Convert a set slot command to a correction command."""
+    structlogger.debug(
+        "command_processor.convert_set_slot_to_correction",
+        command=command,
+    )
+
+    # Group all corrections into one command
+    corrected_slot = CorrectedSlot(command.name, command.value, command.extractor)
+    for c in resulting_commands:
+        if isinstance(c, CorrectSlotsCommand):
+            c.corrected_slots.append(corrected_slot)
+            break
+    else:
+        resulting_commands.append(CorrectSlotsCommand(corrected_slots=[corrected_slot]))
 
     return resulting_commands
 
@@ -742,7 +789,8 @@ def clean_up_chitchat_command(
             0, CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_CHITCHAT)
         )
         structlogger.warn(
-            "command_processor.clean_up_chitchat_command.replace_chitchat_answer_with_cannot_handle",
+            "command_processor.clean_up_chitchat_command."
+            "replace_chitchat_answer_with_cannot_handle",
             command=resulting_commands[0],  # no PII
             pattern_chitchat_uses_action_trigger_chitchat=has_action_trigger_chitchat,
             defined_intentless_policy_in_config=defines_intentless_policy,
@@ -845,3 +893,49 @@ def filter_cannot_handle_command(
         for command in clean_commands
         if not isinstance(command, CannotHandleCommand)
     ]
+
+
+def reorder_commands(
+    commands: List[Command], tracker: DialogueStateTracker
+) -> List[Command]:
+    """Reorder commands.
+
+    In case there is no active flow, we want to make sure to run the start flow
+    commands first.
+    """
+    reordered_commands = commands
+
+    top_flow_frame = top_user_flow_frame(tracker.stack)
+
+    if top_flow_frame is None:
+        # no active flow, we want to make sure to run the start flow commands first
+        start_flow_commands: List[Command] = [
+            command for command in commands if isinstance(command, StartFlowCommand)
+        ]
+
+        # if there are no start flow commands, we can return the commands as they are
+        if not start_flow_commands:
+            reordered_commands = commands
+
+        # if there is just one start flow command, we want to run it first
+        # as the order of commands is reserved later,
+        # we need to add it to the end of the list
+        elif len(start_flow_commands) == 1:
+            reordered_commands = [
+                command for command in commands if command not in start_flow_commands
+            ] + start_flow_commands
+
+        # if there are multiple start flow commands,
+        # we just make sure to move the first start flow command to the end of the list
+        # (due to the reverse execution order of commands) and keep the other commands
+        # as they are.
+        else:
+            reordered_commands = [
+                command for command in commands if command != start_flow_commands[-1]
+            ] + [start_flow_commands[-1]]
+
+    # commands need to be reversed to make sure they end up in the right order
+    # on the stack. e.g. if there multiple start flow commands, the first one
+    # should be on top of the stack. this is achieved by reversing the list
+    # and then pushing the commands onto the stack in the reversed order.
+    return list(reversed(reordered_commands))

rasa/dialogue_understanding/stack/utils.py

@@ -209,14 +209,24 @@ def get_collect_steps_excluding_ask_before_filling_for_active_flow(
         All collect steps that are part of the current active flow,
         excluding the collect steps that have to be asked before filling.
     """
-    active_frame = top_user_flow_frame(
+    active_primary_frame = top_user_flow_frame(dialogue_stack)
+    any_active_frame = top_user_flow_frame(
         dialogue_stack, ignore_call_and_link_frames=False
     )
-    if active_frame is None:
+
+    active_flows = []
+    if any_active_frame:
+        active_flows.append(any_active_frame.flow(all_flows))
+
+    if active_primary_frame and active_primary_frame != any_active_frame:
+        active_flows.append(active_primary_frame.flow(all_flows))
+
+    if not active_flows:
         return set()
-    active_flow = active_frame.flow(all_flows)
+
     return set(
         step.collect
+        for active_flow in active_flows
         for step in active_flow.get_collect_steps()
         if not step.ask_before_filling
     )

rasa/dialogue_understanding_test/du_test_schema.yml

@@ -5,12 +5,12 @@ mapping:
     sequence:
       - type: map
         mapping:
-          regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+          regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
             type: "seq"
             sequence:
               - type: map
                 mapping:
-                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
                     type: any
 
   metadata:
@@ -129,7 +129,7 @@ mapping:
             type: "seq"
             sequence:
               - type: "str"
-                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$
+                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_\-]*$
           metadata:
             type: "str"
             pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$

rasa/dialogue_understanding_test/validation.py

@@ -1,5 +1,4 @@
 import argparse
-import sys
 from typing import List, Optional
 
 import structlog
@@ -9,6 +8,7 @@ from rasa.dialogue_understanding_test.constants import (
     PLACEHOLDER_GENERATED_ANSWER_TEMPLATE,
 )
 from rasa.dialogue_understanding_test.du_test_case import DialogueUnderstandingTestCase
+from rasa.exceptions import ValidationError
 from rasa.shared.core.domain import Domain
 
 structlogger = structlog.get_logger()
@@ -28,14 +28,14 @@ def validate_cli_arguments(args: argparse.Namespace) -> None:
         args.remote_storage
         and args.remote_storage.lower() not in supported_remote_storages
     ):
-        structlogger.error(
-            "dialogue_understanding_test.validate_cli_arguments.invalid_remote_storage",
+        raise ValidationError(
+            code="dialogue_understanding_test.validate_cli_arguments"
+            ".invalid_remote_storage",
             event_info=(
                 f"Invalid remote storage option - '{args.remote_storage}'. Supported "
                 f"options are: {supported_remote_storages}"
             ),
         )
-        sys.exit(1)
 
 
 def validate_test_cases(
@@ -48,11 +48,10 @@ def validate_test_cases(
         domain: Domain of the assistant.
     """
     if not domain:
-        structlogger.error(
-            "dialogue_understanding_test.validate_test_cases.no_domain",
+        raise ValidationError(
+            code="dialogue_understanding_test.validate_test_cases.no_domain",
             event_info="No domain found. Retrain the model with a valid domain.",
         )
-        sys.exit(1)
 
     # Retrieve all valid templates from the domain
     valid_templates = domain.utterances_for_response
@@ -64,8 +63,9 @@ def validate_test_cases(
         for step in test_case.steps:
             if step.actor == ACTOR_BOT and step.template:
                 if step.template not in valid_templates:
-                    structlogger.error(
-                        "dialogue_understanding_test.validate_test_cases.invalid_template",
+                    raise ValidationError(
+                        code="dialogue_understanding_test.validate_test_cases"
+                        ".invalid_template",
                         event_info=(
                             f"Invalid bot utterance template '{step.template}' in test "
                             f"case '{test_case.name}' at line {step.line}. Please "
@@ -74,4 +74,3 @@ def validate_test_cases(
                         test_case=test_case.name,
                         template=step.template,
                     )
-                    sys.exit(1)