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

rasa/core/channels/studio_chat.py

@@ -0,0 +1,212 @@
+import asyncio
+import json
+from functools import partial
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Text,
+)
+
+import structlog
+from sanic import Sanic
+
+from rasa.core.channels.socketio import SocketBlueprint, SocketIOInput
+from rasa.hooks import hookimpl
+from rasa.plugin import plugin_manager
+from rasa.shared.core.constants import ACTION_LISTEN_NAME
+from rasa.shared.core.events import ActionExecuted
+from rasa.shared.core.trackers import EventVerbosity
+
+if TYPE_CHECKING:
+    from rasa.core.channels.channel import UserMessage
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+
+structlogger = structlog.get_logger()
+
+
+def tracker_as_dump(tracker: "DialogueStateTracker") -> str:
+    """Create a dump of the tracker state."""
+    from rasa.shared.core.trackers import get_trackers_for_conversation_sessions
+
+    multiple_tracker_sessions = get_trackers_for_conversation_sessions(tracker)
+
+    if 0 <= len(multiple_tracker_sessions) <= 1:
+        last_tracker = tracker
+    else:
+        last_tracker = multiple_tracker_sessions[-1]
+
+    state = last_tracker.current_state(EventVerbosity.AFTER_RESTART)
+    return json.dumps(state)
+
+
+def does_need_action_prediction(tracker: "DialogueStateTracker") -> bool:
+    """Check if the tracker needs an action prediction."""
+    return (
+        len(tracker.events) == 0
+        or not isinstance(tracker.events[-1], ActionExecuted)
+        or tracker.events[-1].action_name != ACTION_LISTEN_NAME
+    )
+
+
+class StudioTrackerUpdatePlugin:
+    """Plugin for publishing tracker updates a socketio channel."""
+
+    def __init__(self, socket_channel: "StudioChatInput") -> None:
+        self.socket_channel = socket_channel
+        self.tasks: List[asyncio.Task] = []
+
+    def _cancel_tasks(self) -> None:
+        """Cancel all remaining tasks."""
+        for task in self.tasks:
+            task.cancel()
+        self.tasks = []
+
+    def _cleanup_tasks(self) -> None:
+        """Remove tasks that have already completed."""
+        self.tasks = [task for task in self.tasks if not task.done()]
+
+    @hookimpl  # type: ignore[misc]
+    def after_new_user_message(self, tracker: "DialogueStateTracker") -> None:
+        """Triggers a tracker update notification after a new user message."""
+        self.handle_tracker_update(tracker)
+
+    @hookimpl  # type: ignore[misc]
+    def after_action_executed(self, tracker: "DialogueStateTracker") -> None:
+        """Triggers a tracker update notification after an action is executed."""
+        self.handle_tracker_update(tracker)
+
+    def handle_tracker_update(self, tracker: "DialogueStateTracker") -> None:
+        """Handles a tracker update when triggered by a hook."""
+        structlogger.info("studio_chat.after_tracker_update", tracker=tracker)
+        # directly create a dump to avoid the tracker getting modified by another
+        # function before it gets published (since the publishing is scheduled
+        # as an async task)
+        tracker_dump = tracker_as_dump(tracker)
+        task = asyncio.create_task(
+            self.socket_channel.publish_tracker_update(tracker.sender_id, tracker_dump)
+        )
+        self.tasks.append(task)
+        self._cleanup_tasks()
+
+    @hookimpl  # type: ignore[misc]
+    def after_server_stop(self) -> None:
+        """Cancels all remaining tasks when the server stops."""
+        self._cancel_tasks()
+
+
+class StudioChatInput(SocketIOInput):
+    """Input channel for the communication between Rasa Studio and Rasa Pro."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return "studio_chat"
+
+    def __init__(
+        self,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Creates a ``SocketIOInput`` object."""
+        from rasa.core.agent import Agent
+
+        super().__init__(*args, **kwargs)
+        self.agent: Optional[Agent] = None
+
+        self._register_tracker_update_hook()
+
+    def _register_tracker_update_hook(self) -> None:
+        plugin_manager().register(StudioTrackerUpdatePlugin(self))
+
+    async def on_tracker_updated(self, tracker: "DialogueStateTracker") -> None:
+        """Triggers a tracker update notification after a change to the tracker."""
+        await self.publish_tracker_update(tracker.sender_id, tracker_as_dump(tracker))
+
+    async def publish_tracker_update(self, sender_id: str, tracker_dump: Dict) -> None:
+        """Publishes a tracker update notification to the websocket."""
+        if not self.sio:
+            structlogger.error("studio_chat.on_tracker_updated.sio_not_initialized")
+            return
+        await self.sio.emit("tracker", tracker_dump, room=sender_id)
+
+    async def on_message_proxy(
+        self,
+        on_new_message: Callable[["UserMessage"], Awaitable[Any]],
+        message: "UserMessage",
+    ) -> None:
+        """Proxies the on_new_message call to the underlying channel.
+
+        Triggers a tracker update notification after processing the message.
+        """
+        await on_new_message(message)
+
+        if not self.agent:
+            structlogger.error("studio_chat.on_message_proxy.agent_not_initialized")
+            return
+
+        tracker = await self.agent.tracker_store.retrieve(message.sender_id)
+        if tracker is None:
+            structlogger.error("studio_chat.on_message_proxy.tracker_not_found")
+            return
+
+        await self.on_tracker_updated(tracker)
+
+    async def handle_tracker_update(self, sid: str, data: Dict) -> None:
+        from rasa.shared.core.trackers import DialogueStateTracker
+
+        structlogger.debug(
+            "studio_chat.sio.handle_tracker_update",
+            sid=sid,
+            sender_id=data["sender_id"],
+        )
+        if self.agent is None:
+            structlogger.error("studio_chat.sio.agent_not_initialized")
+            return None
+
+        if not (domain := self.agent.domain):
+            structlogger.error("studio_chat.sio.domain_not_initialized")
+            return None
+
+        async with self.agent.lock_store.lock(data["sender_id"]):
+            tracker = DialogueStateTracker.from_dict(
+                data["sender_id"], data["events"], domain.slots
+            )
+
+            # will override an existing tracker with the same id!
+            await self.agent.tracker_store.save(tracker)
+
+            processor = self.agent.processor
+            if processor and does_need_action_prediction(tracker):
+                output_channel = self.get_output_channel()
+
+                await processor._run_prediction_loop(output_channel, tracker)
+                await processor.run_anonymization_pipeline(tracker)
+                await self.agent.tracker_store.save(tracker)
+
+        await self.on_tracker_updated(tracker)
+
+    def blueprint(
+        self, on_new_message: Callable[["UserMessage"], Awaitable[Any]]
+    ) -> SocketBlueprint:
+        socket_blueprint = super().blueprint(
+            partial(self.on_message_proxy, on_new_message)
+        )
+
+        if not self.sio:
+            structlogger.error("studio_chat.blueprint.sio_not_initialized")
+            return socket_blueprint
+
+        @socket_blueprint.listener("after_server_start")  # type: ignore[misc]
+        async def after_server_start(app: Sanic, _: asyncio.AbstractEventLoop) -> None:
+            self.agent = app.ctx.agent
+
+        @self.sio.on("update_tracker", namespace=self.namespace)
+        async def on_update_tracker(sid: Text, data: Dict) -> None:
+            await self.handle_tracker_update(sid, data)
+
+        return socket_blueprint

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,26 +1,28 @@
+import asyncio
 import copy
