rasa-pro 3.14.0.dev20250901__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

rasa/core/policies/intentless_policy.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple
 
 import structlog
 import tiktoken
-from deprecated import deprecated  # type: ignore[import]
+from deprecated import deprecated  # type: ignore[import-untyped]
 from jinja2 import Template
 from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings

rasa/core/policies/ted_policy.py

@@ -58,6 +58,7 @@ from rasa.shared.nlu.training_data.features import (
     save_features,
 )
 from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils import train_utils
 from rasa.utils.tensorflow import rasa_layers
 from rasa.utils.tensorflow.constants import (
@@ -80,7 +81,6 @@ from rasa.utils.tensorflow.constants import (
     EMBEDDING_DIMENSION,
     ENCODING_DIMENSION,
     ENTITY_RECOGNITION,
-    EPOCH_OVERRIDE,
     EPOCHS,
     EVAL_NUM_EPOCHS,
     EVAL_NUM_EXAMPLES,
@@ -363,6 +363,9 @@ class TEDPolicy(Policy):
         entity_tag_specs: Optional[List[EntityTagSpec]] = None,
     ) -> None:
         """Declares instance variables with default values."""
+        raise_deprecation_warning(
+            "TEDPolicy is deprecated and will be removed in a future version."
+        )
         super().__init__(
             config, model_storage, resource, execution_context, featurizer=featurizer
         )
@@ -668,6 +671,7 @@ class TEDPolicy(Policy):
             self.model.compile(
                 optimizer=tf.keras.optimizers.Adam(self.config[LEARNING_RATE])
             )
+
         (
             data_generator,
             validation_data_generator,
@@ -943,14 +947,16 @@ class TEDPolicy(Policy):
 
         with self._model_storage.write_to(self._resource) as model_path:
             model_filename = self._metadata_filename()
-            tf_model_file = model_path / f"{model_filename}.tf_model"
+            tf_model_file = model_path / f"{model_filename}.weights.h5"
 
             rasa.shared.utils.io.create_directory_for_file(tf_model_file)
 
             self.featurizer.persist(model_path)
 
             if self.config[CHECKPOINT_MODEL] and self.tmp_checkpoint_dir:
-                self.model.load_weights(self.tmp_checkpoint_dir / "checkpoint.tf_model")
+                self.model.load_weights(
+                    self.tmp_checkpoint_dir / "checkpoint.weights.h5"
+                )
                 # Save an empty file to flag that this model has been
                 # produced using checkpointing
                 checkpoint_marker = model_path / f"{model_filename}.from_checkpoint.pkl"
@@ -1009,7 +1015,7 @@ class TEDPolicy(Policy):
         Args:
             model_path: Path where model is to be persisted.
         """
-        tf_model_file = model_path / f"{cls._metadata_filename()}.tf_model"
+        tf_model_file = model_path / f"{cls._metadata_filename()}.weights.h5"
 
         # load data example
         loaded_data = deserialize_nested_feature_arrays(
@@ -1109,8 +1115,6 @@ class TEDPolicy(Policy):
         model_utilities = cls._load_model_utilities(model_path)
 
         config = cls._update_loaded_params(config)
-        if execution_context.is_finetuning and EPOCH_OVERRIDE in config:
-            config[EPOCHS] = config.get(EPOCH_OVERRIDE)
 
         (
             model_data_example,
@@ -1125,7 +1129,6 @@ class TEDPolicy(Policy):
                 model_data_example,
                 predict_data_example,
                 featurizer,
-                execution_context.is_finetuning,
             )
 
         return cls._load_policy_with_model(
@@ -1167,7 +1170,6 @@ class TEDPolicy(Policy):
         model_data_example: RasaModelData,
         predict_data_example: RasaModelData,
         featurizer: TrackerFeaturizer,
-        should_finetune: bool,
     ) -> TED:
         model = cls.model_class().load(
             str(model_utilities["tf_model_file"]),
@@ -1180,7 +1182,9 @@ class TEDPolicy(Policy):
             ),
             label_data=model_utilities["label_data"],
             entity_tag_specs=model_utilities["entity_tag_specs"],
-            finetune_mode=should_finetune,
+            # This feature is no longer supported as the updated version
+            # of Keras does not allow updating a compiled model anymore.
+            finetune_mode=False,
         )
         return model
 
@@ -1463,7 +1467,7 @@ class TED(TransformerRasaModel):
 
         dialogue_transformed, attention_weights = self._tf_layers[
             f"transformer.{DIALOGUE}"
-        ](dialogue_in, 1 - mask, self._training)
+        ](dialogue_in, 1 - mask, training=self._training)
         dialogue_transformed = tf.nn.gelu(dialogue_transformed)
 
         if self.max_history_featurizer_is_used:
@@ -1708,7 +1712,7 @@ class TED(TransformerRasaModel):
 
         if attribute in SENTENCE_FEATURES_TO_ENCODE + LABEL_FEATURES_TO_ENCODE:
             attribute_features = self._tf_layers[f"encoding_layer.{attribute}"](
-                attribute_features, self._training
+                attribute_features, training=self._training
             )
 
         # attribute features have shape
@@ -2102,7 +2106,11 @@ class TED(TransformerRasaModel):
         predictions = {
             "scores": scores,
             "similarities": sim_all,
-            DIAGNOSTIC_DATA: {"attention_weights": attention_weights},
+            DIAGNOSTIC_DATA: {
+                "attention_weights": attention_weights.numpy()
+                if attention_weights is not None and hasattr(attention_weights, "numpy")
+                else attention_weights,
+            },
         }
 
         if (

rasa/core/policies/unexpected_intent_policy.py

@@ -54,6 +54,7 @@ from rasa.shared.nlu.constants import (
 )
 from rasa.shared.nlu.training_data.features import Features
 from rasa.shared.utils import common
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils import train_utils
 from rasa.utils.tensorflow import layers
 from rasa.utils.tensorflow.constants import (
@@ -300,6 +301,10 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
         label_quantiles: Optional[Dict[int, List[float]]] = None,
     ):
         """Declares instance variables with default values."""
+        raise_deprecation_warning(
+            "UnexpecTEDIntentPolicy is deprecated and "
+            "will be removed in a future version."
+        )
         # Set all invalid / non configurable parameters
         config[ENTITY_RECOGNITION] = False
         config[BILOU_FLAG] = False
@@ -624,6 +629,7 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
         query_intent = (
             last_user_uttered_event.intent_name
             if last_user_uttered_event is not None
+            and isinstance(last_user_uttered_event, UserUttered)
             else ""
         )
         is_unlikely_intent = self._check_unlikely_intent(

rasa/core/processor.py

@@ -1,6 +1,5 @@
 import copy
 import inspect
-import logging
 import os
 import re
 import tarfile
@@ -69,9 +68,11 @@ from rasa.shared.constants import (
     UTTER_PREFIX,
 )
 from rasa.shared.core.constants import (
+    ACTION_AGENT_REQUEST_USER_INPUT_NAME,
     ACTION_CORRECT_FLOW_SLOT,
     ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
+    ACTION_METADATA_EXECUTION_TIME,
     ACTION_SESSION_START_NAME,
     FOLLOWUP_ACTION,
     SESSION_START_METADATA_SLOT,
@@ -112,10 +113,9 @@ from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
 
 if TYPE_CHECKING:
-    from rasa.core.available_endpoints import AvailableEndpoints
+    from rasa.core.config.available_endpoints import AvailableEndpoints
     from rasa.privacy.privacy_manager import BackgroundPrivacyManager
 
-logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
 MAX_NUMBER_OF_PREDICTIONS = int(os.environ.get("MAX_NUMBER_OF_PREDICTIONS", "10"))
@@ -189,7 +189,11 @@ class MessageProcessor:
         except TypeError:
             raise ModelNotFound(f"Model {model_path} can not be loaded.")
 
-        logger.info(f"Loading model {model_tar}...")
+        structlogger.info(
+            "rasa.core.processor.load_model",
+            event_info="Loading model.",
+            model_path=model_tar,
+        )
         with TempDirectoryPath(get_temp_dir_name()) as temporary_directory:
             try:
                 metadata, runner = loader.load_predict_graph_runner(
@@ -207,6 +211,7 @@ class MessageProcessor:
     ) -> Optional[List[Dict[Text, Any]]]:
         """Handle a single message with this processor."""
         # preprocess message if necessary
+        self.time_turn_start = time.time()
         tracker = await self.log_message(message, should_save_tracker=False)
 
         if self.model_metadata.training_type == TrainingType.NLU:
@@ -363,8 +368,10 @@ class MessageProcessor:
                 `ActionSessionStart`.
         """
         if not tracker.applied_events() or self._has_session_expired(tracker):
-            logger.debug(
-                f"Starting a new session for conversation ID '{tracker.sender_id}'."
+            structlogger.debug(
+                "rasa.core.processor._update_tracker_session",
+                event_info="Starting a new session.",
+                sender_id=tracker.sender_id,
             )
 
             action_session_start = self._get_action(ACTION_SESSION_START_NAME)
@@ -596,9 +603,11 @@ class MessageProcessor:
             prediction.max_confidence_index, self.domain, self.action_endpoint
         )
 
-        logger.debug(
-            f"Predicted next action '{action.name()}' with confidence "
-            f"{prediction.max_confidence:.2f}."
+        structlogger.debug(
+            "rasa.core.processor.predict_next_with_tracker_if_should",
+            event_info="Predicted next action.",
+            action=action.name(),
+            confidence=prediction.max_confidence,
         )
 
         return action, prediction
@@ -648,8 +657,10 @@ class MessageProcessor:
                 and self._has_message_after_reminder(tracker, reminder_event)
                 or not self._is_reminder_still_valid(tracker, reminder_event)
             ):
-                logger.debug(
-                    f"Canceled reminder because it is outdated ({reminder_event})."
+                structlogger.debug(
+                    "rasa.core.processor.handle_reminder",
+                    event_info="Canceled reminder because it is outdated.",
+                    reminder_event=reminder_event,
                 )
             else:
                 intent = reminder_event.intent
@@ -729,7 +740,7 @@ class MessageProcessor:
         if not self.domain or self.domain.is_empty():
             return
 
-        intent = parse_data["intent"][INTENT_NAME_KEY]
+        intent = parse_data[INTENT][INTENT_NAME_KEY]
         if intent and intent not in self.domain.intents:
             rasa.shared.utils.io.raise_warning(
                 f"Parsed an intent '{intent}' "
@@ -738,7 +749,7 @@ class MessageProcessor:
                 docs=DOCS_URL_DOMAINS,
             )
 
-        entities = parse_data["entities"] or []
+        entities = parse_data[ENTITIES] or []
         for element in entities:
             entity = element["entity"]
             if entity and entity not in self.domain.entities:
@@ -822,9 +833,9 @@ class MessageProcessor:
         self._update_full_retrieval_intent(parse_data)
         structlogger.debug(
             "processor.message.parse",
-            parse_data_text=copy.deepcopy(parse_data["text"]),
-            parse_data_intent=parse_data["intent"],
-            parse_data_entities=copy.deepcopy(parse_data["entities"]),
+            parse_data_text=copy.deepcopy(parse_data[TEXT]),
+            parse_data_intent=parse_data[INTENT],
+            parse_data_entities=copy.deepcopy(parse_data[ENTITIES]),
         )
 
         self._check_for_unseen_features(parse_data)
@@ -973,7 +984,7 @@ class MessageProcessor:
                     f"invalid intent: {parse_data[INTENT]['name']}. "
                     f"Returning CannotHandleCommand() as a fallback."
                 ),
-                invalid_intent=parse_data[INTENT]["name"],
+                invalid_intent=parse_data[INTENT][INTENT_NAME_KEY],
             )
             commands.append(
                 CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT)
@@ -983,7 +994,7 @@ class MessageProcessor:
 
     def _contains_undefined_intent(self, message: Message) -> bool:
         """Checks if the message contains an undefined intent."""
-        intent_name = message.get(INTENT, {}).get("name")
+        intent_name = message.get(INTENT, {}).get(INTENT_NAME_KEY)
         return intent_name is not None and intent_name not in self.domain.intents
 
     async def _parse_message_with_graph(
@@ -1033,8 +1044,8 @@ class MessageProcessor:
         tracker.update(
             UserUttered(
                 message.text,
-                parse_data["intent"],
-                parse_data["entities"],
+                parse_data[INTENT],
+                parse_data[ENTITIES],
                 parse_data,
                 input_channel=message.input_channel,
                 message_id=message.message_id,
@@ -1043,13 +1054,16 @@ class MessageProcessor:
             self.domain,
         )
 
-        if parse_data["entities"]:
+        if parse_data[ENTITIES]:
             self._log_slots(tracker)
 
         plugin_manager().hook.after_new_user_message(tracker=tracker)
 
-        logger.debug(
-            f"Logged UserUtterance - tracker now has {len(tracker.events)} events."
+        structlogger.debug(
+            "rasa.core.processor.handle_message_with_tracker",
+            event_info="Logged UserUtterance.",
+            user_message=message.text,
+            number_of_events=len(tracker.events),
         )
 
     @staticmethod
@@ -1154,6 +1168,7 @@ class MessageProcessor:
         should_predict_another_action = True
 
         tracker = await self.run_command_processor(tracker)
+        self.time_command_processor = time.time()
 
         # action loop. predicts actions until we hit action listen
         while should_predict_another_action and self._should_handle_message(tracker):
@@ -1163,9 +1178,11 @@ class MessageProcessor:
                     tracker
                 )
             except ActionLimitReached:
-                logger.warning(
-                    "Circuit breaker tripped. Stopped predicting "
-                    f"more actions for sender '{tracker.sender_id}'."
+                structlogger.warning(
+                    "rasa.core.processor.run_prediction_loop",
+                    event_info="Circuit breaker tripped. Stopped predicting more "
+                    "actions.",
+                    sender_id=tracker.sender_id,
                 )
                 if self.on_circuit_break:
                     # call a registered callback
@@ -1173,9 +1190,11 @@ class MessageProcessor:
                 break
 
             if prediction.is_end_to_end_prediction:
-                logger.debug(
-                    f"An end-to-end prediction was made which has triggered the 2nd "
-                    f"execution of the default action '{ACTION_EXTRACT_SLOTS}'."
+                structlogger.debug(
+                    "rasa.core.processor.run_prediction_loop",
+                    event_info="An end-to-end prediction was made which has "
+                    "triggered the 2nd execution of the default action.",
+                    action=ACTION_EXTRACT_SLOTS,
                 )
                 tracker = await self.run_action_extract_slots(output_channel, tracker)
 
@@ -1194,7 +1213,11 @@ class MessageProcessor:
             `False` if `action_name` is `ACTION_LISTEN_NAME` or
             `ACTION_SESSION_START_NAME`, otherwise `True`.
         """
-        return action_name not in (ACTION_LISTEN_NAME, ACTION_SESSION_START_NAME)
+        return action_name not in (
+            ACTION_LISTEN_NAME,
+            ACTION_SESSION_START_NAME,
+            ACTION_AGENT_REQUEST_USER_INPUT_NAME,
+        )
 
     async def execute_side_effects(
         self,
@@ -1387,10 +1410,11 @@ class MessageProcessor:
             )
 
         if any(isinstance(e, UserUttered) for e in events):
-            logger.debug(
-                f"A `UserUttered` event was returned by executing "
+            structlogger.debug(
+                "rasa.core.processor.run_action",
+                message="A `UserUttered` event was returned by executing "
                 f"action '{action.name()}'. This will run the default action "
-                f"'{ACTION_EXTRACT_SLOTS}'."
+                f"'{ACTION_EXTRACT_SLOTS}'.",
             )
             tracker = await self.run_action_extract_slots(output_channel, tracker)
 
@@ -1403,6 +1427,34 @@ class MessageProcessor:
         plugin_manager().hook.after_action_executed(tracker=tracker)
         return self.should_predict_another_action(action.name())
 
+    def _add_metadata_if_action_listen(
+        self, action: Action, prediction: PolicyPrediction
+    ) -> None:
+        """Adds execution times to the ActionExecuted event metadata."""
+        if not hasattr(self, "time_turn_start"):
+            return
+
+        if not hasattr(self, "time_command_processor"):
+            return
+
+        if not action.name() == ACTION_LISTEN_NAME:
+            return
+
+        if prediction.action_metadata is None:
+            prediction.action_metadata = {}
+
+        # calculate execution times
+        execution_time_prediction_loop = (
+            time.time() - self.time_command_processor
+        ) * 1000
+        execution_time_command_processor = (
+            self.time_command_processor - self.time_turn_start
+        ) * 1000
+        prediction.action_metadata[ACTION_METADATA_EXECUTION_TIME] = {
+            "command_processor": execution_time_command_processor,
+            "prediction_loop": execution_time_prediction_loop,
+        }
+
     def _log_action_and_events_on_tracker(
         self,
         tracker: DialogueStateTracker,
@@ -1448,6 +1500,7 @@ class MessageProcessor:
         tracker.update_with_events(prediction.events)
 
         # log the action and its produced events
+        self._add_metadata_if_action_listen(action, prediction)
         tracker.update(
             action.event_for_successful_execution(
                 prediction, was_successful, error_message
@@ -1467,11 +1520,9 @@ class MessageProcessor:
             # tracker has never expired if sessions are disabled
             return False
 
-        user_uttered_event: Optional[UserUttered] = tracker.get_last_event_for(
-            UserUttered
-        )
+        user_uttered_event = tracker.get_last_event_for(UserUttered)
 
-        if not user_uttered_event:
+        if not user_uttered_event or not isinstance(user_uttered_event, UserUttered):
             # there is no user event so far so the session should not be considered
             # expired
             return False
@@ -1482,9 +1533,10 @@ class MessageProcessor:
             > self.domain.session_config.session_expiration_time
         )
         if has_expired:
-            logger.debug(
-                f"The latest session for conversation ID '{tracker.sender_id}' has "
-                f"expired."
+            structlogger.debug(
+                "rasa.core.processor.has_session_expired",
+                event_info="The latest session has expired.",
+                sender_id=tracker.sender_id,
             )
 
         return has_expired
@@ -1510,10 +1562,14 @@ class MessageProcessor:
                 )
                 return prediction
 
-            logger.error(
-                f"Trying to run unknown follow-up action '{followup_action}'. "
-                "Instead of running that, Rasa Pro will ignore the action "
-                "and predict the next action."
+            structlogger.error(
+                "rasa.core.processor.predict_next_with_tracker",
+                event_info="Trying to run unknown follow-up action.",
+                message=(
+                    "Trying to run unknown follow-up action. Instead of running "
+                    "that, Rasa Pro will ignore the action and predict the next action."
+                ),
+                followup_action=followup_action,
             )
 
         target = self.model_metadata.core_target