rasa-pro 3.12.0.dev1__py3-none-any.whl → 3.12.0.dev3__py3-none-any.whl

rasa/core/channels/telegram.py

@@ -1,23 +1,26 @@
-import asyncio
 import json
 import logging
 from copy import deepcopy
-from sanic import Blueprint, response
-from sanic.request import Request
-from sanic.response import HTTPResponse
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
+
 from aiogram import Bot
+from aiogram.exceptions import TelegramAPIError
 from aiogram.types import (
     InlineKeyboardButton,
-    Update,
-    InlineKeyboardMarkup,
     KeyboardButton,
-    ReplyKeyboardMarkup,
     Message,
+    Update,
 )
-from aiogram.utils.exceptions import TelegramAPIError
-from typing import Dict, Text, Any, List, Optional, Callable, Awaitable
+from aiogram.utils.keyboard import (
+    InlineKeyboardBuilder,
+    KeyboardBuilder,
+    ReplyKeyboardBuilder,
+)
+from sanic import Blueprint, response
+from sanic.request import Request
+from sanic.response import HTTPResponse
 
-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
@@ -68,33 +71,37 @@ class TelegramOutput(Bot, OutputChannel):
         :button_type reply: reply keyboard
         """
         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(
@@ -205,13 +212,14 @@ 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:
@@ -226,24 +234,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 +319,12 @@ 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:
         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,26 +1,26 @@
 import copy
-from datetime import datetime, timezone, timedelta
 import json
 import uuid
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
 from dataclasses import asdict
+from datetime import datetime, timedelta, timezone
+from typing import Any, Awaitable, Callable, Dict, List, Optional, 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()

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()
 

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,

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 (

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

@@ -1,7 +1,8 @@
-from dataclasses import dataclass
-from typing import Any, Dict, Optional
 import json
 import os
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+from urllib.parse import urlencode
 
 import websockets
 from websockets.legacy.client import WebSocketClientProtocol
@@ -19,11 +20,14 @@ from rasa.shared.constants import DEEPGRAM_API_KEY_ENV_VAR
 @dataclass
 class DeepgramASRConfig(ASREngineConfig):
     endpoint: Optional[str] = None
-    # number of miliseconds of silence to determine end of speech
+    # number of milliseconds of silence to determine end of speech
     endpointing: Optional[int] = None
     language: Optional[str] = None
     model: Optional[str] = None
     smart_format: Optional[bool] = None
+    # number of milliseconds of no new transcript to determine end of speech
+    # should be at least 1000 according to docs
+    utterance_end_ms: Optional[int] = None
 
 
 class DeepgramASR(ASREngine[DeepgramASRConfig]):
@@ -37,22 +41,35 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
         """Connect to the ASR system."""
         deepgram_api_key = os.environ[DEEPGRAM_API_KEY_ENV_VAR]
         extra_headers = {"Authorization": f"Token {deepgram_api_key}"}
-        api_url = self._get_api_url()
-        query_params = self._get_query_params()
         return await websockets.connect(  # type: ignore
-            api_url + query_params,
+            self._get_api_url_with_query_params(),
             extra_headers=extra_headers,
         )
 
+    def _get_api_url_with_query_params(self) -> str:
+        """Combine api url and query params."""
+        return self._get_api_url() + self._get_query_params()
+
     def _get_api_url(self) -> str:
+        """Get the api url with the configured endpoint."""
         return f"wss://{self.config.endpoint}/v1/listen?"
 
     def _get_query_params(self) -> str:
-        return (
-            f"encoding=mulaw&sample_rate={HERTZ}&endpointing={self.config.endpointing}"
-            f"&vad_events=true&language={self.config.language}&interim_results=true"
-            f"&model={self.config.model}&smart_format={str(self.config.smart_format).lower()}"
-        )
+        """Get the configured query parameters for the api."""
+        query_params = {
+            "encoding": "mulaw",
+            "sample_rate": HERTZ,
+            "endpointing": self.config.endpointing,
+            "vad_events": "true",
+            "language": self.config.language,
+            "interim_results": "true",
+            "model": self.config.model,
+            "smart_format": str(self.config.smart_format).lower(),
+        }
+        if self.config.utterance_end_ms and self.config.utterance_end_ms > 0:
+            query_params["utterance_end_ms"] = self.config.utterance_end_ms
+
+        return urlencode(query_params)
 
     async def signal_audio_done(self) -> None:
         """Signal to the ASR Api that you are done sending data."""
@@ -67,24 +84,48 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
     def engine_event_to_asr_event(self, e: Any) -> Optional[ASREvent]:
         """Translate an engine event to a common ASREvent."""
         data = json.loads(e)
-        if "is_final" in data:
-            transcript = data["channel"]["alternatives"][0]["transcript"]
+        data_type = data["type"]
+        if data_type == "Results":
+            transcript_data = data["channel"]["alternatives"][0]
+            transcript = transcript_data["transcript"]
             if data["is_final"]:
                 if data.get("speech_final"):
-                    full_transcript = self.accumulated_transcript + transcript
+                    full_transcript = self.concatenate_transcripts(
+                        self.accumulated_transcript, transcript
+                    )
                     self.accumulated_transcript = ""
                     if full_transcript:
                         return NewTranscript(full_transcript)
                 else:
-                    self.accumulated_transcript += transcript
+                    self.accumulated_transcript = self.concatenate_transcripts(
+                        self.accumulated_transcript, transcript
+                    )
             elif transcript:
                 return UserIsSpeaking()
+        # event that comes after utterance_end_ms of no new transcript
+        elif data_type == "UtteranceEnd":
+            if self.accumulated_transcript:
+                transcript = self.accumulated_transcript
+                self.accumulated_transcript = ""
+                return NewTranscript(transcript)
         return None
 
     @staticmethod
     def get_default_config() -> DeepgramASRConfig:
-        return DeepgramASRConfig("api.deepgram.com", 400, "en", "nova-2-general", True)
+        return DeepgramASRConfig(
+            endpoint="api.deepgram.com",
+            endpointing=400,
+            language="en",
+            model="nova-2-general",
+            smart_format=True,
+            utterance_end_ms=1000,
+        )
 
     @classmethod
     def from_config_dict(cls, config: Dict) -> "DeepgramASR":
         return DeepgramASR(DeepgramASRConfig.from_dict(config))
+
+    @staticmethod
+    def concatenate_transcripts(t1: str, t2: str) -> str:
+        """Concatenate two transcripts making sure there is a space between them."""
+        return (t1.strip() + " " + t2.strip()).strip()

rasa/core/channels/voice_stream/browser_audio.py

@@ -1,20 +1,23 @@
 import audioop
 import base64
 import json
-
-import structlog
 import uuid
 from typing import Any, Awaitable, Callable, Optional, Tuple
 
-from sanic import Blueprint, HTTPResponse, Request, response
-from sanic import Websocket  # type: ignore
-
+import structlog
+from sanic import (  # type: ignore[attr-defined]
+    Blueprint,
+    HTTPResponse,
+    Request,
+    Websocket,
+    response,
+)
 
 from rasa.core.channels import UserMessage
 from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.call_state import call_state
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
-from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.voice_channel import (
     ContinueConversationAction,
     EndConversationAction,

rasa/core/channels/voice_stream/call_state.py

@@ -1,9 +1,10 @@
 import asyncio
 from contextvars import ContextVar
-from werkzeug.local import LocalProxy
 from dataclasses import dataclass
 from typing import Optional
 
+from werkzeug.local import LocalProxy
+
 
 # Per voice session data
 # This is similar to how flask makes the "request" object available as a global variable

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

@@ -1,6 +1,6 @@
 import os
-from typing import AsyncIterator, Dict, Optional
 from dataclasses import dataclass
+from typing import AsyncIterator, Dict, Optional
 
 import aiohttp
 import structlog
@@ -15,7 +15,6 @@ from rasa.core.channels.voice_stream.tts.tts_engine import (
 from rasa.shared.constants import AZURE_SPEECH_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
-
 structlogger = structlog.get_logger()
 
 

rasa/core/channels/voice_stream/tts/cartesia.py

@@ -1,16 +1,17 @@
+import os
 from dataclasses import dataclass
 from typing import AsyncIterator, Dict, Optional
-import os
+
 import aiohttp
 import structlog
 from aiohttp import ClientConnectorError, ClientTimeout
 
+from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.core.channels.voice_stream.tts.tts_engine import (
+    TTSEngine,
     TTSEngineConfig,
+    TTSError,
 )
-
-from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
-from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
 from rasa.shared.constants import CARTESIA_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 

rasa/core/channels/voice_stream/tts/tts_cache.py

@@ -1,6 +1,7 @@
-from typing import Optional
-from collections import OrderedDict
 import logging
+from collections import OrderedDict
+from typing import Optional
+
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 
 logger = logging.getLogger(__name__)

rasa/core/channels/voice_stream/tts/tts_engine.py

@@ -1,5 +1,5 @@
-from typing import AsyncIterator, Dict, Generic, Optional, Tuple, Type, TypeVar
 from dataclasses import dataclass
+from typing import AsyncIterator, Dict, Generic, Optional, Tuple, Type, TypeVar
 
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.util import MergeableConfig

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -1,24 +1,27 @@
 import base64
 import json
 import uuid
-
-import structlog
 from typing import Any, Awaitable, Callable, Dict, Optional, Text, Tuple
 
-from sanic import Blueprint, HTTPResponse, Request, response
-from sanic import Websocket  # type: ignore
-
+import structlog
+from sanic import (  # type: ignore[attr-defined]
+    Blueprint,
+    HTTPResponse,
+    Request,
+    Websocket,
+    response,
+)
 
 from rasa.core.channels import UserMessage
 from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.call_state import call_state
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
-from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.voice_channel import (
+    ContinueConversationAction,
     EndConversationAction,
     NewAudioAction,
     VoiceChannelAction,
-    ContinueConversationAction,
     VoiceInputChannel,
     VoiceOutputChannel,
 )

rasa/core/channels/voice_stream/util.py

@@ -1,5 +1,5 @@
-import wave
 import audioop
+import wave
 from dataclasses import asdict, dataclass
 from typing import Optional, Type, TypeVar