rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/core/actions/custom_action_executor.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+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 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 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 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 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
+            )

rasa/core/actions/direct_custom_actions_executor.py

@@ -0,0 +1,109 @@
+from functools import lru_cache
+from importlib.util import find_spec
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    Text,
+)
+
+import structlog
+from rasa_sdk.executor import ActionExecutor
+
+import rasa
+from rasa.core.actions.custom_action_executor import (
+    CustomActionExecutor,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
+
+structlogger = structlog.get_logger(__name__)
+
+
+class DirectCustomActionExecutor(CustomActionExecutor):
+    _actions_module_registered: ClassVar[bool] = False
+
+    def __init__(self, action_name: str, action_endpoint: EndpointConfig):
+        """Initializes the direct custom action executor.
+
+        Args:
+            action_name: Name of the custom action.
+            action_endpoint: The endpoint to execute custom actions.
+        """
+        self.action_name = action_name
+        self.action_endpoint = action_endpoint
+        self.action_executor = self._create_action_executor()
+        self.register_actions_from_a_module()
+        self.action_executor.reload()
+
+    @staticmethod
+    @lru_cache(maxsize=1)
+    def _create_action_executor() -> ActionExecutor:
+        """Creates and returns a cached ActionExecutor instance.
+
+        Returns:
+            ActionExecutor: The cached ActionExecutor instance.
+        """
+        return ActionExecutor()
+
+    def register_actions_from_a_module(self) -> None:
+        """Registers actions from the specified module if not already registered.
+
+        This method checks if the actions module has already been registered to prevent
+        duplicate registrations. If not registered, it attempts to register the actions
+        module specified in the action endpoint configuration. If the module does not
+        exist, it raises a RasaException.
+
+        Raises:
+            RasaException: If the actions module specified does not exist.
+        """
+        if DirectCustomActionExecutor._actions_module_registered:
+            return
+
+        module_name = self.action_endpoint.actions_module
+        if not find_spec(module_name):
+            raise RasaException(
+                f"You've provided the custom actions module '{module_name}' "
+                f"to run directly by the rasa server, however this module does "
+                f"not exist. Please check for typos in your `endpoints.yml` file."
+            )
+
+        self.action_executor.register_package(module_name)
+        DirectCustomActionExecutor._actions_module_registered = True
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        """Executes the custom action directly.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain is included in the request.
+
+        Returns:
+            The response from the execution of the custom action.
+        """
+        structlogger.debug(
+            "action.direct_custom_action_executor.run",
+            action_name=self.action_name,
+        )
+
+        tracker_state = tracker.current_state(EventVerbosity.ALL)
+        action_call = {
+            "next_action": self.action_name,
+            "sender_id": tracker.sender_id,
+            "tracker": tracker_state,
+            "version": rasa.__version__,
+        }
+
+        if domain:
+            action_call["domain"] = domain.as_dict()
+
+        result = await self.action_executor.run(action_call)
+        return result.model_dump() if result else {}

rasa/core/actions/e2e_stub_custom_action_executor.py

@@ -0,0 +1,72 @@
+import typing
+from typing import (
+    Any,
+    Dict,
+    Text,
+)
+
+import structlog
+
+from rasa.core.actions.custom_action_executor import (
+    CustomActionExecutor,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
+
+if typing.TYPE_CHECKING:
+    from rasa.e2e_test.stub_custom_action import StubCustomAction
+
+structlogger = structlog.get_logger(__name__)
+
+
+class E2EStubCustomActionExecutor(CustomActionExecutor):
+    def __init__(
+        self,
+        action_name: str,
+        action_endpoint: EndpointConfig,
+    ):
+        """Initializes the e2e stub custom action executor.
+
+        Args:
+            action_name: Name of the custom action.
+            action_endpoint: The endpoint to execute custom actions.
+        """
+        self.action_name = action_name
+        self.action_endpoint = action_endpoint
+        self.stub_custom_action = self.get_stub_custom_action()
+
+    def get_stub_custom_action(self) -> "StubCustomAction":
+        from rasa.e2e_test.stub_custom_action import get_stub_custom_action
+
+        stub_custom_action = get_stub_custom_action(
+            self.action_endpoint, self.action_name
+        )
+
+        if stub_custom_action:
+            return stub_custom_action
+
+        # TODO Update message below with reference to the docs
+        raise RasaException(
+            f"You are using custom action stubs, however action `{self.action_name}` "
+            f"has not been stubbed. Note that you cannot stub some custom actions "
+            f"while running an action server instance, you must stub all custom "
+            f"actions called by the tests in the provided test path."
+        )
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        from rasa.core.actions.action import RemoteActionJSONValidator
+
+        structlogger.debug(
+            "action.e2e_stub_custom_action_executor.run",
+            action_name=self.action_name,
+        )
+        response = self.stub_custom_action.as_dict()
+        RemoteActionJSONValidator.validate(response)
+        return response