WPyrogram 2.0.149__py3-none-any.whl → 2.0.150__py3-none-any.whl

{WPyrogram-2.0.149.dist-info → WPyrogram-2.0.150.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: WPyrogram
-Version: 2.0.149
+Version: 2.0.150
 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.149.dist-info → WPyrogram-2.0.150.dist-info}/RECORD

@@ -1,13 +1,13 @@
-pyrogram/__init__.py,sha256=L-6OARe-oYpXLMQHueWSGqR9-I2LOxiaFGRcxtcbFkM,1401
-pyrogram/client.py,sha256=cVEv_0pVQVSooQI0fvvfTSOSFRfRwa-rEpK39665RA4,46022
-pyrogram/dispatcher.py,sha256=Xf1G216PcJX2rZFYujNGAcPuBKKvnGRNWPNIzJkYwUA,15465
+pyrogram/__init__.py,sha256=u9UQDjfd1cxA6-EUvI2Db2oi4v9yNdlVJUxGJuFcWG4,1401
+pyrogram/client.py,sha256=Tgtlw85sYEjgzI8cVPL7FwhiCvUNow7FsQcbn5Gx4nY,50088
+pyrogram/dispatcher.py,sha256=cJV2tUDAfgNAh0aSjRHqiWNUBQ7ipGzBNTyJHunxLxc,13947
 pyrogram/emoji.py,sha256=ixb3OXR1XpLf3BQpw8kWIpmbQRowRIaFedjdnuzljac,208021
 pyrogram/file_id.py,sha256=jmMBAt2O_XhLE_AXKffZ4F5gccXJB8GHV7MlFCpiklA,15154
-pyrogram/filters.py,sha256=eR_dAl8qwF-h3SZHLhwNtskh1AZIhp_khaNthK3TwxE,28225
+pyrogram/filters.py,sha256=5d7GL7W2OLwg9E8RUHLudQnbhdK7OrtFs2mSFTmoR1s,28802
 pyrogram/mime_types.py,sha256=JbYF6B-JrxZQNga8dPz2C8Dwp8-2pOrE1uv3KIBbjA0,61915
 pyrogram/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyrogram/sync.py,sha256=cxKmLz9NAJPX2N2n2CogTLXyNo-dWgf6etBRXnqq1XA,3739
-pyrogram/utils.py,sha256=5oyowGt07WMsDWvWPMpFal-dIsh1af5Qv9KzduB_KPQ,16372
+pyrogram/utils.py,sha256=HHlPe3CxShGPUidDdvCSXVgye5OeqTvmj-QUu5zyNh0,20125
 pyrogram/connection/__init__.py,sha256=q7KiWEV6VNDQGoj5s13GPyhRRlafXVPvX1h1VpAsVf8,854
 pyrogram/connection/connection.py,sha256=X5T7jd_lAXsH86f9gaNd4GDg4XIVnll7wrlVvSfgBJ0,2765
 pyrogram/connection/transport/__init__.py,sha256=nRpFdumPinBtuLOZkR8hH_vXlN7ChzW1oyJ6na4a8qw,838
@@ -3316,10 +3316,10 @@ pyrogram/types/user_and_chats/video_chat_ended.py,sha256=J5xTIAMSGDz8_z-EGrKwkoJ
 pyrogram/types/user_and_chats/video_chat_members_invited.py,sha256=9QhonApJd1XjOeJu9fqx2_u6nIOTZhfXZw_tX9XXxd8,1610
 pyrogram/types/user_and_chats/video_chat_scheduled.py,sha256=rUvDXF8r-2MfsAZKAcaWb_UZt5VoHebPjeJXWRDHGSo,1531
 pyrogram/types/user_and_chats/video_chat_started.py,sha256=WOAuM_CnkRA-W_Iedx0fIHB9RJ-AsvJIiSF05HzLRdA,1043
-WPyrogram-2.0.149.dist-info/COPYING,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-WPyrogram-2.0.149.dist-info/COPYING.lesser,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
-WPyrogram-2.0.149.dist-info/METADATA,sha256=RMMZapyMNYHNe1aDLXUJJgfB0FWgopZpk_HRwfpeKek,4922
-WPyrogram-2.0.149.dist-info/NOTICE,sha256=QL3iJdeVh_ZqRZZchyruQic5bYUWdx3yl0OkSUC2PQc,774
-WPyrogram-2.0.149.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-WPyrogram-2.0.149.dist-info/top_level.txt,sha256=vS2-tKX7dJ1uKjistE5CoOVbv4yqglA95SK0KFEDwl0,9
-WPyrogram-2.0.149.dist-info/RECORD,,
+WPyrogram-2.0.150.dist-info/COPYING,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+WPyrogram-2.0.150.dist-info/COPYING.lesser,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
+WPyrogram-2.0.150.dist-info/METADATA,sha256=AnGagkc8BFEJyL0oohTeuZo7eCyZeofShG0E-m1cEHE,4922
+WPyrogram-2.0.150.dist-info/NOTICE,sha256=QL3iJdeVh_ZqRZZchyruQic5bYUWdx3yl0OkSUC2PQc,774
+WPyrogram-2.0.150.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+WPyrogram-2.0.150.dist-info/top_level.txt,sha256=vS2-tKX7dJ1uKjistE5CoOVbv4yqglA95SK0KFEDwl0,9
+WPyrogram-2.0.150.dist-info/RECORD,,

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.149"
+__version__ = "2.0.150"
 __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
