rasa-pro 3.9.18__py3-none-any.whl

rasa/core/channels/twilio.py

@@ -0,0 +1,169 @@
+import logging
+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
+
+if TYPE_CHECKING:
+    from twilio.rest.api.v2010.account.message import MessageInstance
+
+logger = logging.getLogger(__name__)
+
+
+class TwilioOutput(Client, OutputChannel):
+    """Output channel for Twilio."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "twilio"
+
+    def __init__(
+        self,
+        account_sid: Optional[Text],
+        auth_token: Optional[Text],
+        twilio_number: Optional[Text],
+    ) -> None:
+        super().__init__(account_sid, auth_token)
+        self.twilio_number = twilio_number
+        self.send_retry = 0
+        self.max_retry = 5
+
+    async def _send_message(self, message_data: Dict[Text, Any]) -> "MessageInstance":
+        message = None
+        try:
+            while not message and self.send_retry < self.max_retry:
+                message = self.messages.create(**message_data)
+                self.send_retry += 1
+        except TwilioRestException as e:
+            logger.error("Something went wrong " + repr(e.msg))
+        finally:
+            self.send_retry = 0
+
+        if not message and self.send_retry == self.max_retry:
+            logger.error("Failed to send message. Max number of retires exceeded.")
+
+        return message
+
+    async def send_text_message(
+        self, recipient_id: Text, text: Text, **kwargs: Any
+    ) -> None:
+        """Sends text message."""
+        message_data = {"to": recipient_id, "from_": self.twilio_number}
+        for message_part in text.strip().split("\n\n"):
+            message_data.update({"body": message_part})
+            await self._send_message(message_data)
+
+    async def send_image_url(
+        self, recipient_id: Text, image: Text, **kwargs: Any
+    ) -> None:
+        """Sends an image."""
+        message_data = {
+            "to": recipient_id,
+            "from_": self.twilio_number,
+            "media_url": [image],
+        }
+        await self._send_message(message_data)
+
+    async def send_custom_json(
+        self, recipient_id: Text, json_message: Dict[Text, Any], **kwargs: Any
+    ) -> None:
+        """Send custom json dict."""
+        json_message.setdefault("to", recipient_id)
+        if not json_message.get("media_url"):
+            json_message.setdefault("body", "")
+        if not json_message.get("messaging_service_sid"):
+            json_message.setdefault("from_", self.twilio_number)
+
+        await self._send_message(json_message)
+
+
+class TwilioInput(InputChannel):
+    """Twilio input channel."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "twilio"
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
+        if not credentials:
+            cls.raise_missing_credentials_exception()
+
+        return cls(
+            credentials.get("account_sid"),
+            credentials.get("auth_token"),
+            credentials.get("twilio_number"),
+        )
+
+    @classmethod
+    def _is_location_message(cls, request: Request) -> bool:
+        """Check if the users message is a location."""
+        return request.form.get("Latitude") and request.form.get("Longitude")
+
+    def __init__(
+        self,
+        account_sid: Optional[Text],
+        auth_token: Optional[Text],
+        twilio_number: Optional[Text],
+        debug_mode: bool = True,
+    ) -> None:
+        self.account_sid = account_sid
+        self.auth_token = auth_token
+        self.twilio_number = twilio_number
+        self.debug_mode = debug_mode
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> Blueprint:
+        twilio_webhook = Blueprint("twilio_webhook", __name__)
+
+        @twilio_webhook.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @twilio_webhook.route("/webhook", methods=["POST"])
+        async def message(request: Request) -> HTTPResponse:
+            sender = request.form.get("From", None)
+            text = request.form.get("Body", None)
+            out_channel = self.get_output_channel()
+
+            if self._is_location_message(request):
+                # Text is always None with a location message/media from Twilio whatsapp
+                text = "/locationData{{'Latitude': {lat},'Longitude': {long}}}".format(
+                    lat=request.form.get("Latitude"), long=request.form.get("Longitude")
+                )
+
+            if sender is not None and message is not None:
+                metadata = self.get_metadata(request)
+                try:
+                    # @ signs get corrupted in SMSes by some carriers
+                    text = text.replace("¡", "@")
+                    await on_new_message(
+                        UserMessage(
+                            text,
+                            out_channel,
+                            sender,
+                            input_channel=self.name(),
+                            metadata=metadata,
+                        )
+                    )
+                except Exception as e:
+                    logger.error(f"Exception when trying to handle message.{e}")
+                    logger.debug(e, exc_info=True)
+                    if self.debug_mode:
+                        raise
+                    pass
+            else:
+                logger.debug("Invalid message")
+
+            return response.text("", status=204)
+
+        return twilio_webhook
+
+    def get_output_channel(self) -> OutputChannel:
+        return TwilioOutput(self.account_sid, self.auth_token, self.twilio_number)

