Add conversation support

Mahesh0253 · alissonlauffer · commit 23fd547d3fef · 2023-07-11T12:10:13.000-03:00
Squashed commit of the following: commit e5f79a0 Author: Mahesh <44301650+Mahesh0253@users.noreply.github.com> Date: Sun, 21 May 2023 20:30:24 +0530 Remove Scaffold commit d76bb8d Author: Mahesh0253 <maheshmalekar0253@gmail.com> Date: Mon Mar 21 18:19:14 2022 +0530 Update copyright year commit 47193f4 Author: Mahesh0253 <maheshmalekar0253@gmail.com> Date: Mon Mar 21 18:18:20 2022 +0530 Skip outgoing messages commit c818f70 Author: Mahesh <44301650+Mahesh0253@users.noreply.github.com> Date: Mon, 12 Jul 2021 13:49:00 +0530 update commit c34f085 Author: Mahesh0253 <maheshmalekar0253@gmail.com> Date: Mon, 12 Jul 2021 11:36:28 +0530 Add conversation support
diff --git a/pyrogram/dispatcher.py b/pyrogram/dispatcher.py
@@ -26,7 +26,8 @@
 from pyrogram.handlers import (
     CallbackQueryHandler, MessageHandler, EditedMessageHandler, DeletedMessagesHandler,
     UserStatusHandler, RawUpdateHandler, InlineQueryHandler, PollHandler,
-    ChosenInlineResultHandler, ChatMemberUpdatedHandler, ChatJoinRequestHandler
+    ChosenInlineResultHandler, ChatMemberUpdatedHandler, ChatJoinRequestHandler,
+    ConversationHandler
 )
 from pyrogram.raw.types import (
     UpdateNewMessage, UpdateNewChannelMessage, UpdateNewScheduledMessage,
@@ -63,6 +64,9 @@ def __init__(self, client: "pyrogram.Client"):
         self.updates_queue = asyncio.Queue()
         self.groups = OrderedDict()
 
+        self.conversation_handler = ConversationHandler()
+        self.groups[0] = [self.conversation_handler]
+
         async def message_parser(update, users, chats):
             return (
                 await pyrogram.types.Message._parse(self.client, update.message, users, chats,
diff --git a/pyrogram/handlers/__init__.py b/pyrogram/handlers/__init__.py
@@ -19,6 +19,7 @@
 from .callback_query_handler import CallbackQueryHandler
 from .chat_join_request_handler import ChatJoinRequestHandler
 from .chat_member_updated_handler import ChatMemberUpdatedHandler
+from .conversation_handler import ConversationHandler
 from .chosen_inline_result_handler import ChosenInlineResultHandler
 from .deleted_messages_handler import DeletedMessagesHandler
 from .disconnect_handler import DisconnectHandler
diff --git a/pyrogram/handlers/conversation_handler.py b/pyrogram/handlers/conversation_handler.py
@@ -0,0 +1,68 @@
+#  Pyrogram - Telegram MTProto API Client Library for Python
+#  Copyright (C) 2017-present Dan <https://github.com/delivrance>
+#
+#  This file is part of Pyrogram.
+#
+#  Pyrogram is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published
+#  by the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  Pyrogram is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
+
+import inspect
+from typing import Union
+
+import pyrogram
+from pyrogram.types import Message, CallbackQuery
+from .message_handler import MessageHandler
+from .callback_query_handler import CallbackQueryHandler
+
+
+class ConversationHandler(MessageHandler, CallbackQueryHandler):
+    """The Conversation handler class."""
+    def __init__(self):
+        self.waiters = {}
+
+    async def check(self, client: "pyrogram.Client", update: Union[Message, CallbackQuery]):
+        if isinstance(update, Message) and update.outgoing:
+            return False
+
+        try:
+            chat_id = update.chat.id if isinstance(update, Message) else update.message.chat.id
+        except AttributeError:
+            return False
+
+        waiter = self.waiters.get(chat_id)
+        if not waiter or not isinstance(update, waiter['update_type']) or waiter['future'].done():
+            return False
+
+        filters = waiter.get('filters')
+        if callable(filters):
+            if inspect.iscoroutinefunction(filters.__call__):
+                filtered = await filters(client, update)
+            else:
+                filtered = await client.loop.run_in_executor(
+                    client.executor,
+                    filters,
+                    client, update
+                )
+            if not filtered or waiter['future'].done():
+                return False
+
+        waiter['future'].set_result(update)
+        return True
+
+    @staticmethod
+    async def callback(_, __):
+        pass
+
+    def delete_waiter(self, chat_id, future):
+        if future == self.waiters[chat_id]['future']:
+            del self.waiters[chat_id]
diff --git a/pyrogram/methods/messages/__init__.py b/pyrogram/methods/messages/__init__.py
@@ -64,6 +64,8 @@
 from .stop_poll import StopPoll
 from .stream_media import StreamMedia
 from .vote_poll import VotePoll
+from .wait_for_message import WaitForMessage
+from .wait_for_callback_query import WaitForCallbackQuery
 
 
 class Messages(
@@ -114,6 +116,8 @@ class Messages(
     GetDiscussionReplies,
     GetDiscussionRepliesCount,
     StreamMedia,
-    GetCustomEmojiStickers
+    GetCustomEmojiStickers,
+    WaitForMessage,
+    WaitForCallbackQuery
 ):
     pass
diff --git a/pyrogram/methods/messages/wait_for_callback_query.py b/pyrogram/methods/messages/wait_for_callback_query.py
@@ -0,0 +1,80 @@
+#  Pyrogram - Telegram MTProto API Client Library for Python
+#  Copyright (C) 2017-present Dan <https://github.com/delivrance>
+#
+#  This file is part of Pyrogram.
+#
+#  Pyrogram is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published
+#  by the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  Pyrogram is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
+
+import asyncio
+from typing import Union
+from functools import partial
+
+from pyrogram import types
+from pyrogram.filters import Filter
+
+
+class WaitForCallbackQuery:
+    async def wait_for_callback_query(
+        self,
+        chat_id: Union[int, str],
+        filters: Filter = None,
+        timeout: int = None
+    ) -> "types.CallbackQuery":
+        """Wait for callback query.
+
+        Parameters:
+            chat_id (``int`` | ``str``):
+                Unique identifier (int) or username (str) of the target chat.
+
+            filters (:obj:`Filters`):
+                Pass one or more filters to allow only a subset of callback queries to be passed
+                in your callback function.
+
+            timeout (``int``, *optional*):
+                Timeout in seconds.
+
+        Returns:
+            :obj:`~pyrogram.types.CallbackQuery`: On success, the callback query is returned.
+
+        Raises:
+            asyncio.TimeoutError: In case callback query not received within the timeout.
+
+        Example:
+            .. code-block:: python
+
+                # Simple example
+                callback_query = app.wait_for_callback_query(chat_id)
+
+                # Example with filter
+                callback_query = app.wait_for_callback_query(chat_id, filters=filters.user(user_id))
+
+                # Example with timeout
+                callback_query = app.wait_for_callback_query(chat_id, timeout=60)
+        """
+
+        if not isinstance(chat_id, int):
+            chat = await self.get_chat(chat_id)
+            chat_id = chat.id
+
+        conversation_handler = self.dispatcher.conversation_handler
+        future = self.loop.create_future()
+        future.add_done_callback(
+            partial(
+                conversation_handler.delete_waiter,
+                chat_id
+            )
+        )
+        waiter = dict(future=future, filters=filters, update_type=types.CallbackQuery)
+        conversation_handler.waiters[chat_id] = waiter
+        return await asyncio.wait_for(future, timeout=timeout)
diff --git a/pyrogram/methods/messages/wait_for_message.py b/pyrogram/methods/messages/wait_for_message.py
@@ -0,0 +1,80 @@
+#  Pyrogram - Telegram MTProto API Client Library for Python
+#  Copyright (C) 2017-present Dan <https://github.com/delivrance>
+#
+#  This file is part of Pyrogram.
+#
+#  Pyrogram is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published
+#  by the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  Pyrogram is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
+
+import asyncio
+from typing import Union
+from functools import partial
+
+from pyrogram import types
+from pyrogram.filters import Filter
+
+
+class WaitForMessage:
+    async def wait_for_message(
+        self,
+        chat_id: Union[int, str],
+        filters: Filter = None,
+        timeout: int = None
+    ) -> "types.Message":
+        """Wait for message.
+
+        Parameters:
+            chat_id (``int`` | ``str``):
+                Unique identifier (int) or username (str) of the target chat.
+
+            filters (:obj:`Filters`):
+                Pass one or more filters to allow only a subset of callback queries to be passed
+                in your callback function.
+
+            timeout (``int``, *optional*):
+                Timeout in seconds.
+
+        Returns:
+            :obj:`~pyrogram.types.Message`: On success, the reply message is returned.
+
+        Raises:
+            asyncio.TimeoutError: In case message not received within the timeout.
+
+        Example:
+            .. code-block:: python
+
+                # Simple example
+                reply_message = app.wait_for_message(chat_id)
+
+                # Example with filter
+                reply_message = app.wait_for_message(chat_id, filters=filters.text)
+
+                # Example with timeout
+                reply_message = app.wait_for_message(chat_id, timeout=60)
+        """
+
+        if not isinstance(chat_id, int):
+            chat = await self.get_chat(chat_id)
+            chat_id = chat.id
+
+        conversation_handler = self.dispatcher.conversation_handler
+        future = self.loop.create_future()
+        future.add_done_callback(
+            partial(
+                conversation_handler.delete_waiter,
+                chat_id
+            )
+        )
+        waiter = dict(future=future, filters=filters, update_type=types.Message)
+        conversation_handler.waiters[chat_id] = waiter
+        return await asyncio.wait_for(future, timeout=timeout)
diff --git a/pyrogram/types/messages_and_media/message.py b/pyrogram/types/messages_and_media/message.py
@@ -3604,3 +3604,103 @@ async def unpin(self) -> bool:
             chat_id=self.chat.id,
             message_id=self.id
         )
+
+    async def ask(
+        self,
+        text: str,
+        quote: bool = None,
+        parse_mode: Optional[str] = object,
+        entities: List["types.MessageEntity"] = None,
+        disable_web_page_preview: bool = None,
+        disable_notification: bool = None,
+        reply_to_message_id: int = None,
+        reply_markup=None,
+        filters=None,
+        timeout: int = None
+    ) -> "Message":
+        """Bound method *ask* of :obj:`~pyrogram.types.Message`.
+        
+        Use as a shortcut for:
+
+        .. code-block:: python
+
+            client.send_message(chat_id, "What is your name?")
+            client.wait_for_message(chat_id)
+            
+        Example:
+            .. code-block:: python
+
+                message.ask("What is your name?")
+
+        Parameters:
+            text (``str``):
+                Text of the message to be sent.
+
+            quote (``bool``, *optional*):
+                If ``True``, the message will be sent as a reply to this message.
+                If *reply_to_message_id* is passed, this parameter will be ignored.
+                Defaults to ``True`` in group chats and ``False`` in private chats.
+
+            parse_mode (``str``, *optional*):
+                By default, texts are parsed using both Markdown and HTML styles.
+                You can combine both syntaxes together.
+                Pass "markdown" or "md" to enable Markdown-style parsing only.
+                Pass "html" to enable HTML-style parsing only.
+                Pass None to completely disable style parsing.
+
+            entities (List of :obj:`~pyrogram.types.MessageEntity`):
+                List of special entities that appear in message text, which can be specified instead of *parse_mode*.
+
+            disable_web_page_preview (``bool``, *optional*):
+                Disables link previews for links in this message.
+
+            disable_notification (``bool``, *optional*):
+                Sends the message silently.
+                Users will receive a notification with no sound.
+
+            reply_to_message_id (``int``, *optional*):
+                If the message is a reply, ID of the original message.
+
+            reply_markup (:obj:`~pyrogram.types.InlineKeyboardMarkup` | :obj:`~pyrogram.types.ReplyKeyboardMarkup` | :obj:`~pyrogram.types.ReplyKeyboardRemove` | :obj:`~pyrogram.types.ForceReply`, *optional*):
+                Additional interface options. An object for an inline keyboard, custom reply keyboard,
+                instructions to remove reply keyboard or to force a reply from the user.
+
+            filters (:obj:`Filters`):
+                Pass one or more filters to allow only a subset of callback queries to be passed
+                in your callback function.
+
+            timeout (``int``, *optional*):
+                Timeout in seconds.
+
+        Returns:
+            :obj:`~pyrogram.types.Message`: On success, the reply message is returned.
+
+        Raises:
+            RPCError: In case of a Telegram RPC error.
+            asyncio.TimeoutError: In case reply not received within the timeout.
+        """
+        if quote is None:
+            quote = self.chat.type != "private"
+
+        if reply_to_message_id is None and quote:
+            reply_to_message_id = self.id
+
+        request = await self._client.send_message(
+            chat_id=self.chat.id,
+            text=text,
+            parse_mode=parse_mode,
+            entities=entities,
+            disable_web_page_preview=disable_web_page_preview,
+            disable_notification=disable_notification,
+            reply_to_message_id=reply_to_message_id,
+            reply_markup=reply_markup
+        )
+
+        reply_message = await self._client.wait_for_message(
+            self.chat.id,
+            filters=filters,
+            timeout=timeout
+        )
+
+        reply_message.request = request
+        return reply_message