+from typing import Union, List, Optional, Callable, AsyncGenerator, Type, Tuple
 
 import pyrogram
 from pyrogram import __version__, __license__
@@ -45,7 +45,8 @@ from pyrogram.errors import (
     SessionPasswordNeeded,
     VolumeLocNotFound, ChannelPrivate,
     BadRequest, AuthBytesInvalid,
-    FloodWait, FloodPremiumWait
+    FloodWait, FloodPremiumWait,
+    ChannelInvalid, PersistentTimestampInvalid, PersistentTimestampOutdated
 )
 from pyrogram.handlers.handler import Handler
 from pyrogram.methods import Methods
@@ -53,6 +54,8 @@ from pyrogram.session import Auth, Session
 from pyrogram.storage import Storage, FileStorage, MemoryStorage
 from pyrogram.types import User, TermsOfService
 from pyrogram.utils import ainput
+from .connection import Connection
+from .connection.transport import TCP, TCPAbridged
 from .dispatcher import Dispatcher
 from .file_id import FileId, FileType, ThumbnailSource
 from .mime_types import mime_types
@@ -264,7 +267,9 @@ class Client(Methods):
         max_message_cache_size: int = MAX_MESSAGE_CACHE_SIZE,
         storage_engine: Optional[Storage] = None,
         client_platform: "enums.ClientPlatform" = enums.ClientPlatform.OTHER,
-        init_connection_params: Optional["raw.base.JSONValue"] = None
+        init_connection_params: Optional["raw.base.JSONValue"] = None,
+        connection_factory: Type[Connection] = Connection,
+        protocol_factory: Type[TCP] = TCPAbridged
     ):
         super().__init__()
 
@@ -299,6 +304,8 @@ class Client(Methods):
         self.max_message_cache_size = max_message_cache_size
         self.client_platform = client_platform
         self.init_connection_params = init_connection_params
+        self.connection_factory = connection_factory
+        self.protocol_factory = protocol_factory
 
         self.executor = ThreadPoolExecutor(self.workers, thread_name_prefix="Handler")
 
@@ -541,25 +548,26 @@ class Client(Methods):
     async def fetch_peers(self, peers: List[Union[raw.types.User, raw.types.Chat, raw.types.Channel]]) -> bool:
         is_min = False
         parsed_peers = []
+        parsed_usernames = []
 
         for peer in peers:
             if getattr(peer, "min", False):
                 is_min = True
                 continue
 
-            usernames = None
+            usernames = []
             phone_number = None
 
             if isinstance(peer, raw.types.User):
                 peer_id = peer.id
                 access_hash = peer.access_hash
-                usernames = (
-                    [peer.username.lower()] if peer.username
-                    else [username.username.lower() for username in peer.usernames] if peer.usernames
-                    else None
-                )
                 phone_number = peer.phone
                 peer_type = "bot" if peer.bot else "user"
+
+                if peer.username:
+                    usernames.append(peer.username.lower())
+                elif peer.usernames:
+                    usernames.extend(username.username.lower() for username in peer.usernames)
             elif isinstance(peer, (raw.types.Chat, raw.types.ChatForbidden)):
                 peer_id = -peer.id
                 access_hash = 0
@@ -567,12 +575,12 @@ class Client(Methods):
             elif isinstance(peer, raw.types.Channel):
                 peer_id = utils.get_channel_id(peer.id)
                 access_hash = peer.access_hash
-                usernames = (
-                    [peer.username.lower()] if peer.username
-                    else [username.username.lower() for username in peer.usernames] if peer.usernames
-                    else None
-                )
                 peer_type = "channel" if peer.broadcast else "supergroup"
+
+                if peer.username:
+                    usernames.append(peer.username.lower())
+                elif peer.usernames:
+                    usernames.extend(username.username.lower() for username in peer.usernames)
             elif isinstance(peer, raw.types.ChannelForbidden):
                 peer_id = utils.get_channel_id(peer.id)
                 access_hash = peer.access_hash
@@ -580,9 +588,11 @@ class Client(Methods):
             else:
                 continue
 
-            parsed_peers.append((peer_id, access_hash, peer_type, usernames, phone_number))
+            parsed_peers.append((peer_id, access_hash, peer_type, phone_number))
+            parsed_usernames.append((peer_id, usernames))
 
         await self.storage.update_peers(parsed_peers)
+        await self.storage.update_usernames(parsed_usernames)
 
         return is_min
 
@@ -639,10 +649,11 @@ class Client(Methods):
                                         )]
                                     ),
                                     pts=pts - pts_count,
-                                    limit=pts
+                                    limit=pts,
+                                    force=False
                                 )
                             )
-                        except ChannelPrivate:
+                        except (ChannelPrivate, PersistentTimestampOutdated, PersistentTimestampInvalid):
                             pass
                         else:
                             if not isinstance(diff, raw.types.updates.ChannelDifferenceEmpty):
@@ -688,6 +699,92 @@ class Client(Methods):
         elif isinstance(updates, raw.types.UpdatesTooLong):
             log.info(updates)
 
