rasa-pro 3.13.0.dev1__py3-none-any.whl → 3.13.0.dev2__py3-none-any.whl

rasa/core/actions/action_handle_digressions.py

@@ -1,164 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-import structlog
-
-from rasa.core.actions.action import Action, create_bot_utterance
-from rasa.core.channels import OutputChannel
-from rasa.core.nlg import NaturalLanguageGenerator
-from rasa.core.utils import add_bot_utterance_metadata
-from rasa.dialogue_understanding.patterns.continue_interrupted import (
-    ContinueInterruptedPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.handle_digressions import (
-    HandleDigressionsPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
-    FlowStackFrameType,
-    UserFlowStackFrame,
-)
-from rasa.dialogue_understanding.stack.utils import (
-    remove_digression_from_stack,
-    user_flows_on_the_stack,
-)
-from rasa.shared.core.constants import (
-    ACTION_BLOCK_DIGRESSION,
-    ACTION_CONTINUE_DIGRESSION,
-)
-from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import Event, FlowInterrupted
-from rasa.shared.core.trackers import DialogueStateTracker
-
-structlogger = structlog.get_logger()
-
-
-class ActionBlockDigressions(Action):
-    """Action which blocks an interruption and continues the current flow."""
-
-    def name(self) -> str:
-        """Return the action name."""
-        return ACTION_BLOCK_DIGRESSION
-
-    async def run(
-        self,
-        output_channel: OutputChannel,
-        nlg: NaturalLanguageGenerator,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> List[Event]:
-        """Update the stack."""
-        structlogger.debug("action_block_digressions.run")
-        top_frame = tracker.stack.top()
-
-        if not isinstance(top_frame, HandleDigressionsPatternFlowStackFrame):
-            return []
-
-        blocked_flow_id = top_frame.interrupting_flow_id
-        frame_type = FlowStackFrameType.REGULAR
-
-        stack = tracker.stack
-
-        if blocked_flow_id in user_flows_on_the_stack(stack):
-            structlogger.debug(
-                "action_block_digressions.already_blocked_flow",
-                blocked_flow_id=blocked_flow_id,
-            )
-            events = []
-        else:
-            stack.push(
-                UserFlowStackFrame(flow_id=blocked_flow_id, frame_type=frame_type), 0
-            )
-            stack.push(
-                ContinueInterruptedPatternFlowStackFrame(
-                    previous_flow_name=blocked_flow_id
-                ),
-                1,
-            )
-            events = tracker.create_stack_updated_events(stack)
-
-        utterance = "utter_block_digressions"
-        message = await nlg.generate(
-            utterance,
-            tracker,
-            output_channel.name(),
-        )
-
-        if message is None:
-            structlogger.error(
-                "action_block_digressions.run.failed.finding.utter",
-                utterance=utterance,
-            )
-        else:
-            message = add_bot_utterance_metadata(
-                message, utterance, nlg, domain, tracker
-            )
-            events.append(create_bot_utterance(message))
-
-        return events
-
-
-class ActionContinueDigression(Action):
-    """Action which continues with an interruption."""
-
-    def name(self) -> str:
-        """Return the action name."""
-        return ACTION_CONTINUE_DIGRESSION
-
-    async def run(
-        self,
-        output_channel: OutputChannel,
-        nlg: NaturalLanguageGenerator,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> List[Event]:
-        """Update the stack."""
-        structlogger.debug("action_continue_digression.run")
-        top_frame = tracker.stack.top()
-
-        if not isinstance(top_frame, HandleDigressionsPatternFlowStackFrame):
-            return []
-
-        interrupting_flow_id = top_frame.interrupting_flow_id
-        stack = tracker.stack
-
-        if interrupting_flow_id in user_flows_on_the_stack(stack):
-            structlogger.debug(
-                "action_continue_digression.interrupting_flow_id_already_on_the_stack",
-                interrupting_flow_id=interrupting_flow_id,
-            )
-            stack = remove_digression_from_stack(stack, interrupting_flow_id)
-
-        frame_type = FlowStackFrameType.INTERRUPT
-        stack.push(
-            UserFlowStackFrame(flow_id=interrupting_flow_id, frame_type=frame_type)
-        )
-
-        events = [
-            FlowInterrupted(
-                flow_id=top_frame.interrupted_flow_id,
-                step_id=top_frame.interrupted_step_id,
-            )
-        ] + tracker.create_stack_updated_events(stack)
-
-        utterance = "utter_continue_interruption"
-        message = await nlg.generate(
-            utterance,
-            tracker,
-            output_channel.name(),
-        )
-
-        if message is None:
-            structlogger.error(
-                "action_continue_digression.run.failed.finding.utter",
-                utterance=utterance,
-            )
-        else:
-            message = add_bot_utterance_metadata(
-                message, utterance, nlg, domain, tracker
-            )
-            events.append(create_bot_utterance(message))
-
-        return events

rasa/dialogue_understanding/commands/handle_digressions_command.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Dict, List
-
-import structlog
-
-from rasa.dialogue_understanding.commands.command import Command
-from rasa.dialogue_understanding.patterns.cannot_handle import (
-    CannotHandlePatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.handle_digressions import (
-    HandleDigressionsPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.stack.utils import (
-    top_flow_frame,
-)
-from rasa.shared.core.events import Event
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.flows.steps import CollectInformationFlowStep
-from rasa.shared.core.flows.utils import ALL_LABEL
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.nlu.constants import HANDLE_DIGRESSIONS_COMMAND
-
-structlogger = structlog.get_logger()
-
-
-@dataclass
-class HandleDigressionsCommand(Command):
-    """A command to handle digressions during an active flow."""
-
-    flow: str
-    """The interrupting flow."""
-
-    @classmethod
-    def command(cls) -> str:
-        """Returns the command type."""
-        return HANDLE_DIGRESSIONS_COMMAND
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> HandleDigressionsCommand:
-        """Converts the dictionary to a command.
-
-        Returns:
-            The converted dictionary.
-        """
-        try:
-            return HandleDigressionsCommand(flow=data["flow"])
-        except KeyError as e:
-            raise ValueError(
-                f"Missing parameter '{e}' while parsing HandleDigressionsCommand."
-            ) from e
-
-    def run_command_on_tracker(
-        self,
-        tracker: DialogueStateTracker,
-        all_flows: FlowsList,
-        original_tracker: DialogueStateTracker,
-    ) -> List[Event]:
-        """Runs the command on the tracker.
-
-        Args:
-            tracker: The tracker to run the command on.
-            all_flows: All flows in the assistant.
-            original_tracker: The tracker before any command was executed.
-
-        Returns:
-            The events to apply to the tracker.
-        """
-        stack = tracker.stack
-        original_stack = original_tracker.stack
-
-        if self.flow not in all_flows.flow_ids:
-            structlogger.debug(
-                "command_executor.push_cannot_handle.start_invalid_flow_id",
-                command=self,
-            )
-            stack.push(CannotHandlePatternFlowStackFrame())
-            return tracker.create_stack_updated_events(stack)
-
-        # this allows to include called user flows in the stack search
-        latest_user_frame = top_flow_frame(original_stack, ignore_call_frames=False)
-
-        if latest_user_frame is None:
-            structlogger.debug(
-                "command_executor.skip_command.no_top_flow", command=self
-            )
-            return []
-
-        original_top_flow = latest_user_frame.flow(all_flows)
-        current_step = original_top_flow.step_by_id(latest_user_frame.step_id)
-        if not isinstance(current_step, CollectInformationFlowStep):
-            structlogger.debug(
-                "command_executor.skip_command.not_at_a_collect_step", command=self
-            )
-            return []
-
-        ask_confirm_digressions = set(
-            current_step.ask_confirm_digressions
-            + original_top_flow.ask_confirm_digressions
-        )
-
-        block_digressions = set(
-            current_step.block_digressions + original_top_flow.block_digressions
-        )
-
-        if block_digressions:
-            if ALL_LABEL in block_digressions:
-                block_digressions.remove(ALL_LABEL)
-                block_digressions.add(self.flow)
-
-        if ask_confirm_digressions:
-            if ALL_LABEL in ask_confirm_digressions:
-                ask_confirm_digressions.remove(ALL_LABEL)
-                ask_confirm_digressions.add(self.flow)
-
-        structlogger.debug(
-            "command_executor.push_handle_digressions",
-            interrupting_flow_id=self.flow,
-            interrupted_flow_id=original_top_flow.id,
-            interrupted_step_id=current_step.id,
-            ask_confirm_digressions=ask_confirm_digressions,
-            block_digressions=block_digressions,
-        )
-        stack.push(
-            HandleDigressionsPatternFlowStackFrame(
-                interrupting_flow_id=self.flow,
-                interrupted_flow_id=original_top_flow.id,
-                interrupted_step_id=current_step.id,
-                ask_confirm_digressions=ask_confirm_digressions,
-                block_digressions=block_digressions,
-            )
-        )
-
-        return tracker.create_stack_updated_events(stack)
-
-    def __hash__(self) -> int:
-        return hash(self.flow)
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, HandleDigressionsCommand):
-            return False
-
-        return other.flow == self.flow

rasa/dialogue_understanding/patterns/handle_digressions.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, Set
-
-from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
-from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.constants import (
-    KEY_ASK_CONFIRM_DIGRESSIONS,
-    KEY_BLOCK_DIGRESSIONS,
-)
-
-FLOW_PATTERN_HANDLE_DIGRESSIONS = (
-    RASA_DEFAULT_FLOW_PATTERN_PREFIX + "handle_digressions"
-)
-
-
-@dataclass
-class HandleDigressionsPatternFlowStackFrame(PatternFlowStackFrame):
-    """A pattern flow stack frame that gets added if an interruption is completed."""
-
-    flow_id: str = FLOW_PATTERN_HANDLE_DIGRESSIONS
-    """The ID of the flow."""
-    interrupting_flow_id: str = ""
-    """The ID of the flow that interrupted the active flow."""
-    interrupted_flow_id: str = ""
-    """The name of the active flow that was interrupted."""
-    interrupted_step_id: str = ""
-    """The ID of the step that was interrupted."""
-    ask_confirm_digressions: Set[str] = field(default_factory=set)
-    """The set of interrupting flow names to confirm."""
-    block_digressions: Set[str] = field(default_factory=set)
-    """The set of interrupting flow names to block."""
-
-    @classmethod
-    def type(cls) -> str:
-        """Returns the type of the frame."""
-        return FLOW_PATTERN_HANDLE_DIGRESSIONS
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> HandleDigressionsPatternFlowStackFrame:
-        """Creates a `DialogueStackFrame` from a dictionary.
-
-        Args:
-            data: The dictionary to create the `DialogueStackFrame` from.
-
-        Returns:
-            The created `DialogueStackFrame`.
-        """
-        return HandleDigressionsPatternFlowStackFrame(
-            frame_id=data["frame_id"],
-            step_id=data["step_id"],
-            interrupted_step_id=data["interrupted_step_id"],
-            interrupted_flow_id=data["interrupted_flow_id"],
-            interrupting_flow_id=data["interrupting_flow_id"],
-            ask_confirm_digressions=set(data.get(KEY_ASK_CONFIRM_DIGRESSIONS, [])),
-            # This attribute must be converted to a set to enable usage
-            # of subset `contains` pypred operator in the default pattern
-            # conditional branching
-            block_digressions=set(data.get(KEY_BLOCK_DIGRESSIONS, [])),
-        )
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, HandleDigressionsPatternFlowStackFrame):
-            return False
-        return (
-            self.flow_id == other.flow_id
-            and self.interrupted_step_id == other.interrupted_step_id
-            and self.interrupted_flow_id == other.interrupted_flow_id
-            and self.interrupting_flow_id == other.interrupting_flow_id
-            and self.ask_confirm_digressions == other.ask_confirm_digressions
-            and self.block_digressions == other.block_digressions
-        )
-
-    def as_dict(self) -> Dict[str, Any]:
-        """Returns the frame as a dictionary."""
-        data = super().as_dict()
-        # converting back to list to avoid serialization issues
-        data[KEY_ASK_CONFIRM_DIGRESSIONS] = list(self.ask_confirm_digressions)
-        data[KEY_BLOCK_DIGRESSIONS] = list(self.block_digressions)
-        return data