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

rasa/dialogue_understanding/processor/command_processor.py

@@ -1,24 +1,30 @@
-from typing import List, Optional, Type, Set, Dict
+from typing import Dict, List, Optional, Set, Type
 
 import structlog
-from rasa.shared.core.training_data.structures import StoryGraph
+
 from rasa.dialogue_understanding.commands import (
     CancelFlowCommand,
+    CannotHandleCommand,
+    ChitChatAnswerCommand,
     ClarifyCommand,
     Command,
-    CorrectSlotsCommand,
     CorrectedSlot,
+    CorrectSlotsCommand,
+    FreeFormAnswerCommand,
     RepeatBotMessagesCommand,
     SetSlotCommand,
     StartFlowCommand,
-    FreeFormAnswerCommand,
-    ChitChatAnswerCommand,
-    CannotHandleCommand,
 )
 from rasa.dialogue_understanding.commands.handle_code_change_command import (
     HandleCodeChangeCommand,
 )
+from rasa.dialogue_understanding.commands.handle_digressions_command import (
+    HandleDigressionsCommand,
+)
 from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
+from rasa.dialogue_understanding.commands.utils import (
+    create_validate_frames_from_slot_set_events,
+)
 from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
@@ -26,6 +32,9 @@ from rasa.dialogue_understanding.patterns.collect_information import (
 from rasa.dialogue_understanding.patterns.correction import (
     CorrectionPatternFlowStackFrame,
 )
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
+)
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames import (
     BaseFlowStackFrame,
@@ -33,19 +42,25 @@ from rasa.dialogue_understanding.stack.frames import (
 from rasa.dialogue_understanding.stack.utils import (
     filled_slots_for_active_flow,
     top_flow_frame,
+    top_user_flow_frame,
 )
 from rasa.engine.graph import ExecutionContext
 from rasa.shared.constants import (
-    ROUTE_TO_CALM_SLOT,
     RASA_PATTERN_CANNOT_HANDLE_CHITCHAT,
+    ROUTE_TO_CALM_SLOT,
+)
+from rasa.shared.core.constants import (
+    ACTION_TRIGGER_CHITCHAT,
+    FLOW_HASHES_SLOT,
+    SlotMappingType,
 )
-from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT, SlotMappingType
-from rasa.shared.core.constants import FLOW_HASHES_SLOT
 from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.slot_mappings import SlotMapping
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.nlu.constants import COMMANDS
 
 structlogger = structlog.get_logger()
@@ -226,18 +241,51 @@ def execute_commands(
     # and then pushing the commands onto the stack in the reversed order.
     reversed_commands = list(reversed(commands))
 
+    # we need to keep track of the ValidateSlotPatternFlowStackFrame that
+    # should be pushed onto the stack before executing the StartFlowCommands.
+    # This is necessary to make sure that slots filled before the start of a
+    # flow can be immediately validated without waiting till the flow is started
+    # and completed.
+    stack_frames_to_follow_commands: List[ValidateSlotPatternFlowStackFrame] = []
+
     validate_state_of_commands(commands)
 
     for command in reversed_commands:
         new_events = command.run_command_on_tracker(
             tracker, all_flows, original_tracker
         )
+
+        _, stack_frames_to_follow_commands = (
+            create_validate_frames_from_slot_set_events(
+                tracker, new_events, stack_frames_to_follow_commands
+            )
+        )
+
         events.extend(new_events)
         tracker.update_with_events(new_events)
 
+    new_events = push_stack_frames_to_follow_commands(
+        tracker, stack_frames_to_follow_commands
+    )
+    events.extend(new_events)
+
     return remove_duplicated_set_slots(events)
 
 
+def push_stack_frames_to_follow_commands(
+    tracker: DialogueStateTracker, stack_frames: List
+) -> List[Event]:
+    """Push stack frames to follow commands."""
+    new_events = []
+
+    for frame in stack_frames:
+        stack = tracker.stack
+        stack.push(frame)
+        new_events.extend(tracker.create_stack_updated_events(stack))
+    tracker.update_with_events(new_events)
+    return new_events
+
+
 def remove_duplicated_set_slots(events: List[Event]) -> List[Event]:
     """Removes duplicated set slot events.
 
@@ -383,13 +431,29 @@ def clean_up_commands(
                 command=command,
             )
 
-        elif isinstance(command, StartFlowCommand) and command.flow == active_flow:
-            # 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=command,
+        elif isinstance(command, StartFlowCommand):
+            top_user_frame = top_user_flow_frame(
+                tracker.stack, ignore_call_and_link_frames=False
             )
+            top_flow_id = top_user_frame.flow_id if top_user_frame else ""
+
+            if top_flow_id == command.flow:
+                # 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=command,
+                )
+                continue
+
+            if should_add_handle_digressions_command(tracker, all_flows, top_flow_id):
+                clean_commands.append(HandleDigressionsCommand(flow=command.flow))
+                structlogger.debug(
+                    "command_processor.clean_up_commands.push_handle_digressions",
+                    command=command,
+                )
+            else:
+                clean_commands.append(command)
 
         # handle chitchat command differently from other free-form answer commands
         elif isinstance(command, ChitChatAnswerCommand):
@@ -523,13 +587,48 @@ def clean_up_slot_command(
         )
         return resulting_commands
 
-    if not should_slot_be_set(slot, command):
+    if not should_slot_be_set(slot, command, resulting_commands):
+        structlogger.debug(
+            "command_processor.clean_up_slot_command.skip_command.extractor_"
+            "does_not_match_slot_mapping",
+            extractor=command.extractor,
+            slot_name=slot.name,
+        )
+
+        # prevent adding a cannot handle command in case commands_so_far already
+        # contains a valid prior set slot command for the same slot whose current
+        # slot command was rejected by should_slot_be_set
+        slot_command_exists_already = any(
+            isinstance(command, SetSlotCommand) and command.name == slot.name
+            for command in resulting_commands
+        )
+
         cannot_handle = CannotHandleCommand(reason=CANNOT_HANDLE_REASON)
-        if cannot_handle not in resulting_commands:
+        if not slot_command_exists_already and cannot_handle not in resulting_commands:
             resulting_commands.append(cannot_handle)
 
         return resulting_commands
 
+    if (
+        slot.filled_by == SetSlotExtractor.NLU.value
+        and command.extractor == SetSlotExtractor.LLM.value
+    ):
+        allow_nlu_correction = any(
+            [
+                mapping.allow_nlu_correction is True
+                for mapping in slot.mappings
+                if mapping.type == SlotMappingType.FROM_LLM
+            ]
+        )
+
+        if not allow_nlu_correction:
+            structlogger.debug(
+                "command_processor.clean_up_slot_command"
+                ".skip_command.disallow_llm_correction_of_nlu_set_value",
+                command=command,
+            )
+            return resulting_commands
+
     if command.name in slots_so_far and command.name != ROUTE_TO_CALM_SLOT:
         current_collect_info = get_current_collect_step(stack, all_flows)
 
@@ -570,7 +669,7 @@ def clean_up_slot_command(
         )
 
         # Group all corrections into one command
-        corrected_slot = CorrectedSlot(command.name, command.value)
+        corrected_slot = CorrectedSlot(command.name, command.value, command.extractor)
         for c in resulting_commands:
             if isinstance(c, CorrectSlotsCommand):
                 c.corrected_slots.append(corrected_slot)
@@ -654,7 +753,9 @@ def clean_up_chitchat_command(
     return resulting_commands
 
 
-def should_slot_be_set(slot: Slot, command: SetSlotCommand) -> bool:
+def should_slot_be_set(
+    slot: Slot, command: SetSlotCommand, commands_so_far: Optional[List[Command]] = None
+) -> bool:
     """Check if a slot should be set by a command."""
     if command.extractor == SetSlotExtractor.COMMAND_PAYLOAD_READER.value:
         # if the command is issued by the command payload reader, it means the slot
@@ -662,37 +763,61 @@ def should_slot_be_set(slot: Slot, command: SetSlotCommand) -> bool:
         # we can always set it
         return True
 
+    if commands_so_far is None:
+        commands_so_far = []
+
+    set_slot_commands_so_far = [
+        command
+        for command in commands_so_far
+        if isinstance(command, SetSlotCommand) and command.name == slot.name
+    ]
+
     slot_mappings = slot.mappings
 
-    if not slot_mappings:
-        slot_mappings = [{"type": SlotMappingType.FROM_LLM.value}]
+    if not slot.mappings:
+        slot_mappings = [SlotMapping(type=SlotMappingType.FROM_LLM)]
 
-    for mapping in slot_mappings:
-        mapping_type = SlotMappingType(
-            mapping.get("type", SlotMappingType.FROM_LLM.value)
-        )
+    mapping_types = [mapping.type for mapping in slot_mappings]
 
-        should_be_set_by_llm = (
-            command.extractor == SetSlotExtractor.LLM.value
-            and mapping_type == SlotMappingType.FROM_LLM
-        )
-        should_be_set_by_nlu = (
-            command.extractor == SetSlotExtractor.NLU.value
-            and mapping_type.is_predefined_type()
+    slot_has_nlu_mapping = any(
+        [mapping_type.is_predefined_type() for mapping_type in mapping_types]
+    )
+    slot_has_llm_mapping = any(
+        [mapping_type == SlotMappingType.FROM_LLM for mapping_type in mapping_types]
+    )
+    slot_has_controlled_mapping = any(
+        [mapping_type == SlotMappingType.CONTROLLED for mapping_type in mapping_types]
+    )
+
+    if set_slot_commands_so_far and command.extractor == SetSlotExtractor.LLM.value:
+        # covers the following scenarios:
+        # scenario 1: NLU mapping extracts a value for slot_a → If LLM extracts a value for slot_a, it is discarded.  # noqa: E501
+        # scenario 2: NLU mapping is unable to extract a value for slot_a → If LLM extracts a value for slot_a, it is accepted.  # noqa: E501
+        command_has_nlu_extractor = any(
+            [
+                command.extractor == SetSlotExtractor.NLU.value
+                for command in set_slot_commands_so_far
+            ]
         )
+        return not command_has_nlu_extractor and slot_has_llm_mapping
 
-        if should_be_set_by_llm or should_be_set_by_nlu:
-            # if the extractor matches the mapping type, we can continue
-            # setting the slot
-            break
+    if (
+        slot_has_nlu_mapping
+        and command.extractor == SetSlotExtractor.LLM.value
+        and not slot_has_llm_mapping
+    ):
+        return False
 
-        structlogger.debug(
-            "command_processor.clean_up_slot_command.skip_command.extractor_"
-            "does_not_match_slot_mapping",
-            extractor=command.extractor,
-            slot_name=slot.name,
-            mapping_type=mapping_type.value,
-        )
+    if (
+        slot_has_llm_mapping
+        and command.extractor == SetSlotExtractor.NLU.value
+        and not slot_has_nlu_mapping
+    ):
+        return False
+
+    if slot_has_controlled_mapping and not (
+        slot_has_nlu_mapping or slot_has_llm_mapping
+    ):
         return False
 
     return True
@@ -718,3 +843,28 @@ def filter_cannot_handle_command_for_skipped_slots(
             and CANNOT_HANDLE_REASON == command.reason
         )
     ]
+
+
+def should_add_handle_digressions_command(
+    tracker: DialogueStateTracker, all_flows: FlowsList, top_flow_id: str
+) -> bool:
+    """Check if a handle digressions command should be added to the commands.
+
+    The command should replace a StartFlow command only if we are at a collect step of
+    a flow and a new flow is predicted by the command generator to start.
+    """
+    current_flow = all_flows.flow_by_id(top_flow_id)
+    current_flow_condition = current_flow and (
+        current_flow.ask_confirm_digressions or current_flow.block_digressions
+    )
+
+    collect_info = get_current_collect_step(tracker.stack, all_flows)
+
+    if collect_info and (
+        collect_info.ask_confirm_digressions
+        or collect_info.block_digressions
+        or current_flow_condition
+    ):
+        return True
+
+    return False

rasa/dialogue_understanding/processor/command_processor_component.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 from typing import Any, Dict, List, Text
-import rasa.dialogue_understanding.processor.command_processor
 
+import rasa.dialogue_understanding.processor.command_processor
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage

rasa/dialogue_understanding/stack/dialogue_stack.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
-import copy
 
+import copy
+import typing
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional
-import structlog
-import typing
+
 import jsonpatch
+import structlog
 
 if typing.TYPE_CHECKING:
     from rasa.dialogue_understanding.stack.frames import DialogueStackFrame

rasa/dialogue_understanding/stack/frames/__init__.py

@@ -1,13 +1,13 @@
+from rasa.dialogue_understanding.stack.frames.chit_chat_frame import ChitChatStackFrame
 from rasa.dialogue_understanding.stack.frames.dialogue_stack_frame import (
     DialogueStackFrame,
 )
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
-    UserFlowStackFrame,
     BaseFlowStackFrame,
+    UserFlowStackFrame,
 )
 from rasa.dialogue_understanding.stack.frames.pattern_frame import PatternFlowStackFrame
 from rasa.dialogue_understanding.stack.frames.search_frame import SearchStackFrame
-from rasa.dialogue_understanding.stack.frames.chit_chat_frame import ChitChatStackFrame
 
 __all__ = [
     "DialogueStackFrame",

rasa/dialogue_understanding/stack/frames/chit_chat_frame.py

@@ -2,7 +2,10 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from typing import Any, Dict
-from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
+
+from rasa.dialogue_understanding.stack.frames.dialogue_stack_frame import (
+    DialogueStackFrame,
+)
 
 
 @dataclass

rasa/dialogue_understanding/stack/frames/dialogue_stack_frame.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
 
+import dataclasses
 import inspect
 from dataclasses import dataclass, field
-import dataclasses
 from enum import Enum
 from functools import lru_cache
 from typing import Any, Dict, List, Tuple, Type
 
 import structlog
-from rasa.shared.exceptions import RasaException
 
 import rasa.shared.utils.common
+from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.io import random_string
 
-
 structlogger = structlog.get_logger()
 
 

rasa/dialogue_understanding/stack/frames/flow_stack_frame.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Dict, Optional
 
-from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
-from rasa.shared.core.flows.steps.constants import START_STEP
+from rasa.dialogue_understanding.stack.frames.dialogue_stack_frame import (
+    DialogueStackFrame,
+)
 from rasa.shared.core.flows import Flow, FlowsList, FlowStep
+from rasa.shared.core.flows.steps.constants import START_STEP
 from rasa.shared.exceptions import RasaException
 
 

rasa/dialogue_understanding/stack/frames/search_frame.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any, Dict
 
-from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
+from rasa.dialogue_understanding.stack.frames.dialogue_stack_frame import (
+    DialogueStackFrame,
+)
 
 
 @dataclass

rasa/dialogue_understanding/stack/utils.py

@@ -1,17 +1,23 @@
-from typing import List, Optional, Set, Tuple
 import typing
+from typing import List, Optional, Set, Tuple
+
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
 )
-from rasa.dialogue_understanding.stack.frames import BaseFlowStackFrame
+from rasa.dialogue_understanding.patterns.continue_interrupted import (
+    ContinueInterruptedPatternFlowStackFrame,
+)
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
-from rasa.dialogue_understanding.stack.frames import UserFlowStackFrame
+from rasa.dialogue_understanding.stack.frames import (
+    BaseFlowStackFrame,
+    UserFlowStackFrame,
+)
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import FlowStackFrameType
 from rasa.dialogue_understanding.stack.frames.pattern_frame import PatternFlowStackFrame
+from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
 from rasa.shared.core.flows.steps.constants import END_STEP
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
-from rasa.shared.core.flows import FlowsList
 
 if typing.TYPE_CHECKING:
     from rasa.shared.core.trackers import DialogueStateTracker
@@ -57,7 +63,9 @@ def top_flow_frame(
     return None
 
 
-def top_user_flow_frame(dialogue_stack: DialogueStack) -> Optional[UserFlowStackFrame]:
+def top_user_flow_frame(
+    dialogue_stack: DialogueStack, ignore_call_and_link_frames: bool = True
+) -> Optional[UserFlowStackFrame]:
     """Returns the topmost user flow frame from the tracker.
 
     User flows are flows that are created by developers of an assistant and
@@ -69,16 +77,19 @@ def top_user_flow_frame(dialogue_stack: DialogueStack) -> Optional[UserFlowStack
 
     Args:
         dialogue_stack: The dialogue stack to use.
+        ignore_call_and_link_frames: Whether to ignore user frames of type `call`
+            and `link`. By default, these frames are ignored.
 
     Returns:
     The topmost user flow frame from the tracker.
     """
     for frame in reversed(dialogue_stack.frames):
-        if (
-            isinstance(frame, UserFlowStackFrame)
-            and frame.frame_type != FlowStackFrameType.CALL
-            and frame.frame_type != FlowStackFrameType.LINK
-        ):
+        if isinstance(frame, UserFlowStackFrame):
+            if ignore_call_and_link_frames and (
+                frame.frame_type == FlowStackFrameType.CALL
+                or frame.frame_type == FlowStackFrameType.LINK
+            ):
+                continue
             return frame
     return None
 
@@ -210,3 +221,38 @@ def get_collect_steps_excluding_ask_before_filling_for_active_flow(
         for step in active_flow.get_collect_steps()
         if not step.ask_before_filling
     )
+
+
+def remove_digression_from_stack(stack: DialogueStack, flow_id: str) -> DialogueStack:
+    """Remove a specific flow frame from the stack and other frames that reference it.
+
+    The main use-case is to prevent duplicate digressions from being added to the stack.
+
+    Args:
+        stack: The dialogue stack.
+        flow_id: The flow to remove.
+
+    Returns:
+        The updated dialogue stack.
+    """
+    updated_stack = stack.copy()
+    original_frames = updated_stack.frames[:]
+    found_digression_index = -1
+    for index, frame in enumerate(original_frames):
+        if isinstance(frame, BaseFlowStackFrame) and frame.flow_id == flow_id:
+            updated_stack.frames.pop(index)
+            found_digression_index = index
+
+        # we also need to remove the `ContinueInterruptedPatternFlowStackFrame`
+        elif (
+            isinstance(frame, ContinueInterruptedPatternFlowStackFrame)
+            and frame.previous_flow_name == flow_id
+            and found_digression_index + 1 == index
+        ):
+            # we know that this frame is always added after the digressing flow frame
+            # that was blocked previously by action_block_digressions,
+            # so this check would occur after the digressing flow was popped.
+            # Therefore, we need to update the index dynamically before popping.
+            updated_stack.frames.pop(index - 1)
+
+    return updated_stack