+    async def recover_gaps(self) -> Tuple[int, int]:
+        states = await self.storage.update_state()
+
+        message_updates_counter = 0
+        other_updates_counter = 0
+
+        if not states:
+            log.info("No states found, skipping recovery.")
+            return (message_updates_counter, other_updates_counter)
+
+        for state in states:
+            id, local_pts, _, local_date, _ = state
+
+            prev_pts = 0
+
+            while True:
+                try:
+                    diff = await self.invoke(
+                        raw.functions.updates.GetChannelDifference(
+                            channel=await self.resolve_peer(id),
+                            filter=raw.types.ChannelMessagesFilterEmpty(),
+                            pts=local_pts,
+                            limit=10000,
+                            force=False
+                        ) if id < 0 else
+                        raw.functions.updates.GetDifference(
+                            pts=local_pts,
+                            date=local_date,
+                            qts=0
+                        )
+                    )
+                except (ChannelPrivate, ChannelInvalid, PersistentTimestampOutdated, PersistentTimestampInvalid):
+                    break
+
+                if isinstance(diff, raw.types.updates.DifferenceEmpty):
+                    break
+                elif isinstance(diff, raw.types.updates.DifferenceTooLong):
+                    break
+                elif isinstance(diff, raw.types.updates.Difference):
+                    local_pts = diff.state.pts
+                elif isinstance(diff, raw.types.updates.DifferenceSlice):
+                    local_pts = diff.intermediate_state.pts
+                    local_date = diff.intermediate_state.date
+
+                    if prev_pts == local_pts:
+                        break
+
+                    prev_pts = local_pts
+                elif isinstance(diff, raw.types.updates.ChannelDifferenceEmpty):
+                    break
+                elif isinstance(diff, raw.types.updates.ChannelDifferenceTooLong):
+                    break
+                elif isinstance(diff, raw.types.updates.ChannelDifference):
+                    local_pts = diff.pts
+
+                users = {i.id: i for i in diff.users}
+                chats = {i.id: i for i in diff.chats}
+
+                for message in diff.new_messages:
+                    message_updates_counter += 1
+                    self.dispatcher.updates_queue.put_nowait(
+                        (
+                            raw.types.UpdateNewMessage(
+                                message=message,
+                                pts=local_pts,
+                                pts_count=-1
+                            ),
+                            users,
+                            chats
+                        )
+                    )
+
+                for update in diff.other_updates:
+                    other_updates_counter += 1
+                    self.dispatcher.updates_queue.put_nowait(
+                        (update, users, chats)
+                    )
+
+                if isinstance(diff, (raw.types.updates.Difference, raw.types.updates.ChannelDifference)):
+                    break
+
+            await self.storage.update_state(id)
+
+        log.info("Recovered %s messages and %s updates.", message_updates_counter, other_updates_counter)
+        return (message_updates_counter, other_updates_counter)
+
     async def load_session(self):
         await self.storage.open()
 

pyrogram/dispatcher.py

@@ -22,13 +22,12 @@ import logging
 from collections import OrderedDict
 
 import pyrogram
-from pyrogram import errors
 from pyrogram import utils
-from pyrogram import raw
 from pyrogram.handlers import (
     CallbackQueryHandler, MessageHandler, EditedMessageHandler, DeletedMessagesHandler,
     UserStatusHandler, RawUpdateHandler, InlineQueryHandler, PollHandler, PreCheckoutQueryHandler,
-    ChosenInlineResultHandler, ChatMemberUpdatedHandler, ChatJoinRequestHandler, StoryHandler
+    ChosenInlineResultHandler, ChatMemberUpdatedHandler, ChatJoinRequestHandler, StoryHandler,
+    ShippingQueryHandler, MessageReactionHandler, MessageReactionCountHandler, ChatBoostHandler
 )
 from pyrogram.raw.types import (
     UpdateNewMessage, UpdateNewChannelMessage, UpdateNewScheduledMessage,
@@ -38,7 +37,9 @@ from pyrogram.raw.types import (
     UpdateBotCallbackQuery, UpdateInlineBotCallbackQuery, UpdateBotPrecheckoutQuery,
     UpdateUserStatus, UpdateBotInlineQuery, UpdateMessagePoll,
     UpdateBotInlineSend, UpdateChatParticipant, UpdateChannelParticipant,
-    UpdateBotChatInviteRequester, UpdateStory
+    UpdateBotChatInviteRequester, UpdateStory, UpdateBotShippingQuery, UpdateBotMessageReaction,
+    UpdateBotMessageReactions, UpdateBotChatBoost, UpdateBusinessBotCallbackQuery,
+    UpdateBotPurchasedPaidMedia, UpdateMessagePollVote
 )
 
 log = logging.getLogger(__name__)
@@ -48,15 +49,20 @@ class Dispatcher:
     NEW_MESSAGE_UPDATES = (UpdateNewMessage, UpdateNewChannelMessage, UpdateNewScheduledMessage, UpdateBotNewBusinessMessage)
     EDIT_MESSAGE_UPDATES = (UpdateEditMessage, UpdateEditChannelMessage, UpdateBotEditBusinessMessage)
     DELETE_MESSAGES_UPDATES = (UpdateDeleteMessages, UpdateDeleteChannelMessages, UpdateBotDeleteBusinessMessage)
-    CALLBACK_QUERY_UPDATES = (UpdateBotCallbackQuery, UpdateInlineBotCallbackQuery)
+    CALLBACK_QUERY_UPDATES = (UpdateBotCallbackQuery, UpdateInlineBotCallbackQuery, UpdateBusinessBotCallbackQuery)
     CHAT_MEMBER_UPDATES = (UpdateChatParticipant, UpdateChannelParticipant)
     USER_STATUS_UPDATES = (UpdateUserStatus,)
     BOT_INLINE_QUERY_UPDATES = (UpdateBotInlineQuery,)
-    POLL_UPDATES = (UpdateMessagePoll,)
+    POLL_UPDATES = (UpdateMessagePoll, UpdateMessagePollVote)
     CHOSEN_INLINE_RESULT_UPDATES = (UpdateBotInlineSend,)
     CHAT_JOIN_REQUEST_UPDATES = (UpdateBotChatInviteRequester,)
     NEW_STORY_UPDATES = (UpdateStory,)
     PRE_CHECKOUT_QUERY_UPDATES = (UpdateBotPrecheckoutQuery,)
+    SHIPPING_QUERY_UPDATES = (UpdateBotShippingQuery,)
+    MESSAGE_REACTION_UPDATES = (UpdateBotMessageReaction,)
+    MESSAGE_REACTION_COUNT_UPDATES = (UpdateBotMessageReactions,)
+    CHAT_BOOST_UPDATES = (UpdateBotChatBoost,)
+    PURCHASED_PAID_MEDIA_UPDATES = (UpdateBotPurchasedPaidMedia,)
 
     def __init__(self, client: "pyrogram.Client"):
         self.client = client
@@ -69,6 +75,8 @@ class Dispatcher:
         self.groups = OrderedDict()
 
         async def message_parser(update, users, chats):
+            connection_id = getattr(update, "connection_id", None)
+
             return (
                 await pyrogram.types.Message._parse(
                     self.client,
@@ -76,8 +84,9 @@ class Dispatcher:
                     users,
                     chats,
                     is_scheduled=isinstance(update, UpdateNewScheduledMessage),
-                    business_connection_id=getattr(update, "connection_id", None),
-                    reply_to_message=getattr(update, "reply_to_message", None)
+                    replies=0 if getattr(update, "connection_id", None) else 1,
+                    business_connection_id=connection_id,
+                    raw_reply_to_message=getattr(update, "reply_to_message", None)
                 ),
                 MessageHandler
             )
@@ -99,7 +108,7 @@ class Dispatcher:
 
         async def callback_query_parser(update, users, chats):
             return (
-                await pyrogram.types.CallbackQuery._parse(self.client, update, users),
+                await pyrogram.types.CallbackQuery._parse(self.client, update, users, chats),
                 CallbackQueryHandler
             )
 
@@ -117,7 +126,7 @@ class Dispatcher:
 
         async def poll_parser(update, users, chats):
             return (
-                pyrogram.types.Poll._parse_update(self.client, update),
+                pyrogram.types.Poll._parse_update(self.client, update, users),
                 PollHandler
             )
 
@@ -151,6 +160,36 @@ class Dispatcher:
                 PreCheckoutQueryHandler
             )
 
