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

rasa/core/policies/memoization.py

@@ -419,9 +419,9 @@ class AugmentedMemoizationPolicy(MemoizationPolicy):
         logger.debug("Launch DeLorean...")
 
         # Truncate the tracker based on `max_history`
-        truncated_tracker: Optional[
-            DialogueStateTracker
-        ] = _trim_tracker_by_max_history(tracker, self.config[POLICY_MAX_HISTORY])
+        truncated_tracker: Optional[DialogueStateTracker] = (
+            _trim_tracker_by_max_history(tracker, self.config[POLICY_MAX_HISTORY])
+        )
         truncated_tracker = self._strip_leading_events_until_action_executed(
             truncated_tracker
         )

rasa/core/policies/policy.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
+
 import abc
 import copy
 import logging
 from enum import Enum
 from pathlib import Path
-
-from rasa.shared.constants import ROUTE_TO_CALM_SLOT
-from rasa.shared.core.events import Event
 from typing import (
     Any,
     List,
@@ -21,6 +19,8 @@ from typing import (
 
 import numpy as np
 
+from rasa.shared.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.core.events import Event
 from rasa.engine.graph import GraphComponent, ExecutionContext
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
@@ -40,14 +40,12 @@ from rasa.core.constants import (
 from rasa.shared.core.constants import USER, SLOTS, PREVIOUS_ACTION, ACTIVE_LOOP
 import rasa.shared.utils.common
 
-
 if TYPE_CHECKING:
     from rasa.shared.nlu.training_data.features import Features
     from rasa.core.featurizers.tracker_featurizers import TrackerFeaturizer
     from rasa.core.featurizers.tracker_featurizers import MaxHistoryTrackerFeaturizer
     from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
 
-
 logger = logging.getLogger(__name__)
 
 TrackerListTypeVar = TypeVar(
@@ -137,10 +135,20 @@ class Policy(GraphComponent):
     def should_abstain_in_coexistence(
         self, tracker: DialogueStateTracker, is_calm_policy: bool
     ) -> bool:
-        """Whether a policy should abstain making predictions in coexistence."""
+        """Whether a policy should abstain making predictions in coexistence.
+
+        A calm policy should run when the routing slot is set to True.
+        A nlu-based policy should run when the routing slot is set to False or None.
+        """
+        if is_calm_policy:
+            return tracker.has_coexistence_routing_slot and (
+                tracker.get_slot(ROUTE_TO_CALM_SLOT) is False
+                or tracker.get_slot(ROUTE_TO_CALM_SLOT) is None
+            )
+
         return (
             tracker.has_coexistence_routing_slot
-            and tracker.get_slot(ROUTE_TO_CALM_SLOT) != is_calm_policy
+            and tracker.get_slot(ROUTE_TO_CALM_SLOT) is True
         )
 
     def __init__(
@@ -299,8 +307,9 @@ class Policy(GraphComponent):
         max_training_samples = kwargs.get("max_training_samples")
         if max_training_samples is not None:
             logger.debug(
-                "Limit training data to {} training samples."
-                "".format(max_training_samples)
+                "Limit training data to {} training samples.".format(
+                    max_training_samples
+                )
             )
             state_features = state_features[:max_training_samples]
             label_ids = label_ids[:max_training_samples]

rasa/core/policies/rule_policy.py

@@ -60,7 +60,7 @@ logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
 
-# These are Rasa Open Source default actions and overrule everything at any time.
+# These are Rasa Pro default actions and overrule everything at any time.
 DEFAULT_ACTION_MAPPINGS = {
     USER_INTENT_RESTART: ACTION_RESTART_NAME,
     USER_INTENT_BACK: ACTION_BACK_NAME,
@@ -271,15 +271,13 @@ class RulePolicy(MemoizationPolicy):
             if (
                 # loop is predicted after action_listen in unhappy path,
                 # therefore no validation is needed
-                is_prev_action_listen_in_state(states[-1])
-                and action == active_loop
+                is_prev_action_listen_in_state(states[-1]) and action == active_loop
             ):
                 lookup[feature_key] = LOOP_WAS_INTERRUPTED
             elif (
                 # some action other than active_loop is predicted in unhappy path,
                 # therefore active_loop shouldn't be predicted by the rule
-                not is_prev_action_listen_in_state(states[-1])
-                and action != active_loop
+                not is_prev_action_listen_in_state(states[-1]) and action != active_loop
             ):
                 lookup[feature_key] = DO_NOT_PREDICT_LOOP_ACTION
         return lookup
@@ -777,10 +775,10 @@ class RulePolicy(MemoizationPolicy):
         trackers_as_actions = rule_trackers_as_actions + story_trackers_as_actions
 
         # negative rules are not anti-rules, they are auxiliary to actual rules
-        self.lookup[
-            RULES_FOR_LOOP_UNHAPPY_PATH
-        ] = self._create_loop_unhappy_lookup_from_states(
-            trackers_as_states, trackers_as_actions
+        self.lookup[RULES_FOR_LOOP_UNHAPPY_PATH] = (
+            self._create_loop_unhappy_lookup_from_states(
+                trackers_as_states, trackers_as_actions
+            )
         )
 
     def train(
@@ -955,7 +953,6 @@ class RulePolicy(MemoizationPolicy):
     def _find_action_from_loop_happy_path(
         tracker: DialogueStateTracker,
     ) -> Tuple[Optional[Text], Optional[Text]]:
-
         active_loop_name = tracker.active_loop_name
         if active_loop_name is None:
             return None, None
@@ -1132,7 +1129,7 @@ class RulePolicy(MemoizationPolicy):
             tracker, domain, use_text_for_last_user_input=True
         )
 
-        # Rasa Open Source default actions overrule anything. If users want to achieve
+        # Rasa Pro default actions overrule anything. If users want to achieve
         # the same, they need to write a rule or make sure that their loop rejects
         # accordingly.
         (

rasa/core/policies/ted_policy.py

@@ -468,7 +468,7 @@ class TEDPolicy(Policy):
 
     @staticmethod
     def _should_extract_entities(
-        entity_tags: List[List[Dict[Text, List[Features]]]]
+        entity_tags: List[List[Dict[Text, List[Features]]]],
     ) -> bool:
         for turns_tags in entity_tags:
             for turn_tags in turns_tags:
@@ -1092,7 +1092,7 @@ class TEDPolicy(Policy):
 
         model = None
 
-        with (contextlib.nullcontext() if config["use_gpu"] else tf.device("/cpu:0")):
+        with contextlib.nullcontext() if config["use_gpu"] else tf.device("/cpu:0"):
             model = cls._load_tf_model(
                 model_utilities,
                 model_data_example,
@@ -1266,19 +1266,19 @@ class TED(TransformerRasaModel):
             )
             self._prepare_encoding_layers(name)
 
-        self._tf_layers[
-            f"transformer.{DIALOGUE}"
-        ] = rasa_layers.prepare_transformer_layer(
-            attribute_name=DIALOGUE,
-            config=self.config,
-            num_layers=self.config[NUM_TRANSFORMER_LAYERS][DIALOGUE],
-            units=self.config[TRANSFORMER_SIZE][DIALOGUE],
-            drop_rate=self.config[DROP_RATE_DIALOGUE],
-            # use bidirectional transformer, because
-            # we will invert dialogue sequence so that the last turn is located
-            # at the first position and would always have
-            # exactly the same positional encoding
-            unidirectional=not self.max_history_featurizer_is_used,
+        self._tf_layers[f"transformer.{DIALOGUE}"] = (
+            rasa_layers.prepare_transformer_layer(
+                attribute_name=DIALOGUE,
+                config=self.config,
+                num_layers=self.config[NUM_TRANSFORMER_LAYERS][DIALOGUE],
+                units=self.config[TRANSFORMER_SIZE][DIALOGUE],
+                drop_rate=self.config[DROP_RATE_DIALOGUE],
+                # use bidirectional transformer, because
+                # we will invert dialogue sequence so that the last turn is located
+                # at the first position and would always have
+                # exactly the same positional encoding
+                unidirectional=not self.max_history_featurizer_is_used,
+            )
         )
 
         self._prepare_label_classification_layers(DIALOGUE)
@@ -1308,23 +1308,23 @@ class TED(TransformerRasaModel):
         # Attributes with sequence-level features also have sentence-level features,
         # all these need to be combined and further processed.
         if attribute_name in SEQUENCE_FEATURES_TO_ENCODE:
-            self._tf_layers[
-                f"sequence_layer.{attribute_name}"
-            ] = rasa_layers.RasaSequenceLayer(
-                attribute_name, attribute_signature, config_to_use
+            self._tf_layers[f"sequence_layer.{attribute_name}"] = (
+                rasa_layers.RasaSequenceLayer(
+                    attribute_name, attribute_signature, config_to_use
+                )
             )
         # Attributes without sequence-level features require some actual feature
         # processing only if they have sentence-level features. Attributes with no
         # sequence- and sentence-level features (dialogue, entity_tags, label) are
         # skipped here.
         elif SENTENCE in attribute_signature:
-            self._tf_layers[
-                f"sparse_dense_concat_layer.{attribute_name}"
-            ] = rasa_layers.ConcatenateSparseDenseFeatures(
-                attribute=attribute_name,
-                feature_type=SENTENCE,
-                feature_type_signature=attribute_signature[SENTENCE],
-                config=config_to_use,
+            self._tf_layers[f"sparse_dense_concat_layer.{attribute_name}"] = (
+                rasa_layers.ConcatenateSparseDenseFeatures(
+                    attribute=attribute_name,
+                    feature_type=SENTENCE,
+                    feature_type_signature=attribute_signature[SENTENCE],
+                    config=config_to_use,
+                )
             )
 
     def _prepare_encoding_layers(self, name: Text) -> None:
@@ -1360,7 +1360,7 @@ class TED(TransformerRasaModel):
 
     @staticmethod
     def _compute_dialogue_indices(
-        tf_batch_data: Dict[Text, Dict[Text, List[tf.Tensor]]]
+        tf_batch_data: Dict[Text, Dict[Text, List[tf.Tensor]]],
     ) -> None:
         dialogue_lengths = tf.cast(tf_batch_data[DIALOGUE][LENGTH][0], dtype=tf.int32)
         # wrap in a list, because that's the structure of tf_batch_data
@@ -1399,7 +1399,7 @@ class TED(TransformerRasaModel):
 
     @staticmethod
     def _collect_label_attribute_encodings(
-        all_labels_encoded: Dict[Text, tf.Tensor]
+        all_labels_encoded: Dict[Text, tf.Tensor],
     ) -> tf.Tensor:
         # Initialize with at least one attribute first
         # so that the subsequent TF ops are simplified.
@@ -1928,7 +1928,6 @@ class TED(TransformerRasaModel):
         text_output: tf.Tensor,
         text_sequence_lengths: tf.Tensor,
     ) -> tf.Tensor:
-
         text_transformed, text_mask, text_sequence_lengths = self._reshape_for_entities(
             tf_batch_data,
             dialogue_transformer_output,
@@ -2131,7 +2130,6 @@ class TED(TransformerRasaModel):
         text_output: tf.Tensor,
         text_sequence_lengths: tf.Tensor,
     ) -> Tuple[tf.Tensor, tf.Tensor]:
-
         text_transformed, _, text_sequence_lengths = self._reshape_for_entities(
             tf_batch_data,
             dialogue_transformer_output,

rasa/core/policies/unexpected_intent_policy.py

@@ -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.
 

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