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

rasa/core/policies/unexpected_intent_policy.py

@@ -5,7 +5,6 @@ from typing import Any, List, Optional, Text, Dict, Type, Union
 
 import numpy as np
 import tensorflow as tf
-
 import rasa.utils.common
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
@@ -17,7 +16,6 @@ from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.constants import SLOTS, ACTIVE_LOOP, ACTION_UNLIKELY_INTENT_NAME
 from rasa.shared.core.events import UserUttered, ActionExecuted
-import rasa.shared.utils.io
 from rasa.shared.nlu.constants import (
     INTENT,
     TEXT,
@@ -105,6 +103,8 @@ from rasa.utils.tensorflow.constants import (
 )
 from rasa.utils.tensorflow import layers
 from rasa.utils.tensorflow.model_data import RasaModelData, FeatureArray, Data
+
+import rasa.utils.io as io_utils
 from rasa.core.exceptions import RasaCoreException
 from rasa.shared.utils import common
 
@@ -794,7 +794,6 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
         }
 
         for index, all_pos_labels in enumerate(label_ids):
-
             for candidate_label_id in unique_label_ids:
                 if candidate_label_id in all_pos_labels:
                     label_id_scores[candidate_label_id][POSITIVE_SCORES_KEY].append(
@@ -809,7 +808,7 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
 
     @staticmethod
     def _compute_label_quantiles(
-        label_id_scores: Dict[int, Dict[Text, List[float]]]
+        label_id_scores: Dict[int, Dict[Text, List[float]]],
     ) -> Dict[int, List[float]]:
         """Computes multiple quantiles for each label id.
 
@@ -882,12 +881,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted
         """
         super().persist_model_utilities(model_path)
-
-        from safetensors.numpy import save_file
-
-        save_file(
-            {str(k): np.array(v) for k, v in self.label_quantiles.items()},
-            model_path / f"{self._metadata_filename()}.label_quantiles.st",
+        io_utils.pickle_dump(
+            model_path / f"{self._metadata_filename()}.label_quantiles.pkl",
+            self.label_quantiles,
         )
 
     @classmethod
@@ -898,14 +894,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted.
         """
         model_utilties = super()._load_model_utilities(model_path)
-
-        from safetensors.numpy import load_file
-
-        loaded_label_quantiles = load_file(
-            model_path / f"{cls._metadata_filename()}.label_quantiles.st"
+        label_quantiles = io_utils.pickle_load(
+            model_path / f"{cls._metadata_filename()}.label_quantiles.pkl"
         )
-        label_quantiles = {int(k): list(v) for k, v in loaded_label_quantiles.items()}
-
         model_utilties.update({"label_quantiles": label_quantiles})
         return model_utilties
 

rasa/core/processor.py

@@ -3,15 +3,21 @@ import copy
 import logging
 import structlog
 import os
-import re
 from pathlib import Path
 import tarfile
 import time
 from types import LambdaType
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Tuple, Union
 
+from rasa.core.actions.action_exceptions import ActionExecutionRejection
+from rasa.core.actions.forms import FormAction
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
-from rasa.dialogue_understanding.commands import SetSlotCommand, CannotHandleCommand
+from rasa.dialogue_understanding.commands import (
+    Command,
+    NoopCommand,
+    SetSlotCommand,
+    CannotHandleCommand,
+)
 from rasa.engine import loader
 from rasa.engine.constants import (
     PLACEHOLDER_MESSAGE,
@@ -24,7 +30,7 @@ from rasa.engine.storage.storage import ModelMetadata
 from rasa.model import get_latest_model
 from rasa.plugin import plugin_manager
 from rasa.shared.core.flows import FlowsList
-from rasa.shared.data import TrainingType
+from rasa.shared.data import TrainingType, create_regex_pattern_reader
 import rasa.shared.utils.io
 import rasa.core.actions.action
 from rasa.core import jobs
@@ -73,9 +79,6 @@ import rasa.core.tracker_store
 import rasa.core.actions.action
 import rasa.shared.core.trackers
 from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
-from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
-    YAMLStoryReader,
-)
 from rasa.shared.nlu.constants import (
     COMMANDS,
     ENTITIES,
@@ -143,7 +146,7 @@ class MessageProcessor:
 
     @staticmethod
     def _load_model(
-        model_path: Union[Text, Path]
+        model_path: Union[Text, Path],
     ) -> Tuple[Text, ModelMetadata, GraphRunner]:
         """Unpacks a model from a given path using the graph model loader."""
         try:
@@ -185,7 +188,10 @@ class MessageProcessor:
             )
             return None
 
-        tracker = await self.run_action_extract_slots(message.output_channel, tracker)
+        if not self.message_contains_commands(tracker.latest_message):
+            tracker = await self.run_action_extract_slots(
+                message.output_channel, tracker
+            )
 
         await self._run_prediction_loop(message.output_channel, tracker)
 
@@ -213,8 +219,10 @@ class MessageProcessor:
         action_extract_slots = rasa.core.actions.action.action_for_name_or_text(
             ACTION_EXTRACT_SLOTS, self.domain, self.action_endpoint
         )
+        metadata = await self._add_flows_to_metadata()
+
         extraction_events = await action_extract_slots.run(
-            output_channel, self.nlg, tracker, self.domain
+            output_channel, self.nlg, tracker, self.domain, metadata
         )
 
         await self._send_bot_messages(extraction_events, tracker, output_channel)
@@ -735,28 +743,37 @@ class MessageProcessor:
         if self.http_interpreter:
             parse_data = await self.http_interpreter.parse(message)
         else:
-            msg = YAMLStoryReader.unpack_regex_message(
-                message=Message({TEXT: message.text}), domain=self.domain
-            )
+            regex_reader = create_regex_pattern_reader(message, self.domain)
 
-            # Invalid use of slash syntax, sanitize the message before passing
-            # it to the graph
+            processed_message = Message({TEXT: message.text})
+            if regex_reader:
+                processed_message = regex_reader.unpack_regex_message(
+                    message=processed_message, domain=self.domain
+                )
+
+            # Invalid use of slash syntax
             if (
-                msg.data.get(TEXT, "").strip().startswith("/")
-                and msg.data.get(INTENT) is None
+                processed_message.starts_with_slash_syntax()
+                and not processed_message.has_intent()
+                and not processed_message.has_commands()
             ):
-                message = self._sanitize_message(message)
+                parse_data = self._parse_invalid_use_of_slash_syntax(
+                    processed_message, tracker, only_output_properties
+                )
 
-            # No intent trigger used. Pass message to graph.
-            if msg.data.get(INTENT) is None:
+            # Intent or commands are not explicitly present. Pass message to graph.
+            elif not (
+                processed_message.has_intent() or processed_message.has_commands()
+            ):
                 parse_data = await self._parse_message_with_graph(
                     message, tracker, only_output_properties
                 )
 
-            # Intent trigger is used.
+            # Intents or commands are presents. Bypasses the standard parsing
+            # pipeline.
             else:
-                parse_data = await self._parse_message_with_intent_trigger(
-                    msg, tracker, only_output_properties
+                parse_data = await self._parse_message_with_commands_and_intents(
+                    processed_message, tracker, only_output_properties
                 )
 
         self._update_full_retrieval_intent(parse_data)
@@ -771,36 +788,68 @@ class MessageProcessor:
 
         return parse_data
 
-    def _sanitize_message(self, message: UserMessage) -> UserMessage:
-        """Sanitize user message by removing prepended slashes before the
-        actual content.
-        """
-        # Regex pattern to match leading slashes and any whitespace before
-        # actual content
-        pattern = r"^[/\s]+"
-        # Remove the matched pattern from the beginning of the message
-        message.text = re.sub(pattern, "", message.text).strip()
-        return message
-
-    async def _parse_message_with_intent_trigger(
+    def _parse_invalid_use_of_slash_syntax(
         self,
         message: Message,
         tracker: Optional[DialogueStateTracker] = None,
         only_output_properties: bool = True,
     ) -> Dict[Text, Any]:
-        """Parses a message with intent triggers."""
+        structlogger.warning(
+            "processor.message.parse.invalid_use_of_slash_syntax",
+            event_info=(
+                "Message starts with '/', but no intents or commands are"
+                "passed. Returning CannotHandleCommand() as a fallback."
+            ),
+            message=message.get(TEXT),
+        )
         parse_data: Dict[Text, Any] = {
             TEXT: "",
             INTENT: {INTENT_NAME_KEY: None, PREDICTED_CONFIDENCE_KEY: 0.0},
             ENTITIES: [],
-            COMMANDS: [],
         }
         parse_data.update(
             message.as_dict(only_output_properties=only_output_properties)
         )
+        commands = parse_data.get(COMMANDS, [])
+        commands += [
+            CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT).as_dict()
+        ]
+
+        if (
+            tracker is not None
+            and tracker.has_coexistence_routing_slot
+            and tracker.get_slot(ROUTE_TO_CALM_SLOT) is None
+        ):
+            # if we are currently not routing to either CALM or dm1
+            # we make a sticky routing to CALM
+            commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True).as_dict()]
+
+        parse_data[COMMANDS] = commands
+        return parse_data
+
+    async def _parse_message_with_commands_and_intents(
+        self,
+        message: Message,
+        tracker: Optional[DialogueStateTracker] = None,
+        only_output_properties: bool = True,
+    ) -> Dict[Text, Any]:
+        """Parses the message to handle commands or intent trigger."""
+        parse_data: Dict[Text, Any] = {
+            TEXT: "",
+            INTENT: {INTENT_NAME_KEY: None, PREDICTED_CONFIDENCE_KEY: 0.0},
+            ENTITIES: [],
+        }
+        parse_data.update(
+            message.as_dict(only_output_properties=only_output_properties)
+        )
+
+        commands = parse_data.get(COMMANDS, [])
+
+        # add commands from intent payloads
+        if tracker and not commands:
+            nlu_adapted_commands = await self._nlu_to_commands(parse_data, tracker)
+            commands += nlu_adapted_commands
 
-        if tracker:
-            commands = await self._nlu_to_commands(parse_data, tracker)
             if (
                 tracker.has_coexistence_routing_slot
                 and tracker.get_slot(ROUTE_TO_CALM_SLOT) is None
@@ -809,11 +858,13 @@ class MessageProcessor:
                 # we make a sticky routing to CALM if there are any commands
                 # from the trigger intent parsing
                 # or a sticky routing to dm1 if there are no commands
-                commands.append(
-                    SetSlotCommand(ROUTE_TO_CALM_SLOT, len(commands) > 0).as_dict()
-                )
-            parse_data[COMMANDS] = commands
+                commands += [
+                    SetSlotCommand(
+                        ROUTE_TO_CALM_SLOT, len(nlu_adapted_commands) > 0
+                    ).as_dict()
+                ]
 
+        parse_data[COMMANDS] = commands
         return parse_data
 
     def _update_full_retrieval_intent(self, parse_data: Dict[Text, Any]) -> None:
@@ -847,7 +898,7 @@ class MessageProcessor:
         )
 
         commands = NLUCommandAdapter.convert_nlu_to_commands(
-            Message(parse_data), tracker, await self.get_flows()
+            Message(parse_data), tracker, await self.get_flows(), self.domain
         )
 
         # if there are no converted commands and parsed data contains invalid intent
@@ -912,7 +963,6 @@ class MessageProcessor:
     async def _handle_message_with_tracker(
         self, message: UserMessage, tracker: DialogueStateTracker
     ) -> None:
-
         if message.parse_data:
             parse_data = message.parse_data
         else:
@@ -1154,6 +1204,17 @@ class MessageProcessor:
         results = await self.graph_runner.run(inputs={}, targets=[target])
         return results[target]
 
+    async def _add_flows_to_metadata(self) -> Dict[Text, Any]:
+        """Convert the flows to metadata."""
+        flows = await self.get_flows()
+        flows_metadata = {}
+        for flow in flows.underlying_flows:
+            flow_as_json = flow.as_json()
+            flow_as_json.pop("id")
+            flows_metadata[flow.id] = flow_as_json
+
+        return {"all_flows": flows_metadata}
+
     async def _run_action(
         self,
         action: rasa.core.actions.action.Action,
@@ -1172,18 +1233,25 @@ class MessageProcessor:
 
             run_args = inspect.getfullargspec(action.run).args
             if "metadata" in run_args:
+                metadata: Optional[Dict] = prediction.action_metadata
+
+                if isinstance(action, FormAction):
+                    flows_metadata = await self._add_flows_to_metadata()
+                    metadata = prediction.action_metadata or {}
+                    metadata.update(flows_metadata)
+
                 events = await action.run(
                     output_channel,
                     nlg,
                     temporary_tracker,
                     self.domain,
-                    metadata=prediction.action_metadata,
+                    metadata=metadata,
                 )
             else:
                 events = await action.run(
                     output_channel, nlg, temporary_tracker, self.domain
                 )
-        except rasa.core.actions.action.ActionExecutionRejection:
+        except ActionExecutionRejection:
             events = [
                 ActionExecutionRejected(
                     action.name(), prediction.policy_name, prediction.max_confidence
@@ -1312,7 +1380,7 @@ class MessageProcessor:
 
             logger.error(
                 f"Trying to run unknown follow-up action '{followup_action}'. "
-                "Instead of running that, Rasa Open Source will ignore the action "
+                "Instead of running that, Rasa Pro will ignore the action "
                 "and predict the next action."
             )
 
@@ -1329,3 +1397,24 @@ class MessageProcessor:
         )
         policy_prediction = results[target]
         return policy_prediction
+
+    @staticmethod
+    def message_contains_commands(latest_message: Optional[UserUttered]) -> bool:
+        """Check if the latest message contains commands."""
+        if latest_message is None:
+            return False
+
+        commands = [
+            Command.command_from_json(command) for command in latest_message.commands
+        ]
+        filtered_commands = [
+            command
+            for command in commands
+            if not (
+                isinstance(command, SetSlotCommand)
+                and command.name == ROUTE_TO_CALM_SLOT
+            )
+            and not isinstance(command, NoopCommand)
+        ]
+
+        return len(filtered_commands) > 0

rasa/core/run.py

@@ -1,8 +1,10 @@
 import asyncio
 import logging
-import uuid
-import platform
 import os
+import platform
+import uuid
+import warnings
+from asyncio import AbstractEventLoop
 from functools import partial
 from typing import (
     Any,
@@ -15,11 +17,14 @@ from typing import (
     Dict,
 )
 
+from sanic import Sanic
+from sanic.worker.loader import AppLoader
+
 import rasa.core.utils
-from rasa.plugin import plugin_manager
-from rasa.shared.exceptions import RasaException
 import rasa.shared.utils.common
+import rasa.shared.utils.io
 import rasa.utils
+from rasa.utils import licensing
 import rasa.utils.common
 import rasa.utils.io
 from rasa import server, telemetry
@@ -29,10 +34,8 @@ from rasa.core.agent import Agent
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
 from rasa.core.utils import AvailableEndpoints
-import rasa.shared.utils.io
-from sanic import Sanic
-from asyncio import AbstractEventLoop
-
+from rasa.plugin import plugin_manager
+from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.yaml import read_config_file
 
 logger = logging.getLogger()  # get the root logger
@@ -84,6 +87,10 @@ def _create_single_channel(channel: Text, credentials: Dict[Text, Any]) -> Any:
 
 def _create_app_without_api(cors: Optional[Union[Text, List[Text]]] = None) -> Sanic:
     app = Sanic("rasa_core_no_api", configure_logging=False)
+
+    # Reset Sanic warnings filter that allows the triggering of Sanic warnings
+    warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"sanic.*")
+
     server.add_root_route(app)
     server.configure_cors(app, cors)
     return app
@@ -126,19 +133,24 @@ def configure_app(
     )
 
     if enable_api:
-        app = server.create_app(
-            cors_origins=cors,
-            auth_token=auth_token,
-            response_timeout=response_timeout,
-            jwt_secret=jwt_secret,
-            jwt_private_key=jwt_private_key,
-            jwt_method=jwt_method,
-            endpoints=endpoints,
+        loader = AppLoader(
+            factory=partial(
+                server.create_app,
+                cors_origins=cors,
+                auth_token=auth_token,
+                response_timeout=response_timeout,
+                jwt_secret=jwt_secret,
+                jwt_private_key=jwt_private_key,
+                jwt_method=jwt_method,
+                endpoints=endpoints,
+            )
         )
     else:
-        app = _create_app_without_api(cors)
+        loader = AppLoader(factory=partial(_create_app_without_api, cors))
 
+    app = loader.load()
     app.config.KEEP_ALIVE_TIMEOUT = keep_alive_timeout
+
     if _is_apple_silicon_system() or not use_uvloop:
         app.config.USE_UVLOOP = False
         # some library still sets the loop to uvloop, even if disabled for sanic
@@ -154,18 +166,16 @@ def configure_app(
     if logger.isEnabledFor(logging.DEBUG):
         rasa.core.utils.list_routes(app)
 
-    async def configure_async_logging() -> None:
+    @app.main_process_start
+    async def configure_async_logging(running_app: Sanic) -> None:
         if logger.isEnabledFor(logging.DEBUG):
             rasa.utils.io.enable_async_loop_debugging(asyncio.get_event_loop())
 
-    app.add_task(configure_async_logging)
-
     if "cmdline" in {c.name() for c in input_channels}:
 
+        @app.after_server_start
         async def run_cmdline_io(running_app: Sanic) -> None:
             """Small wrapper to shut down the server once cmd io is done."""
-            await asyncio.sleep(1)  # allow server to start
-
             await console.record_messages(
                 server_url=constants.DEFAULT_SERVER_FORMAT.format("http", port),
                 sender_id=conversation_id,
@@ -174,12 +184,13 @@ def configure_app(
 
             logger.info("Killing Sanic server now.")
             running_app.stop()  # kill the sanic server
-            plugin_manager().hook.after_server_stop()
 
-        app.add_task(run_cmdline_io)
+    @app.after_server_stop
+    async def after_server_stop(running_app: Sanic) -> None:
+        plugin_manager().hook.after_server_stop()
 
     if server_listeners:
-        for (listener, event) in server_listeners:
+        for listener, event in server_listeners:
             app.register_listener(listener, event)
 
     return app
@@ -252,6 +263,10 @@ def serve_application(
         "before_server_start",
     )
 
+    app.register_listener(
+        licensing.validate_limited_server_license, "after_server_start"
+    )
+
     app.register_listener(close_resources, "after_server_stop")
 
     number_of_workers = rasa.core.utils.number_of_sanic_workers(
@@ -272,6 +287,7 @@ def serve_application(
         ssl=ssl_context,
         backlog=int(os.environ.get(ENV_SANIC_BACKLOG, "100")),
         workers=number_of_workers,
+        legacy=True,
     )
 
 

rasa/core/secrets_manager/endpoints.py

@@ -47,7 +47,7 @@ class CredentialsLocation:
 
     @staticmethod
     def is_credentials_location_instance(
-        value: Union[Text, "CredentialsLocation"]
+        value: Union[Text, "CredentialsLocation"],
     ) -> bool:
         """Check if the value is a CredentialsLocation.
 
@@ -85,7 +85,7 @@ class CredentialsLocation:
 
     @staticmethod
     def is_credentials_location_valid(
-        raw_credentials_location: Dict[Text, Text]
+        raw_credentials_location: Dict[Text, Text],
     ) -> bool:
         """Check if the configuration is a secret manager configuration.
 

rasa/core/secrets_manager/vault.py

@@ -124,7 +124,6 @@ class VaultEndpointConfigReader:
                 credentials_location.get_secret_manager_name()
                 == VAULT_SECRET_MANAGER_NAME
             ):
-
                 return VaultCredentialsLocation.from_credentials_location(
                     credentials_location=credentials_location
                 )
@@ -161,11 +160,10 @@ class VaultEndpointConfigReader:
                     credentials_location
                 )
             ):
-
                 if credentials_location.transit_key:
-                    transit_keys[
-                        credentials_location.secret_key
-                    ] = credentials_location.transit_key
+                    transit_keys[credentials_location.secret_key] = (
+                        credentials_location.transit_key
+                    )
 
         return transit_keys if transit_keys else None
 
@@ -357,9 +355,9 @@ class VaultTokenManager:
 
     def start(self) -> None:
         """Start refreshing the token if it is expiring."""
-        renew_response: Dict[
-            Text, Dict[Text, Any]
-        ] = self.client.auth.token.lookup_self()
+        renew_response: Dict[Text, Dict[Text, Any]] = (
+            self.client.auth.token.lookup_self()
+        )
         is_token_expiring = renew_response["data"]["renewable"]
         if is_token_expiring:
             refresh_interval_in_seconds = renew_response["data"]["creation_ttl"]

rasa/core/test.py

@@ -300,14 +300,14 @@ class EvaluationStore:
                 filter(
                     lambda x: x.get(ENTITY_ATTRIBUTE_TEXT) == text, self.entity_targets
                 ),
-                key=lambda x: x[ENTITY_ATTRIBUTE_START],  # type: ignore[literal-required] # noqa: E501
+                key=lambda x: x[ENTITY_ATTRIBUTE_START],  # type: ignore[literal-required]
             )
             entity_predictions = sorted(
                 filter(
                     lambda x: x.get(ENTITY_ATTRIBUTE_TEXT) == text,
                     self.entity_predictions,
                 ),
-                key=lambda x: x[ENTITY_ATTRIBUTE_START],  # type: ignore[literal-required] # noqa: E501
+                key=lambda x: x[ENTITY_ATTRIBUTE_START],  # type: ignore[literal-required]
             )
 
             i_pred, i_target = 0, 0
@@ -461,7 +461,7 @@ def _clean_entity_results(
     cleaned_entities = []
 
     for r in tuple(entity_results):
-        cleaned_entity: EntityPrediction = {ENTITY_ATTRIBUTE_TEXT: text}  # type: ignore[misc]  # noqa E501
+        cleaned_entity: EntityPrediction = {ENTITY_ATTRIBUTE_TEXT: text}  # type: ignore[misc]
         for k in (
             ENTITY_ATTRIBUTE_START,
             ENTITY_ATTRIBUTE_END,
@@ -706,7 +706,6 @@ async def _collect_action_executed_predictions(
     event: ActionExecuted,
     fail_on_prediction_errors: bool,
 ) -> Tuple[EvaluationStore, PolicyPrediction, Optional[EntityEvaluationResult]]:
-
     action_executed_eval_store = EvaluationStore()
 
     expected_action_name = event.action_name
@@ -825,7 +824,6 @@ async def _predict_tracker_actions(
     List[Dict[Text, Any]],
     List[EntityEvaluationResult],
 ]:
-
     processor = agent.processor
     if agent.processor is not None:
         processor = agent.processor