rasa-pro 3.11.5__py3-none-any.whl → 3.12.0__py3-none-any.whl

rasa/core/channels/telegram.py

@@ -1,31 +1,25 @@
-import asyncio
 import json
 import logging
+import typing
 from copy import deepcopy
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
+
 from sanic import Blueprint, response
 from sanic.request import Request
 from sanic.response import HTTPResponse
-from aiogram import Bot
-from aiogram.types import (
-    InlineKeyboardButton,
-    Update,
-    InlineKeyboardMarkup,
-    KeyboardButton,
-    ReplyKeyboardMarkup,
-    Message,
-)
-from aiogram.utils.exceptions import TelegramAPIError
-from typing import Dict, Text, Any, List, Optional, Callable, Awaitable
-
-from rasa.core.channels.channel import InputChannel, UserMessage, OutputChannel
+
+from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
 from rasa.shared.constants import INTENT_MESSAGE_PREFIX
 from rasa.shared.core.constants import USER_INTENT_RESTART
 from rasa.shared.exceptions import RasaException
 
 logger = logging.getLogger(__name__)
 
+if typing.TYPE_CHECKING:
+    from aiogram.types import Message, Update
+
 
-class TelegramOutput(Bot, OutputChannel):
+class TelegramOutput(OutputChannel):
     """Output channel for Telegram."""
 
     # skipcq: PYL-W0236
@@ -34,20 +28,28 @@ class TelegramOutput(Bot, OutputChannel):
         return "telegram"
 
     def __init__(self, access_token: Optional[Text]) -> None:
-        Bot.__init__(self, access_token)
+        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'"
+            )
 
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any
     ) -> None:
         """Sends text message."""
         for message_part in text.strip().split("\n\n"):
-            await self.send_message(recipient_id, message_part)
+            await self.bot.send_message(recipient_id, message_part)
 
     async def send_image_url(
         self, recipient_id: Text, image: Text, **kwargs: Any
     ) -> None:
         """Sends an image."""