rasa/core/channels/twilio_voice.py

@@ -0,0 +1,367 @@
+from sanic import Blueprint, response
+from sanic.request import Request
+from sanic.response import HTTPResponse
+from twilio.twiml.voice_response import VoiceResponse, Gather
+from typing import Text, Callable, Awaitable, List, Any, Dict, Optional
+
+import rasa.utils.io
+import rasa.shared.utils.io
+from rasa.shared.core.events import BotUttered
+from rasa.shared.exceptions import InvalidConfigException
+from rasa.core.channels.channel import (
+    InputChannel,
+    CollectingOutputChannel,
+    UserMessage,
+)
+
+
+class TwilioVoiceInput(InputChannel):
+    """Input channel for Twilio Voice."""
+
+    SUPPORTED_VOICES = [  # noqa: RUF012
+        "man",
+        "woman",
+        "alice",
+        "Polly.Mads",
+        "Polly.Naja",
+        "Polly.Lotte",
+        "Polly.Reuben",
+        "Polly.Nicole",
+        "Polly.Russell",
+        "Polly.Amy",
+        "Polly.Brian",
+        "Polly.Emma",
+        "Polly.Amy-Neural",
+        "Polly.Emma-Neural",
+        "Polly.Brian-Neural",
+        "Polly.Raveena",
+        "Polly.Ivy",
+        "Polly.Joanna",
+        "Polly.Joey",
+        "Polly.Justin",
+        "Polly.Kendra",
+        "Polly.Kimberly",
+        "Polly.Matthew",
+        "Polly.Salli",
+        "Polly.Ivy-Neural",
+        "Polly.Joanna-Neural",
+        "Polly.Kendra-Neural",
+        "Polly.Kimberly-Neural",
+        "Polly.Sally-Neural",
+        "Polly.Joey-Neural",
+        "Polly.Justin-Neural",
+        "Polly.Matthew-Neural",
+        "Polly.Geraint",
+        "Polly.Celine",
+        "Polly.Mathieu",
+        "Polly.Chantal",
+        "Polly.Hans",
+        "Polly.Marlene",
+        "Polly.Vicki",
+        "Polly.Dora",
+        "Polly.Karl",
+        "Polly.Carla",
+        "Polly.Giorgio",
+        "Polly.Mizuki",
+        "Polly.Takumi",
+        "Polly.Liv",
+        "Polly.Jacek",
+        "Polly.Jan",
+        "Polly.Ewa",
+        "Polly.Maja",
+        "Polly.Ricardo",
+        "Polly.Vitoria",
+        "Polly.Camila-Neural",
+        "Polly.Cristiano",
+        "Polly.Ines",
+        "Polly.Carmen",
+        "Polly.Maxim",
+        "Polly.Tatyana",
+        "Polly.Conchita",
+        "Polly.Enrique",
+        "Polly.Miguel",
+        "Polly.Penelope",
+        "Polly.Lupe-Neural",
+        "Polly.Astrid",
+        "Polly.Filiz",
+        "Polly.Gwyneth",
+        "Polly.Aditi",
+    ]
+
+    SUPPORTED_SPEECH_MODELS = [  # noqa: RUF012
+        "default",
+        "numbers_and_commands",
+        "phone_call",
+    ]
+
+    @classmethod
+    def name(cls) -> Text:
+        """Name of channel."""
+        return "twilio_voice"
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
+        """Load custom configurations."""
+        credentials = credentials or {}
+
+        return cls(
+            credentials.get("initial_prompt", "hello"),
+            credentials.get(
+                "reprompt_fallback_phrase",
+                "I'm sorry I didn't get that could you rephrase.",
+            ),
+            credentials.get("assistant_voice", "woman"),
+            credentials.get("speech_timeout", "5"),
+            credentials.get("speech_model", "default"),
+            credentials.get("enhanced", "false"),
+        )
+
+    def __init__(
+        self,
+        initial_prompt: Optional[Text],
+        reprompt_fallback_phrase: Optional[Text],
+        assistant_voice: Optional[Text],
+        speech_timeout: Text = "5",
+        speech_model: Text = "default",
+        enhanced: Text = "false",
+    ) -> None:
+        """Creates a connection to Twilio voice.
+
+        Args:
+            initial_prompt: text to use to prompt a conversation when call is answered.
+            reprompt_fallback_phrase: phrase to use if no user response.
+            assistant_voice: name of the assistant voice to use.
+            speech_timeout: how long to pause when user finished speaking.
+            speech_model: type of transcription model to use from Twilio.
+            enhanced: toggle to use Twilio's premium speech transcription model.
+        """
+        self.initial_prompt = initial_prompt
+        self.reprompt_fallback_phrase = reprompt_fallback_phrase
+        self.assistant_voice = assistant_voice
+        self.speech_timeout = speech_timeout
+        self.speech_model = speech_model
+        self.enhanced = enhanced
+
+        self._validate_configuration()
+
+    def _validate_configuration(self) -> None:
+        """Checks that the user configurations are valid."""
+        if self.assistant_voice not in self.SUPPORTED_VOICES:
+            self._raise_invalid_voice_exception()
+
+        try:
+            int(self.speech_timeout)
+        except ValueError:
+            if self.speech_timeout.lower() != "auto":
+                self._raise_invalid_speech_timeout_exception()
+
+        if self.speech_model not in self.SUPPORTED_SPEECH_MODELS:
+            self._raise_invalid_speech_model_exception()
+
+        if self.enhanced.lower() not in [
+            "true",
+            "false",
+        ]:
+            self._raise_invalid_enhanced_option_exception()
+
+        if (
+            self.enhanced.lower() == "true"
+            and self.speech_model.lower() != "phone_call"
+        ):
+            self._raise_invalid_enhanced_speech_model_exception()
+
+        if (
+            self.speech_model.lower() != "numbers_and_commands"
+            and self.speech_timeout.lower() == "auto"
+        ):
+            self._raise_invalid_speech_model_timeout_exception()
+
+    def _raise_invalid_speech_model_timeout_exception(self) -> None:
+        """Raises an error if incompatible speech_timeout and speech_model used."""
+        raise InvalidConfigException(
+            "If speech_timeout is 'auto' the speech_model must be "
+            "'numbers_and_commands'. Please update your speech_model "
+            "to be 'numbers_and_commands' if you would like to continue "
+            "using the 'auto' speech_model."
+        )
+
+    def _raise_invalid_enhanced_option_exception(self) -> None:
+        """Raises an error if an invalid value is passed to the enhanced parameter."""
+        raise InvalidConfigException(
+            f"The value {self.enhanced} is invalid for the enhanced parameter. "
+            f"You must provide either `true` or `false` for this value."
+        )
+
+    def _raise_invalid_speech_model_exception(self) -> None:
+        """Raises an error if an invalid speech_model is provided."""
+        raise InvalidConfigException(
+            f"The value {self.speech_model} for speech_model is invalid. "
+            f"You must choose one of 'default', 'numbers_and_commands', "
+            f"or 'phone_call'. Refer to the documentation for details "
+            f"about the selections."
+        )
+
+    def _raise_invalid_speech_timeout_exception(self) -> None:
+        """Raises an error if an invalid speech_timeout is provided."""
+        raise InvalidConfigException(
+            f"The vale {self.speech_timeout} is an invalid value for speech_timeout. "
+            f"Only integers and 'auto' are valid entries."
+        )
+
+    def _raise_invalid_voice_exception(self) -> None:
+        """Raises an error if an invalid voice is provided."""
+        raise InvalidConfigException(
+            f"The value {self.assistant_voice} is an invalid for assistant_voice. "
+            f"Please refer to the documentation for a list of valid voices "
+            f"you can use for your voice assistant."
+        )
+
+    def _raise_invalid_enhanced_speech_model_exception(self) -> None:
+        """Raises error if enhanced is used with an incompatible speech_model."""
+        raise InvalidConfigException(
+            f"If you set enhanced to 'true' then speech_model must be 'phone_call'. "
+            f"Current speech_model is: {self.speech_model}."
+        )
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[None]]
+    ) -> Blueprint:
+        """Defines endpoints for Twilio voice channel."""
+        twilio_voice_webhook = Blueprint("Twilio_voice_webhook", __name__)
+
+        @twilio_voice_webhook.route("/", methods=["GET"])
+        async def health(request: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @twilio_voice_webhook.route("/webhook", methods=["POST"])
+        async def receive(request: Request) -> HTTPResponse:
+            sender_id = request.form.get("From")
+            text = request.form.get("SpeechResult")
+            input_channel = self.name()
+            call_status = request.form.get("CallStatus")
+
+            collector = TwilioVoiceCollectingOutputChannel()
+
+            # Provide an initial greeting to answer the user's call.
+            if (text is None) and (call_status == "ringing"):
+                text = self.initial_prompt
+
+            # determine the response.
+            if text is not None:
+                await on_new_message(
+                    UserMessage(text, collector, sender_id, input_channel=input_channel)
+                )
+
+                twilio_response = self._build_twilio_voice_response(collector.messages)
+            # If the user doesn't respond resend the last message.
+            else:
+                # Get last user utterance from tracker.
+                tracker = await request.app.ctx.agent.tracker_store.retrieve(sender_id)
+                last_response = None
+                if tracker:
+                    last_response = next(
+                        (
+                            e
+                            for e in reversed(tracker.events)
+                            if isinstance(e, BotUttered)
+                        ),
+                        None,
+                    )
+
+                # If no previous utterance found use the reprompt_fallback phrase.
+                if last_response is None:
+                    last_response_text = self.reprompt_fallback_phrase
+                else:
+                    last_response_text = last_response.text
+
+                twilio_response = self._build_twilio_voice_response(
+                    [{"text": last_response_text}]
+                )
+            return response.text(str(twilio_response), content_type="text/xml")
+
+        return twilio_voice_webhook
+
+    def _build_twilio_voice_response(
+        self, messages: List[Dict[Text, Any]]
+    ) -> VoiceResponse:
+        """Builds the Twilio Voice Response object."""
+        voice_response = VoiceResponse()
+        gather = Gather(
+            input="speech",
+            action=f"/webhooks/{self.name()}/webhook",
+            actionOnEmptyResult=True,
+            speechTimeout=self.speech_timeout,
+            speechModel=self.speech_model,
+            enhanced=self.enhanced,
+        )
+
+        # Add pauses between messages.
+        # Add a listener to the last message to listen for user response.
+        for i, message in enumerate(messages):
+            msg_text = message["text"]
+            if i + 1 == len(messages):
+                gather.say(msg_text, voice=self.assistant_voice)
+                voice_response.append(gather)
+            else:
+                voice_response.say(msg_text, voice=self.assistant_voice)
+                voice_response.pause(length=1)
+
+        return voice_response
+
+
+class TwilioVoiceCollectingOutputChannel(CollectingOutputChannel):
+    """Output channel that collects send messages in a list.
+
+    (doesn't send them anywhere, just collects them).
+    """
+
+    @classmethod
+    def name(cls) -> Text:
+        """Name of the output channel."""
+        return "twilio_voice"
+
+    @staticmethod
+    def _emoji_warning(text: Text) -> None:
+        """Raises a warning if text contains an emoji."""
+        emoji_regex = rasa.utils.io.get_emoji_regex()
+        if emoji_regex.findall(text):
+            rasa.shared.utils.io.raise_warning(
+                "Text contains an emoji in a voice response. "
+                "Review responses to provide a voice-friendly alternative."
+            )
+
+    async def send_text_message(
+        self, recipient_id: Text, text: Text, **kwargs: Any
+    ) -> None:
+        """Sends the text message after removing emojis."""
+        self._emoji_warning(text)
+        for message_part in text.strip().split("\n\n"):
+            await self._persist_message(self._message(recipient_id, text=message_part))
+
+    async def send_text_with_buttons(
+        self,
+        recipient_id: Text,
+        text: Text,
+        buttons: List[Dict[Text, Any]],
+        **kwargs: Any,
+    ) -> None:
+        """Convert buttons into a voice representation."""
+        self._emoji_warning(text)
+        await self._persist_message(self._message(recipient_id, text=text))
+
+        for b in buttons:
+            self._emoji_warning(b["title"])
+            await self._persist_message(self._message(recipient_id, text=b["title"]))
+
+    async def send_image_url(
+        self, recipient_id: Text, image: Text, **kwargs: Any
+    ) -> None:
+        """For voice channel do not send images."""
+        rasa.shared.utils.io.raise_warning(
+            "An image was removed from the voice message and "
+            "only the text of message was sent. "
+            "It's recommended that you define voice-friendly "
+            "alternatives for all responses "
+            "with a visual elements such as images and emojis "
+            "that are used in your voice channel."
+        )