rasa-pro 3.14.0.dev9__py3-none-any.whl → 3.14.0.dev11__py3-none-any.whl

rasa/core/channels/__init__.py

@@ -1,5 +1,5 @@
 # ruff: noqa: I001
-from typing import Text, Dict, List, Type
+from typing import Text, Dict, List, Type, Optional
 
 from rasa.core.channels.channel import (  # noqa: F401
     InputChannel,
@@ -15,54 +15,101 @@ from rasa.core.channels.socketio import SocketIOInput
 from rasa.core.channels.botframework import BotFrameworkInput
 from rasa.core.channels.callback import CallbackInput
 from rasa.core.channels.console import CmdlineInput
-from rasa.core.channels.facebook import FacebookInput
 from rasa.core.channels.mattermost import MattermostInput
 from rasa.core.channels.rasa_chat import RasaChatInput
 from rasa.core.channels.rest import RestInput
 from rasa.core.channels.rocketchat import RocketChatInput
-from rasa.core.channels.slack import SlackInput
-from rasa.core.channels.telegram import TelegramInput
-from rasa.core.channels.twilio import TwilioInput
-from rasa.core.channels.voice_ready.twilio_voice import TwilioVoiceInput
 from rasa.core.channels.voice_ready.jambonz import JambonzVoiceReadyInput
 from rasa.core.channels.voice_ready.audiocodes import AudiocodesInput
 from rasa.core.channels.voice_stream.browser_audio import BrowserAudioInputChannel
-from rasa.core.channels.webexteams import WebexTeamsInput
 from rasa.core.channels.hangouts import HangoutsInput
-from rasa.core.channels.vier_cvg import CVGInput
-from rasa.core.channels.voice_stream.twilio_media_streams import (
-    TwilioMediaStreamsInputChannel,
-)
 from rasa.core.channels.voice_stream.genesys import GenesysInputChannel
 from rasa.core.channels.studio_chat import StudioChatInput
 from rasa.core.channels.voice_stream.audiocodes import AudiocodesVoiceInputChannel
 from rasa.core.channels.voice_stream.jambonz import JambonzStreamInputChannel
 
+# Type annotations for channels with optional dependencies
+FacebookInput: Optional[Type[InputChannel]]
+SlackInput: Optional[Type[InputChannel]]
+TelegramInput: Optional[Type[InputChannel]]
+TwilioInput: Optional[Type[InputChannel]]
+TwilioVoiceInput: Optional[Type[InputChannel]]
+TwilioMediaStreamsInputChannel: Optional[Type[InputChannel]]
+WebexTeamsInput: Optional[Type[InputChannel]]
+CVGInput: Optional[Type[InputChannel]]
+
+# Channels with optional dependencies - import with try-except
+try:
+    from rasa.core.channels.facebook import FacebookInput
+except ImportError:
+    FacebookInput = None
+
+try:
+    from rasa.core.channels.slack import SlackInput
+except ImportError:
+    SlackInput = None
+
+try:
+    from rasa.core.channels.telegram import TelegramInput
+except ImportError:
+    TelegramInput = None
+
+try:
+    from rasa.core.channels.twilio import TwilioInput
+except ImportError:
+    TwilioInput = None
+
+try:
+    from rasa.core.channels.voice_ready.twilio_voice import TwilioVoiceInput
+except ImportError:
+    TwilioVoiceInput = None
+
+try:
+    from rasa.core.channels.voice_stream.twilio_media_streams import (
+        TwilioMediaStreamsInputChannel,
+    )
+except ImportError:
+    TwilioMediaStreamsInputChannel = None
+
+try:
+    from rasa.core.channels.webexteams import WebexTeamsInput
+except ImportError:
+    WebexTeamsInput = None
+
+try:
+    from rasa.core.channels.vier_cvg import CVGInput
+except ImportError:
+    CVGInput = None
+
 input_channel_classes: List[Type[InputChannel]] = [
-    CmdlineInput,
-    FacebookInput,
-    SlackInput,
-    TelegramInput,
-    MattermostInput,
-    TwilioInput,
-    TwilioVoiceInput,
-    RasaChatInput,
-    BotFrameworkInput,
-    RocketChatInput,
-    CallbackInput,
-    RestInput,
-    SocketIOInput,
-    WebexTeamsInput,
-    HangoutsInput,
-    AudiocodesInput,
-    CVGInput,
-    JambonzVoiceReadyInput,
-    TwilioMediaStreamsInputChannel,
-    BrowserAudioInputChannel,
-    GenesysInputChannel,
-    StudioChatInput,
-    AudiocodesVoiceInputChannel,
-    JambonzStreamInputChannel,
+    c
+    for c in [
+        CmdlineInput,
+        FacebookInput,
+        SlackInput,
+        TelegramInput,
+        MattermostInput,
+        TwilioInput,
+        TwilioVoiceInput,
+        RasaChatInput,
+        BotFrameworkInput,
+        RocketChatInput,
+        CallbackInput,
+        RestInput,
+        SocketIOInput,
+        WebexTeamsInput,
+        HangoutsInput,
+        AudiocodesInput,
+        CVGInput,
+        JambonzVoiceReadyInput,
+        TwilioMediaStreamsInputChannel,
+        BrowserAudioInputChannel,
+        GenesysInputChannel,
+        StudioChatInput,
+        AudiocodesVoiceInputChannel,
+        JambonzStreamInputChannel,
+    ]
+    if c is not None
 ]
 
 # Mapping from an input channel name to its class to allow name based lookup.

rasa/core/channels/inspector/README.md

@@ -1,4 +1,4 @@
-nu# Rasa Inspector
+# Rasa Inspector
 
 A rapid prototyping tool for enterprise developer personas working in Rasa Pro built with React + Typescript + Vite.
 

rasa/core/channels/telegram.py

@@ -4,6 +4,9 @@ import typing
 from copy import deepcopy
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
 
+# Import aiogram at module level to raise error if not installed
+from aiogram import Bot
+from aiogram.types import Message, Update
 from sanic import Blueprint, response
 from sanic.request import Request
 from sanic.response import HTTPResponse
@@ -28,15 +31,7 @@ class TelegramOutput(OutputChannel):
         return "telegram"
 
     def __init__(self, access_token: Optional[Text]) -> None:
-        try:
-            from aiogram import Bot
-
-            self.bot = Bot(access_token)
-        except ImportError:
-            raise ImportError(
-                "To use the Telegram channel, please install the aiogram package "
-                "with 'pip install aiogram'"
-            )
+        self.bot = Bot(access_token)
 
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -14,6 +14,9 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
+# Import twilio at module level to raise error if not installed
+from twilio.twiml.voice_response import VoiceResponse
+
 from rasa.core.channels import UserMessage
 from rasa.core.channels.channel import (
     create_auth_requested_response_provider,
@@ -145,7 +148,8 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         """Get the sender ID for the channel.
 
         Twilio Media Streams uses the Stream ID as Sender ID because
-        it is required in OutputChannel.send_text_message to send messages."""
+        it is required in OutputChannel.send_text_message to send messages.
+        """
         return call_parameters.stream_id  # type: ignore[return-value]
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:

rasa/core/concurrent_lock_store.py

@@ -4,6 +4,7 @@ from collections import deque
 from typing import Deque, Optional, Text
 
 import structlog
+from pydantic import ValidationError
 
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
@@ -12,6 +13,12 @@ from rasa.core.lock_store import (
     LockError,
     LockStore,
 )
+from rasa.core.redis_connection_factory import (
+    DeploymentMode,
+    RedisConfig,
+    RedisConnectionFactory,
+)
+from rasa.shared.exceptions import RasaException
 from rasa.utils.endpoints import EndpointConfig
 
 DEFAULT_REDIS_DB = 1
@@ -74,9 +81,10 @@ class ConcurrentRedisLockStore(LockStore):
                 alphanumeric.
             socket_timeout - Timeout in seconds after which an exception will be raised
                 in case Redis doesn't respond within `socket_timeout` seconds.
+            deployment_mode - Redis deployment mode: standard, cluster, or sentinel.
+            endpoints - List of endpoints for cluster/sentinel mode in host:port format.
+            sentinel_service - Sentinel service name.
         """
-        import redis
-
         host = endpoint_config.kwargs.get("host", DEFAULT_HOSTNAME)
         port = endpoint_config.kwargs.get("port", DEFAULT_PORT)
         db = endpoint_config.kwargs.get("db", DEFAULT_REDIS_DB)
@@ -90,20 +98,33 @@ class ConcurrentRedisLockStore(LockStore):
         socket_timeout = endpoint_config.kwargs.get(
             "socket_timeout", DEFAULT_SOCKET_TIMEOUT_IN_SECONDS
         )
-
-        self.red = redis.StrictRedis(
-            host=host,
-            port=int(port),
-            db=int(db),
-            username=username,
-            password=password,
-            ssl=use_ssl,
-            ssl_certfile=ssl_certfile,
-            ssl_keyfile=ssl_keyfile,
-            ssl_ca_certs=ssl_ca_certs,
-            socket_timeout=socket_timeout,
+        deployment_mode = endpoint_config.kwargs.get(
+            "deployment_mode", DeploymentMode.STANDARD.value
         )
+        endpoints = endpoint_config.kwargs.get("endpoints", [])
+        sentinel_service = endpoint_config.kwargs.get("sentinel_service")
 
+        try:
+            redis_config = RedisConfig(
+                host=host,
+                port=port,
+                db=db,
+                username=username,
+                password=password,
+                use_ssl=use_ssl,
+                ssl_certfile=ssl_certfile,
+                ssl_keyfile=ssl_keyfile,
+                ssl_ca_certs=ssl_ca_certs,
+                socket_timeout=socket_timeout,
+                deployment_mode=deployment_mode,
+                endpoints=endpoints,
+                sentinel_service=sentinel_service,
+            )
+            self.red = RedisConnectionFactory.create_connection(redis_config)
+        except ValidationError as e:
+            raise RasaException(f"Invalid Redis configuration: {e}")
+
+        self.deployment_mode = deployment_mode
         self.key_prefix = DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
         if key_prefix:
             structlogger.debug(
@@ -129,6 +150,32 @@ class ConcurrentRedisLockStore(LockStore):
                 ),
             )
 
+    def _get_keys_by_pattern(self, pattern: Text) -> list:
+        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
+        if self.deployment_mode == DeploymentMode.CLUSTER.value:
+            # In cluster mode, use SCAN to get keys more reliably
+            keys = []
+            cursor = 0
+
+            while True:
+                try:
+                    cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
+                    keys.extend(batch_keys)
+                    if cursor == 0:
+                        break
+                except Exception as e:
+                    structlogger.warning(
+                        "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
+                        event_info=f"SCAN interrupted in cluster mode: {e}. "
+                        f"Returning {len(keys)} keys found so far.",
+                    )
+                    break
+        else:
+            # Standard and sentinel modes use KEYS
+            keys = self.red.keys(pattern)
+
+        return keys
+
     def issue_ticket(
         self, conversation_id: Text, lock_lifetime: float = LOCK_LIFETIME
     ) -> int:
@@ -157,11 +204,14 @@ class ConcurrentRedisLockStore(LockStore):
         tickets: Deque[Ticket] = deque()
 
         pattern = self.key_prefix + conversation_id + ":" + "[0-9]*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         for key in redis_keys:
             serialised_ticket = self.red.get(key)
             if serialised_ticket:
+                # Handle bytes to string conversion for JSON parsing
+                if isinstance(serialised_ticket, bytes):
+                    serialised_ticket = serialised_ticket.decode("utf-8")
                 ticket = Ticket.from_dict(json.loads(serialised_ticket))
                 tickets.appendleft(ticket)
 
@@ -172,7 +222,7 @@ class ConcurrentRedisLockStore(LockStore):
     def delete_lock(self, conversation_id: Text) -> None:
         """Deletes lock for conversation ID."""
         pattern = self.key_prefix + conversation_id + ":*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         if not redis_keys:
             structlogger.debug(

rasa/core/iam_credentials_providers/aws_iam_credentials_providers.py

@@ -1,7 +1,11 @@
+import os
+import threading
+import time
 from typing import Optional
 
 import boto3
 import structlog
+from aws_msk_iam_sasl_signer import MSKAuthTokenProvider
 from botocore.exceptions import BotoCoreError
 
 from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
@@ -10,6 +14,7 @@ from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
     SupportedServiceType,
     TemporaryCredentials,
 )
+from rasa.shared.exceptions import ConnectionException
 
 structlogger = structlog.get_logger(__name__)
 
@@ -17,7 +22,7 @@ structlogger = structlog.get_logger(__name__)
 class AWSRDSIAMCredentialsProvider(IAMCredentialsProvider):
     """Generates temporary credentials for AWS RDS using IAM roles."""
 
-    def __init__(self, username: str, host: str, port: int):
+    def __init__(self, username: str, host: str, port: int) -> None:
         """Initializes the provider."""
         self.username = username
         self.host = host
@@ -52,6 +57,73 @@ class AWSRDSIAMCredentialsProvider(IAMCredentialsProvider):
             return TemporaryCredentials(auth_token=None)
 
 
+class AWSMSKafkaIAMCredentialsProvider(IAMCredentialsProvider):
+    """Generates temporary credentials for AWS MSK using IAM roles."""
+
+    def __init__(self) -> None:
+        self.region = os.getenv("AWS_DEFAULT_REGION", os.getenv("AWS_REGION"))
+        self._token: Optional[str] = None
+        self._expires_at: float = 0
+        self.refresh_margin_seconds = 60  # Refresh 60 seconds before expiry
+        # ensure thread safety when refreshing token because the
+        # kafka client library we use (confluent-kafka) is multithreaded
+        self.lock = threading.Lock()
+
+    @property
+    def token(self) -> Optional[str]:
+        return self._token
+
+    @token.setter
+    def token(self, value: str) -> None:
+        self._token = value
+
+    @property
+    def expires_at(self) -> float:
+        return self._expires_at
+
+    @expires_at.setter
+    def expires_at(self, value: float) -> None:
+        self._expires_at = value
+
+    def get_credentials(self) -> TemporaryCredentials:
+        """Generates temporary credentials for AWS MSK."""
+        with self.lock:
+            current_time = time.time()  # Current time in seconds
+            if (
+                not self.token
+                or current_time >= self.expires_at - self.refresh_margin_seconds
+            ):
+                try:
+                    auth_token, expiry_ms = MSKAuthTokenProvider.generate_auth_token(
+                        self.region
+                    )
+                    structlogger.debug(
+                        "rasa.core.aws_msk_iam_credentials_provider.get_credentials",
+                        event_info="Successfully generated AWS IAM token for "
+                        "Kafka authentication.",
+                    )
+                    self.token = auth_token
+                    self.expires_at = int(expiry_ms) / 1000  # Convert ms to seconds
+                    return TemporaryCredentials(
+                        auth_token=auth_token,
+                        expiration=self.expires_at,
+                    )
+                except Exception as exc:
+                    raise ConnectionException(
+                        f"Failed to generate AWS IAM token "
+                        f"for MSK authentication. Original exception: {exc}"
+                    ) from exc
+            else:
+                structlogger.debug(
+                    "rasa.core.aws_msk_iam_credentials_provider.get_credentials",
+                    event_info="Using cached AWS IAM token for Kafka authentication.",
+                )
+                return TemporaryCredentials(
+                    auth_token=self.token,
+                    expiration=self.expires_at,
+                )
+
+
 def create_aws_iam_credentials_provider(
     provider_input: "IAMCredentialsProviderInput",
 ) -> Optional["IAMCredentialsProvider"]:
@@ -63,4 +135,7 @@ def create_aws_iam_credentials_provider(
             port=provider_input.port,
         )
 
+    if provider_input.service_name == SupportedServiceType.EVENT_BROKER:
+        return AWSMSKafkaIAMCredentialsProvider()
+
     return None

rasa/core/iam_credentials_providers/credentials_provider_protocol.py

@@ -16,7 +16,7 @@ class TemporaryCredentials(BaseModel):
     """Dataclass storing temporary credentials."""
 
     auth_token: Optional[str] = None
-    expiration: Optional[int] = None
+    expiration: Optional[float] = None
     username: Optional[str] = None
     presigned_url: Optional[str] = None
 

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.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
@@ -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
@@ -298,9 +316,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 +329,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,
+                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 +380,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