WPyrogram 2.0.153__tar.gz → 2.0.154__tar.gz

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: WPyrogram
-Version: 2.0.153
+Version: 2.0.154
 Summary: Elegant, modern and asynchronous Telegram MTProto API framework in Python for users and bots - Woto's experimental fork
 Home-page: https://github.com/ALiwoto/WPyrogram
 Download-URL: https://github.com/ALiwoto/WPyrogram

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/WPyrogram.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: WPyrogram
-Version: 2.0.153
+Version: 2.0.154
 Summary: Elegant, modern and asynchronous Telegram MTProto API framework in Python for users and bots - Woto's experimental fork
 Home-page: https://github.com/ALiwoto/WPyrogram
 Download-URL: https://github.com/ALiwoto/WPyrogram

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/WPyrogram.egg-info/SOURCES.txt

@@ -42,8 +42,10 @@ pyrogram/dispatcher.py
 pyrogram/emoji.py
 pyrogram/file_id.py
 pyrogram/filters.py
+pyrogram/helper_bot.py
 pyrogram/mime_types.py
 pyrogram/py.typed
+pyrogram/reply_markup.py
 pyrogram/sync.py
 pyrogram/utils.py
 pyrogram/connection/__init__.py

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/__init__.py

@@ -16,7 +16,7 @@
 #  You should have received a copy of the GNU Lesser General Public License
 #  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
 
-__version__ = "2.0.153"
+__version__ = "2.0.154"
 __license__ = "GNU Lesser General Public License v3.0 (LGPL-3.0)"
 __copyright__ = "Copyright (C) 2017-present Dan <https://github.com/delivrance>"
 

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/client.py

@@ -32,7 +32,7 @@ from importlib import import_module
 from io import StringIO, BytesIO
 from mimetypes import MimeTypes
 from pathlib import Path
-from typing import Union, List, Optional, Callable, AsyncGenerator, Type, Tuple
+from typing import Union, List, Optional, Callable, AsyncGenerator, Type, Tuple, Dict
 
 import pyrogram
 from pyrogram import __version__, __license__
@@ -58,6 +58,7 @@ from .connection import Connection
 from .connection.transport import TCP, TCPAbridged
 from .dispatcher import Dispatcher
 from .file_id import FileId, FileType, ThumbnailSource
+from .helper_bot import HelperBotQuery, answer_helper_bot_query
 from .mime_types import mime_types
 from .parser import Parser
 from .session.internals import MsgId
@@ -269,7 +270,9 @@ class Client(Methods):
         client_platform: "enums.ClientPlatform" = enums.ClientPlatform.OTHER,
         init_connection_params: Optional["raw.base.JSONValue"] = None,
         connection_factory: Type[Connection] = Connection,
-        protocol_factory: Type[TCP] = TCPAbridged
+        protocol_factory: Type[TCP] = TCPAbridged,
+        helper_bot: Optional["Client"] = None,
+        helper_bot_chat_id: Optional[Union[int, str]] = None
     ):
         super().__init__()
 
@@ -306,6 +309,9 @@ class Client(Methods):
         self.init_connection_params = init_connection_params
         self.connection_factory = connection_factory
         self.protocol_factory = protocol_factory
+        self.helper_bot = helper_bot
+        self.helper_bot_chat_id = helper_bot_chat_id
+        self._helper_bot_queries: Dict[str, HelperBotQuery] = {}
 
         self.executor = ThreadPoolExecutor(self.workers, thread_name_prefix="Handler")
 
@@ -660,6 +666,9 @@ class Client(Methods):
                                 users.update({u.id: u for u in diff.users})
                                 chats.update({c.id: c for c in diff.chats})
 
+                # Internal inline replies must not wait for a busy application handler.
+                if await answer_helper_bot_query(self, update):
+                    continue
                 self.dispatcher.updates_queue.put_nowait((update, users, chats))
         elif isinstance(updates, (raw.types.UpdateShortMessage, raw.types.UpdateShortChatMessage)):
             if not self.skip_updates:
@@ -695,6 +704,8 @@ class Client(Methods):
                 if diff.other_updates:  # The other_updates list can be empty
                     self.dispatcher.updates_queue.put_nowait((diff.other_updates[0], {}, {}))
         elif isinstance(updates, raw.types.UpdateShort):
+            if await answer_helper_bot_query(self, updates.update):
+                return
             self.dispatcher.updates_queue.put_nowait((updates.update, {}, {}))
         elif isinstance(updates, raw.types.UpdatesTooLong):
             log.info(updates)

