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

rasa/core/lock_store.py

@@ -4,7 +4,7 @@ import asyncio
 import json
 import os
 from contextlib import asynccontextmanager
-from typing import Any, AsyncGenerator, Dict, Literal, Optional, Text, Union
+from typing import Any, AsyncGenerator, Dict, List, Literal, Optional, Text, Union
 
 import structlog
 from pydantic import (
@@ -12,12 +12,18 @@ from pydantic import (
     BaseModel,
     Field,
     NonNegativeInt,
+    ValidationError,
     model_validator,
 )
 
 import rasa.shared.utils.common
-from rasa.core.constants import DEFAULT_LOCK_LIFETIME
+from rasa.core.constants import DEFAULT_LOCK_LIFETIME, IAM_CLOUD_PROVIDER_ENV_VAR_NAME
 from rasa.core.lock import TicketLock
+from rasa.core.redis_connection_factory import (
+    DeploymentMode,
+    RedisConfig,
+    RedisConnectionFactory,
+)
 from rasa.shared.exceptions import ConnectionException, RasaException
 from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils.endpoints import EndpointConfig
@@ -221,7 +227,7 @@ class LockStore:
 
 
 class RedisLockStoreConfig(BaseModel):
-    host: Union[AnyUrl, Literal["localhost"]] = Field(
+    host: Union[AnyUrl, Literal["localhost"], str] = Field(
         default="localhost", description="The host of the redis server."
     )
     port: NonNegativeInt = Field(
@@ -269,6 +275,18 @@ class RedisLockStoreConfig(BaseModel):
         "will be raised in case Redis doesn't respond "
         "within `socket_timeout` seconds.",
     )
+    deployment_mode: DeploymentMode = Field(
+        default=DeploymentMode.STANDARD,
+        description="Redis deployment mode: 'standard', 'cluster', or 'sentinel'",
+    )
+    endpoints: Optional[List[str]] = Field(
+        default=None,
+        description="List of endpoints for cluster/sentinel mode in 'host:port' format",
+    )
+    sentinel_service: Optional[str] = Field(
+        default=None,
+        description="Sentinel service name",
+    )
 
     @model_validator(mode="before")
     @classmethod
@@ -290,7 +308,9 @@ class RedisLockStoreConfig(BaseModel):
 
     @model_validator(mode="after")
     def verify_username_password(self) -> RedisLockStoreConfig:
-        if bool(self.username) ^ bool(self.password):
+        if os.getenv(IAM_CLOUD_PROVIDER_ENV_VAR_NAME) is None and (
+            bool(self.username) ^ bool(self.password)
+        ):
             raise ValueError(
                 f"Expected username and password. "
                 f"Found: username: {'<has value>' if self.username else '<N/A>'}, "
@@ -298,9 +318,6 @@ class RedisLockStoreConfig(BaseModel):
             )
         return self
 
-    def to_strict_redis(self) -> Dict[str, Any]:
-        return self.model_dump(by_alias=True, exclude={"key_prefix"})
-
 
 class RedisLockStore(LockStore):
     """Redis store for ticket locks."""
@@ -314,10 +331,26 @@ class RedisLockStore(LockStore):
         Args:
             config: Redis lock store configuration.
         """
-        import redis
-
         self.config = config
-        self.red = redis.StrictRedis(**self.config.to_strict_redis())
+        try:
+            redis_config = RedisConfig(
+                host=str(self.config.host),
+                port=self.config.port,
+                db=self.config.db,
+                username=self.config.username,
+                password=self.config.password,
+                use_ssl=self.config.use_ssl,
+                ssl_keyfile=self.config.ssl_keyfile,
+                ssl_certfile=self.config.ssl_certfile,
+                ssl_ca_certs=self.config.ssl_ca_certs,
+                deployment_mode=self.config.deployment_mode.value,
+                endpoints=self.config.endpoints,
+                sentinel_service=self.config.sentinel_service,
+                socket_timeout=self.config.socket_timeout,
+            )
+            self.red = RedisConnectionFactory.create_connection(redis_config)
+        except ValidationError as e:
+            raise RasaException(f"Invalid Redis configuration: {e}")
 
         self.key_prefix = DEFAULT_REDIS_LOCK_STORE_KEY_PREFIX
         if self.config.key_prefix:
@@ -349,6 +382,9 @@ class RedisLockStore(LockStore):
         """Retrieves lock (see parent docstring for more information)."""
         serialised_lock = self.red.get(self.key_prefix + conversation_id)
         if serialised_lock:
+            # Handle bytes to string conversion for JSON parsing
+            if isinstance(serialised_lock, bytes):
+                serialised_lock = serialised_lock.decode("utf-8")
             return TicketLock.from_dict(json.loads(serialised_lock))
 
         return None

rasa/core/nlg/generator.py

@@ -2,7 +2,6 @@ from typing import Any, Dict, List, Optional, Text, Union
 
 import structlog
 from jinja2 import Template
-from pypred import Predicate
 
 import rasa.shared.utils.common
 import rasa.shared.utils.io
@@ -12,6 +11,7 @@ from rasa.shared.constants import CHANNEL, RESPONSE_CONDITION
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig
+from rasa.utils.pypred import Predicate
 
 structlogger = structlog.get_logger()
 

rasa/core/policies/flows/flow_executor.py

@@ -4,7 +4,6 @@ from typing import Any, Dict, List, Optional, Text
 
 import structlog
 from jinja2 import Template
-from pypred import Predicate
 from structlog.contextvars import (
     bound_contextvars,
 )
@@ -92,6 +91,7 @@ from rasa.shared.core.slots import Slot, SlotRejection
 from rasa.shared.core.trackers import (
     DialogueStateTracker,
 )
+from rasa.utils.pypred import Predicate
 
 structlogger = structlog.get_logger()
 

rasa/core/processor.py

@@ -72,6 +72,7 @@ from rasa.shared.core.constants import (
     ACTION_CORRECT_FLOW_SLOT,
     ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
+    ACTION_METADATA_EXECUTION_TIME,
     ACTION_SESSION_START_NAME,
     FOLLOWUP_ACTION,
     SESSION_START_METADATA_SLOT,
@@ -207,6 +208,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:
@@ -1154,6 +1156,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):
@@ -1403,6 +1406,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 +1479,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

rasa/core/redis_connection_factory.py

@@ -0,0 +1,469 @@
+import os
+from enum import Enum
+from typing import Any, Dict, List, Optional, Text, Tuple, Union
+
+import redis
+import structlog
+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__)
+
+DEFAULT_SOCKET_TIMEOUT_IN_SECONDS = 10
+
+
+class DeploymentMode(Enum):
+    """Supported Redis deployment modes."""
+
+    STANDARD = "standard"
+    CLUSTER = "cluster"
+    SENTINEL = "sentinel"
+
+
+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
+    password: Optional[Text] = None
+    use_ssl: bool = False
+    ssl_keyfile: Optional[Text] = None
+    ssl_certfile: Optional[Text] = None
+    ssl_ca_certs: Optional[Text] = None
+    db: int = 0
+    socket_timeout: float = DEFAULT_SOCKET_TIMEOUT_IN_SECONDS
+    decode_responses: bool = False
+    iam_credentials_provider: Optional[IAMCredentialsProvider] = None
+
+
+class ClusterRedisConfig(StandardRedisConfig):
+    """Configuration for Redis Cluster connections."""
+
+    endpoints: List[Tuple[Text, int]]
+
+
+class SentinelRedisConfig(StandardRedisConfig):
+    """Configuration for Redis Sentinel connections."""
+
+    endpoints: List[Tuple[Text, int]]
+    sentinel_service: Optional[Text] = "mymaster"
+
+
+class RedisConfig(BaseModel):
+    """Base configuration for Redis connections."""
+
+    host: Text = "localhost"
+    port: int = 6379
+    username: Optional[Text] = None
+    password: Optional[Text] = None
+    use_ssl: bool = False
+    ssl_keyfile: Optional[Text] = None
+    ssl_certfile: Optional[Text] = None
+    ssl_ca_certs: Optional[Text] = None
+    db: int = 0
+    socket_timeout: float = DEFAULT_SOCKET_TIMEOUT_IN_SECONDS
+    decode_responses: bool = False
+    deployment_mode: Text = DeploymentMode.STANDARD.value
+    endpoints: Optional[List[Text]] = None
+    sentinel_service: Optional[Text] = None
+
+
+class RedisConnectionFactory:
+    """Factory class for creating Redis connections with different modes."""
+
+    @classmethod
+    def create_connection(
+        cls,
+        config: RedisConfig,
+    ) -> Union[redis.Redis, redis.RedisCluster]:
+        """Create a Redis connection based on the configuration.
+
+        Args:
+            config: Redis configuration object containing all connection parameters.
+
+        Returns:
+            A Redis connection - either a standard Redis connection, a RedisCluster
+            connection, or a Redis master connection managed by Sentinel.
+
+        Raises:
+            RasaException: If configuration is invalid.
+        """
+        if config.endpoints is None:
+            config.endpoints = []
+
+        try:
+            deployment_mode_enum = DeploymentMode(config.deployment_mode)
+        except ValueError:
+            valid_modes = [mode.value for mode in DeploymentMode]
+            raise RasaException(
+                f"Invalid deployment_mode '{config.deployment_mode}'. "
+                f"Must be one of: {', '.join(valid_modes)}"
+            )
+
+        parsed_endpoints = cls._parse_and_validate_endpoints(
+            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(
+                username=config.username,
+                password=config.password,
+                use_ssl=config.use_ssl,
+                ssl_certfile=config.ssl_certfile,
+                ssl_keyfile=config.ssl_keyfile,
+                ssl_ca_certs=config.ssl_ca_certs,
+                db=config.db,
+                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:
+            sentinel_kwargs = {
+                "username": config.username,
+                "password": config.password,
+                "use_ssl": config.use_ssl,
+                "ssl_certfile": config.ssl_certfile,
+                "ssl_keyfile": config.ssl_keyfile,
+                "ssl_ca_certs": config.ssl_ca_certs,
+                "db": config.db,
+                "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:
+                sentinel_kwargs["sentinel_service"] = config.sentinel_service
+
+            sentinel_config = SentinelRedisConfig(**sentinel_kwargs)
+            return cls._create_sentinel_connection(sentinel_config)
+        else:
+            standard_config = StandardRedisConfig(
+                host=config.host,
+                port=config.port,
+                username=config.username,
+                password=config.password,
+                use_ssl=config.use_ssl,
+                ssl_certfile=config.ssl_certfile,
+                ssl_keyfile=config.ssl_keyfile,
+                ssl_ca_certs=config.ssl_ca_certs,
+                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)
+
+    @classmethod
+    def _parse_and_validate_endpoints(
+        cls,
+        deployment_mode: DeploymentMode,
+        endpoints: List[str],
+        host: Text,
+        port: int,
+    ) -> List[Union[Dict[str, Any], Tuple[str, int]]]:
+        """Parse and validate endpoints based on deployment mode."""
+        if deployment_mode == DeploymentMode.STANDARD:
+            if endpoints:
+                structlogger.warning(
+                    "redis_connection_factory.standard_endpoints_ignored",
+                    event_info="Parameter `endpoints` ignored in standard mode. "
+                    "Only 'host' and 'port' are used for standard Redis connections.",
+                )
+            return []
+
+        if not endpoints:
+            endpoints = cls._get_default_endpoints(deployment_mode, host, port)
+
+        # Parse endpoints into appropriate format
+        parsed_endpoints = cls._parse_all_endpoints(endpoints, deployment_mode)
+
+        if not parsed_endpoints:
+            raise RasaException(
+                f"No valid '{deployment_mode.value}' endpoints provided"
+            )
+
+        return parsed_endpoints
+
+    @classmethod
+    def _get_default_endpoints(
+        cls,
+        deployment_mode: DeploymentMode,
+        host: Text,
+        port: int,
+    ) -> List[str]:
+        """Get default endpoints when none provided."""
+        if deployment_mode == DeploymentMode.CLUSTER:
+            structlogger.warning(
+                "redis_connection_factory.cluster_endpoints_not_provided",
+                event_info="No endpoints provided for cluster mode. "
+                "Using default 'host:port' configuration.",
+            )
+            return [f"{host}:{port}"]
+        elif deployment_mode == DeploymentMode.SENTINEL:
+            raise RasaException("Sentinel mode requires endpoints configuration")
+
+        return []
+
+    @classmethod
+    def _parse_single_endpoint(
+        cls, endpoint: str, deployment_mode: DeploymentMode
+    ) -> Optional[Union[Dict[str, Any], Tuple[str, int]]]:
+        """Parse a single endpoint string into the appropriate format."""
+        if not isinstance(endpoint, str):
+            structlogger.warning(
+                f"redis_connection_factory.invalid_{deployment_mode.value}_endpoint_type",
+                event_info=f"Invalid endpoint type for endpoint '{endpoint}'. "
+                "Expected string in 'host:port' format.",
+            )
+            return None
+
+        if ":" not in endpoint:
+            structlogger.warning(
+                f"redis_connection_factory.invalid_{deployment_mode.value}_endpoint_format",
+                event_info=f"Invalid format for endpoint '{endpoint}'. "
+                "Expected 'host:port'.",
+            )
+            return None
+
+        host, port_str = endpoint.rsplit(":", 1)
+        try:
+            port = int(port_str)
+        except ValueError:
+            structlogger.warning(
+                f"redis_connection_factory.invalid_{deployment_mode.value}_endpoint",
+                event_info=f"Invalid port in endpoint '{endpoint}'. "
+                "Expected format 'host:port'.",
+            )
+            return None
+
+        return (host, port)
+
+    @classmethod
+    def _parse_all_endpoints(
+        cls,
+        endpoints: List[str],
+        deployment_mode: DeploymentMode,
+    ) -> List[Union[Dict[str, Any], Tuple[str, int]]]:
+        """Parse a list of endpoint strings into appropriate format."""
+        parsed_endpoints = []
+        for endpoint in endpoints:
+            parsed = cls._parse_single_endpoint(endpoint, deployment_mode)
+            if parsed:
+                parsed_endpoints.append(parsed)
+        return parsed_endpoints
+
+    @classmethod
+    def _create_cluster_connection(
+        cls,
+        config: ClusterRedisConfig,
+    ) -> redis.RedisCluster:
+        """Create a Redis Cluster connection.
+
+        Note: Database parameter is ignored in cluster mode (always uses db=0).
+
+        Args:
+            config: Cluster configuration containing all connection parameters.
+
+        Returns:
+            redis.RedisCluster: Configured cluster connection.
+
+        Raises:
+            ConnectionException: If cluster initialization fails.
+        """
+        from redis.cluster import ClusterNode
+
+        structlogger.info(
+            "redis_connection_factory.cluster_mode",
+            event_info=f"Initializing Redis Cluster with {len(config.endpoints)} nodes",
+        )
+
+        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:
+            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}")
+
+        return redis_cluster
+
+    @classmethod
+    def _create_sentinel_connection(
+        cls,
+        config: SentinelRedisConfig,
+    ) -> redis.Redis:
+        """Create a Sentinel-managed Redis connection.
+
+        Connects to Redis master through Sentinel service discovery.
+        Tests connection with ping() before returning.
+
+        Args:
+            config: Sentinel configuration containing all connection parameters.
+
+        Returns:
+            redis.Redis: Connection to the Redis master via sentinel.
+
+        Raises:
+            ConnectionException: If sentinel initialization or connection test fails.
+        """
+        from redis.sentinel import Sentinel
+
+        structlogger.info(
+            "redis_connection_factory.sentinel_mode",
+            event_info=f"Initializing Redis Sentinel with {len(config.endpoints)} "
+            f"sentinel endpoints and service: {config.sentinel_service}",
+        )
+
+        # Configuration for Sentinel connection
+        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:
+            connection_kwargs.update(
+                {
+                    "ssl": config.use_ssl,
+                    "ssl_certfile": config.ssl_certfile,
+                    "ssl_keyfile": config.ssl_keyfile,
+                    "ssl_ca_certs": config.ssl_ca_certs,
+                }
+            )
+
+        # Configuration for Redis client (master/replica)
+        client_kwargs = {
+            "db": config.db,
+            "decode_responses": config.decode_responses,
+            "socket_timeout": config.socket_timeout,
+        }
+
+        # Create Sentinel instance
+        try:
+            sentinel = Sentinel(
+                config.endpoints, sentinel_kwargs=sentinel_kwargs, **connection_kwargs
+            )
+            master = sentinel.master_for(config.sentinel_service, **client_kwargs)
+
+            # Test the connection
+            master.ping()
+
+        except Exception as e:
+            raise ConnectionException(f"Error initializing Redis Sentinel: {e}")
+
+        return master
+
+    @classmethod
+    def _create_standard_connection(
+        cls,
+        config: StandardRedisConfig,
+    ) -> redis.Redis:
+        """Create a standard Redis connection.
+
+        Args:
+            config: Standard configuration containing all connection parameters.
+
+        Returns:
+            redis.Redis: Configured Redis connection.
+        """
+        structlogger.info(
+            "redis_connection_factory.standard_mode",
+            event_info="Initializing Redis connection",
+        )
+        # Build connection arguments
+        connection_args: Dict[str, Any] = {
+            "host": config.host,
+            "port": int(config.port),
+            "db": config.db,
+            "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,
+            "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:
+            raise ConnectionException(f"Error initializing Redis connection: {e}")
+
+        return standard_redis
+
+    @classmethod
+    def _log_cluster_db_warning(cls, deployment_mode: DeploymentMode, db: int) -> None:
+        """Log warning if db parameter is set in cluster mode."""
+        if deployment_mode == DeploymentMode.CLUSTER and db != 0:
+            structlogger.warning(
+                "redis_connection_factory.cluster_db_ignored",
+                event_info=f"Database parameter 'db={db}' ignored in cluster mode. "
+                "Redis Cluster only supports database 0.",
+            )