rasa-pro 3.8.18__py3-none-any.whl → 3.9.14__py3-none-any.whl

rasa/core/actions/action.py

@@ -1,5 +1,4 @@
 import copy
-import json
 import logging
 from typing import (
     List,
@@ -13,14 +12,15 @@ from typing import (
     cast,
 )
 
-import aiohttp
 import rasa.core
-from rasa.core.actions.constants import DEFAULT_SELECTIVE_DOMAIN, SELECTIVE_DOMAIN
-from rasa.core.constants import (
-    DEFAULT_REQUEST_TIMEOUT,
-    COMPRESS_ACTION_SERVER_REQUEST_ENV_NAME,
-    DEFAULT_COMPRESS_ACTION_SERVER_REQUEST,
+import rasa.shared.utils.io
+from rasa.core.actions.custom_action_executor import (
+    CustomActionExecutor,
+    RetryCustomActionExecutor,
+    NoEndpointCustomActionExecutor,
 )
+from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
+from rasa.core.actions.http_custom_action_executor import HTTPCustomActionExecutor
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.nlu.constants import (
     RESPONSE_SELECTOR_DEFAULT_INTENT,
@@ -52,8 +52,6 @@ from rasa.shared.core.constants import (
     REQUESTED_SLOT,
     ACTION_EXTRACT_SLOTS,
     DEFAULT_SLOT_NAMES,
-    MAPPING_CONDITIONS,
-    ACTIVE_LOOP,
     ACTION_VALIDATE_SLOT_MAPPINGS,
     MAPPING_TYPE,
     SlotMappingType,
@@ -72,21 +70,20 @@ from rasa.shared.core.events import (
     Restarted,
     SessionStarted,
 )
-from rasa.shared.core.slot_mappings import SlotMapping
-from rasa.shared.core.slots import ListSlot
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.slot_mappings import (
+    SlotFillingManager,
+    extract_slot_value,
+)
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.constants import (
     INTENT_NAME_KEY,
     INTENT_RANKING_KEY,
-    ENTITY_ATTRIBUTE_TYPE,
-    ENTITY_ATTRIBUTE_ROLE,
-    ENTITY_ATTRIBUTE_GROUP,
 )
 from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
-import rasa.shared.utils.io
-from rasa.utils.common import get_bool_env_variable
 from rasa.utils.endpoints import EndpointConfig, ClientResponseError
+from rasa.utils.url_tools import get_url_schema, UrlSchema
 
 if TYPE_CHECKING:
     from rasa.core.nlg import NaturalLanguageGenerator
@@ -345,8 +342,9 @@ class ActionBotResponse(Action):
         if message is None:
             if not self.silent_fail:
                 logger.error(
-                    "Couldn't create message for response '{}'."
-                    "".format(self.utter_action)
+                    "Couldn't create message for response '{}'.".format(
+                        self.utter_action
+                    )
                 )
             return []
         message["utter_action"] = self.utter_action
@@ -492,8 +490,9 @@ class ActionRetrieveResponse(ActionBotResponse):
         else:
             if not self.silent_fail:
                 logger.error(
-                    "Couldn't create message for response action '{}'."
-                    "".format(self.action_name)
+                    "Couldn't create message for response action '{}'.".format(
+                        self.action_name
+                    )
                 )
             return []
 
@@ -702,41 +701,46 @@ class ActionDeactivateLoop(Action):
 
 
 class RemoteAction(Action):
-    def __init__(self, name: Text, action_endpoint: Optional[EndpointConfig]) -> None:
-
+    def __init__(
+        self, name: Text, action_endpoint: Optional[EndpointConfig] = None
+    ) -> None:
         self._name = name
         self.action_endpoint = action_endpoint
+        self.executor = self._create_executor()
 
-    def _action_call_format(
-        self,
-        tracker: "DialogueStateTracker",
-        domain: "Domain",
-    ) -> Dict[Text, Any]:
-        """Create the request json send to the action server."""
-        from rasa.shared.core.trackers import EventVerbosity
+    def _create_executor(self) -> CustomActionExecutor:
+        """Creates an executor based on the action endpoint configuration.
 
-        tracker_state = tracker.current_state(EventVerbosity.ALL)
+        Returns:
+            An instance of CustomActionExecutor.
 
-        result = {
-            "next_action": self._name,
-            "sender_id": tracker.sender_id,
-            "tracker": tracker_state,
-            "version": rasa.__version__,
-        }
+        Raises:
+            RasaException: If no valid action endpoint is configured.
+        """
 
-        if (
-            not self._is_selective_domain_enabled()
-            or domain.does_custom_action_explicitly_need_domain(self.name())
-        ):
-            result["domain"] = domain.as_dict()
+        if not self.action_endpoint:
+            return NoEndpointCustomActionExecutor(self.name())
 
-        return result
+        url_schema = get_url_schema(self.action_endpoint.url)
 
-    def _is_selective_domain_enabled(self) -> bool:
-        if self.action_endpoint is None:
-            return False
-        return bool(
-            self.action_endpoint.kwargs.get(SELECTIVE_DOMAIN, DEFAULT_SELECTIVE_DOMAIN)
+        if url_schema == UrlSchema.GRPC:
+            return RetryCustomActionExecutor(
+                GRPCCustomActionExecutor(self.name(), self.action_endpoint)
+            )
+        elif (
+            url_schema == UrlSchema.HTTP
+            or url_schema == UrlSchema.HTTPS
+            or url_schema == UrlSchema.NOT_SPECIFIED
+        ):
+            return RetryCustomActionExecutor(
+                HTTPCustomActionExecutor(self.name(), self.action_endpoint)
+            )
+        raise RasaException(
+            f"Failed to create a custom action executor. "
+            f"Please make sure to include an action endpoint configuration in your "
+            f"endpoints configuration file. Make sure that for grpc, http and https "
+            f"an url schema is set. "
+            f"Found url '{self.action_endpoint.url}'."
         )
 
     @staticmethod
@@ -813,102 +817,22 @@ class RemoteAction(Action):
         metadata: Optional[Dict[Text, Any]] = None,
     ) -> List[Event]:
         """Runs action. Please see parent class for the full docstring."""
-        json_body = self._action_call_format(tracker, domain)
-        if not self.action_endpoint:
-            raise RasaException(
-                f"Failed to execute custom action '{self.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"
-            )
-
-        try:
-            logger.debug(
-                "Calling action endpoint to run action '{}'.".format(self.name())
-            )
-
-            should_compress = get_bool_env_variable(
-                COMPRESS_ACTION_SERVER_REQUEST_ENV_NAME,
-                DEFAULT_COMPRESS_ACTION_SERVER_REQUEST,
-            )
+        response = await self.executor.run(tracker=tracker, domain=domain)
+        self._validate_action_result(response)
 
-            response: Any = await self.action_endpoint.request(
-                json=json_body,
-                method="post",
-                timeout=DEFAULT_REQUEST_TIMEOUT,
-                compress=should_compress,
-            )
-            self._validate_action_result(response)
-
-            events_json = response.get("events", [])
-            responses = response.get("responses", [])
-            bot_messages = await self._utter_responses(
-                responses, output_channel, nlg, tracker
-            )
-
-            events = rasa.shared.core.events.deserialise_events(events_json)
-            return cast(List[Event], bot_messages) + events
-
-        except ClientResponseError as e:
-            if e.status == 400:
-                response_data = json.loads(e.text)
-                exception = ActionExecutionRejection(
-                    response_data["action_name"], response_data.get("error")
-                )
-                logger.error(exception.message)
-                raise exception
-            else:
-                raise RasaException(
-                    f"Failed to execute custom action '{self.name()}'"
-                ) from e
-
-        except aiohttp.ClientConnectionError as e:
-            logger.error(
-                f"Failed to run custom action '{self.name()}'. Couldn't connect "
-                f"to the server at '{self.action_endpoint.url}'. "
-                f"Is the server running? "
-                f"Error: {e}"
-            )
-            raise RasaException(
-                f"Failed to execute custom action '{self.name()}'. Couldn't connect "
-                f"to the server at '{self.action_endpoint.url}."
-            )
+        events_json = response.get("events", [])
+        responses = response.get("responses", [])
+        bot_messages = await self._utter_responses(
+            responses, output_channel, nlg, tracker
+        )
 
-        except aiohttp.ClientError as e:
-            # not all errors have a status attribute, but
-            # helpful to log if they got it
-
-            # noinspection PyUnresolvedReferences
-            status = getattr(e, "status", None)
-            raise RasaException(
-                "Failed to run custom action '{}'. Action server "
-                "responded with a non 200 status code of {}. "
-                "Make sure your action server properly runs actions "
-                "and returns a 200 once the action is executed. "
-                "Error: {}".format(self.name(), status, e)
-            )
+        events = rasa.shared.core.events.deserialise_events(events_json)
+        return cast(List[Event], bot_messages) + events
 
     def name(self) -> Text:
         return self._name
 
 
-class ActionExecutionRejection(RasaException):
-    """Raising this exception allows other policies to predict a different action."""
-
-    def __init__(self, action_name: Text, message: Optional[Text] = 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) -> Text:
-        return self.message
-
-
 class ActionRevertFallbackEvents(Action):
     """Reverts events which were done during the `TwoStageFallbackPolicy`.
 
@@ -987,7 +911,7 @@ def _revert_affirmation_events(tracker: "DialogueStateTracker") -> List[Event]:
     last_user_event = copy.deepcopy(last_user_event)
     # FIXME: better type annotation for `parse_data` would require
     # a larger refactoring (e.g. switch to dataclass)
-    last_user_event.parse_data["intent"]["confidence"] = 1.0  # type: ignore[typeddict-item]  # noqa: E501
+    last_user_event.parse_data["intent"]["confidence"] = 1.0  # type: ignore[typeddict-item]
 
     return revert_events + [last_user_event]
 
@@ -1061,7 +985,7 @@ class ActionDefaultAskAffirmation(Action):
             intent_to_affirm == DEFAULT_NLU_FALLBACK_INTENT_NAME
             and len(intent_ranking) > 1
         ):
-            intent_to_affirm = intent_ranking[1][INTENT_NAME_KEY]  # type: ignore[literal-required] # noqa: E501
+            intent_to_affirm = intent_ranking[1][INTENT_NAME_KEY]  # type: ignore[literal-required]
 
         affirmation_message = f"Did you mean '{intent_to_affirm}'?"
 
@@ -1127,51 +1051,6 @@ class ActionExtractSlots(Action):
         """Returns action_extract_slots name."""
         return ACTION_EXTRACT_SLOTS
 
-    @staticmethod
-    def _matches_mapping_conditions(
-        mapping: Dict[Text, Any], tracker: "DialogueStateTracker", slot_name: Text
-    ) -> bool:
-        slot_mapping_conditions = mapping.get(MAPPING_CONDITIONS)
-
-        if not slot_mapping_conditions:
-            return True
-
-        if (
-            tracker.is_active_loop_rejected
-            and tracker.get_slot(REQUESTED_SLOT) == slot_name
-        ):
-            return False
-
-        # check if found mapping conditions matches form
-        for condition in slot_mapping_conditions:
-            active_loop = condition.get(ACTIVE_LOOP)
-
-            if active_loop and active_loop == tracker.active_loop_name:
-                condition_requested_slot = condition.get(REQUESTED_SLOT)
-                if not condition_requested_slot:
-                    return True
-                if condition_requested_slot == tracker.get_slot(REQUESTED_SLOT):
-                    return True
-
-            if active_loop is None and tracker.active_loop_name is None:
-                return True
-
-        return False
-
-    @staticmethod
-    def _verify_mapping_conditions(
-        mapping: Dict[Text, Any], tracker: "DialogueStateTracker", slot_name: Text
-    ) -> bool:
-        if mapping.get(MAPPING_CONDITIONS) and mapping[MAPPING_TYPE] != str(
-            SlotMappingType.FROM_TRIGGER_INTENT
-        ):
-            if not ActionExtractSlots._matches_mapping_conditions(
-                mapping, tracker, slot_name
-            ):
-                return False
-
-        return True
-
     async def _run_custom_action(
         self,
         custom_action: Text,
@@ -1221,12 +1100,19 @@ class ActionExtractSlots(Action):
         nlg: "NaturalLanguageGenerator",
         tracker: "DialogueStateTracker",
         domain: "Domain",
+        calm_custom_action_names: Optional[Set[str]] = None,
     ) -> Tuple[List[Event], Set[Text]]:
         custom_action = mapping.get("action")
 
         if not custom_action or custom_action in executed_custom_actions:
             return [], executed_custom_actions
 
+        if (
+            calm_custom_action_names is not None
+            and custom_action in calm_custom_action_names
+        ):
+            return [], executed_custom_actions
+
         slot_events = await self._run_custom_action(
             custom_action, output_channel, nlg, tracker, domain
         )
@@ -1272,36 +1158,6 @@ class ActionExtractSlots(Action):
             event for event in slot_events if event.key not in validated_slot_names
         ]
 
-    def _fails_unique_entity_mapping_check(
-        self,
-        slot_name: Text,
-        mapping: Dict[Text, Any],
-        tracker: "DialogueStateTracker",
-        domain: "Domain",
-    ) -> bool:
-        from rasa.core.actions.forms import FormAction
-
-        if mapping[MAPPING_TYPE] != str(SlotMappingType.FROM_ENTITY):
-            return False
-
-        form_name = tracker.active_loop_name
-
-        if not form_name:
-            return False
-
-        if tracker.get_slot(REQUESTED_SLOT) == slot_name:
-            return False
-
-        form = FormAction(form_name, self._action_endpoint)
-
-        if slot_name not in form.required_slots(domain):
-            return False
-
-        if form.entity_mapping_is_unique(mapping, domain):
-            return False
-
-        return True
-
     async def run(
         self,
         output_channel: "OutputChannel",
@@ -1320,50 +1176,32 @@ class ActionExtractSlots(Action):
             if slot.name not in DEFAULT_SLOT_NAMES | KNOWLEDGE_BASE_SLOT_NAMES
         ]
 
-        for slot in user_slots:
-            for mapping in slot.mappings:
-                mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
-
-                if not SlotMapping.check_mapping_validity(
-                    slot_name=slot.name,
-                    mapping_type=mapping_type,
-                    mapping=mapping,
-                    domain=domain,
-                ):
-                    continue
-
-                intent_is_desired = SlotMapping.intent_is_desired(
-                    mapping, tracker, domain
-                )
-
-                if not intent_is_desired:
-                    continue
+        calm_slot_names = set()
+        calm_custom_action_names = None
+        flows = None
 
-                if not ActionExtractSlots._verify_mapping_conditions(
-                    mapping, tracker, slot.name
-                ):
-                    continue
+        if metadata is not None:
+            flows = metadata.get("all_flows")
 
-                if self._fails_unique_entity_mapping_check(
-                    slot.name, mapping, tracker, domain
-                ):
-                    continue
+        if flows is not None:
+            flows = FlowsList.from_json(flows)
+            calm_slot_names = flows.available_slot_names()
+            calm_custom_action_names = flows.available_custom_actions()
 
-                if mapping_type.is_predefined_type():
-                    value = extract_slot_value_from_predefined_mapping(
-                        mapping_type, mapping, tracker
-                    )
-                else:
-                    value = None
+        slot_filling_manager = SlotFillingManager(
+            domain, tracker, action_endpoint=self._action_endpoint
+        )
 
-                if value:
-                    if not isinstance(slot, ListSlot):
-                        value = value[-1]
+        for slot in user_slots:
+            if slot.name in calm_slot_names:
+                continue
 
-                    if value is not None or tracker.get_slot(slot.name) is not None:
-                        slot_events.append(SlotSet(slot.name, value))
-                        break
+            slot_value, is_extracted = extract_slot_value(slot, slot_filling_manager)
+            if is_extracted:
+                slot_events.append(SlotSet(slot.name, slot_value))
 
+            for mapping in slot.mappings:
+                mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
                 should_fill_custom_slot = mapping_type == SlotMappingType.CUSTOM
 
                 if should_fill_custom_slot:
@@ -1377,6 +1215,7 @@ class ActionExtractSlots(Action):
                         nlg,
                         tracker,
                         domain,
+                        calm_custom_action_names,
                     )
                     slot_events.extend(custom_evts)
 
@@ -1384,67 +1223,3 @@ class ActionExtractSlots(Action):
             slot_events, output_channel, nlg, tracker, domain
         )
         return validated_events
-
-
-def extract_slot_value_from_predefined_mapping(
-    mapping_type: SlotMappingType,
-    mapping: Dict[Text, Any],
-    tracker: "DialogueStateTracker",
-) -> List[Any]:
-    """Extracts slot value if slot has an applicable predefined mapping."""
-    if tracker.has_bot_message_after_latest_user_message():
-        # TODO: this needs further validation - not sure if this breaks something!!!
-
-        # If the bot sent a message after the user sent a message, we can't
-        # extract any slots from the user message. We assume that the user
-        # message was already processed by the bot and the slot value was
-        # already extracted (e.g. for a prior form slot).
-        return []
-
-    should_fill_entity_slot = (
-        mapping_type == SlotMappingType.FROM_ENTITY
-        and SlotMapping.entity_is_desired(mapping, tracker)
-    )
-
-    should_fill_intent_slot = mapping_type == SlotMappingType.FROM_INTENT
-
-    should_fill_text_slot = mapping_type == SlotMappingType.FROM_TEXT
-
-    active_loops_in_mapping_conditions = [
-        active_loop.get(ACTIVE_LOOP)
-        for active_loop in mapping.get(MAPPING_CONDITIONS, [])
-    ]
-
-    trigger_mapping_condition_met = True
-
-    if tracker.active_loop_name is None:
-        trigger_mapping_condition_met = False
-    elif (
-        active_loops_in_mapping_conditions
-        and tracker.active_loop_name is not None
-        and (tracker.active_loop_name not in active_loops_in_mapping_conditions)
-    ):
-        trigger_mapping_condition_met = False
-
-    should_fill_trigger_slot = (
-        mapping_type == SlotMappingType.FROM_TRIGGER_INTENT
-        and trigger_mapping_condition_met
-    )
-
-    value: List[Any] = []
-    if should_fill_entity_slot:
-        value = list(
-            tracker.get_latest_entity_values(
-                mapping.get(ENTITY_ATTRIBUTE_TYPE),
-                mapping.get(ENTITY_ATTRIBUTE_ROLE),
-                mapping.get(ENTITY_ATTRIBUTE_GROUP),
-            )
-        )
-    elif should_fill_intent_slot or should_fill_trigger_slot:
-        value = [mapping.get("value")]
-    elif should_fill_text_slot:
-        value = [
-            tracker.latest_message.text if tracker.latest_message is not None else None
-        ]
-
-    return value

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/constants.py

@@ -1,2 +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"