wpyrogram-2.0.154/pyrogram/helper_bot.py

@@ -0,0 +1,325 @@
+# pyright: strict
+
+from __future__ import annotations
+
+import logging
+from copy import copy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional, TypedDict, Union, cast
+from uuid import uuid4
+
+from pyrogram import enums, raw, types, utils
+
+if TYPE_CHECKING:
+    from pyrogram import Client
+
+
+log = logging.getLogger(__name__)
+
+
+SendRequest = Union[raw.functions.messages.SendMessage, raw.functions.messages.SendMedia]
+
+
+class InvokeOptions(TypedDict):
+    retries: int
+    timeout: float
+    sleep_threshold: Optional[float]
+
+
+@dataclass
+class HelperBotQuery:
+    user_id: int
+    result: raw.base.InputBotInlineResult
+    error: Optional[Exception] = None
+
+
+async def answer_helper_bot_query(client: Client, update: raw.base.Update) -> bool:
+    if not isinstance(update, raw.types.UpdateBotInlineQuery):
+        return False
+
+    pending = client._helper_bot_queries.get(update.query)  # pyright: ignore[reportPrivateUsage]
+    if pending is None or pending.user_id != update.user_id:
+        return False
+
+    try:
+        await client.invoke(
+            raw.functions.messages.SetInlineBotResults(
+                query_id=update.query_id, results=[pending.result], cache_time=0, private=True
+            )
+        )
+    except Exception as error:
+        pending.error = error
+        log.exception("Failed to answer a helper bot query")
+
+    return True
+
+
+async def send_with_helper_bot(
+    client: Client,
+    query: SendRequest,
+    retries: int,
+    timeout: float,
+    sleep_threshold: Optional[float],
+) -> raw.base.Updates:
+    helper = client.helper_bot
+    if helper is None or not helper.is_connected or helper.me is None or not helper.me.is_bot:
+        raise ValueError("helper_bot must be a started bot Client")
+    if helper.no_updates or not helper.me.username:
+        raise ValueError("helper_bot needs a username and incoming updates enabled")
+
+    # Fail explicitly when the inline API cannot preserve a send option.
+    content_fields = {"message", "entities", "reply_markup", "no_webpage", "invert_media", "media"}
+    send_fields = {
+        "peer",
+        "random_id",
+        "silent",
+        "background",
+        "clear_draft",
+        "reply_to",
+        "schedule_date",
+        "send_as",
+        "quick_reply_shortcut",
+        "allow_paid_stars",
+    }
+    for name in query.__slots__:
+        if name not in send_fields and name not in content_fields:
+            if getattr(query, name) not in (None, False):
+                raise ValueError(f"The helper bot inline API does not support {name}")
+
+    invoke_options: InvokeOptions = {
+        "retries": retries,
+        "timeout": timeout,
+        "sleep_threshold": sleep_threshold,
+    }
+    result = await build_inline_result(client, helper, query, invoke_options)
+    if result is None:
+        # The staging send was not confirmed. Do not send or retry the destination message.
+        return raw.types.Updates(updates=[], users=[], chats=[], date=0, seq=0)
+
+    token = "wpy_helper_" + uuid4().hex
+    pending = HelperBotQuery(cast(types.User, client.me).id, result)
+    helper._helper_bot_queries[token] = pending  # pyright: ignore[reportPrivateUsage]
+    try:
+        results = cast(
+            raw.types.messages.BotResults,
+            await client.invoke(
+                raw.functions.messages.GetInlineBotResults(
+                    bot=cast(raw.base.InputUser, await client.resolve_peer(helper.me.username)),
+                    peer=query.peer,
+                    query=token,
+                    offset="",
+                ),
+                **invoke_options,
+            ),
+        )
+    except Exception:
+        if pending.error is not None:
+            raise pending.error
+        raise
+    finally:
+        helper._helper_bot_queries.pop(token, None)  # pyright: ignore[reportPrivateUsage]
+
+    if not any(item.id == result.id for item in results.results):
+        raise ValueError("The helper bot returned no matching inline result")
+
+    # Reuse the caller's random_id, including across transport and flood-wait retries.
+    return cast(
+        raw.base.Updates,
+        await client.invoke(
+            raw.functions.messages.SendInlineBotResult(
+                peer=query.peer,
+                random_id=query.random_id,
+                query_id=results.query_id,
+                id=result.id,
+                silent=query.silent,
+                background=query.background,
+                clear_draft=query.clear_draft,
+                reply_to=query.reply_to,
+                schedule_date=query.schedule_date,
+                send_as=query.send_as,
+                quick_reply_shortcut=query.quick_reply_shortcut,
+                allow_paid_stars=query.allow_paid_stars,
+            ),
+            **invoke_options,
+        ),
+    )
+
+
+async def build_inline_result(
+    client: Client, helper: Client, query: SendRequest, invoke_options: InvokeOptions
+) -> Optional[raw.base.InputBotInlineResult]:
+    entities: List[raw.base.MessageEntity] = []
+    for entity in query.entities or []:
+        if isinstance(entity, raw.types.InputMessageEntityMentionName):
+            entity = copy(entity)
+            if isinstance(entity.user_id, raw.types.InputUserEmpty):
+                raise ValueError("A helper bot mention requires a user ID")
+            user_id = (
+                cast(types.User, client.me).id
+                if isinstance(entity.user_id, raw.types.InputUserSelf)
+                else entity.user_id.user_id
+            )
+            entity.user_id = cast(raw.base.InputUser, await helper.resolve_peer(user_id))
+        entities.append(entity)
+
+    if isinstance(query, raw.functions.messages.SendMessage):
+        return raw.types.InputBotInlineResult(
+            id="message",
+            type="article",
+            title="Message",
+            send_message=raw.types.InputBotInlineMessageText(
+                no_webpage=query.no_webpage,
+                message=query.message,
+                entities=entities or None,
+                reply_markup=query.reply_markup,
+                invert_media=query.invert_media,
+            ),
+        )
+
+    media = query.media
+    inline_message: Optional[raw.base.InputBotInlineMessage] = None
+    result_type = "article"
+    if isinstance(media, (raw.types.InputMediaGeoPoint, raw.types.InputMediaGeoLive)):
+        if isinstance(media, raw.types.InputMediaGeoLive) and media.stopped:
+            raise ValueError("The helper bot cannot send a stopped live location")
+        result_type = "geo"
+        inline_message = raw.types.InputBotInlineMessageMediaGeo(
+            geo_point=media.geo_point,
+            heading=media.heading if isinstance(media, raw.types.InputMediaGeoLive) else None,
+            period=media.period if isinstance(media, raw.types.InputMediaGeoLive) else None,
+            proximity_notification_radius=media.proximity_notification_radius
+            if isinstance(media, raw.types.InputMediaGeoLive)
+            else None,
+            reply_markup=query.reply_markup,
+        )
+    elif isinstance(media, raw.types.InputMediaVenue):
+        result_type = "venue"
+        inline_message = raw.types.InputBotInlineMessageMediaVenue(
+            geo_point=media.geo_point,
+            title=media.title,
+            address=media.address,
+            provider=media.provider,
+            venue_id=media.venue_id,
+            venue_type=media.venue_type,
+            reply_markup=query.reply_markup,
+        )
+    elif isinstance(media, raw.types.InputMediaContact):
+        result_type = "contact"
+        inline_message = raw.types.InputBotInlineMessageMediaContact(
+            phone_number=media.phone_number,
+            first_name=media.first_name,
+            last_name=media.last_name,
+            vcard=media.vcard,
+            reply_markup=query.reply_markup,
+        )
+    elif isinstance(media, raw.types.InputMediaWebPage):
+        inline_message = raw.types.InputBotInlineMessageMediaWebPage(
+            url=media.url,
+            message=query.message,
+            entities=entities or None,
+            force_large_media=media.force_large_media,
+            force_small_media=media.force_small_media,
+            optional=media.optional,
+            invert_media=query.invert_media,
+            reply_markup=query.reply_markup,
+        )
+
+    if inline_message is not None:
+        return raw.types.InputBotInlineResult(
+            id="message", type=result_type, title="Message", send_message=inline_message
+        )
+
+    if not isinstance(
+        media,
+        (
+            raw.types.InputMediaPhoto,
+            raw.types.InputMediaUploadedPhoto,
+            raw.types.InputMediaPhotoExternal,
+            raw.types.InputMediaDocument,
+            raw.types.InputMediaUploadedDocument,
+            raw.types.InputMediaDocumentExternal,
+        ),
+    ):
+        raise ValueError(f"The helper bot inline API does not support {type(media).__name__}")
+
+    for name in ("ttl_seconds", "spoiler", "video_cover", "video_timestamp"):
+        if getattr(media, name, None) not in (None, False):
+            raise ValueError(f"The helper bot inline API does not support media option {name}")
+    if isinstance(media, raw.types.InputMediaUploadedDocument):
+        for attribute in media.attributes:
+            if isinstance(attribute, raw.types.DocumentAttributeVideo) and attribute.round_message:
+                raise ValueError("The helper bot inline API does not support video notes")
+
+    if not client.helper_bot_chat_id:
+        raise ValueError("Sending media through helper_bot requires helper_bot_chat_id")
+    peer = await client.resolve_peer(client.helper_bot_chat_id)
+    if not isinstance(peer, raw.types.InputPeerChannel):
+        raise ValueError(
+            "helper_bot_chat_id must be a channel or supergroup accessible to both clients"
+        )
+
+    # The bot must see the uploaded media to obtain a file reference for its own account.
+    staged = cast(
+        Union[raw.types.Updates, raw.types.UpdatesCombined],
+        await client.invoke(
+            raw.functions.messages.SendMedia(
+                peer=peer, media=media, message="", random_id=client.rnd_id(), silent=True
+            ),
+            **invoke_options,
+        ),
+    )
+    message_id: Optional[int] = None
+    for update in staged.updates:
+        if isinstance(update, raw.types.UpdateNewChannelMessage):
+            message_id = update.message.id
+            break
+
+    if message_id is None:
+        log.warning("Helper bot media upload returned no message update; destination send skipped")
+        return None
+
+    message = cast(types.Message, await helper.get_messages(client.helper_bot_chat_id, message_id))
+    if message.empty or message.media is None:
+        log.warning("Helper bot staging message is unavailable; destination send skipped")
+        return None
+
+    media_types = {
+        enums.MessageMediaType.ANIMATION: "gif",
+        enums.MessageMediaType.AUDIO: "audio",
+        enums.MessageMediaType.DOCUMENT: "file",
+        enums.MessageMediaType.VIDEO: "video",
+        enums.MessageMediaType.VOICE: "voice",
+        enums.MessageMediaType.STICKER: "sticker",
+    }
+    send_message = raw.types.InputBotInlineMessageMediaAuto(
+        message=query.message,
+        entities=entities or None,
+        reply_markup=query.reply_markup,
+        invert_media=query.invert_media,
+    )
+    if message.photo is not None:
+        photo = cast(
+            raw.types.InputMediaPhoto, utils.get_input_media_from_file_id(message.photo.file_id)
+        )
+        return raw.types.InputBotInlineResultPhoto(
+            id="message", type="photo", photo=photo.id, send_message=send_message
+        )
+
+    file = (
+        message.animation
+        or message.audio
+        or message.document
+        or message.video
+        or message.voice
+        or message.sticker
+    )
+    if file is None or message.media not in media_types:
+        raise ValueError(f"The helper bot inline API does not support {message.media}")
+    document = cast(raw.types.InputMediaDocument, utils.get_input_media_from_file_id(file.file_id))
+    return raw.types.InputBotInlineResultDocument(
+        id="message",
+        type=media_types[message.media],
+        title="Media",
+        document=document.id,
+        send_message=send_message,
+    )

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/methods/advanced/invoke.py