+        async def shipping_query_parser(update, users, chats):
+            return (
+                await pyrogram.types.ShippingQuery._parse(self.client, update, users),
+                ShippingQueryHandler
+            )
+
+        async def message_reaction_parser(update, users, chats):
+            return (
+                pyrogram.types.MessageReactionUpdated._parse(self.client, update, users, chats),
+                MessageReactionHandler
+            )
+
+        async def message_reaction_count_parser(update, users, chats):
+            return (
+                pyrogram.types.MessageReactionCountUpdated._parse(self.client, update, users, chats),
+                MessageReactionCountHandler
+            )
+
+        async def chat_boost_parser(update, users, chats):
+            return (
+                pyrogram.types.ChatBoostUpdated._parse(self.client, update, users, chats),
+                ChatBoostHandler
+            )
+
+        async def purchased_paid_media_parser(update, users, chats):
+            return (
+                pyrogram.types.PurchasedPaidMedia._parse(self.client, update, users),
+                ChatBoostHandler
+            )
+
         self.update_parsers = {
             Dispatcher.NEW_MESSAGE_UPDATES: message_parser,
             Dispatcher.EDIT_MESSAGE_UPDATES: edited_message_parser,
@@ -163,7 +202,12 @@ class Dispatcher:
             Dispatcher.CHAT_MEMBER_UPDATES: chat_member_updated_parser,
             Dispatcher.CHAT_JOIN_REQUEST_UPDATES: chat_join_request_parser,
             Dispatcher.NEW_STORY_UPDATES: story_parser,
-            Dispatcher.PRE_CHECKOUT_QUERY_UPDATES: pre_checkout_query_parser
+            Dispatcher.PRE_CHECKOUT_QUERY_UPDATES: pre_checkout_query_parser,
+            Dispatcher.SHIPPING_QUERY_UPDATES: shipping_query_parser,
+            Dispatcher.MESSAGE_REACTION_UPDATES: message_reaction_parser,
+            Dispatcher.MESSAGE_REACTION_COUNT_UPDATES: message_reaction_count_parser,
+            Dispatcher.CHAT_BOOST_UPDATES: chat_boost_parser,
+            Dispatcher.PURCHASED_PAID_MEDIA_UPDATES: purchased_paid_media_parser,
         }
 
         self.update_parsers = {key: value for key_tuple, value in self.update_parsers.items() for key in key_tuple}
@@ -180,93 +224,7 @@ class Dispatcher:
             log.info("Started %s HandlerTasks", self.client.workers)
 
             if not self.client.skip_updates:
