rasa-pro 3.14.0a20__py3-none-any.whl → 3.14.0a23__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,6 +68,7 @@ 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,
@@ -113,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"))
@@ -190,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(
@@ -365,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)
@@ -598,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
@@ -650,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
@@ -731,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}' "
@@ -740,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:
@@ -824,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)
@@ -975,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)
@@ -985,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(
@@ -1035,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,
@@ -1045,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
@@ -1166,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
@@ -1176,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)
 
@@ -1197,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,
@@ -1390,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)
 
@@ -1499,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
@@ -1514,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
@@ -1542,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

rasa/core/redis_connection_factory.py

@@ -1,10 +1,18 @@
+import os
 from enum import Enum
 from typing import Any, Dict, List, Optional, Text, Tuple, Union
 
 import redis
 import structlog
-from pydantic import BaseModel
-
+from pydantic import BaseModel, ConfigDict
+
+from rasa.core.constants import AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    IAMCredentialsProvider,
+    IAMCredentialsProviderInput,
+    SupportedServiceType,
+    create_iam_credentials_provider,
+)
 from rasa.shared.exceptions import ConnectionException, RasaException
 
 structlogger = structlog.getLogger(__name__)
@@ -23,6 +31,8 @@ class DeploymentMode(Enum):
 class StandardRedisConfig(BaseModel):
     """Base configuration for Redis connections."""
 
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
     host: Text = "localhost"
     port: int = 6379
     username: Optional[Text] = None
@@ -34,6 +44,7 @@ class StandardRedisConfig(BaseModel):
     db: int = 0
     socket_timeout: float = DEFAULT_SOCKET_TIMEOUT_IN_SECONDS
     decode_responses: bool = False
+    iam_credentials_provider: Optional[IAMCredentialsProvider] = None
 
 
 class ClusterRedisConfig(StandardRedisConfig):
@@ -104,6 +115,14 @@ class RedisConnectionFactory:
             deployment_mode_enum, config.endpoints, config.host, config.port
         )
 
+        iam_credentials_provider = create_iam_credentials_provider(
+            IAMCredentialsProviderInput(
+                service_name=SupportedServiceType.LOCK_STORE,
+                username=config.username,
+                cluster_name=os.getenv(AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME),
+            )
+        )
+
         if deployment_mode_enum == DeploymentMode.CLUSTER:
             cls._log_cluster_db_warning(deployment_mode_enum, config.db)
             cluster_config = ClusterRedisConfig(
@@ -117,6 +136,7 @@ class RedisConnectionFactory:
                 socket_timeout=config.socket_timeout,
                 decode_responses=config.decode_responses,
                 endpoints=parsed_endpoints,
+                iam_credentials_provider=iam_credentials_provider,
             )
             return cls._create_cluster_connection(cluster_config)
         elif deployment_mode_enum == DeploymentMode.SENTINEL:
@@ -131,6 +151,7 @@ class RedisConnectionFactory:
                 "socket_timeout": config.socket_timeout,
                 "decode_responses": config.decode_responses,
                 "endpoints": parsed_endpoints,
+                "iam_credentials_provider": iam_credentials_provider,
             }
 
             if config.sentinel_service is not None:
@@ -151,6 +172,7 @@ class RedisConnectionFactory:
                 db=config.db,
                 socket_timeout=config.socket_timeout,
                 decode_responses=config.decode_responses,
+                iam_credentials_provider=iam_credentials_provider,
             )
             return cls._create_standard_connection(standard_config)
 
@@ -279,18 +301,31 @@ class RedisConnectionFactory:
         )
 
         cluster_nodes = [ClusterNode(host, port) for host, port in config.endpoints]
+
+        common_config_kwargs = {
+            "startup_nodes": cluster_nodes,
+            "ssl": config.use_ssl,
+            "ssl_certfile": config.ssl_certfile,
+            "ssl_keyfile": config.ssl_keyfile,
+            "ssl_ca_certs": config.ssl_ca_certs,
+            "socket_timeout": config.socket_timeout,
+            "decode_responses": config.decode_responses,
+        }
+
         try:
-            redis_cluster: redis.RedisCluster = redis.RedisCluster(
-                startup_nodes=cluster_nodes,
-                username=config.username,
-                password=config.password,
-                ssl=config.use_ssl,
-                ssl_certfile=config.ssl_certfile,
-                ssl_keyfile=config.ssl_keyfile,
-                ssl_ca_certs=config.ssl_ca_certs,
-                socket_timeout=config.socket_timeout,
-                decode_responses=config.decode_responses,
-            )
+            if config.iam_credentials_provider is not None:
+                structlogger.debug("redis_connection_factory.cluster_iam_auth_enabled")
+
+                redis_cluster: redis.RedisCluster = redis.RedisCluster(
+                    credential_provider=config.iam_credentials_provider,
+                    **common_config_kwargs,
+                )
+            else:
+                redis_cluster = redis.RedisCluster(
+                    username=config.username,
+                    password=config.password,
+                    **common_config_kwargs,
+                )
         except Exception as e:
             raise ConnectionException(f"Error initializing Redis Cluster: {e}")
 
@@ -324,15 +359,25 @@ class RedisConnectionFactory:
         )
 
         # Configuration for Sentinel connection
-        sentinel_kwargs = {
-            "username": config.username,
-            "password": config.password,
+        connection_kwargs: Dict[str, Any] = {
             "socket_timeout": config.socket_timeout,
         }
 
+        sentinel_kwargs: Optional[Dict] = None
+        if config.iam_credentials_provider is not None:
+            structlogger.debug("redis_connection_factory.sentinel_iam_auth_enabled")
+            sentinel_kwargs = {"credential_provider": config.iam_credentials_provider}
+        else:
+            connection_kwargs.update(
+                {
+                    "username": config.username,
+                    "password": config.password,
+                }
+            )
+
         # SSL configuration
         if config.use_ssl:
-            sentinel_kwargs.update(
+            connection_kwargs.update(
                 {
                     "ssl": config.use_ssl,
                     "ssl_certfile": config.ssl_certfile,
@@ -350,7 +395,9 @@ class RedisConnectionFactory:
 
         # Create Sentinel instance
         try:
-            sentinel = Sentinel(config.endpoints, **sentinel_kwargs)
+            sentinel = Sentinel(
+                config.endpoints, sentinel_kwargs=sentinel_kwargs, **connection_kwargs
+            )
             master = sentinel.master_for(config.sentinel_service, **client_kwargs)
 
             # Test the connection
@@ -383,16 +430,27 @@ class RedisConnectionFactory:
             "host": config.host,
             "port": int(config.port),
             "db": config.db,
-            "password": config.password,
             "socket_timeout": float(config.socket_timeout),
             "ssl": config.use_ssl,
             "ssl_certfile": config.ssl_certfile,
             "ssl_keyfile": config.ssl_keyfile,
             "ssl_ca_certs": config.ssl_ca_certs,
-            "username": config.username,
             "decode_responses": config.decode_responses,
         }
 
+        if config.iam_credentials_provider is not None:
+            structlogger.debug("redis_connection_factory.standard_iam_auth_enabled")
+            connection_args.update(
+                {"credential_provider": config.iam_credentials_provider}
+            )
+        else:
+            connection_args.update(
+                {
+                    "password": config.password,
+                    "username": config.username,
+                }
+            )
+
         try:
             standard_redis = redis.StrictRedis(**connection_args)
         except Exception as e: