WPyrogram 2.0.153__py3-none-any.whl → 2.0.154__py3-none-any.whl

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>"
 

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)

pyrogram/errors/exceptions/__init__.py

@@ -16,11 +16,11 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
 
-from .bad_request_400 import *
-from .unauthorized_401 import *
 from .forbidden_403 import *
-from .see_other_303 import *
 from .service_unavailable_503 import *
+from .bad_request_400 import *
+from .unauthorized_401 import *
 from .not_acceptable_406 import *
 from .internal_server_error_500 import *
+from .see_other_303 import *
 from .flood_420 import *

pyrogram/errors/exceptions/all.py

@@ -19,6 +19,65 @@
 count = 736
 
 exceptions = {
+    403: {
+        "_": "Forbidden",
+        "ANONYMOUS_REACTIONS_DISABLED": "AnonymousReactionsDisabled",
+        "BROADCAST_FORBIDDEN": "BroadcastForbidden",
+        "CHANNEL_PUBLIC_GROUP_NA": "ChannelPublicGroupNa",
+        "CHAT_ACTION_FORBIDDEN": "ChatActionForbidden",
+        "CHAT_ADMIN_INVITE_REQUIRED": "ChatAdminInviteRequired",
+        "CHAT_ADMIN_REQUIRED": "ChatAdminRequired",
+        "CHAT_FORBIDDEN": "ChatForbidden",
+        "CHAT_GUEST_SEND_FORBIDDEN": "ChatGuestSendForbidden",
+        "CHAT_SEND_AUDIOS_FORBIDDEN": "ChatSendAudiosForbidden",
+        "CHAT_SEND_DOCS_FORBIDDEN": "ChatSendDocsForbidden",
+        "CHAT_SEND_GAME_FORBIDDEN": "ChatSendGameForbidden",
+        "CHAT_SEND_GIFS_FORBIDDEN": "ChatSendGifsForbidden",
+        "CHAT_SEND_INLINE_FORBIDDEN": "ChatSendInlineForbidden",
+        "CHAT_SEND_MEDIA_FORBIDDEN": "ChatSendMediaForbidden",
+        "CHAT_SEND_PHOTOS_FORBIDDEN": "ChatSendPhotosForbidden",
+        "CHAT_SEND_PLAIN_FORBIDDEN": "ChatSendPlainForbidden",
+        "CHAT_SEND_POLL_FORBIDDEN": "ChatSendPollForbidden",
+        "CHAT_SEND_ROUNDVIDEOS_FORBIDDEN": "ChatSendRoundvideosForbidden",
+        "CHAT_SEND_STICKERS_FORBIDDEN": "ChatSendStickersForbidden",
+        "CHAT_SEND_VIDEOS_FORBIDDEN": "ChatSendVideosForbidden",
+        "CHAT_SEND_VOICES_FORBIDDEN": "ChatSendVoicesForbidden",
+        "CHAT_WRITE_FORBIDDEN": "ChatWriteForbidden",
+        "EDIT_BOT_INVITE_FORBIDDEN": "EditBotInviteForbidden",
+        "GROUPCALL_ALREADY_STARTED": "GroupcallAlreadyStarted",
+        "GROUPCALL_FORBIDDEN": "GroupcallForbidden",
+        "INLINE_BOT_REQUIRED": "InlineBotRequired",
+        "LIVE_DISABLED": "LiveDisabled",
+        "MESSAGE_AUTHOR_REQUIRED": "MessageAuthorRequired",
+        "MESSAGE_DELETE_FORBIDDEN": "MessageDeleteForbidden",
+        "NOT_ALLOWED": "NotAllowed",
+        "NOT_ELIGIBLE": "NotEligible",
+        "PARTICIPANT_JOIN_MISSING": "ParticipantJoinMissing",
+        "POLL_VOTE_REQUIRED": "PollVoteRequired",
+        "PREMIUM_ACCOUNT_REQUIRED": "PremiumAccountRequired",
+        "PRIVACY_PREMIUM_REQUIRED": "PrivacyPremiumRequired",
+        "PUBLIC_CHANNEL_MISSING": "PublicChannelMissing",
+        "RIGHT_FORBIDDEN": "RightForbidden",
+        "SENSITIVE_CHANGE_FORBIDDEN": "SensitiveChangeForbidden",
+        "TAKEOUT_REQUIRED": "TakeoutRequired",
+        "USER_BOT_INVALID": "UserBotInvalid",
+        "USER_CHANNELS_TOO_MUCH": "UserChannelsTooMuch",
+        "USER_DELETED": "UserDeleted",
+        "USER_INVALID": "UserInvalid",
+        "USER_IS_BLOCKED": "UserIsBlocked",
+        "USER_NOT_MUTUAL_CONTACT": "UserNotMutualContact",
+        "USER_NOT_PARTICIPANT": "UserNotParticipant",
+        "USER_PRIVACY_RESTRICTED": "UserPrivacyRestricted",
+        "USER_RESTRICTED": "UserRestricted",
+        "VOICE_MESSAGES_FORBIDDEN": "VoiceMessagesForbidden",
+        "YOUR_PRIVACY_RESTRICTED": "YourPrivacyRestricted",
+    },
+    503: {
+        "_": "ServiceUnavailable",
+        "ApiCallError": "ApiCallError",
+        "Timedout": "Timedout",
+        "Timeout": "Timeout",
+    },
     400: {
         "_": "BadRequest",
         "ABOUT_TOO_LONG": "AboutTooLong",
@@ -612,73 +671,6 @@ exceptions = {
         "USER_DEACTIVATED": "UserDeactivated",
         "USER_DEACTIVATED_BAN": "UserDeactivatedBan",
     },
-    403: {
-        "_": "Forbidden",
-        "ANONYMOUS_REACTIONS_DISABLED": "AnonymousReactionsDisabled",
-        "BROADCAST_FORBIDDEN": "BroadcastForbidden",
-        "CHANNEL_PUBLIC_GROUP_NA": "ChannelPublicGroupNa",
-        "CHAT_ACTION_FORBIDDEN": "ChatActionForbidden",
-        "CHAT_ADMIN_INVITE_REQUIRED": "ChatAdminInviteRequired",
-        "CHAT_ADMIN_REQUIRED": "ChatAdminRequired",
-        "CHAT_FORBIDDEN": "ChatForbidden",
-        "CHAT_GUEST_SEND_FORBIDDEN": "ChatGuestSendForbidden",
-        "CHAT_SEND_AUDIOS_FORBIDDEN": "ChatSendAudiosForbidden",
-        "CHAT_SEND_DOCS_FORBIDDEN": "ChatSendDocsForbidden",
-        "CHAT_SEND_GAME_FORBIDDEN": "ChatSendGameForbidden",
-        "CHAT_SEND_GIFS_FORBIDDEN": "ChatSendGifsForbidden",
-        "CHAT_SEND_INLINE_FORBIDDEN": "ChatSendInlineForbidden",
-        "CHAT_SEND_MEDIA_FORBIDDEN": "ChatSendMediaForbidden",
-        "CHAT_SEND_PHOTOS_FORBIDDEN": "ChatSendPhotosForbidden",
-        "CHAT_SEND_PLAIN_FORBIDDEN": "ChatSendPlainForbidden",
-        "CHAT_SEND_POLL_FORBIDDEN": "ChatSendPollForbidden",
-        "CHAT_SEND_ROUNDVIDEOS_FORBIDDEN": "ChatSendRoundvideosForbidden",
-        "CHAT_SEND_STICKERS_FORBIDDEN": "ChatSendStickersForbidden",
-        "CHAT_SEND_VIDEOS_FORBIDDEN": "ChatSendVideosForbidden",
-        "CHAT_SEND_VOICES_FORBIDDEN": "ChatSendVoicesForbidden",
-        "CHAT_WRITE_FORBIDDEN": "ChatWriteForbidden",
-        "EDIT_BOT_INVITE_FORBIDDEN": "EditBotInviteForbidden",
-        "GROUPCALL_ALREADY_STARTED": "GroupcallAlreadyStarted",
-        "GROUPCALL_FORBIDDEN": "GroupcallForbidden",
-        "INLINE_BOT_REQUIRED": "InlineBotRequired",
-        "LIVE_DISABLED": "LiveDisabled",
-        "MESSAGE_AUTHOR_REQUIRED": "MessageAuthorRequired",
-        "MESSAGE_DELETE_FORBIDDEN": "MessageDeleteForbidden",
-        "NOT_ALLOWED": "NotAllowed",
-        "NOT_ELIGIBLE": "NotEligible",
-        "PARTICIPANT_JOIN_MISSING": "ParticipantJoinMissing",
-        "POLL_VOTE_REQUIRED": "PollVoteRequired",
-        "PREMIUM_ACCOUNT_REQUIRED": "PremiumAccountRequired",
-        "PRIVACY_PREMIUM_REQUIRED": "PrivacyPremiumRequired",
-        "PUBLIC_CHANNEL_MISSING": "PublicChannelMissing",
-        "RIGHT_FORBIDDEN": "RightForbidden",
-        "SENSITIVE_CHANGE_FORBIDDEN": "SensitiveChangeForbidden",
-        "TAKEOUT_REQUIRED": "TakeoutRequired",
-        "USER_BOT_INVALID": "UserBotInvalid",
-        "USER_CHANNELS_TOO_MUCH": "UserChannelsTooMuch",
-        "USER_DELETED": "UserDeleted",
-        "USER_INVALID": "UserInvalid",
-        "USER_IS_BLOCKED": "UserIsBlocked",
-        "USER_NOT_MUTUAL_CONTACT": "UserNotMutualContact",
-        "USER_NOT_PARTICIPANT": "UserNotParticipant",
-        "USER_PRIVACY_RESTRICTED": "UserPrivacyRestricted",
-        "USER_RESTRICTED": "UserRestricted",
-        "VOICE_MESSAGES_FORBIDDEN": "VoiceMessagesForbidden",
-        "YOUR_PRIVACY_RESTRICTED": "YourPrivacyRestricted",
-    },
-    303: {
-        "_": "SeeOther",
-        "FILE_MIGRATE_X": "FileMigrate",
-        "NETWORK_MIGRATE_X": "NetworkMigrate",
-        "PHONE_MIGRATE_X": "PhoneMigrate",
-        "STATS_MIGRATE_X": "StatsMigrate",
-        "USER_MIGRATE_X": "UserMigrate",
-    },
-    503: {
-        "_": "ServiceUnavailable",
-        "ApiCallError": "ApiCallError",
-        "Timedout": "Timedout",
-        "Timeout": "Timeout",
-    },
     406: {
         "_": "NotAcceptable",
         "AUTH_KEY_DUPLICATED": "AuthKeyDuplicated",
@@ -767,6 +759,14 @@ exceptions = {
         "WORKER_BUSY_TOO_LONG_RETRY": "WorkerBusyTooLongRetry",
         "WP_ID_GENERATE_FAILED": "WpIdGenerateFailed",
     },
+    303: {
+        "_": "SeeOther",
+        "FILE_MIGRATE_X": "FileMigrate",
+        "NETWORK_MIGRATE_X": "NetworkMigrate",
+        "PHONE_MIGRATE_X": "PhoneMigrate",
+        "STATS_MIGRATE_X": "StatsMigrate",
+        "USER_MIGRATE_X": "UserMigrate",
+    },
     420: {
         "_": "Flood",
         "2FA_CONFIRM_WAIT_X": "TwoFaConfirmWait",

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,
+    )

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:

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
             )
         )

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)
         )