@@ -17,12 +17,14 @@
 #  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
 
 import logging
+from typing import Any, Optional
 
 import pyrogram
 from pyrogram import raw
 from pyrogram.raw.core import TLObject
 from pyrogram.session import Session
 from pyrogram.methods.messages.business_session import get_session
+from pyrogram.helper_bot import send_with_helper_bot
 
 log = logging.getLogger(__name__)
 
@@ -33,9 +35,9 @@ class Invoke:
         query: TLObject,
         retries: int = Session.MAX_RETRIES,
         timeout: float = Session.WAIT_TIMEOUT,
-        sleep_threshold: float = None,
-        business_connection_id: str = None
-    ):
+        sleep_threshold: Optional[float] = None,
+        business_connection_id: Optional[str] = None
+    ) -> Any:
         """Invoke raw Telegram functions.
 
         This method makes it possible to manually call every single Telegram API method in a low-level manner.
@@ -75,6 +77,15 @@ class Invoke:
         if not self.is_connected:
             raise ConnectionError("Client has not been started yet")
 
+        if (self.helper_bot is not None and self.me is not None and not self.me.is_bot
+                and isinstance(query, (raw.functions.messages.SendMessage, raw.functions.messages.SendMedia))
+                and isinstance(query.reply_markup, raw.types.ReplyInlineMarkup)):
+            if business_connection_id:
+                raise ValueError("The helper bot inline API does not support business connections")
+            return await send_with_helper_bot(
+                self, query, retries=retries, timeout=timeout, sleep_threshold=sleep_threshold
+            )
+
         session = self.session
 
         if business_connection_id:

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/methods/bots/send_game.py

@@ -19,6 +19,8 @@
 from typing import Union
 
 import pyrogram
+from typing import Optional
+from pyrogram.reply_markup import ReplyMarkup
 from pyrogram import raw
 from pyrogram import types
 from pyrogram import utils
@@ -36,12 +38,7 @@ class SendGame:
         reply_to_chat_id: Union[int, str] = None,
         protect_content: bool = None,
         allow_paid_broadcast: bool = None,
-        reply_markup: Union[
-            "types.InlineKeyboardMarkup",
-            "types.ReplyKeyboardMarkup",
-            "types.ReplyKeyboardRemove",
-            "types.ForceReply"
-        ] = None
+        reply_markup: "Optional[ReplyMarkup]" = None
     ) -> "types.Message":
         """Send a game.
 
