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

rasa/core/channels/mattermost.py

@@ -0,0 +1,229 @@
+import json
+
+import logging
+import requests
+from requests import Response
+from sanic import Blueprint, response
+from sanic.request import Request
+from typing import Text, Dict, Any, List, Callable, Awaitable, Optional
+
+from rasa.core.channels.channel import UserMessage, OutputChannel, InputChannel
+from sanic.response import HTTPResponse
+
+logger = logging.getLogger(__name__)
+
+
+class MattermostBot(OutputChannel):
+    """A Mattermost communication channel."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "mattermost"
+
+    @classmethod
+    def token_from_login(cls, url: Text, user: Text, password: Text) -> Optional[Text]:
+        """Retrieve access token for mattermost user."""
+        data = {"login_id": user, "password": password}
+        r = requests.post(url + "/users/login", data=json.dumps(data))
+        if r.status_code == 200:
+            return r.headers["Token"]
+        else:
+            logger.error(f"Failed to login mattermost user {user}. Response: {r}")
+            return None
+
+    def __init__(
+        self, url: Text, token: Text, bot_channel: Text, webhook_url: Optional[Text]
+    ) -> None:
+        self.url = url
+        self.token = token
+        self.bot_channel = bot_channel
+        self.webhook_url = webhook_url
+
+        super(MattermostBot, self).__init__()
+
+    def _post_message_to_channel(self, channel_id: Text, message: Text) -> Response:
+        return self._post_data_to_channel(
+            {"channel_id": channel_id, "message": message}
+        )
+
+    def _post_data_to_channel(self, data: Dict[Text, Any]) -> Response:
+        """Send a message to a mattermost channel."""
+        headers = {"Authorization": "Bearer " + self.token}
+        r = requests.post(self.url + "/posts", headers=headers, data=json.dumps(data))
+        if not r.status_code == 200:
+            logger.error(
+                f"Failed to send message to mattermost channel "
+                f"{data.get('channel_id')}. Response: {r}"
+            )
+        return r
+
+    async def send_text_message(
+        self, recipient_id: Text, text: Text, **kwargs: Any
+    ) -> None:
+        for message_part in text.strip().split("\n\n"):
+            self._post_message_to_channel(self.bot_channel, message_part)
+
+    async def send_custom_json(
+        self, recipient_id: Text, json_message: Dict[Text, Any], **kwargs: Any
+    ) -> None:
+        json_message.setdefault("channel_id", self.bot_channel)
+        json_message.setdefault("message", "")
+
+        self._post_data_to_channel(json_message)
+
+    async def send_image_url(
+        self, recipient_id: Text, image: Text, **kwargs: Any
+    ) -> None:
+        """Sends an image."""
+        self._post_data_to_channel(
+            {
+                "channel_id": self.bot_channel,
+                "props": {"attachments": [{"image_url": image}]},
+            }
+        )
+
+    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."""
+        # buttons are a list of objects: [(option_name, payload)]
+        # See https://docs.mattermost.com/developer/interactive-messages.html#message-buttons # noqa: E501
+
+        actions = [
+            {
+                "name": button["title"],
+                "integration": {
+                    "url": self.webhook_url,
+                    "context": {"action": button["payload"]},
+                },
+            }
+            for button in buttons
+        ]
+
+        props = {"attachments": [{"actions": actions}]}
+
+        self._post_data_to_channel(
+            {"channel_id": self.bot_channel, "message": text, "props": props}
+        )
+
+
+class MattermostInput(InputChannel):
+    """Mattermost input channel implemenation."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "mattermost"
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
+        if credentials is None:
+            cls.raise_missing_credentials_exception()
+
+        token = credentials.get("token")
+
+        return cls(credentials.get("url"), token, credentials.get("webhook_url"))
+
+    def __init__(self, url: Text, token: Text, webhook_url: Text) -> None:
+        """Create a Mattermost input channel.
+        Needs a couple of settings to properly authenticate and validate
+        messages.
+
+        Args:
+            url: Your Mattermost team url including /v4 example
+                https://mysite.example.com/api/v4
+            token: Your mattermost bot token
+            webhook_url: The mattermost callback url as specified
+                in the outgoing webhooks in mattermost example
+                https://mysite.example.com/webhooks/mattermost/webhook
+        """
+        self.url = url
+        self.token = token
+        self.webhook_url = webhook_url
+
+    async def message_with_trigger_word(
+        self,
+        on_new_message: Callable[[UserMessage], Awaitable[None]],
+        output: Dict[Text, Any],
+        metadata: Optional[Dict],
+    ) -> None:
+        # splitting to get rid of the @botmention
+        # trigger we are using for this
+        split_message = output["text"].split(" ", 1)
+        if len(split_message) >= 2:
+            message = split_message[1]
+        else:
+            message = output["text"]
+
+        await self._handle_message(
+            message, output["user_id"], output["channel_id"], metadata, on_new_message
+        )
+
+    async def action_from_button(
+        self,
+        on_new_message: Callable[[UserMessage], Awaitable[None]],
+        output: Dict[Text, Any],
+        metadata: Optional[Dict],
+    ) -> None:
+        # get the action, the buttons triggers
+        action = output["context"]["action"]
+
+        await self._handle_message(
+            action, output["user_id"], output["channel_id"], metadata, on_new_message
+        )
+
+    async def _handle_message(
+        self,
+        message: Text,
+        sender_id: Text,
+        bot_channel: Text,
+        metadata: Optional[Dict],
+        on_new_message: Callable[[UserMessage], Awaitable[None]],
+    ) -> None:
+        try:
+            out_channel = MattermostBot(
+                self.url, self.token, bot_channel, self.webhook_url
+            )
+            user_msg = UserMessage(
+                message,
+                out_channel,
+                sender_id,
+                input_channel=self.name(),
+                metadata=metadata,
+            )
+            await on_new_message(user_msg)
+        except Exception as e:
+            logger.error(f"Exception when trying to handle message.{e}")
+            logger.debug(e, exc_info=True)
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[None]]
+    ) -> Blueprint:
+        mattermost_webhook = Blueprint("mattermost_webhook", __name__)
+
+        @mattermost_webhook.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @mattermost_webhook.route("/webhook", methods=["POST"])
+        async def webhook(request: Request) -> HTTPResponse:
+            output = request.json
+
+            if not output:
+                return response.text("")
+
+            metadata = self.get_metadata(request)
+            # handle normal message with trigger_word
+            if "trigger_word" in output:
+                await self.message_with_trigger_word(on_new_message, output, metadata)
+
+            # handle context actions from buttons
+            elif "context" in output:
+                await self.action_from_button(on_new_message, output, metadata)
+
+            return response.text("success")
+
+        return mattermost_webhook

rasa/core/channels/rasa_chat.py

@@ -0,0 +1,126 @@
+import json
+from typing import Text, Optional, Dict, Any
+
+import aiohttp
+import logging
+from sanic.exceptions import SanicException
+import jwt
+import jwt.exceptions
+
+import rasa.core.channels.channel
+from rasa.core.channels.channel import InputChannel
+from rasa.core.channels.rest import RestInput
+from rasa.core.constants import DEFAULT_REQUEST_TIMEOUT
+from sanic.request import Request
+
+logger = logging.getLogger(__name__)
+
+CONVERSATION_ID_KEY = "conversation_id"
+JWT_USERNAME_KEY = "username"
+INTERACTIVE_LEARNING_PERMISSION = "clientEvents:create"
+
+
+class RasaChatInput(RestInput):
+    """Chat input channel for Rasa Enterprise."""
+
+    @classmethod
+    def name(cls) -> Text:
+        """Name of the channel."""
+        return "rasa"
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
+        if not credentials:
+            cls.raise_missing_credentials_exception()
+
+        return cls(credentials.get("url"))
+
+    def __init__(self, url: Optional[Text]) -> None:
+        """Initialise the channel with attributes."""
+        self.base_url = url
+        self.jwt_key: Optional[Text] = None
+        self.jwt_algorithm = None
+
+    async def _fetch_public_key(self) -> None:
+        public_key_url = f"{self.base_url}/version"
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                public_key_url, timeout=DEFAULT_REQUEST_TIMEOUT
+            ) as resp:
+                status_code = resp.status
+                if status_code != 200:
+                    logger.error(
+                        "Failed to fetch JWT public key from URL '{}' with "
+                        "status code {}: {}"
+                        "".format(public_key_url, status_code, await resp.text())
+                    )
+                    return
+                rjs = await resp.json()
+                public_key_field = "keys"
+                if public_key_field in rjs:
+                    self.jwt_key = rjs["keys"][0]["key"]
+                    self.jwt_algorithm = rjs["keys"][0]["alg"]
+                    logger.debug(
+                        "Fetched JWT public key from URL '{}' for algorithm '{}':\n{}"
+                        "".format(public_key_url, self.jwt_algorithm, self.jwt_key)
+                    )
+                else:
+                    logger.error(
+                        "Retrieved json response from URL '{}' but could not find "
+                        "'{}' field containing the JWT public key. Please make sure "
+                        "you use an up-to-date version of Rasa Enterprise (>= 0.20.2). "
+                        "Response was: {}"
+                        "".format(public_key_url, public_key_field, json.dumps(rjs))
+                    )
+
+    async def _decode_bearer_token(self, bearer_token: Text) -> Optional[Dict]:
+        if self.jwt_key is None:
+            await self._fetch_public_key()
+
+        try:
+            return rasa.core.channels.channel.decode_jwt(
+                bearer_token, self.jwt_key, self.jwt_algorithm
+            )
+        except jwt.InvalidSignatureError:
+            logger.error("JWT public key invalid, fetching new one.")
+            await self._fetch_public_key()
+            return rasa.core.channels.channel.decode_jwt(
+                bearer_token, self.jwt_key, self.jwt_algorithm
+            )
+
+    async def _extract_sender(self, req: Request) -> Optional[Text]:
+        """Fetch user from the Rasa Enterprise Admin API."""
+        jwt_payload = None
+        if req.headers.get("Authorization"):
+            jwt_payload = await self._decode_bearer_token(req.headers["Authorization"])
+
+        if not jwt_payload:
+            jwt_payload = await self._decode_bearer_token(req.args.get("token"))
+
+        if not jwt_payload:
+            raise SanicException(status_code=401)
+
+        if CONVERSATION_ID_KEY in req.json:
+            if self._has_user_permission_to_send_messages_to_conversation(
+                jwt_payload, req.json
+            ):
+                return req.json[CONVERSATION_ID_KEY]
+            else:
+                logger.error(
+                    "User '{}' does not have permissions to send messages to "
+                    "conversation '{}'.".format(
+                        jwt_payload[JWT_USERNAME_KEY], req.json[CONVERSATION_ID_KEY]
+                    )
+                )
+                raise SanicException(status_code=401)
+
+        return jwt_payload[JWT_USERNAME_KEY]
+
+    @staticmethod
+    def _has_user_permission_to_send_messages_to_conversation(
+        jwt_payload: Dict, message: Dict
+    ) -> bool:
+        user_scopes = jwt_payload.get("scopes", [])
+        return INTERACTIVE_LEARNING_PERMISSION in user_scopes or message[
+            CONVERSATION_ID_KEY
+        ] == jwt_payload.get(JWT_USERNAME_KEY)

rasa/core/channels/rest.py

@@ -0,0 +1,230 @@
+import asyncio
+import copy
+import inspect
+import json
+import logging
+from functools import partial
+
+import structlog
+from asyncio import Queue, CancelledError
+from sanic import Blueprint, response
+from sanic.request import Request
+from typing import (
+    Text,
+    Dict,
+    Any,
+    Optional,
+    Callable,
+    Awaitable,
+    NoReturn,
+    Union,
+)
+from sanic.response import HTTPResponse, ResponseStream, BaseHTTPResponse
+
+import rasa.utils.endpoints
+from rasa.core.channels.channel import (
+    InputChannel,
+    CollectingOutputChannel,
+    UserMessage,
+)
+
+
+logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
+
+
+class RestInput(InputChannel):
+    """A custom http input channel.
+
+    This implementation is the basis for a custom implementation of a chat
+    frontend. You can customize this to send messages to Rasa and
+    retrieve responses from the assistant.
+    """
+
+    @classmethod
+    def name(cls) -> Text:
+        return "rest"
+
+    @staticmethod
+    async def on_message_wrapper(
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+        text: Text,
+        queue: Queue,
+        sender_id: Text,
+        input_channel: Text,
+        metadata: Optional[Dict[Text, Any]],
+    ) -> None:
+        collector = QueueOutputChannel(queue)
+
+        message = UserMessage(
+            text, collector, sender_id, input_channel=input_channel, metadata=metadata
+        )
+        await on_new_message(message)
+
+        await queue.put("DONE")
+
+    async def _extract_sender(self, req: Request) -> Optional[Text]:
+        return req.json.get("sender", None)
+
+    # noinspection PyMethodMayBeStatic
+    def _extract_message(self, req: Request) -> Optional[Text]:
+        return req.json.get("message", None)
+
+    def _extract_input_channel(self, req: Request) -> Text:
+        return req.json.get("input_channel") or self.name()
+
+    def get_metadata(self, request: Request) -> Optional[Dict[Text, Any]]:
+        """Extracts additional information from the incoming request.
+
+         Implementing this function is not required. However, it can be used to extract
+         metadata from the request. The return value is passed on to the
+         ``UserMessage`` object and stored in the conversation tracker.
+
+        Args:
+            request: incoming request with the message of the user
+
+        Returns:
+            Metadata which was extracted from the request.
+        """
+        return request.json.get("metadata", None)
+
+    async def stream_response(
+        self,
+        on_new_message: Callable[[UserMessage], Awaitable[None]],
+        text: Text,
+        sender_id: Text,
+        input_channel: Text,
+        metadata: Optional[Dict[Text, Any]],
+        resp: ResponseStream,
+    ) -> None:
+        """Streams response to the client.
+
+         If the stream option is enabled, this method will be called to
+         stream the response to the client
+
+        Args:
+            on_new_message: sanic event
+            text: message text
+            sender_id: message sender_id
+            input_channel: input channel name
+            metadata: optional metadata sent with the message
+            resp: response stream
+
+        Returns:
+            Sanic stream
+        """
+        q: Queue = Queue()
+        task = asyncio.ensure_future(
+            self.on_message_wrapper(
+                on_new_message, text, q, sender_id, input_channel, metadata
+            )
+        )
+        while True:
+            result = await q.get()
+            if result == "DONE":
+                break
+            else:
+                await resp.write(json.dumps(result) + "\n")
+
+        await task
+
+    async def receive_messages(
+        self, request: Request, on_new_message: Callable[[UserMessage], Awaitable[None]]
+    ) -> Union[BaseHTTPResponse, ResponseStream]:
+        sender_id = await self._extract_sender(request)
+        text = self._extract_message(request)
+        should_use_stream = rasa.utils.endpoints.bool_arg(
+            request, "stream", default=False
+        )
+        input_channel = self._extract_input_channel(request)
+        metadata = self.get_metadata(request)
+
+        if should_use_stream:
+            return ResponseStream(
+                partial(
+                    self.stream_response,
+                    on_new_message,
+                    text,
+                    sender_id,
+                    input_channel,
+                    metadata,
+                ),
+                content_type="text/event-stream",
+            )
+        else:
+            collector = CollectingOutputChannel()
+            # noinspection PyBroadException
+            try:
+                await on_new_message(
+                    UserMessage(
+                        text,
+                        collector,
+                        sender_id,
+                        input_channel=input_channel,
+                        metadata=metadata,
+                        headers=request.headers,
+                    )
+                )
+            except CancelledError:
+                structlogger.error(
+                    "rest.message.received.timeout", text=copy.deepcopy(text)
+                )
+            except Exception:
+                structlogger.exception(
+                    "rest.message.received.failure", text=copy.deepcopy(text)
+                )
+
+            return response.json(collector.messages)
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[None]]
+    ) -> Blueprint:
+        """Groups the collection of endpoints used by rest channel."""
+        module_type = inspect.getmodule(self)
+        if module_type is not None:
+            module_name = module_type.__name__
+        else:
+            module_name = None
+
+        custom_webhook = Blueprint(
+            "custom_webhook_{}".format(type(self).__name__),
+            module_name,
+        )
+
+        # noinspection PyUnusedLocal
+        @custom_webhook.route("/", methods=["GET"])
+        async def health(request: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @custom_webhook.route("/webhook", methods=["POST"])
+        async def receive(request: Request) -> Union[ResponseStream, BaseHTTPResponse]:
+            return await self.receive_messages(request, on_new_message)
+
+        return custom_webhook
+
+
+class QueueOutputChannel(CollectingOutputChannel):
+    """Output channel that collects send messages in a list.
+
+    (doesn't send them anywhere, just collects them).
+    """
+
+    # FIXME: this is breaking Liskov substitution principle
+    # and would require some user-facing refactoring to address
+    messages: Queue  # type: ignore[assignment]
+
+    @classmethod
+    def name(cls) -> Text:
+        """Name of QueueOutputChannel."""
+        return "queue"
+
+    # noinspection PyMissingConstructor
+    def __init__(self, message_queue: Optional[Queue] = None) -> None:
+        super().__init__()
+        self.messages = Queue() if not message_queue else message_queue
+
+    def latest_output(self) -> NoReturn:
+        raise NotImplementedError("A queue doesn't allow to peek at messages.")
+
+    async def _persist_message(self, message: Dict[Text, Any]) -> None:
+        await self.messages.put(message)