-                states = await self.client.storage.update_state()
-
-                if not states:
-                    log.info("No states found, skipping recovery.")
-                    return
-
-                message_updates_counter = 0
-                other_updates_counter = 0
-
-                for state in states:
-                    id, local_pts, _, local_date, _ = state
-
-                    prev_pts = 0
-
-                    while True:
-                        try:
-                            diff = await self.client.invoke(
-                                raw.functions.updates.GetChannelDifference(
-                                    channel=await self.client.resolve_peer(id),
-                                    filter=raw.types.ChannelMessagesFilterEmpty(),
-                                    pts=local_pts,
-                                    limit=10000
-                                ) if id < 0 else
-                                raw.functions.updates.GetDifference(
-                                    pts=local_pts,
-                                    date=local_date,
-                                    qts=0
-                                )
-                            )
-                        except (errors.ChannelPrivate, errors.ChannelInvalid):
-                            break
-
-                        if isinstance(diff, raw.types.updates.DifferenceEmpty):
-                            break
-                        elif isinstance(diff, raw.types.updates.DifferenceTooLong):
-                            break
-                        elif isinstance(diff, raw.types.updates.Difference):
-                            local_pts = diff.state.pts
-                        elif isinstance(diff, raw.types.updates.DifferenceSlice):
-                            local_pts = diff.intermediate_state.pts
-                            local_date = diff.intermediate_state.date
-
-                            if prev_pts == local_pts:
-                                break
-
-                            prev_pts = local_pts
-                        elif isinstance(diff, raw.types.updates.ChannelDifferenceEmpty):
-                            break
-                        elif isinstance(diff, raw.types.updates.ChannelDifferenceTooLong):
-                            break
-                        elif isinstance(diff, raw.types.updates.ChannelDifference):
-                            local_pts = diff.pts
-
-                        users = {i.id: i for i in getattr(diff, "users", [])}
-                        chats = {i.id: i for i in getattr(diff, "chats", [])}
-
-                        for message in diff.new_messages:
-                            message_updates_counter += 1
-                            self.updates_queue.put_nowait(
-                                (
-                                    raw.types.UpdateNewMessage(
-                                        message=message,
-                                        pts=local_pts,
-                                        pts_count=-1
-                                    ) if id == self.client.me.id else
-                                    raw.types.UpdateNewChannelMessage(
-                                        message=message,
-                                        pts=local_pts,
-                                        pts_count=-1
-                                    ),
-                                    users,
-                                    chats
-                                )
-                            )
-
-                        for update in diff.other_updates:
-                            other_updates_counter += 1
-                            self.updates_queue.put_nowait(
-                                (update, users, chats)
-                            )
-
-                        if isinstance(diff, (raw.types.updates.Difference, raw.types.updates.ChannelDifference)):
-                            break
-
-                    await self.client.storage.update_state(id)
-
-                log.info("Recovered %s messages and %s updates.", message_updates_counter, other_updates_counter)
+                await self.client.recover_gaps()
 
     async def stop(self):
         if not self.client.no_updates:
@@ -345,7 +303,12 @@ class Dispatcher:
                                     continue
 
                             elif isinstance(handler, RawUpdateHandler):
-                                args = (update, users, chats)
+                                try:
+                                    if await handler.check(self.client, update):
+                                        args = (update, users, chats)
+                                except Exception as e:
+                                    log.exception(e)
+                                    continue
 
                             if args is None:
                                 continue

pyrogram/filters.py

@@ -18,7 +18,7 @@
 
 import inspect
 import re
-from typing import Callable, Union, List, Pattern
+from typing import Callable, Union, List, Pattern, Optional
 
 import pyrogram
 from pyrogram import enums
@@ -261,6 +261,16 @@ caption = create(caption_filter)
 
 # endregion
 
+# region self_destruction_filter
+async def self_destruction_filter(_, __, m: Message):
+    return bool(m.media and getattr(getattr(m, m.media.value, None), "ttl_seconds", None))
+
+
+self_destruction = create(self_destruction_filter)
+"""Filter self-destruction media messages."""
+
+
+# endregion
 
 # region audio_filter
 async def audio_filter(_, __, m: Message):
@@ -339,13 +349,13 @@ giveaway = create(giveaway_filter)
 
 # endregion
 
-# region giveaway_result_filter
-async def giveaway_result_filter(_, __, m: Message):
-    return bool(m.giveaway_result)
+# region giveaway_winners_filter
+async def giveaway_winners_filter(_, __, m: Message):
+    return bool(m.giveaway_winners)
 
 
-giveaway_result = create(giveaway_result_filter)
-"""Filter messages that contain :obj:`~pyrogram.types.GiveawayResult` objects."""
+giveaway_winners = create(giveaway_winners_filter)
+"""Filter messages that contain :obj:`~pyrogram.types.GiveawayWinners` objects."""
 
 
 # endregion
@@ -359,6 +369,17 @@ gift_code = create(gift_code_filter)
 """Filter messages that contain :obj:`~pyrogram.types.GiftCode` objects."""
 
 
+# endregion
+
+# region star_gift_filter
+async def star_gift_filter(_, __, m: Message):
+    return bool(m.star_gift)
+
+
+star_gift = create(star_gift_filter)
+"""Filter messages that contain :obj:`~pyrogram.types.StarGift` objects."""
+
+
 # endregion
 
 # region requested_chats_filter
@@ -971,7 +992,7 @@ def regex(pattern: Union[str, Pattern], flags: int = 0):
         elif isinstance(update, InlineQuery):
             value = update.query
         elif isinstance(update, PreCheckoutQuery):
-            value = update.payload
+            value = update.invoice_payload
         else:
             raise ValueError(f"Regex filter doesn't work with {type(update)}")
 