-        await self.send_photo(recipient_id, image)
+        await self.bot.send_photo(recipient_id, image)
 
     async def send_text_with_buttons(
         self,
@@ -67,34 +69,45 @@ class TelegramOutput(Bot, OutputChannel):
 
         :button_type reply: reply keyboard
         """
+        from aiogram.types import InlineKeyboardButton, KeyboardButton
+        from aiogram.utils.keyboard import (
+            InlineKeyboardBuilder,
+            KeyboardBuilder,
+            ReplyKeyboardBuilder,
+        )
+
         if button_type == "inline":
-            reply_markup = InlineKeyboardMarkup()
+            reply_markup_builder: "KeyboardBuilder" = InlineKeyboardBuilder()
             button_list = [
-                InlineKeyboardButton(s["title"], callback_data=s["payload"])
+                InlineKeyboardButton(text=s["title"], callback_data=s["payload"])
                 for s in buttons
             ]
-            reply_markup.row(*button_list)
+            reply_markup_builder.row(*button_list)
+            reply_markup = reply_markup_builder.as_markup()
 
         elif button_type == "vertical":
-            reply_markup = InlineKeyboardMarkup()
+            reply_markup_builder = InlineKeyboardBuilder()
             [
-                reply_markup.row(
-                    InlineKeyboardButton(s["title"], callback_data=s["payload"])
+                reply_markup_builder.row(
+                    InlineKeyboardButton(text=s["title"], callback_data=s["payload"])
                 )
                 for s in buttons
             ]
+            reply_markup = reply_markup_builder.as_markup()
 
         elif button_type == "reply":
-            reply_markup = ReplyKeyboardMarkup(
-                resize_keyboard=False, one_time_keyboard=True
-            )
-            # drop button_type from button_list
-            button_list = [b for b in buttons if b.get("title")]
+            reply_markup_builder = ReplyKeyboardBuilder()
+
             for idx, button in enumerate(buttons):
                 if isinstance(button, list):
-                    reply_markup.add(KeyboardButton(s["title"]) for s in button)
+                    reply_markup_builder.add(
+                        *[KeyboardButton(text=s["title"]) for s in button]
+                    )
                 else:
-                    reply_markup.add(KeyboardButton(button["title"]))
+                    reply_markup_builder.add(KeyboardButton(text=button["title"]))
+            reply_markup = reply_markup_builder.as_markup(
+                resize_keyboard=False, one_time_keyboard=True
+            )
         else:
             logger.error(
                 "Trying to send text with buttons for unknown button type {}".format(
@@ -103,7 +116,7 @@ class TelegramOutput(Bot, OutputChannel):
             )
             return
 
-        await self.send_message(recipient_id, text, reply_markup=reply_markup)
+        await self.bot.send_message(recipient_id, text, reply_markup=reply_markup)
 
     async def send_custom_json(
         self, recipient_id: Text, json_message: Dict[Text, Any], **kwargs: Any
@@ -143,9 +156,17 @@ class TelegramOutput(Bot, OutputChannel):
         for params in send_functions.keys():
             if all(json_message.get(p) is not None for p in params):
                 args = [json_message.pop(p) for p in params]
-                api_call = getattr(self, send_functions[params])
+                api_call = getattr(self.bot, send_functions[params])
                 await api_call(recipient_id, *args, **json_message)
 
+    async def get_me(self) -> Any:
+        """Get information about the bot itself."""
+        return await self.bot.get_me()
+
+    async def set_webhook(self, url: Text) -> None:
+        """Set the webhook URL for telegram."""
+        await self.bot.set_webhook(url=url)
+
 
 class TelegramInput(InputChannel):
     """Telegram input channel."""
@@ -178,19 +199,19 @@ class TelegramInput(InputChannel):
         self.debug_mode = debug_mode
 
     @staticmethod
-    def _is_location(message: Message) -> bool:
+    def _is_location(message: "Message") -> bool:
         return message.location is not None
 
     @staticmethod
-    def _is_user_message(message: Message) -> bool:
+    def _is_user_message(message: "Message") -> bool:
         return message.text is not None
 
     @staticmethod
-    def _is_edited_message(message: Update) -> bool:
+    def _is_edited_message(message: "Update") -> bool:
         return message.edited_message is not None
 
     @staticmethod
-    def _is_button(message: Update) -> bool:
+    def _is_button(message: "Update") -> bool:
         return message.callback_query is not None
 
     def blueprint(
@@ -205,16 +226,19 @@ class TelegramInput(InputChannel):
 
         @telegram_webhook.route("/set_webhook", methods=["GET", "POST"])
         async def set_webhook(_: Request) -> HTTPResponse:
-            s = await out_channel.set_webhook(self.webhook_url)
-            if s:
-                logger.info("Webhook Setup Successful")
-                return response.text("Webhook setup successful")
-            else:
-                logger.warning("Webhook Setup Failed")
-                return response.text("Invalid webhook")
+            try:
+                await self.set_webhook(out_channel)
+            except RasaException as exc:
+                logger.error(exc)
+                return response.text(str(exc))
+
+            logger.info("Webhook Setup Successful")
+            return response.text("Webhook setup successful")
 
         @telegram_webhook.route("/webhook", methods=["GET", "POST"])
         async def message(request: Request) -> Any:
+            from aiogram.types import Update
+
             if request.method == "POST":
                 request_dict = request.json
                 if isinstance(request_dict, Text):
@@ -226,24 +250,49 @@ class TelegramInput(InputChannel):
                     return response.text("failed")
 
                 if self._is_button(update):
-                    msg = update.callback_query.message
-                    text = update.callback_query.data
+                    msg = (
+                        update.callback_query.message
+                        if update.callback_query is not None
+                        else None
+                    )
+                    text = (
+                        update.callback_query.data
+                        if update.callback_query is not None
+                        else None
+                    )
                 elif self._is_edited_message(update):
                     msg = update.edited_message
-                    text = update.edited_message.text
+                    text = (
+                        update.edited_message.text
+                        if update.edited_message is not None
+                        else None
+                    )
                 else:
                     msg = update.message
                     if self._is_user_message(msg):
-                        text = msg.text.replace("/bot", "")
+                        text = (
+                            msg.text.replace("/bot", "")
+                            if msg is not None and msg.text is not None
+                            else None
+                        )
                     elif self._is_location(msg):
-                        text = '{{"lng":{0}, "lat":{1}}}'.format(
-                            msg.location.longitude, msg.location.latitude
+                        text = (
+                            '{{"lng":{0}, "lat":{1}}}'.format(
+                                msg.location.longitude, msg.location.latitude
+                            )
+                            if msg is not None and msg.location is not None
+                            else None
                         )
                     else:
                         return response.text("success")
-                sender_id = msg.chat.id
+
                 metadata = self.get_metadata(request)
                 try:
+                    if msg is not None:
+                        sender_id = str(msg.chat.id)
+                    else:
+                        raise ValueError("No message found.")
+
                     if text == (INTENT_MESSAGE_PREFIX + USER_INTENT_RESTART):
                         await on_new_message(
                             UserMessage(
@@ -286,13 +335,14 @@ class TelegramInput(InputChannel):
 
     def get_output_channel(self) -> TelegramOutput:
         """Loads the telegram channel."""
-        channel = TelegramOutput(self.access_token)
+        return TelegramOutput(self.access_token)
+
+    async def set_webhook(self, channel: TelegramOutput) -> None:
+        from aiogram.exceptions import TelegramAPIError
 
         try:
-            asyncio.run(channel.set_webhook(url=self.webhook_url))
+            await channel.set_webhook(url=self.webhook_url)
         except TelegramAPIError as error:
             raise RasaException(
                 "Failed to set channel webhook: " + str(error)
             ) from error
-
-        return channel

rasa/core/channels/twilio.py

@@ -1,13 +1,13 @@
 import logging
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Optional, Text
+
 from sanic import Blueprint, response
 from sanic.request import Request
 from sanic.response import HTTPResponse
 from twilio.base.exceptions import TwilioRestException
 from twilio.rest import Client
-from typing import Dict, Text, Any, Callable, Awaitable, Optional, TYPE_CHECKING
 
-from rasa.core.channels.channel import InputChannel
-from rasa.core.channels.channel import UserMessage, OutputChannel
+from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
 
 if TYPE_CHECKING:
     from twilio.rest.api.v2010.account.message import MessageInstance

rasa/core/channels/vier_cvg.py

@@ -8,10 +8,10 @@ from dataclasses import dataclass
 from functools import wraps
 from typing import Any, Awaitable, Callable, Dict, Optional, Text
 
-import rasa.shared.utils.io
 import structlog
-from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
 
+import rasa.shared.utils.io
+from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
 from rasa.utils.beta import ensure_beta_feature_is_enabled
 
 # ignore ResourceWarning, InsecureRequestWarning

rasa/core/channels/voice_ready/audiocodes.py

@@ -1,28 +1,28 @@
 import asyncio
 import copy
-from datetime import datetime, timezone, timedelta
 import json
 import uuid
 from collections import defaultdict
 from dataclasses import asdict
+from datetime import datetime, timedelta, timezone
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Text, Union
 
 import structlog
 from jsonschema import ValidationError, validate
+from sanic import Blueprint, response
+from sanic.exceptions import NotFound, SanicException, ServerError
+from sanic.request import Request
+from sanic.response import HTTPResponse
+
 from rasa.core import jobs
 from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
 from rasa.core.channels.voice_ready.utils import (
-    validate_voice_license_scope,
     CallParameters,
+    validate_voice_license_scope,
 )
 from rasa.shared.constants import INTENT_MESSAGE_PREFIX
 from rasa.shared.core.constants import USER_INTENT_SESSION_START
 from rasa.shared.exceptions import RasaException
-from sanic import Blueprint, response
-from sanic.exceptions import NotFound, SanicException, ServerError
-from sanic.request import Request
-from sanic.response import HTTPResponse
-
 from rasa.utils.io import remove_emojis
 
 structlogger = structlog.get_logger()
@@ -47,8 +47,8 @@ def map_call_params(parameters: Dict[Text, Any]) -> CallParameters:
     """Map the Audiocodes parameters to the CallParameters dataclass."""
     return CallParameters(
         call_id=parameters.get("vaigConversationId"),
-        user_phone=parameters.get("callee"),
-        bot_phone=parameters.get("caller"),
+        user_phone=parameters.get("caller"),
+        bot_phone=parameters.get("callee"),
         user_name=parameters.get("callerDisplayName"),
         user_host=parameters.get("callerHost"),
         bot_host=parameters.get("calleeHost"),

rasa/core/channels/voice_ready/jambonz.py

@@ -1,18 +1,18 @@
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
 
 import structlog
+from sanic import Blueprint, Websocket, response  # type: ignore[attr-defined]
+from sanic.request import Request
+from sanic.response import HTTPResponse
+
 from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
 from rasa.core.channels.voice_ready.jambonz_protocol import (
+    send_ws_hangup_message,
     send_ws_text_message,
     websocket_message_handler,
-    send_ws_hangup_message,
 )
 from rasa.core.channels.voice_ready.utils import validate_voice_license_scope
 from rasa.shared.exceptions import RasaException
-from sanic import Blueprint, response, Websocket  # type: ignore[attr-defined]
-from sanic.request import Request
-from sanic.response import HTTPResponse
-
 from rasa.shared.utils.common import mark_as_beta_feature
 from rasa.utils.io import remove_emojis
 

rasa/core/channels/voice_ready/jambonz_protocol.py

@@ -1,14 +1,13 @@
-from dataclasses import dataclass, field
 import json
 import uuid
+from dataclasses import asdict, dataclass, field
 from typing import Any, Awaitable, Callable, Dict, List, Text
 
 import structlog
-from rasa.core.channels.channel import UserMessage
-from rasa.core.channels.voice_ready.utils import CallParameters
-from dataclasses import asdict
 from sanic import Websocket  # type: ignore[attr-defined]
 
+from rasa.core.channels.channel import UserMessage
+from rasa.core.channels.voice_ready.utils import CallParameters
 
 structlogger = structlog.get_logger()
 

rasa/core/channels/voice_ready/twilio_voice.py

@@ -1,21 +1,22 @@
+from dataclasses import asdict
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
+
+import structlog
 from sanic import Blueprint, response
 from sanic.request import Request, RequestParameters
 from sanic.response import HTTPResponse
-from twilio.twiml.voice_response import VoiceResponse, Gather
-from typing import Text, Callable, Awaitable, List, Any, Dict, Optional
-from dataclasses import asdict
+from twilio.twiml.voice_response import Gather, VoiceResponse
 
-import structlog
-import rasa.utils.io
 import rasa.shared.utils.io
-from rasa.shared.core.events import BotUttered
-from rasa.shared.exceptions import InvalidConfigException
+import rasa.utils.io
 from rasa.core.channels.channel import (
-    InputChannel,
     CollectingOutputChannel,
+    InputChannel,
     UserMessage,
 )
 from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.shared.core.events import BotUttered
+from rasa.shared.exceptions import InvalidConfigException
 
 logger = structlog.get_logger(__name__)
 

rasa/core/channels/voice_ready/utils.py

@@ -1,7 +1,7 @@
-import structlog
 from dataclasses import dataclass
 from typing import Optional
 
+import structlog
 
 structlogger = structlog.get_logger()
 
@@ -29,7 +29,7 @@ class CallParameters:
 
     call_id: str
     user_phone: str
-    bot_phone: str
+    bot_phone: Optional[str] = None
     user_name: Optional[str] = None
     user_host: Optional[str] = None
     bot_host: Optional[str] = None

rasa/core/channels/voice_stream/asr/asr_engine.py

@@ -1,8 +1,8 @@
 from dataclasses import dataclass
 from typing import (
-    Dict,
-    AsyncIterator,
     Any,
+    AsyncIterator,
+    Dict,
     Generic,
     Optional,
     Tuple,
@@ -10,6 +10,7 @@ from typing import (
     TypeVar,
 )
 
+import structlog
 from websockets.legacy.client import WebSocketClientProtocol
 
 from rasa.core.channels.voice_stream.asr.asr_event import ASREvent
@@ -20,6 +21,7 @@ from rasa.shared.utils.common import validate_environment
 
 T = TypeVar("T", bound="ASREngineConfig")
 E = TypeVar("E", bound="ASREngine")
+logger = structlog.get_logger(__name__)
 
 
 @dataclass
@@ -74,10 +76,14 @@ class ASREngine(Generic[T]):
         """Stream the events returned by the ASR system as it is fed audio bytes."""
         if self.asr_socket is None:
             raise ConnectionException("Websocket not connected.")
-        async for message in self.asr_socket:
-            asr_event = self.engine_event_to_asr_event(message)
-            if asr_event:
-                yield asr_event
+
+        try:
+            async for message in self.asr_socket:
+                asr_event = self.engine_event_to_asr_event(message)
+                if asr_event:
+                    yield asr_event
+        except Exception as e:
+            logger.warning(f"Error while streaming ASR events: {e}")
 
     def engine_event_to_asr_event(self, e: Any) -> Optional[ASREvent]:
         """Translate an engine event to a common ASREvent."""

rasa/core/channels/voice_stream/asr/asr_event.py

@@ -16,3 +16,8 @@ class NewTranscript(ASREvent):
 @dataclass
 class UserIsSpeaking(ASREvent):
     pass
+
+
+@dataclass
+class UserSilence(ASREvent):
+    pass

rasa/core/channels/voice_stream/asr/azure.py

@@ -1,7 +1,7 @@
+import asyncio
 import os
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, AsyncIterator
-import asyncio
+from typing import Any, AsyncIterator, Dict, Optional
 
 from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineConfig
 from rasa.core.channels.voice_stream.asr.asr_event import (
@@ -18,6 +18,8 @@ from rasa.shared.exceptions import ConnectionException
 class AzureASRConfig(ASREngineConfig):
     language: Optional[str] = None
     speech_region: Optional[str] = None
+    speech_host: Optional[str] = None
+    speech_endpoint: Optional[str] = None
 
 
 class AzureASR(ASREngine[AzureASRConfig]):
@@ -52,9 +54,18 @@ class AzureASR(ASREngine[AzureASRConfig]):
     async def connect(self) -> None:
         import azure.cognitiveservices.speech as speechsdk
 
+        # connecting to eastus by default
+        if (
+            self.config.speech_region is None
+            and self.config.speech_host is None
+            and self.config.speech_endpoint is None
+        ):
+            self.config.speech_region = "eastus"
         speech_config = speechsdk.SpeechConfig(
             subscription=os.environ[AZURE_SPEECH_API_KEY_ENV_VAR],
             region=self.config.speech_region,
+            endpoint=self.config.speech_endpoint,
+            host=self.config.speech_host,
         )
         audio_format = speechsdk.audio.AudioStreamFormat(
             samples_per_second=HERTZ,
@@ -123,7 +134,9 @@ class AzureASR(ASREngine[AzureASRConfig]):
 
     @staticmethod
     def get_default_config() -> AzureASRConfig:
-        return AzureASRConfig("en-US", "germanywestcentral")
+        return AzureASRConfig(
+            language=None, speech_region=None, speech_host=None, speech_endpoint=None
+        )
 
     @classmethod
     def from_config_dict(cls, config: Dict) -> "AzureASR":