@@ -114,7 +111,7 @@ class SendGame:
                 random_id=self.rnd_id(),
                 noforwards=protect_content,
                 allow_paid_floodskip=allow_paid_broadcast,
-                reply_markup=await reply_markup.write(self) if reply_markup else None,
+                reply_markup=await utils.write_reply_markup(self, reply_markup, for_send=True),
                 effect=effect_id
             )
         )

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/methods/bots/send_invoice.py

@@ -20,6 +20,7 @@ import logging
 from typing import List, Optional, Union
 
 import pyrogram
+from pyrogram.reply_markup import ReplyMarkup
 from pyrogram import enums, raw, utils, types
 
 log = logging.getLogger(__name__)
@@ -56,12 +57,7 @@ class SendInvoice:
         message_effect_id: Optional[int] = None,
         reply_to_message_id: Optional[int] = None,
         allow_paid_broadcast: bool = None,
-        reply_markup: Optional[Union[
-            "types.InlineKeyboardMarkup",
-            "types.ReplyKeyboardMarkup",
-            "types.ReplyKeyboardRemove",
-            "types.ForceReply"
-        ]] = None,
+        reply_markup: "Optional[ReplyMarkup]" = None,
         caption: str = "",
         parse_mode: Optional["enums.ParseMode"] = None,
         caption_entities: Optional[List["types.MessageEntity"]] = None
