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

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -1,68 +1,38 @@
 import importlib.resources
-import re
-from typing import Dict, Any, List, Optional, Text
+from typing import Any, Dict, Optional, Text
 
 import structlog
 
-import rasa.shared.utils.io
-from rasa.dialogue_understanding.commands import (
-    Command,
-    ErrorCommand,
-    SetSlotCommand,
-    CancelFlowCommand,
-    HumanHandoffCommand,
-    ChitChatAnswerCommand,
-    SkipQuestionCommand,
-    KnowledgeAnswerCommand,
-    ClarifyCommand,
-    CannotHandleCommand,
-    RepeatBotMessagesCommand,
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
 )
 from rasa.dialogue_understanding.generator.constants import (
+    DEFAULT_LLM_CONFIG,
+    FLOW_RETRIEVAL_KEY,
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
-    FLOW_RETRIEVAL_KEY,
-    DEFAULT_LLM_CONFIG,
 )
-from rasa.dialogue_understanding.generator.flow_retrieval import (
-    FlowRetrieval,
+from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
+from rasa.dialogue_understanding.generator.single_step.compact_llm_command_generator import (  # noqa: E501
+    CompactLLMCommandGenerator,
 )
-from rasa.dialogue_understanding.generator.llm_based_command_generator import (
-    LLMBasedCommandGenerator,
-)
-from rasa.dialogue_understanding.stack.utils import top_flow_frame
-from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.constants import (
-    ROUTE_TO_CALM_SLOT,
+    EMBEDDINGS_CONFIG_KEY,
     PROMPT_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
-    EMBEDDINGS_CONFIG_KEY,
 )
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.exceptions import ProviderClientAPIException
-from rasa.shared.nlu.constants import TEXT, LLM_COMMANDS, LLM_PROMPT
-from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.utils.io import deep_container_fingerprint
-from rasa.shared.utils.llm import (
-    get_prompt_template,
-    tracker_as_readable_transcript,
-    sanitize_message_for_prompt,
-    resolve_model_client_config,
-)
-from rasa.utils.beta import ensure_beta_feature_is_enabled, BetaNotEnabledException
-from rasa.utils.log_utils import log_llm
-
-COMMAND_PROMPT_FILE_NAME = "command_prompt.jinja2"
+from rasa.shared.utils.llm import get_prompt_template, resolve_model_client_config
 
 DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
-    "rasa.dialogue_understanding.generator.single_step",
+    "rasa.dialogue_understanding.generator.prompt_templates",
     "command_prompt_template.jinja2",
 )
-SINGLE_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE = "config.json"
+
 
 structlogger = structlog.get_logger()
 
@@ -73,7 +43,7 @@ structlogger = structlog.get_logger()
     ],
     is_trainable=True,
 )
-class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
+class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
     """A single step LLM-based command generator."""
 
     def __init__(
@@ -102,20 +72,15 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
                     "Please use the config parameter 'prompt_template' instead. "
                 ),
             )
-        config_prompt = (
-            config.get(PROMPT_CONFIG_KEY)
-            or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
-            or None
-        )
-        self.prompt_template = prompt_template or get_prompt_template(
-            config_prompt,
-            DEFAULT_COMMAND_PROMPT_TEMPLATE,
+        self.prompt_template = self.resolve_component_prompt_template(
+            config, prompt_template
         )
 
-        self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
-        self.repeat_command_enabled = self.is_repeat_command_enabled()
+        # Set the command syntax version to v1
+        CommandSyntaxManager.set_syntax_version(
+            self.get_component_command_syntax_version()
+        )
 
-    ### Implementations of LLMBasedCommandGenerator parent
     @staticmethod
     def get_default_config() -> Dict[str, Any]:
         """The component's default config (see parent class for full docstring)."""
@@ -127,279 +92,10 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             FLOW_RETRIEVAL_KEY: FlowRetrieval.get_default_config(),
         }
 