@@ -1001,7 +1022,7 @@ class user(Filter, set):
             Defaults to None (no users).
     """
 
-    def __init__(self, users: Union[int, str, List[Union[int, str]]] = None):
+    def __init__(self, users: Optional[Union[int, str, List[Union[int, str]]]] = None):
         users = [] if users is None else users if isinstance(users, list) else [users]
 
         super().__init__(
@@ -1033,7 +1054,7 @@ class chat(Filter, set):
             Defaults to None (no chats).
     """
 
-    def __init__(self, chats: Union[int, str, List[Union[int, str]]] = None):
+    def __init__(self, chats: Optional[Union[int, str, List[Union[int, str]]]] = None):
         chats = [] if chats is None else chats if isinstance(chats, list) else [chats]
 
         super().__init__(
@@ -1066,7 +1087,7 @@ class topic(Filter, set):
             Defaults to None (no topics).
     """
 
-    def __init__(self, topics: Union[int, List[int]] = None):
+    def __init__(self, topics: Optional[Union[int, List[int]]] = None):
         topics = [] if topics is None else topics if isinstance(topics, list) else [topics]
 
         super().__init__(

pyrogram/utils.py

@@ -16,21 +16,23 @@
 #  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 concurrent.futures.thread import ThreadPoolExecutor
+from datetime import datetime, timezone
+from getpass import getpass
+from io import BytesIO
+from typing import Union, List, Dict, Optional
 import asyncio
 import base64
 import functools
 import hashlib
 import os
-import struct
-from concurrent.futures.thread import ThreadPoolExecutor
-from datetime import datetime, timezone
-from getpass import getpass
 import re
-from typing import Union, List, Dict, Optional
+import struct
 
 import pyrogram
 from pyrogram import raw, enums
 from pyrogram import types
+from pyrogram.types.messages_and_media.message import Str
 from pyrogram.file_id import FileId, FileType, PHOTO_TYPES, DOCUMENT_TYPES
 
 
@@ -89,122 +91,112 @@ def get_input_media_from_file_id(
 
 
 async def parse_messages(
-    client,
-    messages: "raw.types.messages.Messages",
+    client: "pyrogram.Client",
+    messages: Union["raw.base.messages.Messages", "raw.base.Updates"],
     replies: int = 1,
     business_connection_id: str = None
 ) -> List["types.Message"]:
-    users = {i.id: i for i in messages.users if hasattr(i, "id")}
-    chats = {i.id: i for i in messages.chats  if hasattr(i, "id")}
-    topics = {i.id: i for i in messages.topics if hasattr(i, "id")} \
-        if hasattr(messages, "topics") else None
-
-    if not messages.messages:
-        return types.List()
+    users = {i.id: i for i in getattr(messages, "users", [])}
+    chats = {i.id: i for i in getattr(messages, "chats", [])}
+    topics = {i.id: i for i in getattr(messages, "topics", [])}
 
     parsed_messages = []
 
-    for message in messages.messages:
-        parsed_messages.append(
-            await types.Message._parse(
-                client,
-                message,
-                users,
-                chats,
-                topics,
-                replies=0,
-                business_connection_id=business_connection_id
-            )
+    if isinstance(
+        messages,
+        (
+            raw.types.messages.ChannelMessages,
+            raw.types.messages.Messages,
+            raw.types.messages.MessagesNotModified,
+            raw.types.messages.MessagesSlice
         )
+    ):
+        if not messages.messages:
+            return types.List()
+
+        for message in messages.messages:
+            parsed_messages.append(
+                await types.Message._parse(
+                    client=client,
+                    message=message,
+                    users=users,
+                    chats=chats,
+                    topics=topics,
+                    replies=0,
+                    business_connection_id=business_connection_id
+                )
+            )
 
-    if replies:
-        messages_with_replies = {
-            i.id: i.reply_to
-            for i in messages.messages
-            if not isinstance(i, raw.types.MessageEmpty) and i.reply_to and isinstance(i.reply_to, raw.types.MessageReplyHeader)
-        }
-
-        message_reply_to_story = {
-            i.id: {'user_id': i.reply_to.user_id, 'story_id': i.reply_to.story_id}
-            for i in messages.messages
-            if not isinstance(i, raw.types.MessageEmpty) and i.reply_to and isinstance(i.reply_to, raw.types.MessageReplyStoryHeader)
-        }
-
-        if messages_with_replies:
-            # We need a chat id, but some messages might be empty (no chat attribute available)
-            # Scan until we find a message with a chat available (there must be one, because we are fetching replies)
-            for m in parsed_messages:
-                if not isinstance(m, types.Message):
-                    continue
-
-                if m.chat:
-                    chat_id = m.chat.id
-                    break
-            else:
-                chat_id = 0
+        if replies:
+            messages_with_replies = {}
+            messages_with_story_replies = {}
 
-            is_all_within_chat = not any(
-                value.reply_to_peer_id
-                for value in messages_with_replies.values()
-            )
-            reply_messages: List[pyrogram.types.Message] = []
-            if is_all_within_chat:
-                # fast path: fetch all messages within the same chat
-                reply_messages = await client.get_messages(
-                    chat_id,
-                    reply_to_message_ids=messages_with_replies.keys(),
-                    replies=replies - 1
-                )
-            else:
-                # slow path: fetch all messages individually
-                for target_reply_to in messages_with_replies.values():
-                    to_be_added_msg = None
-                    the_chat_id = chat_id
-                    if target_reply_to.reply_to_peer_id:
-                        the_chat_id = get_channel_id(target_reply_to.reply_to_peer_id.channel_id)
-                    to_be_added_msg = await client.get_messages(
-                        chat_id=the_chat_id,
-                        message_ids=target_reply_to.reply_to_msg_id,
-                        replies=replies - 1
-                    )
-                    if isinstance(to_be_added_msg, list):
-                        for current_to_be_added in to_be_added_msg:
-                            reply_messages.append(current_to_be_added)
-                    elif to_be_added_msg:
-                        reply_messages.append(to_be_added_msg)
-
-            for message in parsed_messages:
-                reply_to = messages_with_replies.get(message.id, None)
-                if not reply_to:
+            for m in messages.messages:
+                if isinstance(m, raw.types.MessageEmpty):
                     continue
 
-                reply_id = reply_to.reply_to_msg_id
+                if m.reply_to and isinstance(m.reply_to, raw.types.MessageReplyHeader):
+                    messages_with_replies[m.id] = m.reply_to
 
-                for reply in reply_messages:
-                    if reply.id == reply_id and not reply.forum_topic_created:
-                        message.reply_to_message = reply
+                if m.reply_to and isinstance(m.reply_to, raw.types.MessageReplyStoryHeader):
+                    messages_with_story_replies[m.id] = m.reply_to
 
-        if message_reply_to_story:
-            for m in parsed_messages:
-                if not isinstance(m, types.Message):
-                    continue
+            if messages_with_replies:
+                # We need a chat id, but some messages might be empty (no chat attribute available)
+                # Scan until we find a message with a chat available (there must be one, because we are fetching replies)
+                chat_id = next((m.chat.id for m in parsed_messages if m.chat), 0)
 
-                if m.chat:
-                    chat_id = m.chat.id
-                    break
-            else:
-                chat_id = 0
+                is_all_replies_in_same_chat = not any(m.reply_to_peer_id for m in messages_with_replies.values())
+                reply_messages: List["types.Message"] = []
 
-            reply_messages = {}
-            for msg_id in message_reply_to_story:
-                reply_messages[msg_id] = await client.get_stories(
-                    message_reply_to_story[msg_id]['user_id'],
-                    message_reply_to_story[msg_id]['story_id']
+                if is_all_replies_in_same_chat:
+                    reply_messages = await client.get_messages(
+                        chat_id,
+                        reply_to_message_ids=list(messages_with_replies.keys()),
+                        replies=replies - 1
+                    )
+                else:
+                    for reply_header in messages_with_replies.values():
+                        reply_messages.append(
+                            await client.get_messages(
+                                chat_id=get_peer_id(reply_header.reply_to_peer_id) if getattr(reply_header, "reply_to_peer_id", None) else chat_id,
+                                message_ids=reply_header.reply_to_msg_id,
+                                replies=replies - 1
+                            )
+                        )
+
+                for message in parsed_messages:
+                    reply_to = messages_with_replies.get(message.id, None)
+
+                    if not reply_to:
+                        continue
+
+                    for reply in reply_messages:
+                        if reply.id == reply_to.reply_to_msg_id:
+                            message.reply_to_message = reply
+    else:
+        for u in getattr(messages, "updates", []):
+            if isinstance(
+                u,
+                (
+                    raw.types.UpdateNewMessage,
+                    raw.types.UpdateNewChannelMessage,
+                    raw.types.UpdateNewScheduledMessage,
+                    raw.types.UpdateBotNewBusinessMessage,
+                )
+            ):
+                parsed_messages.append(
+                    await types.Message._parse(
+                        client,
+                        u.message,
+                        users,
+                        chats,
+                        is_scheduled=isinstance(u, raw.types.UpdateNewScheduledMessage),
+                        business_connection_id=getattr(u, "connection_id", business_connection_id),
+                        raw_reply_to_message=getattr(u, "reply_to_message", None),
+                        replies=0
+                    )
                 )
-
-            for message in parsed_messages:
-                if message.id in reply_messages:
-                    message.reply_to_story = reply_messages[message.id]
 
     return types.List(parsed_messages)
 
@@ -212,7 +204,6 @@ async def parse_messages(
 def parse_deleted_messages(client, update, users, chats) -> List["types.Message"]:
     messages = update.messages
     channel_id = getattr(update, "channel_id", None)
-    business_connection_id = getattr(update, "connection_id", None)
     peer = getattr(update, "peer", None)
 
     chat = None
@@ -244,7 +235,7 @@ def parse_deleted_messages(client, update, users, chats) -> List["types.Message"
             types.Message(
                 id=message,
                 chat=chat,
-                business_connection_id=business_connection_id,
+                business_connection_id=getattr(update, "connection_id", None),
                 client=client
             )
         )
@@ -465,8 +456,8 @@ def compute_password_check(
 async def parse_text_entities(
     client: "pyrogram.Client",
     text: str,
-    parse_mode: enums.ParseMode,
-    entities: List["types.MessageEntity"]
+    parse_mode: Optional[enums.ParseMode],
+    entities: Optional[List["types.MessageEntity"]]
 ) -> Dict[str, Union[str, List[raw.base.MessageEntity]]]:
     if entities:
         # Inject the client instance because parsing user mentions requires it
@@ -506,3 +497,80 @@ def get_first_url(text):
     matches = re.findall(r"(https?):\/\/([\w_-]+(?:(?:\.[\w_-]+)+))([\w.,@?^=%&:\/~+#-]*[\w@?^=%&\/~+#-])", text)
 
     return f"{matches[0][0]}://{matches[0][1]}{matches[0][2]}" if matches else None
+
+
+def parse_text_with_entities(client, message: "raw.types.TextWithEntities", users):
+    entities = types.List(
+        filter(
+            lambda x: x is not None,
+            [
+                types.MessageEntity._parse(client, entity, users)
+                for entity in getattr(message, "entities", [])
+            ]
+        )
+    )
+
+    return {
+        "text": Str(getattr(message, "text", "")).init(entities) or None,
+        "entities": entities or None
+    }
+
+
+def expand_inline_bytes(bytes_data: bytes):
+    if len(bytes_data) < 3 or bytes_data[0] != 0x01:
+        return bytearray()
+
+    header = bytearray(
+        b"\xff\xd8\xff\xe0\x00\x10\x4a\x46\x49"
+        b"\x46\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00\xff\xdb\x00\x43\x00\x28\x1c"
+        b"\x1e\x23\x1e\x19\x28\x23\x21\x23\x2d\x2b\x28\x30\x3c\x64\x41\x3c\x37\x37"
+        b"\x3c\x7b\x58\x5d\x49\x64\x91\x80\x99\x96\x8f\x80\x8c\x8a\xa0\xb4\xe6\xc3"
+        b"\xa0\xaa\xda\xad\x8a\x8c\xc8\xff\xcb\xda\xee\xf5\xff\xff\xff\x9b\xc1\xff"
+        b"\xff\xff\xfa\xff\xe6\xfd\xff\xf8\xff\xdb\x00\x43\x01\x2b\x2d\x2d\x3c\x35"
+        b"\x3c\x76\x41\x41\x76\xf8\xa5\x8c\xa5\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8"
+        b"\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8"
+        b"\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8\xf8"
+        b"\xf8\xf8\xf8\xf8\xf8\xff\xc0\x00\x11\x08\x00\x00\x00\x00\x03\x01\x22\x00"
+        b"\x02\x11\x01\x03\x11\x01\xff\xc4\x00\x1f\x00\x00\x01\x05\x01\x01\x01\x01"
+        b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08"
+        b"\x09\x0a\x0b\xff\xc4\x00\xb5\x10\x00\x02\x01\x03\x03\x02\x04\x03\x05\x05"
+        b"\x04\x04\x00\x00\x01\x7d\x01\x02\x03\x00\x04\x11\x05\x12\x21\x31\x41\x06"
+        b"\x13\x51\x61\x07\x22\x71\x14\x32\x81\x91\xa1\x08\x23\x42\xb1\xc1\x15\x52"
+        b"\xd1\xf0\x24\x33\x62\x72\x82\x09\x0a\x16\x17\x18\x19\x1a\x25\x26\x27\x28"
+        b"\x29\x2a\x34\x35\x36\x37\x38\x39\x3a\x43\x44\x45\x46\x47\x48\x49\x4a\x53"
+        b"\x54\x55\x56\x57\x58\x59\x5a\x63\x64\x65\x66\x67\x68\x69\x6a\x73\x74\x75"
+        b"\x76\x77\x78\x79\x7a\x83\x84\x85\x86\x87\x88\x89\x8a\x92\x93\x94\x95\x96"
+        b"\x97\x98\x99\x9a\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xb2\xb3\xb4\xb5\xb6"
+        b"\xb7\xb8\xb9\xba\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xd2\xd3\xd4\xd5\xd6"
+        b"\xd7\xd8\xd9\xda\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xf1\xf2\xf3\xf4"
+        b"\xf5\xf6\xf7\xf8\xf9\xfa\xff\xc4\x00\x1f\x01\x00\x03\x01\x01\x01\x01\x01"
+        b"\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08"
+        b"\x09\x0a\x0b\xff\xc4\x00\xb5\x11\x00\x02\x01\x02\x04\x04\x03\x04\x07\x05"
+        b"\x04\x04\x00\x01\x02\x77\x00\x01\x02\x03\x11\x04\x05\x21\x31\x06\x12\x41"
+        b"\x51\x07\x61\x71\x13\x22\x32\x81\x08\x14\x42\x91\xa1\xb1\xc1\x09\x23\x33"
+        b"\x52\xf0\x15\x62\x72\xd1\x0a\x16\x24\x34\xe1\x25\xf1\x17\x18\x19\x1a\x26"
+        b"\x27\x28\x29\x2a\x35\x36\x37\x38\x39\x3a\x43\x44\x45\x46\x47\x48\x49\x4a"
+        b"\x53\x54\x55\x56\x57\x58\x59\x5a\x63\x64\x65\x66\x67\x68\x69\x6a\x73\x74"
+        b"\x75\x76\x77\x78\x79\x7a\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x92\x93\x94"
+        b"\x95\x96\x97\x98\x99\x9a\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xb2\xb3\xb4"
+        b"\xb5\xb6\xb7\xb8\xb9\xba\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xd2\xd3\xd4"
+        b"\xd5\xd6\xd7\xd8\xd9\xda\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xf2\xf3\xf4"
+        b"\xf5\xf6\xf7\xf8\xf9\xfa\xff\xda\x00\x0c\x03\x01\x00\x02\x11\x03\x11\x00"
+        b"\x3f\x00"
+    )
+
+    footer = bytearray(b"\xff\xd9")
+
+    header[164] = bytes_data[1]
+    header[166] = bytes_data[2]
+
+    return header + bytes_data[3:] + footer
+
+
+def from_inline_bytes(data: bytes, file_name: str = None) -> BytesIO:
+    b = BytesIO()
+
+    b.write(data)
+    b.name = file_name or f"photo_{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.jpg"
+
+    return b