@@ -224,7 +220,7 @@ class SendInvoice:
             random_id=self.rnd_id(),
             noforwards=protect_content,
             allow_paid_floodskip=allow_paid_broadcast,
-            reply_markup=await reply_markup.write(self) if reply_markup else None,
+            reply_markup=await utils.write_reply_markup(self, reply_markup, for_send=True),
             effect=message_effect_id,
             **await utils.parse_text_entities(self, caption, parse_mode, caption_entities)
         )

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/methods/messages/edit_inline_media.py

@@ -22,6 +22,8 @@ import os
 import re
 
 import pyrogram
+from typing import Optional
+from pyrogram.reply_markup import ReplyMarkup
 from pyrogram import raw
 from pyrogram import types
 from pyrogram import utils
@@ -37,7 +39,7 @@ class EditInlineMedia:
         self: "pyrogram.Client",
         inline_message_id: str,
         media: "types.InputMedia",
-        reply_markup: "types.InlineKeyboardMarkup" = None
+        reply_markup: "Optional[ReplyMarkup]" = None
     ) -> bool:
         """Edit inline animation, audio, document, photo or video messages, or to add media to text messages.
 
@@ -231,7 +233,7 @@ class EditInlineMedia:
                     raw.functions.messages.EditInlineBotMessage(
                         id=unpacked,
                         media=actual_media,
-                        reply_markup=await reply_markup.write(self) if reply_markup else None,
+                        reply_markup=await utils.write_reply_markup(self, reply_markup),
                         **await utils.parse_text_entities(self, caption, parse_mode, caption_entities)
                     ),
                     sleep_threshold=self.sleep_threshold

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/methods/messages/edit_inline_reply_markup.py

@@ -17,6 +17,8 @@
 #  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
 
 import pyrogram
+from typing import Optional
+from pyrogram.reply_markup import ReplyMarkup
 from pyrogram import raw
 from pyrogram import types
 from pyrogram import utils
@@ -27,7 +29,7 @@ class EditInlineReplyMarkup:
     async def edit_inline_reply_markup(
         self: "pyrogram.Client",
         inline_message_id: str,
-        reply_markup: "types.InlineKeyboardMarkup" = None
+        reply_markup: "Optional[ReplyMarkup]" = None
     ) -> bool:
         """Edit only the reply markup of inline messages sent via the bot (for inline bots).
 