-    @classmethod
-    def load(
-        cls: Any,
-        config: Dict[str, Any],
-        model_storage: ModelStorage,
-        resource: Resource,
-        execution_context: ExecutionContext,
-        **kwargs: Any,
-    ) -> "SingleStepLLMCommandGenerator":
-        """Loads trained component (see parent class for full docstring)."""
-
-        # Perform health check of the LLM API endpoint
-        llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
-        cls.perform_llm_health_check(
-            llm_config,
-            DEFAULT_LLM_CONFIG,
-            "single_step_llm_command_generator.load",
-            SingleStepLLMCommandGenerator.__name__,
-        )
-
-        # load prompt template from the model storage.
-        prompt_template = cls.load_prompt_template_from_model_storage(
-            model_storage, resource, COMMAND_PROMPT_FILE_NAME
-        )
-
-        # init base command generator
-        command_generator = cls(config, model_storage, resource, prompt_template)
-        # load flow retrieval if enabled
-        if command_generator.enabled_flow_retrieval:
-            command_generator.flow_retrieval = cls.load_flow_retrival(
-                command_generator.config, model_storage, resource
-            )
-
-        return command_generator
-
-    def persist(self) -> None:
-        """Persist this component to disk for future loading."""
-        self._persist_prompt_template()
-        self._persist_config()
-        if self.flow_retrieval is not None:
-            self.flow_retrieval.persist()
-
-    def _persist_prompt_template(self) -> None:
-        """Persist prompt template for future loading."""
-        with self._model_storage.write_to(self._resource) as path:
-            rasa.shared.utils.io.write_text_file(
-                self.prompt_template, path / COMMAND_PROMPT_FILE_NAME
-            )
-
-    def _persist_config(self) -> None:
-        """Persist config as a source of truth for resolved clients."""
-        with self._model_storage.write_to(self._resource) as path:
-            rasa.shared.utils.io.dump_obj_as_json_to_file(
-                path / SINGLE_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE, self.config
-            )
-
-    async def predict_commands(
-        self,
-        message: Message,
-        flows: FlowsList,
-        tracker: Optional[DialogueStateTracker] = None,
-        **kwargs: Any,
-    ) -> List[Command]:
-        """Predict commands using the LLM.
-
-        Args:
-            message: The message from the user.
-            flows: The flows available to the user.
-            tracker: The tracker containing the current state of the conversation.
-            **kwargs: Keyword arguments for forward compatibility.
-
-        Returns:
-            The commands generated by the llm.
-        """
-        if tracker is None or flows.is_empty():
-            # cannot do anything if there are no flows or no tracker
-            return []
-
-        try:
-            commands = await self._predict_commands(message, flows, tracker)
-        except ProviderClientAPIException:
-            # if command predictions resulted in API exception
-            # "predict" the ErrorCommand
-            commands = [ErrorCommand()]
-
-        if not commands:
-            # no commands are parsed or there's an invalid command
-            structlogger.warning(
-                "single_step_llm_command_generator.predict_commands",
-                message="No commands were predicted as the LLM response could "
-                "not be parsed or the LLM responded with an invalid command."
-                "Returning a CannotHandleCommand instead.",
-            )
-            commands = [CannotHandleCommand()]
-
-        if tracker.has_coexistence_routing_slot:
-            # if coexistence feature is used, set the routing slot
-            commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True)]
-
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.finished",
-            commands=commands,
-        )
-
-        return commands
-
-    async def _predict_commands(
-        self,
-        message: Message,
-        flows: FlowsList,
-        tracker: Optional[DialogueStateTracker] = None,
-    ) -> List[Command]:
-        """Predict commands using the LLM.
-
-        Args:
-            message: The message from the user.
-            flows: The flows available to the user.
-            tracker: The tracker containing the current state of the conversation.
-
-        Returns:
-            The commands generated by the llm.
-
-        Raises:
-            ProviderClientAPIException: If API calls raised an error.
-        """
-        # retrieve flows
-        filtered_flows = await self.filter_flows(message, flows, tracker)
-
-        flow_prompt = self.render_template(message, tracker, filtered_flows, flows)
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.prompt_rendered",
-            prompt=flow_prompt,
-        )
-
-        action_list = await self.invoke_llm(flow_prompt)
-        # The check for 'None' maintains compatibility with older versions
-        # of LLMCommandGenerator. In previous implementations, 'invoke_llm'
-        # might return 'None' to indicate a failure to generate actions.
-        if action_list is None:
-            return [ErrorCommand()]
-
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.actions_generated",
-            action_list=action_list,
-        )
-
-        commands = self.parse_commands(action_list, tracker, flows)
-
-        self._update_message_parse_data_for_fine_tuning(message, commands, flow_prompt)
-
-        return commands
-
-    @staticmethod
-    def _update_message_parse_data_for_fine_tuning(
-        message: Message, commands: List[Command], prompt: str
-    ) -> None:
-        from rasa.llm_fine_tuning.annotation_module import preparing_fine_tuning_data
-
-        if preparing_fine_tuning_data:
-            # Add commands and prompt to the message object in order to create
-            # prompt -> commands pairs for fine-tuning
-            message.set(
-                LLM_COMMANDS,
-                [command.as_dict() for command in commands],
-                add_to_output=True,
-            )
-            message.set(LLM_PROMPT, prompt, add_to_output=True)
-
-    @classmethod
-    def parse_commands(
-        cls, actions: Optional[str], tracker: DialogueStateTracker, flows: FlowsList
-    ) -> List[Command]:
-        """Parse the actions returned by the llm into intent and entities.
-
-        Args:
-            actions: The actions returned by the llm.
-            tracker: The tracker containing the current state of the conversation.
-            flows: the list of flows
-
-        Returns:
-            The parsed commands.
-        """
-        if actions is None:
-            return []
-
-        commands: List[Command] = []
-
-        slot_set_re = re.compile(
-            r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
-        )
-        start_flow_re = re.compile(r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)")
-        cancel_flow_re = re.compile(r"CancelFlow\(\)")
-        chitchat_re = re.compile(r"ChitChat\(\)")
-        skip_question_re = re.compile(r"SkipQuestion\(\)")
-        knowledge_re = re.compile(r"SearchAndReply\(\)")
-        humand_handoff_re = re.compile(r"HumanHandoff\(\)")
-        clarify_re = re.compile(r"Clarify\(([\"\'a-zA-Z0-9_, ]+)\)")
-        repeat_re = re.compile(r"RepeatLastBotMessages\(\)")
-
-        for action in actions.strip().splitlines():
-            if match := slot_set_re.search(action):
-                slot_name = match.group(1).strip()
-                slot_value = cls.clean_extracted_value(match.group(2))
-                # error case where the llm tries to start a flow using a slot set
-                if slot_name == "flow_name":
-                    commands.extend(cls.start_flow_by_name(slot_value, flows))
-                else:
-                    typed_slot_value = cls.get_nullable_slot_value(slot_value)
-                    commands.append(
-                        SetSlotCommand(name=slot_name, value=typed_slot_value)
-                    )
-            elif match := start_flow_re.search(action):
-                flow_name = match.group(1).strip()
-                commands.extend(cls.start_flow_by_name(flow_name, flows))
-            elif cancel_flow_re.search(action):
-                commands.append(CancelFlowCommand())
-            elif chitchat_re.search(action):
-                commands.append(ChitChatAnswerCommand())
-            elif skip_question_re.search(action):
-                commands.append(SkipQuestionCommand())
-            elif knowledge_re.search(action):
-                commands.append(KnowledgeAnswerCommand())
-            elif humand_handoff_re.search(action):
-                commands.append(HumanHandoffCommand())
-            elif repeat_re.search(action):
-                commands.append(RepeatBotMessagesCommand())
-            elif match := clarify_re.search(action):
-                options = sorted([opt.strip() for opt in match.group(1).split(",")])
-                # Remove surrounding quotes if present
-                cleaned_options = []
-                for flow in options:
-                    if (flow.startswith('"') and flow.endswith('"')) or (
-                        flow.startswith("'") and flow.endswith("'")
-                    ):
-                        cleaned_options.append(flow[1:-1])
-                    else:
-                        cleaned_options.append(flow)
-                # check if flow is valid
-                valid_options = [
-                    flow for flow in cleaned_options if flow in flows.user_flow_ids
-                ]
-                if len(set(valid_options)) == 1:
-                    commands.extend(cls.start_flow_by_name(valid_options[0], flows))
-                elif len(valid_options) > 1:
-                    commands.append(ClarifyCommand(valid_options))
-
-        if not commands:
-            structlogger.debug(
-                "single_step_llm_command_generator.parse_commands",
-                message="No commands were parsed from the LLM actions.",
-                actions=actions,
-            )
-
-        return commands
-
     @classmethod
     def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint for the graph."""
-        config_prompt = (
-            config.get(PROMPT_CONFIG_KEY)
-            or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
-            or None
-        )
-        prompt_template = get_prompt_template(
-            config_prompt,
-            DEFAULT_COMMAND_PROMPT_TEMPLATE,
-        )
+        prompt_template = cls.resolve_component_prompt_template(config)
         llm_config = resolve_model_client_config(
             config.get(LLM_CONFIG_KEY), SingleStepLLMCommandGenerator.__name__
         )
@@ -411,68 +107,27 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             [prompt_template, llm_config, embedding_config]
         )
 
-    ### Helper methods
-    def render_template(
-        self,
-        message: Message,
-        tracker: DialogueStateTracker,
-        startable_flows: FlowsList,
-        all_flows: FlowsList,
-    ) -> str:
-        """Render the jinja template to create the prompt for the LLM.
-
-        Args:
-            message: The current message from the user.
-            tracker: The tracker containing the current state of the conversation.
-            startable_flows: The flows startable at this point in time by the user.
-            all_flows: all flows present in the assistant
-
-        Returns:
-            The rendered prompt template.
-        """
-        # need to make this distinction here because current step of the
-        # top_calling_frame would be the call step, but we need the collect step from
-        # the called frame. If no call is active calling and called frame are the same.
-        top_calling_frame = top_flow_frame(tracker.stack)
-        top_called_frame = top_flow_frame(tracker.stack, ignore_call_frames=False)
+    @staticmethod
+    def get_default_llm_config() -> Dict[str, Any]:
+        """Get the default LLM config for the command generator."""
+        return DEFAULT_LLM_CONFIG
 
-        top_flow = top_calling_frame.flow(all_flows) if top_calling_frame else None
-        current_step = top_called_frame.step(all_flows) if top_called_frame else None
+    @staticmethod
+    def get_component_command_syntax_version() -> CommandSyntaxVersion:
+        return CommandSyntaxVersion.v1
 
-        flow_slots = self.prepare_current_flow_slots_for_template(
-            top_flow, current_step, tracker
+    @staticmethod
+    def resolve_component_prompt_template(
+        config: Dict[str, Any], prompt_template: Optional[str] = None
+    ) -> Optional[str]:
+        """Get the prompt template from the config or the default prompt template."""
+        # Get the default prompt template based on the model name.
+        config_prompt = (
+            config.get(PROMPT_CONFIG_KEY)
+            or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            or None
         )
-        current_slot, current_slot_description = self.prepare_current_slot_for_template(
-            current_step
+        return prompt_template or get_prompt_template(
+            config_prompt,
+            DEFAULT_COMMAND_PROMPT_TEMPLATE,
         )
-        current_conversation = tracker_as_readable_transcript(tracker)
-        latest_user_message = sanitize_message_for_prompt(message.get(TEXT))
-        current_conversation += f"\nUSER: {latest_user_message}"
-
-        inputs = {
-            "available_flows": self.prepare_flows_for_template(
-                startable_flows, tracker
-            ),
-            "current_conversation": current_conversation,
-            "flow_slots": flow_slots,
-            "current_flow": top_flow.id if top_flow is not None else None,
-            "current_slot": current_slot,
-            "current_slot_description": current_slot_description,
-            "user_message": latest_user_message,
-            "is_repeat_command_enabled": self.repeat_command_enabled,
-        }
-
-        return self.compile_template(self.prompt_template).render(**inputs)
-
-    def is_repeat_command_enabled(self) -> bool:
-        """Check for feature flag"""
-        RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME = "RASA_PRO_BETA_REPEAT_COMMAND"
-        try:
-            ensure_beta_feature_is_enabled(
-                "Repeat Command",
-                env_flag=RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME,
-            )
-        except BetaNotEnabledException:
-            return False
-
-        return True

rasa/dialogue_understanding/generator/utils.py

@@ -0,0 +1,76 @@
+from typing import Dict, List, Set, Type
+
+from rasa.dialogue_understanding.commands import (
+    CancelFlowCommand,
+    CannotHandleCommand,
+    ChitChatAnswerCommand,
+    Command,
+    CorrectSlotsCommand,
+    HumanHandoffCommand,
+    KnowledgeAnswerCommand,
+    RestartCommand,
+    SessionStartCommand,
+    SetSlotCommand,
+    SkipQuestionCommand,
+)
+from rasa.dialogue_understanding.commands.user_silence_command import UserSilenceCommand
+from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.cannot_handle import (
+    CannotHandlePatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.chitchat import ChitchatPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.human_handoff import (
+    HumanHandoffPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.restart import RestartPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.search import SearchPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.session_start import (
+    SessionStartPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.skip_question import (
+    SkipQuestionPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.user_silence import (
+    UserSilencePatternFlowStackFrame,
+)
+
+triggerable_pattern_to_command_class: Dict[str, Type[Command]] = {
+    SessionStartPatternFlowStackFrame.flow_id: SessionStartCommand,
+    UserSilencePatternFlowStackFrame.flow_id: UserSilenceCommand,
+    CancelPatternFlowStackFrame.flow_id: CancelFlowCommand,
+    ChitchatPatternFlowStackFrame.flow_id: ChitChatAnswerCommand,
+    HumanHandoffPatternFlowStackFrame.flow_id: HumanHandoffCommand,
+    SearchPatternFlowStackFrame.flow_id: KnowledgeAnswerCommand,
+    SkipQuestionPatternFlowStackFrame.flow_id: SkipQuestionCommand,
+    CannotHandlePatternFlowStackFrame.flow_id: CannotHandleCommand,
+    RestartPatternFlowStackFrame.flow_id: RestartCommand,
+}
+
+
+def filter_slot_commands(
+    commands: List[Command], overlapping_slot_names: Set[str]
+) -> List[Command]:
+    """Filter out slot commands that set overlapping slots."""
+    filtered_commands = []
+
+    for command in commands:
+        if (
+            isinstance(command, SetSlotCommand)
+            and command.name in overlapping_slot_names
+        ):
+            continue
+
+        if isinstance(command, CorrectSlotsCommand):
+            allowed_slots = [
+                slot
+                for slot in command.corrected_slots
+                if slot.name not in overlapping_slot_names
+            ]
+            if not allowed_slots:
+                continue
+
+            command.corrected_slots = allowed_slots
+
+        filtered_commands.append(command)
+
+    return filtered_commands

rasa/dialogue_understanding/patterns/cancel.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
 import structlog
+
 from rasa.core.actions import action
 from rasa.core.channels.channel import OutputChannel
 from rasa.core.nlg.generator import NaturalLanguageGenerator
@@ -18,7 +20,6 @@ from rasa.shared.core.flows.steps.constants import END_STEP
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
 from rasa.shared.core.trackers import DialogueStateTracker
 
-
 structlogger = structlog.get_logger()
 
 FLOW_PATTERN_CANCEL = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "cancel_flow"

rasa/dialogue_understanding/patterns/cannot_handle.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any, Dict, Optional, Text
 

rasa/dialogue_understanding/patterns/chitchat.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any, Dict
 
 from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
 
-
 FLOW_PATTERN_CHITCHAT = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "chitchat"
 
 

rasa/dialogue_understanding/patterns/clarify.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
 import structlog
+
 from rasa.core.actions import action
 from rasa.core.channels.channel import OutputChannel
 from rasa.core.nlg.generator import NaturalLanguageGenerator
@@ -13,7 +15,6 @@ from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import Event
 from rasa.shared.core.trackers import DialogueStateTracker
 
-
 structlogger = structlog.get_logger()
 
 FLOW_PATTERN_CLARIFICATION = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "clarification"

rasa/dialogue_understanding/patterns/code_change.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any, Dict
 
 import structlog
+
 from rasa.dialogue_understanding.stack.frames import (
     PatternFlowStackFrame,
 )

rasa/dialogue_understanding/patterns/collect_information.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
-from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
-from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
-from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.flows.steps.collect import SlotRejection
 
+from rasa.dialogue_understanding.stack.frames import (
+    DialogueStackFrame,
+    PatternFlowStackFrame,
+)
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.slots import SlotRejection
 
 FLOW_PATTERN_COLLECT_INFORMATION = (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX + "collect_information"

rasa/dialogue_understanding/patterns/completed.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any, Dict
 
 from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
 
-
 FLOW_PATTERN_COMPLETED = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "completed"
 
 

rasa/dialogue_understanding/patterns/continue_interrupted.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any, Dict
 
 from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
 
-
 FLOW_PATTERN_CONTINUE_INTERRUPTED = (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX + "continue_interrupted"
 )