rasa-pro 3.9.18__py3-none-any.whl

rasa/core/actions/action_clean_stack.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import structlog
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.dialogue_understanding.stack.frames import (
+    BaseFlowStackFrame,
+    UserFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import FlowStackFrameType
+from rasa.shared.core.constants import ACTION_CLEAN_STACK
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event
+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()
+
+
+class ActionCleanStack(Action):
+    """Action which cancels a flow from the stack."""
+
+    def name(self) -> str:
+        """Return the flow name."""
+        return ACTION_CLEAN_STACK
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Clean the stack."""
+        structlogger.debug("action_clean_stack.run")
+        new_frames = []
+        # Set all frames to their end step, filter out any non-BaseFlowStackFrames
+        for frame in tracker.stack.frames:
+            if isinstance(frame, BaseFlowStackFrame):
+                structlogger.debug(
+                    "action_clean_stack.terminating_frame",
+                    frame_id=frame.frame_id,
+                    flow_id=frame.flow_id,
+                )
+                frame.step_id = ContinueFlowStep.continue_step_for_id(END_STEP)
+                if isinstance(frame, UserFlowStackFrame):
+                    # Making sure there are no "continue interrupts" triggered
+                    frame.frame_type = FlowStackFrameType.REGULAR
+                new_frames.append(frame)
+        new_stack = DialogueStack.from_dict([frame.as_dict() for frame in new_frames])
+
+        return tracker.create_stack_updated_events(new_stack)

rasa/core/actions/action_exceptions.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from rasa.shared.exceptions import RasaException
+
+
+class ActionExecutionRejection(RasaException):
+    """Raising this exception allows other policies to predict a different action."""
+
+    def __init__(self, action_name: str, message: Optional[str] = None) -> None:
+        """Create a new ActionExecutionRejection exception."""
+        self.action_name = action_name
+        self.message = message or "Custom action '{}' rejected to run".format(
+            action_name
+        )
+        super(ActionExecutionRejection, self).__init__()
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class DomainNotFound(Exception):
+    """Exception raised when domain is not found."""
+
+    pass

rasa/core/actions/action_run_slot_rejections.py

@@ -0,0 +1,207 @@
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Union
+
+import structlog
+from jinja2 import Template
+from pypred import Predicate
+
+from rasa.core.actions.action import Action, create_bot_utterance
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.shared.core.constants import ACTION_RUN_SLOT_REJECTIONS_NAME
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.flows.steps.collect import SlotRejection
+from rasa.shared.core.slots import (
+    BooleanSlot,
+    CategoricalSlot,
+    FloatSlot,
+    Slot,
+)
+
+if TYPE_CHECKING:
+    from rasa.core.nlg import NaturalLanguageGenerator
+    from rasa.core.channels.channel import OutputChannel
+    from rasa.shared.core.domain import Domain
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+UTTERANCE_NOT_DEFINED_BY_USER = "TO.UPDATE.VALUE.BUT.MISSING.UTTERANCE"
+
+
+def utterance_for_slot_type(slot: Slot) -> Optional[str]:
+    """Return the utterance to use for the slot type."""
+    if isinstance(slot, BooleanSlot):
+        return "utter_boolean_slot_rejection"
+    elif isinstance(slot, FloatSlot):
+        return "utter_float_slot_rejection"
+    elif isinstance(slot, CategoricalSlot):
+        return "utter_categorical_slot_rejection"
+    return None
+
+
+def coerce_slot_value(
+    slot_value: str, slot_name: str, tracker: "DialogueStateTracker"
+) -> Union[str, bool, float, None]:
+    """Coerce the slot value to the correct type.
+
+    Tries to coerce the slot value to the correct type. If the
+    conversion fails, `None` is returned.
+
+    Args:
+        slot_value: The value to coerce.
+        slot_name: The name of the slot.
+        tracker: The tracker containing the current state of the conversation.
+
+    Returns:
+        The coerced value or `None` if the conversion failed.
+    """
+    if slot_name not in tracker.slots:
+        return slot_value
+
+    slot = tracker.slots[slot_name]
+
+    if not slot.is_valid_value(slot_value):
+        structlogger.debug(
+            "run.rejection.slot_value_not_valid",
+            rejection=slot_value,
+        )
+        return None
+
+    return slot.coerce_value(slot_value)
+
+
+def run_rejections(
+    slot_value: Union[str, bool, float, None],
+    slot_name: str,
+    rejections: List[SlotRejection],
+) -> Optional[str]:
+    """Run the predicate checks under rejections."""
+    violation = False
+    internal_error = False
+    current_context = {"slots": {slot_name: slot_value}}
+
+    structlogger.debug("run.predicate.context", context=current_context)
+    document = current_context.copy()
+
+    for rejection in rejections:
+        condition = rejection.if_
+        utterance = rejection.utter
+
+        try:
+            rendered_template = Template(condition).render(current_context)
+            predicate = Predicate(rendered_template)
+            violation = predicate.evaluate(document)
+            structlogger.debug(
+                "run.predicate.result",
+                predicate=predicate.description(),
+                violation=violation,
+            )
+        except (TypeError, Exception) as e:
+            structlogger.error(
+                "run.predicate.error",
+                predicate=condition,
+                document=document,
+                error=str(e),
+            )
+            violation = True
+            internal_error = True
+
+        if violation:
+            break
+
+    if not violation:
+        return None
+    if internal_error:
+        utterance = "utter_internal_error_rasa"
+    if not isinstance(utterance, str):
+        utterance = UTTERANCE_NOT_DEFINED_BY_USER
+    return utterance
+
+
+class ActionRunSlotRejections(Action):
+    """Action which evaluates the predicate checks under rejections."""
+
+    def name(self) -> Text:
+        """Return the name of the action."""
+        return ACTION_RUN_SLOT_REJECTIONS_NAME
+
+    async def run(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        """Run the predicate checks."""
+        utterance = None
+        top_frame = tracker.stack.top()
+        if not isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            return []
+
+        slot_name = top_frame.collect
+        slot_instance = tracker.slots.get(slot_name)
+        if slot_instance and not slot_instance.has_been_set:
+            # this is the first time the assistant asks for the slot value,
+            # therefore we skip the predicate validation because the slot
+            # value has not been provided
+            structlogger.debug(
+                "first.collect.slot.not.set",
+                slot_name=slot_name,
+                slot_value=slot_instance.value,
+            )
+            return []
+
+        slot_value = tracker.get_slot(slot_name)
+
+        if slot_instance and slot_instance.has_been_set and slot_value is None:
+            return []
+
+        typed_slot_value = coerce_slot_value(slot_value, slot_name, tracker)
+        if typed_slot_value is None:
+            # the slot value could not be coerced to the correct type
+            utterance = utterance_for_slot_type(slot_instance)
+        elif top_frame.rejections:
+            # run the predicate checks under rejections
+            utterance = run_rejections(
+                typed_slot_value, slot_name, top_frame.rejections
+            )
+
+        events: List[Event] = []
+        if utterance:
+            # the slot value has been rejected
+            events.append(SlotSet(slot_name, None))
+        elif slot_value != typed_slot_value or type(slot_value) != type(
+            typed_slot_value
+        ):
+            # the slot value has been coerced to the correct type
+            return [SlotSet(slot_name, typed_slot_value)]
+        elif slot_value == typed_slot_value:
+            # the slot value has not changed and no utterance present
+            return []
+
+        if utterance == UTTERANCE_NOT_DEFINED_BY_USER:
+            structlogger.error(
+                "run.rejection.missing.utter",
+                utterance=None,
+            )
+            return events
+
+        message = await nlg.generate(
+            utterance,
+            tracker,
+            output_channel.name(),
+            value=slot_value,
+        )
+
+        if message is None:
+            structlogger.error(
+                "run.rejection.failed.finding.utter",
+                utterance=utterance,
+            )
+        else:
+            message["utter_action"] = utterance
+            events.append(create_bot_utterance(message))
+
+        return events

rasa/core/actions/action_trigger_chitchat.py

@@ -0,0 +1,31 @@
+from typing import Optional, Dict, Any, List
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.stack.frames import ChitChatStackFrame
+from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class ActionTriggerChitchat(Action):
+    """Action which triggers a chitchat answer."""
+
+    def name(self) -> str:
+        """Return the name of the action."""
+        return ACTION_TRIGGER_CHITCHAT
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Run the predicate checks."""
+        stack = tracker.stack
+        stack.push(ChitChatStackFrame())
+        return tracker.create_stack_updated_events(stack)

rasa/core/actions/action_trigger_flow.py

@@ -0,0 +1,109 @@
+from typing import Any, Dict, Optional, Text, List
+
+import structlog
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+from rasa.core.actions import action
+from rasa.core.channels import OutputChannel
+from rasa.shared.constants import FLOW_PREFIX
+
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import (
+    ActiveLoop,
+    Event,
+    FlowInterrupted,
+    SlotSet,
+)
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger(__name__)
+
+
+class ActionTriggerFlow(action.Action):
+    """Action which triggers a flow by putting it on the dialogue stack."""
+
+    def __init__(self, flow_action_name: Text) -> None:
+        """Creates a `ActionTriggerFlow`.
+
+        Args:
+            flow_action_name: Name of the flow.
+        """
+        super().__init__()
+
+        if not flow_action_name.startswith(FLOW_PREFIX):
+            raise ValueError(
+                f"Flow action name '{flow_action_name}' needs to start with "
+                f"'{FLOW_PREFIX}'."
+            )
+
+        self._flow_name = flow_action_name[len(FLOW_PREFIX) :]
+        self._flow_action_name = flow_action_name
+
+    def name(self) -> Text:
+        """Return the flow name."""
+        return self._flow_action_name
+
+    def create_events_to_start_flow(self, tracker: DialogueStateTracker) -> List[Event]:
+        """Create events to start the flow.
+
+        Args:
+            tracker: The tracker to start the flow on.
+
+        Returns:
+            The event to start the flow."""
+        stack = tracker.stack
+        events: List[Event] = []
+
+        frame_type = FlowStackFrameType.REGULAR
+
+        if not stack.is_empty():
+            frame_type = FlowStackFrameType.INTERRUPT
+            top_user_frame = top_user_flow_frame(stack)
+            if top_user_frame is not None:
+                events.append(
+                    FlowInterrupted(top_user_frame.flow_id, top_user_frame.step_id)
+                )
+
+        stack.push(
+            UserFlowStackFrame(
+                flow_id=self._flow_name,
+                frame_type=frame_type,
+            )
+        )
+        return events + tracker.create_stack_updated_events(stack)
+
+    def create_events_to_set_flow_slots(self, metadata: Dict[str, Any]) -> List[Event]:
+        """Create events to set the flow slots.
+
+        Set additional slots to prefill information for the flow.
+
+        Args:
+            metadata: The metadata to set the slots from.
+
+        Returns:
+            The events to set the flow slots.
+        """
+        slots_to_be_set = metadata.get("slots", {}) if metadata else {}
+        return [SlotSet(key, value) for key, value in slots_to_be_set.items()]
+
+    async def run(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        """Trigger the flow."""
+        events: List[Event] = self.create_events_to_start_flow(tracker)
+        events.extend(self.create_events_to_set_flow_slots(metadata))
+
+        if tracker.active_loop_name:
+            # end any active loop to ensure we are progressing the started flow
+            events.append(ActiveLoop(None))
+
+        return events

rasa/core/actions/action_trigger_search.py

@@ -0,0 +1,31 @@
+from typing import Optional, Dict, Any, List
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.stack.frames import SearchStackFrame
+from rasa.shared.core.constants import ACTION_TRIGGER_SEARCH
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class ActionTriggerSearch(Action):
+    """Action which triggers a search"""
+
+    def name(self) -> str:
+        """Return the name of the action."""
+        return ACTION_TRIGGER_SEARCH
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Run the predicate checks."""
+        stack = tracker.stack
+        stack.push(SearchStackFrame())
+        return tracker.create_stack_updated_events(stack)

rasa/core/actions/constants.py

@@ -0,0 +1,5 @@
+DEFAULT_SELECTIVE_DOMAIN = False
+SELECTIVE_DOMAIN = "enable_selective_domain"
+
+SSL_CLIENT_CERT_FIELD = "ssl_client_cert"
+SSL_CLIENT_KEY_FIELD = "ssl_client_key"

rasa/core/actions/custom_action_executor.py

@@ -0,0 +1,188 @@
+import abc
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Text
+
+import rasa
+from rasa.core.actions.action_exceptions import DomainNotFound
+from rasa.core.actions.constants import DEFAULT_SELECTIVE_DOMAIN, SELECTIVE_DOMAIN
+from rasa.shared.constants import DOCS_BASE_URL
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
+
+if TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+
+logger = logging.getLogger(__name__)
+
+
+class CustomActionExecutor(abc.ABC):
+    """Interface for custom action executors.
+
+    Provides an abstraction layer for executing custom actions
+    regardless of the communication protocol.
+    """
+
+    @abc.abstractmethod
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        """Executes the custom action.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain information is included in the request.
+
+        Returns:
+            The response from the execution of the custom action.
+        """
+        pass
+
+
+class NoEndpointCustomActionExecutor(CustomActionExecutor):
+    """Implementation of a custom action executor when endpoint is not set.
+
+    Used to handle the case where no endpoint is configured.
+
+    Raises RasaException when executed.
+    """
+
+    def __init__(self, action_name: str) -> None:
+        """Initializes the custom action executor.
+
+        Args:
+            action_name: The name of the custom action.
+        """
+        self.action_name = action_name
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        """Executes the custom action.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain information
+                            is included in the request.
+
+        Returns:
+            The response from the execution of the custom action.
+        """
+        raise RasaException(
+            f"Failed to execute custom action '{self.action_name}' "
+            f"because no endpoint is configured to run this "
+            f"custom action. Please take a look at "
+            f"the docs and set an endpoint configuration via the "
+            f"--endpoints flag. "
+            f"{DOCS_BASE_URL}/custom-actions"
+        )
+
+
+class CustomActionRequestWriter:
+    """Writes the request payload for a custom action."""
+
+    def __init__(self, action_name: str, action_endpoint: EndpointConfig) -> None:
+        """Initializes the request writer.
+
+        Args:
+            action_name: The name of the custom action.
+            action_endpoint: The endpoint configuration for the action server.
+        """
+        self.action_name = action_name
+        self.action_endpoint = action_endpoint
+
+    def _is_selective_domain_enabled(self) -> bool:
+        """Check if selective domain handling is enabled.
+
+        Returns:
+            True if selective domain handling is enabled, otherwise False.
+        """
+        if self.action_endpoint is None:
+            return False
+        return bool(
+            self.action_endpoint.kwargs.get(SELECTIVE_DOMAIN, DEFAULT_SELECTIVE_DOMAIN)
+        )
+
+    def create(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[str, Any]:
+        """Create the JSON payload for the action server request.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain information is included in the request.
+
+        Returns:
+            A JSON payload to be sent to the action server.
+        """
+        from rasa.shared.core.trackers import EventVerbosity
+
+        tracker_state = tracker.current_state(EventVerbosity.ALL)
+
+        result = {
+            "next_action": self.action_name,
+            "sender_id": tracker.sender_id,
+            "tracker": tracker_state,
+            "version": rasa.__version__,
+        }
+
+        if include_domain and (
+            not self._is_selective_domain_enabled()
+            or domain.does_custom_action_explicitly_need_domain(self.action_name)
+        ):
+            result["domain"] = domain.as_dict()
+
+        result["domain_digest"] = domain.fingerprint()
+
+        return result
+
+
+class RetryCustomActionExecutor(CustomActionExecutor):
+    """Retries the execution of a custom action."""
+
+    def __init__(self, custom_action_executor: CustomActionExecutor) -> None:
+        self._custom_action_executor = custom_action_executor
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        """Runs the wrapped custom action executor.
+
+        First request to the action server is made with/without the domain
+        as specified by the `include_domain` parameter.
+
+        If the action server responds with a `DomainNotFound` error, by running the
+        custom action executor again with the domain information.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain information is included in the request
+
+        Returns:
+            The response from the execution of the custom action.
+        """
+        try:
+            return await self._custom_action_executor.run(
+                tracker, domain, include_domain=include_domain
+            )
+        except DomainNotFound:
+            return await self._custom_action_executor.run(
+                tracker, domain, include_domain=True
+            )