@@ -63,7 +65,7 @@ class EditInlineReplyMarkup:
         return await session.invoke(
             raw.functions.messages.EditInlineBotMessage(
                 id=unpacked,
-                reply_markup=await reply_markup.write(self) if reply_markup else None,
+                reply_markup=await utils.write_reply_markup(self, reply_markup),
             ),
             sleep_threshold=self.sleep_threshold
         )

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/methods/messages/edit_inline_text.py

@@ -19,6 +19,7 @@
 from typing import Optional, List
 
 import pyrogram
+from pyrogram.reply_markup import ReplyMarkup
 from pyrogram import raw, enums
 from pyrogram import types
 from pyrogram import utils
@@ -33,7 +34,7 @@ class EditInlineText:
         parse_mode: Optional["enums.ParseMode"] = None,
         entities: List["types.MessageEntity"] = None,
         disable_web_page_preview: bool = None,
-        reply_markup: "types.InlineKeyboardMarkup" = None
+        reply_markup: "Optional[ReplyMarkup]" = None
     ) -> bool:
         """Edit the text of inline messages.
 
@@ -85,7 +86,7 @@ class EditInlineText:
             raw.functions.messages.EditInlineBotMessage(
                 id=unpacked,
                 no_webpage=disable_web_page_preview or None,
-                reply_markup=await reply_markup.write(self) if reply_markup else None,
+                reply_markup=await utils.write_reply_markup(self, reply_markup),
                 **await utils.parse_text_entities(self, text, parse_mode, entities)
             ),
             sleep_threshold=self.sleep_threshold

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/methods/messages/edit_message_media.py

@@ -23,6 +23,8 @@ import re
 from typing import Union
 
 import pyrogram
+from typing import Optional
+from pyrogram.reply_markup import ReplyMarkup
 from pyrogram import raw
 from pyrogram import types
 from pyrogram import utils
@@ -37,7 +39,7 @@ class EditMessageMedia:
         media: "types.InputMedia",
         show_caption_above_media: bool = None,
         schedule_date: datetime = None,
-        reply_markup: "types.InlineKeyboardMarkup" = None,
+        reply_markup: "Optional[ReplyMarkup]" = None,
         file_name: str = None
     ) -> "types.Message":
         """Edit animation, audio, document, photo or video messages, or to add media to text messages.
@@ -288,7 +290,7 @@ class EditMessageMedia:
                 invert_media=show_caption_above_media,
                 media=media,
                 schedule_date=utils.datetime_to_timestamp(schedule_date),
-                reply_markup=await reply_markup.write(self) if reply_markup else None,
+                reply_markup=await utils.write_reply_markup(self, reply_markup),
                 message=message,
                 entities=entities
             )

{wpyrogram-2.0.153 → wpyrogram-2.0.154}/pyrogram/methods/messages/edit_message_reply_markup.py

@@ -20,6 +20,8 @@ from datetime import datetime
 from typing import Union
 
 import pyrogram
+from typing import Optional
+from pyrogram.reply_markup import ReplyMarkup
 from pyrogram import raw
 from pyrogram import types
 from pyrogram import utils
@@ -31,7 +33,7 @@ class EditMessageReplyMarkup:
         chat_id: Union[int, str],
         message_id: int,
         schedule_date: datetime = None,
-        reply_markup: "types.InlineKeyboardMarkup" = None,
+        reply_markup: "Optional[ReplyMarkup]" = None,
     ) -> "types.Message":
         """Edit only the reply markup of messages sent by the bot.
 
@@ -71,7 +73,7 @@ class EditMessageReplyMarkup:
                 peer=await self.resolve_peer(chat_id),
                 id=message_id,
                 schedule_date=utils.datetime_to_timestamp(schedule_date),
-                reply_markup=await reply_markup.write(self) if reply_markup else None,
+                reply_markup=await utils.write_reply_markup(self, reply_markup),
             )
         )