-from datetime import datetime, timezone, timedelta
 import json
 import uuid
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
+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()
@@ -45,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"),
@@ -223,6 +225,16 @@ class AudiocodesInput(InputChannel):
         self.scheduler_job = None
         self.keep_alive = keep_alive
         self.keep_alive_expiration_factor = keep_alive_expiration_factor
+        self.background_tasks: Dict[Text, Set[asyncio.Task]] = defaultdict(set)
+
+    def _create_task(self, conversation_id: Text, coro: Awaitable[Any]) -> asyncio.Task:
+        """Create and track an asyncio task for a conversation."""
+        task: asyncio.Task = asyncio.create_task(coro)
+        self.background_tasks[conversation_id].add(task)
+        task.add_done_callback(
+            lambda t: self.background_tasks[conversation_id].discard(t)
+        )
+        return task
 
     async def _set_scheduler_job(self) -> None:
         if self.scheduler_job:
@@ -251,11 +263,20 @@ class AudiocodesInput(InputChannel):
         )
         now = datetime.now(timezone.utc)
         delta = timedelta(seconds=self.keep_alive * self.keep_alive_expiration_factor)
-        self.conversations = {
-            k: v
-            for k, v in self.conversations.items()
-            if v.is_active_conversation(now, delta)
-        }
+
+        # clean up conversations
+        inactive = [
+            conv_id
+            for conv_id, conv in self.conversations.items()
+            if not conv.is_active_conversation(now, delta)
+        ]
+
+        # cancel tasks and remove conversations
+        for conv_id in inactive:
+            for task in self.background_tasks[conv_id]:
+                task.cancel()
+            self.background_tasks.pop(conv_id, None)
+            self.conversations.pop(conv_id, None)
 
     def handle_start_conversation(self, body: Dict[Text, Any]) -> Dict[Text, Any]:
         conversation_id = body["conversation"]
@@ -347,31 +368,29 @@ class AudiocodesInput(InputChannel):
             structlogger.debug("audiocodes.on_activities", conversation=conversation_id)
             conversation = self._get_conversation(request.token, conversation_id)
             if conversation is None:
+                structlogger.warning(
+                    "audiocodes.on_activities.no_conversation", request=request.json
+                )
                 return response.json({})
             elif conversation.ws:
                 ac_output: Union[WebsocketOutput, AudiocodesOutput] = WebsocketOutput(
                     conversation.ws, conversation_id
                 )
-                await conversation.handle_activities(
-                    request.json,
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                )
-                return response.json({})
+                response_json = {}
             else:
                 # handle non websocket case where messages get returned in json
                 ac_output = AudiocodesOutput()
-                await conversation.handle_activities(
-                    request.json,
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                )
-                return response.json(
-                    {
-                        "conversation": conversation_id,
-                        "activities": ac_output.messages,
-                    }
-                )
+                response_json = {
+                    "conversation": conversation_id,
+                    "activities": ac_output.messages,
+                }
+
+            # start a background task to handle activities
+            self._create_task(
+                conversation_id,
+                conversation.handle_activities(request.json, ac_output, on_new_message),
+            )
+            return response.json(response_json)
 
         @ac_webhook.route(
             "/conversation/<conversation_id>/disconnect", methods=["POST"]