rasa-pro 3.9.18__py3-none-any.whl

rasa/core/channels/socketio.py

@@ -0,0 +1,274 @@
+import inspect
+import logging
+import uuid
+import json
+from typing import Any, Awaitable, Callable, Dict, Iterable, List, Optional, Text
+
+import rasa.core.channels.channel
+from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
+import rasa.shared.utils.io
+from sanic import Blueprint, response, Sanic
+from sanic.request import Request
+from sanic.response import HTTPResponse
+from socketio import AsyncServer
+
+logger = logging.getLogger(__name__)
+
+
+class SocketBlueprint(Blueprint):
+    """Blueprint for socketio connections."""
+
+    def __init__(
+        self, sio: AsyncServer, socketio_path: Text, *args: Any, **kwargs: Any
+    ) -> None:
+        """Creates a :class:`sanic.Blueprint` for routing socketio connenctions.
+
+        :param sio: Instance of :class:`socketio.AsyncServer` class
+        :param socketio_path: string indicating the route to accept requests on.
+        """
+        super().__init__(*args, **kwargs)
+        self.ctx.sio = sio
+        self.ctx.socketio_path = socketio_path
+
+    def register(self, app: Sanic, options: Dict[Text, Any]) -> None:
+        """Attach the Socket.IO webserver to the given Sanic instance.
+
+        :param app: Instance of :class:`sanic.app.Sanic` class
+        :param options: Options to be used while registering the
+            blueprint into the app.
+        """
+        self.ctx.sio.attach(app, self.ctx.socketio_path)
+        super().register(app, options)
+
+
+class SocketIOOutput(OutputChannel):
+    @classmethod
+    def name(cls) -> Text:
+        return "socketio"
+
+    def __init__(self, sio: AsyncServer, bot_message_evt: Text) -> None:
+        self.sio = sio
+        self.bot_message_evt = bot_message_evt
+
+    async def _send_message(self, socket_id: Text, response: Any) -> None:
+        """Sends a message to the recipient using the bot event."""
+        await self.sio.emit(self.bot_message_evt, response, room=socket_id)
+
+    async def send_text_message(
+        self, recipient_id: Text, text: Text, **kwargs: Any
+    ) -> None:
+        """Send a message through this channel."""
+        for message_part in text.strip().split("\n\n"):
+            await self._send_message(recipient_id, {"text": message_part})
+
+    async def send_image_url(
+        self, recipient_id: Text, image: Text, **kwargs: Any
+    ) -> None:
+        """Sends an image to the output."""
+        message = {"attachment": {"type": "image", "payload": {"src": image}}}
+        await self._send_message(recipient_id, message)
+
+    async def send_text_with_buttons(
+        self,
+        recipient_id: Text,
+        text: Text,
+        buttons: List[Dict[Text, Any]],
+        **kwargs: Any,
+    ) -> None:
+        """Sends buttons to the output."""
+        # split text and create a message for each text fragment
+        # the `or` makes sure there is at least one message we can attach the quick
+        # replies to
+        message_parts = text.strip().split("\n\n") or [text]
+        messages: List[Dict[Text, Any]] = [
+            {"text": message, "quick_replies": []} for message in message_parts
+        ]
+
+        # attach all buttons to the last text fragment
+        messages[-1]["quick_replies"] = [
+            {
+                "content_type": "text",
+                "title": button["title"],
+                "payload": button.get("payload", button["title"]),
+            }
+            for button in buttons
+        ]
+
+        for message in messages:
+            await self._send_message(recipient_id, message)
+
+    async def send_elements(
+        self, recipient_id: Text, elements: Iterable[Dict[Text, Any]], **kwargs: Any
+    ) -> None:
+        """Sends elements to the output."""
+        for element in elements:
+            message = {
+                "attachment": {
+                    "type": "template",
+                    "payload": {"template_type": "generic", "elements": element},
+                }
+            }
+
+            await self._send_message(recipient_id, message)
+
+    async def send_custom_json(
+        self, recipient_id: Text, json_message: Dict[Text, Any], **kwargs: Any
+    ) -> None:
+        """Sends custom json to the output."""
+        if "data" in json_message:
+            json_message.setdefault("room", recipient_id)
+            await self.sio.emit(self.bot_message_evt, **json_message)
+        else:
+            await self.sio.emit(self.bot_message_evt, json_message, room=recipient_id)
+
+    async def send_attachment(  # type: ignore[override]
+        self, recipient_id: Text, attachment: Dict[Text, Any], **kwargs: Any
+    ) -> None:
+        """Sends an attachment to the user."""
+        await self._send_message(recipient_id, {"attachment": attachment})
+
+
+class SocketIOInput(InputChannel):
+    """A socket.io input channel."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "socketio"
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
+        credentials = credentials or {}
+        return cls(
+            credentials.get("user_message_evt", "user_uttered"),
+            credentials.get("bot_message_evt", "bot_uttered"),
+            credentials.get("namespace"),
+            credentials.get("session_persistence", False),
+            credentials.get("socketio_path", "/socket.io"),
+            credentials.get("jwt_key"),
+            credentials.get("jwt_method", "HS256"),
+            credentials.get("metadata_key", "metadata"),
+        )
+
+    def __init__(
+        self,
+        user_message_evt: Text = "user_uttered",
+        bot_message_evt: Text = "bot_uttered",
+        namespace: Optional[Text] = None,
+        session_persistence: bool = False,
+        socketio_path: Optional[Text] = "/socket.io",
+        jwt_key: Optional[Text] = None,
+        jwt_method: Optional[Text] = "HS256",
+        metadata_key: Optional[Text] = "metadata",
+    ):
+        """Creates a ``SocketIOInput`` object."""
+        self.bot_message_evt = bot_message_evt
+        self.session_persistence = session_persistence
+        self.user_message_evt = user_message_evt
+        self.namespace = namespace
+        self.socketio_path = socketio_path
+        self.sio: Optional[AsyncServer] = None
+        self.metadata_key = metadata_key
+
+        self.jwt_key = jwt_key
+        self.jwt_algorithm = jwt_method
+
+    def get_output_channel(self) -> Optional["OutputChannel"]:
+        """Creates socket.io output channel object."""
+        if self.sio is None:
+            rasa.shared.utils.io.raise_warning(
+                "SocketIO output channel cannot be recreated. "
+                "This is expected behavior when using multiple Sanic "
+                "workers or multiple Rasa Pro instances. "
+                "Please use a different channel for external events in these "
+                "scenarios."
+            )
+            return None
+        return SocketIOOutput(self.sio, self.bot_message_evt)
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> Blueprint:
+        """Defines a Sanic blueprint."""
+        # Workaround so that socketio works with requests from other origins.
+        # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183
+        sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
+        socketio_webhook = SocketBlueprint(
+            sio, self.socketio_path, "socketio_webhook", __name__
+        )
+
+        # make sio object static to use in get_output_channel
+        self.sio = sio
+
+        @socketio_webhook.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @sio.on("connect", namespace=self.namespace)
+        async def connect(sid: Text, environ: Dict, auth: Optional[Dict]) -> bool:
+            if self.jwt_key:
+                jwt_payload = None
+                if auth and auth.get("token"):
+                    jwt_payload = rasa.core.channels.channel.decode_bearer_token(
+                        auth.get("token"), self.jwt_key, self.jwt_algorithm
+                    )
+
+                if jwt_payload:
+                    logger.debug(f"User {sid} connected to socketIO endpoint.")
+                    return True
+                else:
+                    return False
+            else:
+                logger.debug(f"User {sid} connected to socketIO endpoint.")
+                return True
+
+        @sio.on("disconnect", namespace=self.namespace)
+        async def disconnect(sid: Text) -> None:
+            logger.debug(f"User {sid} disconnected from socketIO endpoint.")
+
+        @sio.on("session_request", namespace=self.namespace)
+        async def session_request(sid: Text, data: Optional[Dict]) -> None:
+            if data is None:
+                data = {}
+            if "session_id" not in data or data["session_id"] is None:
+                data["session_id"] = uuid.uuid4().hex
+            if self.session_persistence:
+                if inspect.iscoroutinefunction(sio.enter_room):
+                    await sio.enter_room(sid, data["session_id"])
+                else:
+                    # for backwards compatibility with python-socketio < 5.10.
+                    # previously, this function was NOT async.
+                    sio.enter_room(sid, data["session_id"])
+            await sio.emit("session_confirm", data["session_id"], room=sid)
+            logger.debug(f"User {sid} connected to socketIO endpoint.")
+
+        @sio.on(self.user_message_evt, namespace=self.namespace)
+        async def handle_message(sid: Text, data: Dict) -> None:
+            output_channel = SocketIOOutput(sio, self.bot_message_evt)
+
+            if self.session_persistence:
+                if not data.get("session_id"):
+                    rasa.shared.utils.io.raise_warning(
+                        "A message without a valid session_id "
+                        "was received. This message will be "
+                        "ignored. Make sure to set a proper "
+                        "session id using the "
+                        "`session_request` socketIO event."
+                    )
+                    return
+                sender_id = data["session_id"]
+            else:
+                sender_id = sid
+
+            metadata = data.get(self.metadata_key, {})
+            if isinstance(metadata, Text):
+                metadata = json.loads(metadata)
+            message = UserMessage(
+                data.get("message", ""),
+                output_channel,
+                sender_id,
+                input_channel=self.name(),
+                metadata=metadata,
+            )
+            await on_new_message(message)
+
+        return socketio_webhook

rasa/core/channels/telegram.py

@@ -0,0 +1,298 @@
+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 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.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__)
+
+
+class TelegramOutput(Bot, OutputChannel):
+    """Output channel for Telegram."""
+
+    # skipcq: PYL-W0236
+    @classmethod
+    def name(cls) -> Text:
+        return "telegram"
+
+    def __init__(self, access_token: Optional[Text]) -> None:
+        super().__init__(access_token)
+
+    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)
+
+    async def send_image_url(
+        self, recipient_id: Text, image: Text, **kwargs: Any
+    ) -> None:
+        """Sends an image."""
+        await self.send_photo(recipient_id, image)
+
+    async def send_text_with_buttons(
+        self,
+        recipient_id: Text,
+        text: Text,
+        buttons: List[Dict[Text, Any]],
+        button_type: Optional[Text] = "inline",
+        **kwargs: Any,
+    ) -> None:
+        """Sends a message with keyboard.
+
+        For more information: https://core.telegram.org/bots#keyboards
+
+        :button_type inline: horizontal inline keyboard
+
+        :button_type vertical: vertical inline keyboard
+
+        :button_type reply: reply keyboard
+        """
+        if button_type == "inline":
+            reply_markup = InlineKeyboardMarkup()
+            button_list = [
+                InlineKeyboardButton(s["title"], callback_data=s["payload"])
+                for s in buttons
+            ]
+            reply_markup.row(*button_list)
+
+        elif button_type == "vertical":
+            reply_markup = InlineKeyboardMarkup()
+            [
+                reply_markup.row(
+                    InlineKeyboardButton(s["title"], callback_data=s["payload"])
+                )
+                for s in buttons
+            ]
+
+        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")]
+            for idx, button in enumerate(buttons):
+                if isinstance(button, list):
+                    reply_markup.add(KeyboardButton(s["title"]) for s in button)
+                else:
+                    reply_markup.add(KeyboardButton(button["title"]))
+        else:
+            logger.error(
+                "Trying to send text with buttons for unknown button type {}".format(
+                    button_type
+                )
+            )
+            return
+
+        await self.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
+    ) -> None:
+        """Sends a message with a custom json payload."""
+        json_message = deepcopy(json_message)
+
+        recipient_id = json_message.pop("chat_id", recipient_id)
+
+        send_functions = {
+            ("text",): "send_message",
+            ("photo",): "send_photo",
+            ("audio",): "send_audio",
+            ("document",): "send_document",
+            ("sticker",): "send_sticker",
+            ("video",): "send_video",
+            ("video_note",): "send_video_note",
+            ("animation",): "send_animation",
+            ("voice",): "send_voice",
+            ("media",): "send_media_group",
+            ("latitude", "longitude", "title", "address"): "send_venue",
+            ("latitude", "longitude"): "send_location",
+            ("phone_number", "first_name"): "send_contact",
+            ("game_short_name",): "send_game",
+            ("action",): "send_chat_action",
+            (
+                "title",
+                "decription",
+                "payload",
+                "provider_token",
+                "start_parameter",
+                "currency",
+                "prices",
+            ): "send_invoice",
+        }
+
+        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])
+                await api_call(recipient_id, *args, **json_message)
+
+
+class TelegramInput(InputChannel):
+    """Telegram input channel."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "telegram"
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
+        if not credentials:
+            cls.raise_missing_credentials_exception()
+
+        return cls(
+            credentials.get("access_token"),
+            credentials.get("verify"),
+            credentials.get("webhook_url"),
+        )
+
+    def __init__(
+        self,
+        access_token: Optional[Text],
+        verify: Optional[Text],
+        webhook_url: Optional[Text],
+        debug_mode: bool = True,
+    ) -> None:
+        self.access_token = access_token
+        self.verify = verify
+        self.webhook_url = webhook_url
+        self.debug_mode = debug_mode
+
+    @staticmethod
+    def _is_location(message: Message) -> bool:
+        return message.location is not None
+
+    @staticmethod
+    def _is_user_message(message: Message) -> bool:
+        return message.text is not None
+
+    @staticmethod
+    def _is_edited_message(message: Update) -> bool:
+        return message.edited_message is not None
+
+    @staticmethod
+    def _is_button(message: Update) -> bool:
+        return message.callback_query is not None
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> Blueprint:
+        telegram_webhook = Blueprint("telegram_webhook", __name__)
+        out_channel = self.get_output_channel()
+
+        @telegram_webhook.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @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")
+
+        @telegram_webhook.route("/webhook", methods=["GET", "POST"])
+        async def message(request: Request) -> Any:
+            if request.method == "POST":
+                request_dict = request.json
+                if isinstance(request_dict, Text):
+                    request_dict = json.loads(request_dict)
+                update = Update(**request_dict)
+                credentials = await out_channel.get_me()
+                if not credentials.username == self.verify:
+                    logger.debug("Invalid access token, check it matches Telegram")
+                    return response.text("failed")
+
+                if self._is_button(update):
+                    msg = update.callback_query.message
+                    text = update.callback_query.data
+                elif self._is_edited_message(update):
+                    msg = update.edited_message
+                    text = update.edited_message.text
+                else:
+                    msg = update.message
+                    if self._is_user_message(msg):
+                        text = msg.text.replace("/bot", "")
+                    elif self._is_location(msg):
+                        text = '{{"lng":{0}, "lat":{1}}}'.format(
+                            msg.location.longitude, msg.location.latitude
+                        )
+                    else:
+                        return response.text("success")
+                sender_id = msg.chat.id
+                metadata = self.get_metadata(request)
+                try:
+                    if text == (INTENT_MESSAGE_PREFIX + USER_INTENT_RESTART):
+                        await on_new_message(
+                            UserMessage(
+                                text,
+                                out_channel,
+                                sender_id,
+                                input_channel=self.name(),
+                                metadata=metadata,
+                            )
+                        )
+                        await on_new_message(
+                            UserMessage(
+                                "/start",
+                                out_channel,
+                                sender_id,
+                                input_channel=self.name(),
+                                metadata=metadata,
+                            )
+                        )
+                    else:
+                        await on_new_message(
+                            UserMessage(
+                                text,
+                                out_channel,
+                                sender_id,
+                                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
+
+                return response.text("success")
+
+        return telegram_webhook
+
+    def get_output_channel(self) -> TelegramOutput:
+        """Loads the telegram channel."""
+        channel = TelegramOutput(self.access_token)
+
+        try:
+            asyncio.run(channel.set_webhook(url=self.webhook_url))
+        except TelegramAPIError as error:
+            raise RasaException(
+                "Failed to set channel webhook: " + str(error)
+            ) from error
+
+        return channel