rasa-pro 3.12.4__py3-none-any.whl → 3.12.6__py3-none-any.whl

rasa/dialogue_understanding/processor/command_processor.py

@@ -18,9 +18,6 @@ from rasa.dialogue_understanding.commands import (
 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,
@@ -54,9 +51,11 @@ from rasa.shared.core.constants import (
     FLOW_HASHES_SLOT,
     SlotMappingType,
 )
+from rasa.shared.core.domain import Domain
 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.policies.utils import contains_intentless_policy_responses
 from rasa.shared.core.slot_mappings import SlotMapping
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -197,6 +196,7 @@ def execute_commands(
     all_flows: FlowsList,
     execution_context: ExecutionContext,
     story_graph: Optional[StoryGraph] = None,
+    domain: Optional[Domain] = None,
 ) -> List[Event]:
     """Executes a list of commands.
 
@@ -206,6 +206,7 @@ def execute_commands(
         all_flows: All flows.
         execution_context: Information about the single graph run.
         story_graph: StoryGraph object with stories available for training.
+        domain: The domain of the bot.
 
     Returns:
         A list of the events that were created.
@@ -214,7 +215,7 @@ def execute_commands(
     original_tracker = tracker.copy()
 
     commands = clean_up_commands(
-        commands, tracker, all_flows, execution_context, story_graph
+        commands, tracker, all_flows, execution_context, story_graph, domain
     )
 
     updated_flows = find_updated_flows(tracker, all_flows)
@@ -381,6 +382,7 @@ def clean_up_commands(
     all_flows: FlowsList,
     execution_context: ExecutionContext,
     story_graph: Optional[StoryGraph] = None,
+    domain: Optional[Domain] = None,
 ) -> List[Command]:
     """Clean up a list of commands.
 
@@ -396,10 +398,13 @@ def clean_up_commands(
         all_flows: All flows.
         execution_context: Information about a single graph run.
         story_graph: StoryGraph object with stories available for training.
+        domain: The domain of the bot.
 
     Returns:
     The cleaned 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] = []
@@ -446,26 +451,17 @@ def clean_up_commands(
                 )
                 continue
 
-            if should_add_handle_digressions_command(tracker, all_flows, top_flow_id):
-                handle_digression_command = HandleDigressionsCommand(flow=command.flow)
-                if handle_digression_command in clean_commands:
-                    structlogger.debug(
-                        "command_processor.clean_up_commands.skip_handle_digressions.command_already_present",
-                        command=handle_digression_command,
-                    )
-                    continue
-                clean_commands.append(handle_digression_command)
-                structlogger.debug(
-                    "command_processor.clean_up_commands.push_handle_digressions",
-                    command=command,
-                )
-            else:
-                clean_commands.append(command)
+            clean_commands.append(command)
 
         # handle chitchat command differently from other free-form answer commands
         elif isinstance(command, ChitChatAnswerCommand):
             clean_commands = clean_up_chitchat_command(
-                clean_commands, command, all_flows, execution_context, story_graph
+                clean_commands,
+                command,
+                all_flows,
+                execution_context,
+                domain,
+                story_graph,
             )
 
         elif isinstance(command, FreeFormAnswerCommand):
@@ -490,21 +486,9 @@ def clean_up_commands(
     # when coexistence is enabled, by default there will be a SetSlotCommand
     # for the ROUTE_TO_CALM_SLOT slot.
     if tracker.has_coexistence_routing_slot and len(clean_commands) > 2:
-        clean_commands = filter_cannot_handle_command_for_skipped_slots(clean_commands)
+        clean_commands = filter_cannot_handle_command(clean_commands)
     elif not tracker.has_coexistence_routing_slot and len(clean_commands) > 1:
-        clean_commands = filter_cannot_handle_command_for_skipped_slots(clean_commands)
-
-    # remove cancel flow when there is a handle digression command
-    # otherwise the cancel command will cancel the active flow which defined a specific
-    # behavior for the digression
-    if contains_command(clean_commands, HandleDigressionsCommand) and contains_command(
-        clean_commands, CancelFlowCommand
-    ):
-        clean_commands = [
-            command
-            for command in clean_commands
-            if not isinstance(command, CancelFlowCommand)
-        ]
+        clean_commands = filter_cannot_handle_command(clean_commands)
 
     clean_commands = ensure_max_number_of_command_type(
         clean_commands, RepeatBotMessagesCommand, 1
@@ -708,6 +692,7 @@ def clean_up_chitchat_command(
     command: ChitChatAnswerCommand,
     flows: FlowsList,
     execution_context: ExecutionContext,
+    domain: Domain,
     story_graph: Optional[StoryGraph] = None,
 ) -> List[Command]:
     """Clean up a chitchat answer command.
@@ -721,6 +706,8 @@ def clean_up_chitchat_command(
         flows: All flows.
         execution_context: Information about a single graph run.
         story_graph: StoryGraph object with stories available for training.
+        domain: The domain of the bot.
+
     Returns:
         The cleaned up commands.
     """
@@ -746,10 +733,9 @@ def clean_up_chitchat_command(
     )
     defines_intentless_policy = execution_context.has_node(IntentlessPolicy)
 
-    has_e2e_stories = True if (story_graph and story_graph.has_e2e_stories()) else False
-
     if (has_action_trigger_chitchat and not defines_intentless_policy) or (
-        defines_intentless_policy and not has_e2e_stories
+        defines_intentless_policy
+        and not contains_intentless_policy_responses(flows, domain, story_graph)
     ):
         resulting_commands.insert(
             0, CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_CHITCHAT)
@@ -842,12 +828,12 @@ def should_slot_be_set(
     return True
 
 
-def filter_cannot_handle_command_for_skipped_slots(
+def filter_cannot_handle_command(
     clean_commands: List[Command],
 ) -> List[Command]:
-    """Filter out a 'cannot handle' command for skipped slots.
+    """Filter out a 'cannot handle' command.
 
-    This is used to filter out a 'cannot handle' command for skipped slots
+    This is used to filter out a 'cannot handle' command
     in case other commands are present.
 
     Returns:
@@ -856,34 +842,5 @@ def filter_cannot_handle_command_for_skipped_slots(
     return [
         command
         for command in clean_commands
-        if not (
-            isinstance(command, CannotHandleCommand)
-            and command.reason
-            and CANNOT_HANDLE_REASON == command.reason
-        )
+        if not isinstance(command, CannotHandleCommand)
     ]
-
-
-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

@@ -6,6 +6,7 @@ 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
+from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -15,7 +16,8 @@ from rasa.shared.core.training_data.structures import StoryGraph
 class CommandProcessorComponent(GraphComponent):
     """Processes commands by issuing events to modify a tracker.
 
-    Minimal component that applies commands to a tracker."""
+    Minimal component that applies commands to a tracker.
+    """
 
     def __init__(self, execution_context: ExecutionContext):
         self._execution_context = execution_context
@@ -36,8 +38,9 @@ class CommandProcessorComponent(GraphComponent):
         tracker: DialogueStateTracker,
         flows: FlowsList,
         story_graph: StoryGraph,
+        domain: Domain,
     ) -> List[Event]:
         """Execute commands to update tracker state."""
         return rasa.dialogue_understanding.processor.command_processor.execute_commands(
-            tracker, flows, self._execution_context, story_graph
+            tracker, flows, self._execution_context, story_graph, domain
         )

rasa/dialogue_understanding/stack/utils.py

@@ -4,9 +4,6 @@ from typing import List, Optional, Set, Tuple
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
 )
-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 (
     BaseFlowStackFrame,
@@ -221,38 +218,3 @@ 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

rasa/e2e_test/llm_judge_prompts/answer_relevance_prompt_template.jinja2

@@ -6,7 +6,7 @@ Each question variation should be a question that the input answer is attempting
 Follow these steps to complete the task:
 
 1. Generate {{ num_variations }} question variations that the input answer is attempting to answer.
-3. Compile all the question variations  into a JSON object.
+2. Compile all the question variations into a JSON object.
 
 ### JSON Output
 

rasa/engine/validation.py

@@ -86,7 +86,9 @@ from rasa.shared.constants import (
 from rasa.shared.core.constants import ACTION_RESET_ROUTING, ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import Flow, FlowsList
+from rasa.shared.core.policies.utils import contains_intentless_policy_responses
 from rasa.shared.core.slots import Slot
+from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.utils.common import display_research_study_prompt
@@ -642,11 +644,18 @@ def _recursively_check_required_components(
 
 
 def validate_flow_component_dependencies(
-    flows: FlowsList, model_configuration: GraphModelConfiguration
+    flows: FlowsList,
+    domain: Domain,
+    story_graph: StoryGraph,
+    model_configuration: GraphModelConfiguration,
 ) -> None:
     if (pattern_chitchat := flows.flow_by_id(FLOW_PATTERN_CHITCHAT)) is not None:
         _validate_chitchat_dependencies(pattern_chitchat, model_configuration)
 
+    _validate_intentless_policy_responses(
+        flows, domain, story_graph, model_configuration
+    )
+
 
 def _validate_chitchat_dependencies(
     pattern_chitchat: Flow, model_configuration: GraphModelConfiguration
@@ -674,6 +683,32 @@ def _validate_chitchat_dependencies(
         )
 
 
+def _validate_intentless_policy_responses(
+    flows: FlowsList,
+    domain: Domain,
+    story_graph: StoryGraph,
+    model_configuration: GraphModelConfiguration,
+) -> None:
+    """If IntentlessPolicy is configured, validate that it has responses to use:
+    either responses from the domain that are not part of any flow, or from
+    end-to-end stories.
+    """
+    if not model_configuration.predict_schema.has_node(IntentlessPolicy):
+        return
+
+    if not contains_intentless_policy_responses(flows, domain, story_graph):
+        structlogger.error(
+            "validation.intentless_policy.no_applicable_responses_found",
+            event_info=(
+                "IntentlessPolicy is configured, but no applicable responses are "
+                "found. Please make sure that there are responses defined in the "
+                "domain that are not part of any flow, or that there are "
+                "end-to-end stories in the training data."
+            ),
+        )
+        sys.exit(1)
+
+
 def get_component_index(schema: GraphSchema, component_class: Type) -> Optional[int]:
     """Extracts the index of a component of the given class in the schema.
     This function assumes that each component's node name is stored in a way

rasa/model_training.py

@@ -315,6 +315,7 @@ async def _train_graph(
     )
     flows = file_importer.get_flows()
     domain = file_importer.get_domain()
+    story_graph = file_importer.get_stories()
     model_configuration = recipe.graph_config_for_recipe(
         config,
         kwargs,
@@ -330,7 +331,7 @@ async def _train_graph(
         config
     )
     rasa.engine.validation.validate_flow_component_dependencies(
-        flows, model_configuration
+        flows, domain, story_graph, model_configuration
     )
     rasa.engine.validation.validate_command_generator_setup(model_configuration)
 

rasa/shared/constants.py

@@ -99,6 +99,8 @@ UTTER_ASK_PREFIX = "utter_ask_"
 ACTION_ASK_PREFIX = "action_ask_"
 FLOW_PREFIX = "flow_"
 
+UTTER_FREE_CHITCHAT_RESPONSE = "utter_free_chitchat_response"
+
 ASSISTANT_ID_KEY = "assistant_id"
 ASSISTANT_ID_DEFAULT_VALUE = "placeholder_default"
 

rasa/shared/core/constants.py

@@ -52,8 +52,6 @@ ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
 ACTION_HANGUP = "action_hangup"
 ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
-ACTION_BLOCK_DIGRESSION = "action_block_digression"
-ACTION_CONTINUE_DIGRESSION = "action_continue_digression"
 
 ACTION_METADATA_EXECUTION_SUCCESS = "execution_success"
 ACTION_METADATA_EXECUTION_ERROR_MESSAGE = "execution_error_message"
@@ -84,8 +82,6 @@ DEFAULT_ACTION_NAMES = [
     ACTION_RESET_ROUTING,
     ACTION_HANGUP,
     ACTION_REPEAT_BOT_MESSAGES,
-    ACTION_BLOCK_DIGRESSION,
-    ACTION_CONTINUE_DIGRESSION,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"
@@ -205,8 +201,4 @@ CLASSIFIER_NAME_FALLBACK = "FallbackClassifier"
 
 POLICIES_THAT_EXTRACT_ENTITIES = {"TEDPolicy"}
 
-# digression constants
-KEY_ASK_CONFIRM_DIGRESSIONS = "ask_confirm_digressions"
-KEY_BLOCK_DIGRESSIONS = "block_digressions"
-
 ERROR_CODE_KEY = "error_code"

rasa/shared/core/domain.py

@@ -1678,6 +1678,14 @@ class Domain:
         """Write domain to a file."""
         as_yaml = self.as_yaml()
         rasa.shared.utils.io.write_text_file(as_yaml, filename)
+        # run the check again on the written domain to catch any errors
+        # that may have been missed in the user defined domain files
+        structlogger.info(
+            "domain.persist.domain_written_to_file",
+            event_info="The entire domain content has been written to file.",
+            filename=filename,
+        )
+        Domain.is_domain_file(filename)
 
     def as_yaml(self) -> Text:
         """Dump the `Domain` object as a YAML string.
@@ -1972,17 +1980,18 @@ class Domain:
 
         try:
             content = read_yaml_file(filename, expand_env_vars=cls.expand_env_vars)
-        except (RasaException, YamlSyntaxException):
-            structlogger.warning(
+        except (RasaException, YamlSyntaxException) as error:
+            structlogger.error(
                 "domain.cannot_load_domain_file",
                 file=filename,
+                error=error,
                 event_info=(
                     f"The file {filename} could not be loaded as domain file. "
                     f"You can use https://yamlchecker.com/ to validate "
                     f"the YAML syntax of your file."
                 ),
             )
-            return False
+            raise RasaException(f"Domain could not be loaded: {error}")
 
         return any(key in content for key in ALL_DOMAIN_KEYS)
 

rasa/shared/core/flows/flow.py

@@ -13,10 +13,6 @@ from pypred import Predicate
 import rasa.shared.utils.io
 from rasa.engine.language import Language
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.constants import (
-    KEY_ASK_CONFIRM_DIGRESSIONS,
-    KEY_BLOCK_DIGRESSIONS,
-)
 from rasa.shared.core.flows.constants import (
     KEY_ALWAYS_INCLUDE_IN_PROMPT,
     KEY_DESCRIPTION,
@@ -52,7 +48,6 @@ from rasa.shared.core.flows.steps.constants import (
     START_STEP,
 )
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
-from rasa.shared.core.flows.utils import extract_digression_prop
 from rasa.shared.core.slots import Slot
 
 structlogger = structlog.get_logger()
@@ -94,10 +89,6 @@ class Flow:
     """The path to the file where the flow is stored."""
     persisted_slots: List[str] = field(default_factory=list)
     """The list of slots that should be persisted after the flow ends."""
-    ask_confirm_digressions: List[str] = field(default_factory=list)
-    """The flow ids for which the assistant should ask for confirmation."""
-    block_digressions: List[str] = field(default_factory=list)
-    """The flow ids that the assistant should block from digressing to."""
     run_pattern_completed: bool = True
     """Whether the pattern_completed flow should be run after the flow ends."""
 
@@ -138,10 +129,6 @@ class Flow:
             # data. When the model is trained, take the provided file_path.
             file_path=data.get(KEY_FILE_PATH) if KEY_FILE_PATH in data else file_path,
             persisted_slots=data.get(KEY_PERSISTED_SLOTS, []),
-            ask_confirm_digressions=extract_digression_prop(
-                KEY_ASK_CONFIRM_DIGRESSIONS, data
-            ),
-            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
             run_pattern_completed=data.get(KEY_RUN_PATTERN_COMPLETED, True),
             translation=extract_translations(
                 translation_data=data.get(KEY_TRANSLATION, {})
@@ -220,10 +207,6 @@ class Flow:
             data[KEY_FILE_PATH] = self.file_path
         if self.persisted_slots:
             data[KEY_PERSISTED_SLOTS] = self.persisted_slots
-        if self.ask_confirm_digressions:
-            data[KEY_ASK_CONFIRM_DIGRESSIONS] = self.ask_confirm_digressions
-        if self.block_digressions:
-            data[KEY_BLOCK_DIGRESSIONS] = self.block_digressions
         if self.run_pattern_completed is not None:
             data["run_pattern_completed"] = self.run_pattern_completed
         if self.translation:

rasa/shared/core/flows/flows_yaml_schema.json

@@ -217,15 +217,12 @@
                             "reset_after_flow_ends": {
                                 "type": "boolean"
                             },
-                            "ask_confirm_digressions": {
-                                "$ref": "#/$defs/ask_confirm_digressions"
-                            },
-                            "block_digressions": {
-                                "$ref": "#/$defs/block_digressions"
-                            },
                             "utter": {
                                 "type": "string"
                             },
+                            "force_slot_filling": {
+                                "type": "boolean"
+                            },
                             "rejections": {
                                 "type": "array",
                                 "schema_name": "list of rejections",
@@ -253,32 +250,6 @@
                 }
             }
         },
-        "ask_confirm_digressions": {
-            "oneOf": [
-                {
-                    "type": "boolean"
-                },
-                {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    }
-                }
-            ]
-        },
-        "block_digressions": {
-            "oneOf": [
-                {
-                    "type": "boolean"
-                },
-                {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    }
-                }
-            ]
-        },
         "flow": {
             "required": [
                 "steps",
@@ -340,12 +311,6 @@
                 "persisted_slots": {
                     "$ref": "#/$defs/persisted_slots"
                 },
-                "ask_confirm_digressions": {
-                    "$ref": "#/$defs/ask_confirm_digressions"
-                },
-                "block_digressions": {
-                    "$ref": "#/$defs/block_digressions"
-                },
                 "run_pattern_completed": {
                     "type": "boolean"
                 }

rasa/shared/core/flows/steps/collect.py

@@ -1,15 +1,10 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Any, Dict, List, Set, Text
 
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
-from rasa.shared.core.constants import (
-    KEY_ASK_CONFIRM_DIGRESSIONS,
-    KEY_BLOCK_DIGRESSIONS,
-)
 from rasa.shared.core.flows.flow_step import FlowStep
-from rasa.shared.core.flows.utils import extract_digression_prop
 from rasa.shared.core.slots import SlotRejection
 
 
@@ -29,10 +24,8 @@ class CollectInformationFlowStep(FlowStep):
     """Whether to always ask the question even if the slot is already filled."""
     reset_after_flow_ends: bool = True
     """Whether to reset the slot value at the end of the flow."""
-    ask_confirm_digressions: List[str] = field(default_factory=list)
-    """The flow id digressions for which the assistant should ask for confirmation."""
-    block_digressions: List[str] = field(default_factory=list)
-    """The flow id digressions that should be blocked during the flow step."""
+    force_slot_filling: bool = False
+    """Whether to keep only the SetSlot command for the collected slot."""
 
     @classmethod
     def from_json(
@@ -60,10 +53,7 @@ class CollectInformationFlowStep(FlowStep):
                 SlotRejection.from_dict(rejection)
                 for rejection in data.get("rejections", [])
             ],
-            ask_confirm_digressions=extract_digression_prop(
-                KEY_ASK_CONFIRM_DIGRESSIONS, data
-            ),
-            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
+            force_slot_filling=data.get("force_slot_filling", False),
             **base.__dict__,
         )
 
@@ -79,10 +69,7 @@ class CollectInformationFlowStep(FlowStep):
         data["ask_before_filling"] = self.ask_before_filling
         data["reset_after_flow_ends"] = self.reset_after_flow_ends
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
-        data["ask_confirm_digressions"] = self.ask_confirm_digressions
-        data["block_digressions"] = (
-            self.block_digressions if self.block_digressions else False
-        )
+        data["force_slot_filling"] = self.force_slot_filling
 
         return data
 

rasa/shared/core/flows/utils.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Set, Text
+from typing import TYPE_CHECKING, Any, Dict, Set, Text
 
 from rasa.shared.utils.io import raise_deprecation_warning
 
@@ -8,7 +8,6 @@ if TYPE_CHECKING:
 
 RESET_PROPERTY_NAME = "reset_after_flow_ends"
 PERSIST_PROPERTY_NAME = "persisted_slots"
-ALL_LABEL = "ALL"
 
 
 def warn_deprecated_collect_step_config() -> None:
@@ -45,20 +44,6 @@ def get_invalid_slot_persistence_config_error_message(
     )
 
 
-def extract_digression_prop(prop: str, data: Dict[str, Any]) -> List[str]:
-    """Extracts the digression property from the data.
-
-    There can be two types of properties: ask_confirm_digressions and
-    block_digressions.
-    """
-    digression_property = data.get(prop, [])
-
-    if isinstance(digression_property, bool):
-        digression_property = [ALL_LABEL] if digression_property else []
-
-    return digression_property
-
-
 def extract_translations(
     translation_data: Dict[Text, Any],
 ) -> Dict[Text, "FlowLanguageTranslation"]: