rasa-pro 3.14.0.dev20250922__py3-none-any.whl → 3.14.0rc2__py3-none-any.whl

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

@@ -6,7 +6,10 @@ import redis
 import structlog
 from pydantic import BaseModel, ConfigDict
 
-from rasa.core.constants import AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME
+from rasa.core.constants import (
+    AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME,
+    REDIS_SERVICE_NAME,
+)
 from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
     IAMCredentialsProvider,
     IAMCredentialsProviderInput,
@@ -65,6 +68,7 @@ class RedisConfig(BaseModel):
 
     host: Text = "localhost"
     port: int = 6379
+    service_type: SupportedServiceType
     username: Optional[Text] = None
     password: Optional[Text] = None
     use_ssl: bool = False
@@ -117,7 +121,8 @@ class RedisConnectionFactory:
 
         iam_credentials_provider = create_iam_credentials_provider(
             IAMCredentialsProviderInput(
-                service_name=SupportedServiceType.LOCK_STORE,
+                service_type=config.service_type,
+                service_name=REDIS_SERVICE_NAME,
                 username=config.username,
                 cluster_name=os.getenv(AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME),
             )

rasa/core/run.py

@@ -30,34 +30,35 @@ from rasa import server, telemetry
 from rasa.constants import ENV_SANIC_BACKLOG
 from rasa.core import agent, channels, constants
 from rasa.core.agent import Agent
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.available_agents import AvailableAgents
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
 from rasa.core.channels.development_inspector import DevelopmentInspectProxy
+from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.credentials import CredentialsConfig
 from rasa.core.persistor import StorageType
 from rasa.shared.exceptions import RasaException
-from rasa.shared.utils.yaml import read_config_file
 from rasa.utils import licensing
 
 logger = logging.getLogger()  # get the root logger
 
 
 def create_input_channels(
-    channel: Optional[Text], credentials_file: Optional[Text]
+    channel: Optional[Text], credentials_config: Optional[CredentialsConfig]
 ) -> List[InputChannel]:
     """Instantiate the chosen input channel.
 
     Args:
         channel (optional): The name of the specific input channel to create.
-        credentials_file: Path to the credentials file containing channel credentials.
+        credentials_config: CredentialsConfig object containing channel credentials.
 
     Returns:
         A list of instantiated input channels. If a specific channel is provided,
         it returns a list with that single channel. If no channel is specified,
         it returns a list of all channels defined in the credentials file.
     """
-    if credentials_file:
-        all_credentials = read_config_file(credentials_file)
+    if credentials_config:
+        all_credentials = credentials_config.channels
     else:
         all_credentials = {}
     if channel:
@@ -96,10 +97,32 @@ def _create_single_channel(
     """
     from rasa.core.channels import BUILTIN_CHANNELS
 
+    # Channels that have optional dependencies
+    channels_with_optional_deps = {
+        "facebook": "fbmessenger",
+        "slack": "slack-sdk",
+        "telegram": "aiogram",
+        "twilio": "twilio",
+        "twilio_voice": "twilio",
+        "twilio_media_streams": "twilio",
+        "webexteams": "webexteamssdk",
+        "vier_cvg": "cvg_sdk",
+    }
+
     if channel in BUILTIN_CHANNELS:
         channel_class = BUILTIN_CHANNELS[channel]
 
         return channel_class.from_credentials(credentials)
+    elif channel in channels_with_optional_deps:
+        # Channel is known but not available due to missing dependency
+        dependency = channels_with_optional_deps[channel]
+        raise RasaException(
+            f"Channel '{channel}' is not available "
+            f"due to missing '{dependency}' dependency. "
+            f"Please install the required extra by running: "
+            f"pip install 'rasa-pro[channels]' OR "
+            f"poetry add 'rasa-pro[channels]'"
+        )
     else:
         # try to load channel based on class name
         try:
@@ -151,6 +174,7 @@ def configure_app(
     route: Optional[Text] = "/webhooks/",
     port: int = constants.DEFAULT_SERVER_PORT,
     endpoints: Optional[AvailableEndpoints] = None,
+    sub_agents: Optional[AvailableAgents] = None,
     log_file: Optional[Text] = None,
     conversation_id: Optional[Text] = uuid.uuid4().hex,
     use_syslog: bool = False,
@@ -179,6 +203,7 @@ def configure_app(
                 jwt_private_key=jwt_private_key,
                 jwt_method=jwt_method,
                 endpoints=endpoints,
+                sub_agents=sub_agents,
                 is_inspector_enabled=is_inspector_enabled,
             )
         )
@@ -234,7 +259,7 @@ def serve_application(
     channel: Optional[Text] = None,
     interface: Optional[Text] = constants.DEFAULT_SERVER_INTERFACE,
     port: int = constants.DEFAULT_SERVER_PORT,
-    credentials: Optional[Text] = None,
+    credentials: Optional[CredentialsConfig] = None,
     cors: Optional[Union[Text, List[Text]]] = None,
     auth_token: Optional[Text] = None,
     enable_api: bool = True,
@@ -243,6 +268,7 @@ def serve_application(
     jwt_private_key: Optional[Text] = None,
     jwt_method: Optional[Text] = None,
     endpoints: Optional[AvailableEndpoints] = None,
+    sub_agents: Optional[AvailableAgents] = None,
     remote_storage: Optional[StorageType] = None,
     log_file: Optional[Text] = None,
     ssl_certificate: Optional[Text] = None,
@@ -283,6 +309,7 @@ def serve_application(
         jwt_method,
         port=port,
         endpoints=endpoints,
+        sub_agents=sub_agents,
         log_file=log_file,
         conversation_id=conversation_id,
         use_syslog=use_syslog,
@@ -302,7 +329,7 @@ def serve_application(
     logger.info(f"Starting Rasa server on {protocol}://{interface}:{port}")
 
     app.register_listener(
-        partial(load_agent_on_start, model_path, endpoints, remote_storage),
+        partial(load_agent_on_start, model_path, endpoints, remote_storage, sub_agents),
         "before_server_start",
     )
 
@@ -340,6 +367,7 @@ async def load_agent_on_start(
     model_path: Text,
     endpoints: AvailableEndpoints,
     remote_storage: Optional[StorageType],
+    sub_agents: Optional[AvailableAgents],
     app: Sanic,
     loop: AbstractEventLoop,
 ) -> Agent:
@@ -352,6 +380,7 @@ async def load_agent_on_start(
         model_path=model_path,
         remote_storage=remote_storage,
         endpoints=endpoints,
+        sub_agents=sub_agents,
         loop=loop,
     )
 

rasa/core/test.py

@@ -1281,6 +1281,10 @@ async def compare_models_in_dir(
         for k, v in number_correct_in_run.items():
             number_correct[k].append(v)
 
+    logger.info("current working directory: " + os.getcwd())
+    logger.info(
+        f"Writing model comparison results to '{os.path.join(output, RESULTS_FILE)}'"
+    )
     rasa.shared.utils.io.dump_obj_as_json_to_file(
         os.path.join(output, RESULTS_FILE), number_correct
     )

rasa/core/tracker_stores/redis_tracker_store.py

@@ -8,6 +8,9 @@ from pydantic import ValidationError
 
 import rasa.shared
 from rasa.core.brokers.broker import EventBroker
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    SupportedServiceType,
+)
 from rasa.core.redis_connection_factory import (
     DeploymentMode,
     RedisConfig,
@@ -54,6 +57,7 @@ class RedisTrackerStore(TrackerStore, SerializedTrackerAsText):
             config = RedisConfig(
                 host=host,
                 port=port,
+                service_type=SupportedServiceType.TRACKER_STORE,
                 db=db,
                 username=username,
                 password=password,

rasa/core/tracker_stores/sql_tracker_store.py

@@ -27,6 +27,7 @@ from rasa.core.constants import (
     POSTGRESQL_MAX_OVERFLOW,
     POSTGRESQL_POOL_SIZE,
     POSTGRESQL_SCHEMA,
+    SQL_SERVICE_NAME,
     SQL_TRACKER_STORE_SSL_MODE_ENV_VAR_NAME,
     SQL_TRACKER_STORE_SSL_ROOT_CERTIFICATE_ENV_VAR_NAME,
 )
@@ -229,7 +230,8 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
 
         iam_credentials_provider = create_iam_credentials_provider(
             IAMCredentialsProviderInput(
-                service_name=SupportedServiceType.TRACKER_STORE,
+                service_type=SupportedServiceType.TRACKER_STORE,
+                service_name=SQL_SERVICE_NAME,
                 username=username,
                 host=host,
                 port=port,

rasa/core/tracker_stores/tracker_store.py

@@ -542,7 +542,7 @@ class FailSafeTrackerStore(TrackerStore):
         return self._tracker_store.domain
 
     @domain.setter
-    def domain(self, domain: Domain) -> None:
+    def domain(self, domain: Optional[Domain]) -> None:
         self._tracker_store.domain = domain
 
         if self._fallback_tracker_store:
@@ -805,9 +805,7 @@ class AwaitableTrackerStore(TrackerStore):
     async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
         """Wrapper to call `retrieve` method of primary tracker store."""
         result = self._tracker_store.retrieve(sender_id)
-        return (
-            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
-        )
+        return await result if isawaitable(result) else result
 
     async def keys(self) -> Iterable[Text]:
         """Wrapper to call `keys` method of primary tracker store."""
@@ -834,6 +832,4 @@ class AwaitableTrackerStore(TrackerStore):
     ) -> Optional[DialogueStateTracker]:
         """Wrapper to call `retrieve_full_tracker` method of primary tracker store."""
         result = self._tracker_store.retrieve_full_tracker(conversation_id)
-        return (
-            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
-        )
+        return await result if isawaitable(result) else result

rasa/core/train.py

@@ -46,7 +46,7 @@ async def train_comparison_models(
                     output=str(Path(output_path, f"run_{r +1}")),
                     fixed_model_name=config_name + PERCENTAGE_KEY + str(percentage),
                     additional_arguments={
-                        **additional_arguments,
+                        **(additional_arguments or {}),
                         "exclusion_percentage": percentage,
                     },
                 )