Все подряд

.venv2/Lib/site-packages/telethon/__init__.py

@@ -0,0 +1,13 @@
+from .client.telegramclient import TelegramClient
+from .network import connection
+from .tl.custom import Button
+from .tl import patched as _  # import for its side-effects
+from . import version, events, utils, errors, types, functions, custom
+
+__version__ = version.__version__
+
+__all__ = [
+    'TelegramClient', 'Button',
+    'types', 'functions', 'custom', 'errors',
+    'events', 'utils', 'connection'
+]

.venv2/Lib/site-packages/telethon/_updates/__init__.py

@@ -0,0 +1,3 @@
+from .entitycache import EntityCache
+from .messagebox import MessageBox, GapError, PrematureEndReason
+from .session import SessionState, ChannelState, Entity, EntityType

.venv2/Lib/site-packages/telethon/_updates/entitycache.py

@@ -0,0 +1,62 @@
+from .session import EntityType, Entity
+
+
+_sentinel = object()
+
+
+class EntityCache:
+    def __init__(
+        self,
+        hash_map: dict = _sentinel,
+        self_id: int = None,
+        self_bot: bool = None
+    ):
+        self.hash_map = {} if hash_map is _sentinel else hash_map
+        self.self_id = self_id
+        self.self_bot = self_bot
+
+    def set_self_user(self, id, bot, hash):
+        self.self_id = id
+        self.self_bot = bot
+        if hash:
+            self.hash_map[id] = (hash, EntityType.BOT if bot else EntityType.USER)
+
+    def get(self, id):
+        try:
+            hash, ty = self.hash_map[id]
+            return Entity(ty, id, hash)
+        except KeyError:
+            return None
+
+    def extend(self, users, chats):
+        # See https://core.telegram.org/api/min for "issues" with "min constructors".
+        self.hash_map.update(
+            (u.id, (
+                u.access_hash,
+                EntityType.BOT if u.bot else EntityType.USER,
+            ))
+            for u in users
+            if getattr(u, 'access_hash', None) and not u.min
+        )
+        self.hash_map.update(
+            (c.id, (
+                c.access_hash,
+                EntityType.MEGAGROUP if c.megagroup else (
+                    EntityType.GIGAGROUP if getattr(c, 'gigagroup', None) else EntityType.CHANNEL
+                ),
+            ))
+            for c in chats
+            if getattr(c, 'access_hash', None) and not getattr(c, 'min', None)
+        )
+
+    def get_all_entities(self):
+        return [Entity(ty, id, hash) for id, (hash, ty) in self.hash_map.items()]
+
+    def put(self, entity):
+        self.hash_map[entity.id] = (entity.hash, entity.ty)
+
+    def retain(self, filter):
+        self.hash_map = {k: v for k, v in self.hash_map.items() if filter(k)}
+
+    def __len__(self):
+        return len(self.hash_map)

.venv2/Lib/site-packages/telethon/_updates/messagebox.py

@@ -0,0 +1,832 @@
+"""
+This module deals with correct handling of updates, including gaps, and knowing when the code
+should "get difference" (the set of updates that the client should know by now minus the set
+of updates that it actually knows).
+
+Each chat has its own [`Entry`] in the [`MessageBox`] (this `struct` is the "entry point").
+At any given time, the message box may be either getting difference for them (entry is in
+[`MessageBox::getting_diff_for`]) or not. If not getting difference, a possible gap may be
+found for the updates (entry is in [`MessageBox::possible_gaps`]). Otherwise, the entry is
+on its happy path.
+
+Gaps are cleared when they are either resolved on their own (by waiting for a short time)
+or because we got the difference for the corresponding entry.
+
+While there are entries for which their difference must be fetched,
+[`MessageBox::check_deadlines`] will always return [`Instant::now`], since "now" is the time
+to get the difference.
+"""
+import asyncio
+import datetime
+import time
+import logging
+from enum import Enum
+from .session import SessionState, ChannelState
+from ..tl import types as tl, functions as fn
+from ..helpers import get_running_loop
+
+
+# Telegram sends `seq` equal to `0` when "it doesn't matter", so we use that value too.
+NO_SEQ = 0
+
+# See https://core.telegram.org/method/updates.getChannelDifference.
+BOT_CHANNEL_DIFF_LIMIT = 100000
+USER_CHANNEL_DIFF_LIMIT = 100
+
+# > It may be useful to wait up to 0.5 seconds
+POSSIBLE_GAP_TIMEOUT = 0.5
+
+# After how long without updates the client will "timeout".
+#
+# When this timeout occurs, the client will attempt to fetch updates by itself, ignoring all the
+# updates that arrive in the meantime. After all updates are fetched when this happens, the
+# client will resume normal operation, and the timeout will reset.
+#
+# Documentation recommends 15 minutes without updates (https://core.telegram.org/api/updates).
+NO_UPDATES_TIMEOUT = 15 * 60
+
+# object() but with a tag to make it easier to debug
+class Sentinel:
+    __slots__ = ('tag',)
+
+    def __init__(self, tag=None):
+        self.tag = tag or '_'
+
+    def __repr__(self):
+        return self.tag
+
+# Entry "enum".
+# Account-wide `pts` includes private conversations (one-to-one) and small group chats.
+ENTRY_ACCOUNT = Sentinel('ACCOUNT')
+# Account-wide `qts` includes only "secret" one-to-one chats.
+ENTRY_SECRET = Sentinel('SECRET')
+# Integers will be Channel-specific `pts`, and includes "megagroup", "broadcast" and "supergroup" channels.
+
+# Python's logging doesn't define a TRACE level. Pick halfway between DEBUG and NOTSET.
+# We don't define a name for this as libraries shouldn't do that though.
+LOG_LEVEL_TRACE = (logging.DEBUG - logging.NOTSET) // 2
+
+_sentinel = Sentinel()
+
+def next_updates_deadline():
+    return get_running_loop().time() + NO_UPDATES_TIMEOUT
+
+def epoch():
+    return datetime.datetime(*time.gmtime(0)[:6]).replace(tzinfo=datetime.timezone.utc)
+
+class GapError(ValueError):
+    def __repr__(self):
+        return 'GapError()'
+
+
+class PrematureEndReason(Enum):
+    TEMPORARY_SERVER_ISSUES = 'tmp'
+    BANNED = 'ban'
+
+
+# Represents the information needed to correctly handle a specific `tl::enums::Update`.
+class PtsInfo:
+    __slots__ = ('pts', 'pts_count', 'entry')
+
+    def __init__(
+        self,
+        pts: int,
+        pts_count: int,
+        entry: object
+    ):
+        self.pts = pts
+        self.pts_count = pts_count
+        self.entry = entry
+
+    @classmethod
+    def from_update(cls, update):
+        pts = getattr(update, 'pts', None)
+        if pts:
+            pts_count = getattr(update, 'pts_count', None) or 0
+            try:
+                entry = update.message.peer_id.channel_id
+            except AttributeError:
+                entry = getattr(update, 'channel_id', None) or ENTRY_ACCOUNT
+            return cls(pts=pts, pts_count=pts_count, entry=entry)
+
+        qts = getattr(update, 'qts', None)
+        if qts:
+            pts_count = 1 if isinstance(update, tl.UpdateNewEncryptedMessage) else 0
+            return cls(pts=qts, pts_count=pts_count, entry=ENTRY_SECRET)
+
+        return None
+
+    def __repr__(self):
+        return f'PtsInfo(pts={self.pts}, pts_count={self.pts_count}, entry={self.entry})'
+
+
+# The state of a particular entry in the message box.
+class State:
+    __slots__ = ('pts', 'deadline')
+
+    def __init__(
+        self,
+        # Current local persistent timestamp.
+        pts: int,
+        # Next instant when we would get the update difference if no updates arrived before then.
+        deadline: float
+    ):
+        self.pts = pts
+        self.deadline = deadline
+
+    def __repr__(self):
+        return f'State(pts={self.pts}, deadline={self.deadline})'
+
+
+# > ### Recovering gaps
+# > […] Manually obtaining updates is also required in the following situations:
+# > • Loss of sync: a gap was found in `seq` / `pts` / `qts` (as described above).
+# >   It may be useful to wait up to 0.5 seconds in this situation and abort the sync in case a new update
+# >   arrives, that fills the gap.
+#
+# This is really easy to trigger by spamming messages in a channel (with as little as 3 members works), because
+# the updates produced by the RPC request take a while to arrive (whereas the read update comes faster alone).
+class PossibleGap:
+    __slots__ = ('deadline', 'updates')
+
+    def __init__(
+        self,
+        deadline: float,
+        # Pending updates (those with a larger PTS, producing the gap which may later be filled).
+        updates: list  # of updates
+    ):
+        self.deadline = deadline
+        self.updates = updates
+
+    def __repr__(self):
+        return f'PossibleGap(deadline={self.deadline}, update_count={len(self.updates)})'
+
+
+# Represents a "message box" (event `pts` for a specific entry).
+#
+# See https://core.telegram.org/api/updates#message-related-event-sequences.
+class MessageBox:
+    __slots__ = ('_log', 'map', 'date', 'seq', 'next_deadline', 'possible_gaps', 'getting_diff_for')
+
+    def __init__(
+        self,
+        log,
+        # Map each entry to their current state.
+        map: dict = _sentinel,  # entry -> state
+
+        # Additional fields beyond PTS needed by `ENTRY_ACCOUNT`.
+        date: datetime.datetime = epoch() + datetime.timedelta(seconds=1),
+        seq: int = NO_SEQ,
+
+        # Holds the entry with the closest deadline (optimization to avoid recalculating the minimum deadline).
+        next_deadline: object = None,  # entry
+
+        # Which entries have a gap and may soon trigger a need to get difference.
+        #
+        # If a gap is found, stores the required information to resolve it (when should it timeout and what updates
+        # should be held in case the gap is resolved on its own).
+        #
+        # Not stored directly in `map` as an optimization (else we would need another way of knowing which entries have
+        # a gap in them).
+        possible_gaps: dict = _sentinel,  # entry -> possiblegap
+
+        # For which entries are we currently getting difference.
+        getting_diff_for: set = _sentinel,  # entry
+    ):
+        self._log = log
+        self.map = {} if map is _sentinel else map
+        self.date = date
+        self.seq = seq
+        self.next_deadline = next_deadline
+        self.possible_gaps = {} if possible_gaps is _sentinel else possible_gaps
+        self.getting_diff_for = set() if getting_diff_for is _sentinel else getting_diff_for
+
+        if __debug__:
+            self._trace('MessageBox initialized')
+
+    def _trace(self, msg, *args, **kwargs):
+        # Calls to trace can't really be removed beforehand without some dark magic.
+        # So every call to trace is prefixed with `if __debug__`` instead, to remove
+        # it when using `python -O`. Probably unnecessary, but it's nice to avoid
+        # paying the cost for something that is not used.
+        self._log.log(LOG_LEVEL_TRACE, 'Current MessageBox state: seq = %r, date = %s, map = %r',
+                      self.seq, self.date.isoformat(), self.map)
+        self._log.log(LOG_LEVEL_TRACE, msg, *args, **kwargs)
+
+    # region Creation, querying, and setting base state.
+
+    def load(self, session_state, channel_states):
+        """
+        Create a [`MessageBox`] from a previously known update state.
+        """
+        if __debug__:
+            self._trace('Loading MessageBox with session_state = %r, channel_states = %r', session_state, channel_states)
+
+        deadline = next_updates_deadline()
+
+        self.map.clear()
+        if session_state.pts != NO_SEQ:
+            self.map[ENTRY_ACCOUNT] = State(pts=session_state.pts, deadline=deadline)
+        if session_state.qts != NO_SEQ:
+            self.map[ENTRY_SECRET] = State(pts=session_state.qts, deadline=deadline)
+        self.map.update((s.channel_id, State(pts=s.pts, deadline=deadline)) for s in channel_states)
+
+        self.date = datetime.datetime.fromtimestamp(session_state.date, tz=datetime.timezone.utc)
+        self.seq = session_state.seq
+        self.next_deadline = ENTRY_ACCOUNT
+
+    def session_state(self):
+        """
+        Return the current state.
+
+        This should be used for persisting the state.
+        """
+        return dict(
+            pts=self.map[ENTRY_ACCOUNT].pts if ENTRY_ACCOUNT in self.map else NO_SEQ,
+            qts=self.map[ENTRY_SECRET].pts if ENTRY_SECRET in self.map else NO_SEQ,
+            date=self.date,
+            seq=self.seq,
+        ), {id: state.pts for id, state in self.map.items() if isinstance(id, int)}
+
+    def is_empty(self) -> bool:
+        """
+        Return true if the message box is empty and has no state yet.
+        """
+        return ENTRY_ACCOUNT not in self.map
+
+    def check_deadlines(self):
+        """
+        Return the next deadline when receiving updates should timeout.
+
+        If a deadline expired, the corresponding entries will be marked as needing to get its difference.
+        While there are entries pending of getting their difference, this method returns the current instant.
+        """
+        now = get_running_loop().time()
+
+        if self.getting_diff_for:
+            return now
+
+        deadline = next_updates_deadline()
+
+        # Most of the time there will be zero or one gap in flight so finding the minimum is cheap.
+        if self.possible_gaps:
+            deadline = min(deadline, *(gap.deadline for gap in self.possible_gaps.values()))
+        elif self.next_deadline in self.map:
+            deadline = min(deadline, self.map[self.next_deadline].deadline)
+
+        # asyncio's loop time precision only seems to be about 3 decimal places, so it's possible that
+        # we find the same number again on repeated calls. Without the "or equal" part we would log the
+        # timeout for updates several times (it also makes sense to get difference if now is the deadline).
+        if now >= deadline:
+            # Check all expired entries and add them to the list that needs getting difference.
+            self.getting_diff_for.update(entry for entry, gap in self.possible_gaps.items() if now >= gap.deadline)
+            self.getting_diff_for.update(entry for entry, state in self.map.items() if now >= state.deadline)
+
+            if __debug__:
+                self._trace('Deadlines met, now getting diff for %r', self.getting_diff_for)
+
+            # When extending `getting_diff_for`, it's important to have the moral equivalent of
+            # `begin_get_diff` (that is, clear possible gaps if we're now getting difference).
+            for entry in self.getting_diff_for:
+                self.possible_gaps.pop(entry, None)
+
+        return deadline
+
+    # Reset the deadline for the periods without updates for the given entries.
+    #
+    # It also updates the next deadline time to reflect the new closest deadline.
+    def reset_deadlines(self, entries, deadline):
+        for entry in entries:
+            if entry not in self.map:
+                raise RuntimeError('Called reset_deadline on an entry for which we do not have state')
+            self.map[entry].deadline = deadline
+
+        if self.next_deadline in entries:
+            # If the updated deadline was the closest one, recalculate the new minimum.
+            self.next_deadline = min(self.map.items(), key=lambda entry_state: entry_state[1].deadline)[0]
+        elif self.next_deadline in self.map and deadline < self.map[self.next_deadline].deadline:
+            # If the updated deadline is smaller than the next deadline, change the next deadline to be the new one.
+            # Any entry will do, so the one from the last iteration is fine.
+            self.next_deadline = entry
+        # else an unrelated deadline was updated, so the closest one remains unchanged.
+
+    # Convenience to reset a channel's deadline, with optional timeout.
+    def reset_channel_deadline(self, channel_id, timeout):
+        self.reset_deadlines({channel_id}, get_running_loop().time() + (timeout or NO_UPDATES_TIMEOUT))
+
+    # Sets the update state.
+    #
+    # Should be called right after login if [`MessageBox::new`] was used, otherwise undesirable
+    # updates will be fetched.
+    def set_state(self, state, reset=True):
+        if __debug__:
+            self._trace('Setting state %s', state)
+
+        deadline = next_updates_deadline()
+
+        if state.pts != NO_SEQ or not reset:
+            self.map[ENTRY_ACCOUNT] = State(pts=state.pts, deadline=deadline)
+        else:
+            self.map.pop(ENTRY_ACCOUNT, None)
+
+        # Telegram seems to use the `qts` for bot accounts, but while applying difference,
+        # it might be reset back to 0. See issue #3873 for more details.
+        #
+        # During login, a value of zero would mean the `pts` is unknown,
+        # so the map shouldn't contain that entry.
+        # But while applying difference, if the value is zero, it (probably)
+        # truly means that's what should be used (hence the `reset` flag).
+        if state.qts != NO_SEQ or not reset:
+            self.map[ENTRY_SECRET] = State(pts=state.qts, deadline=deadline)
+        else:
+            self.map.pop(ENTRY_SECRET, None)
+
+        self.date = state.date
+        self.seq = state.seq
+
+    # Like [`MessageBox::set_state`], but for channels. Useful when getting dialogs.
+    #
+    # The update state will only be updated if no entry was known previously.
+    def try_set_channel_state(self, id, pts):
+        if __debug__:
+            self._trace('Trying to set channel state for %r: %r', id, pts)
+
+        if id not in self.map:
+            self.map[id] = State(pts=pts, deadline=next_updates_deadline())
+
+    # Try to begin getting difference for the given entry.
+    # Fails if the entry does not have a previously-known state that can be used to get its difference.
+    #
+    # Clears any previous gaps.
+    def try_begin_get_diff(self, entry, reason):
+        if entry not in self.map:
+            # Won't actually be able to get difference for this entry if we don't have a pts to start off from.
+            if entry in self.possible_gaps:
+                raise RuntimeError('Should not have a possible_gap for an entry not in the state map')
+
+            if __debug__:
+                self._trace('Should get difference for %r because %s but cannot due to missing hash', entry, reason)
+            return
+
+        if __debug__:
+            self._trace('Marking %r as needing difference because %s', entry, reason)
+        self.getting_diff_for.add(entry)
+        self.possible_gaps.pop(entry, None)
+
+    # Finish getting difference for the given entry.
+    #
+    # It also resets the deadline.
+    def end_get_diff(self, entry):
+        try:
+            self.getting_diff_for.remove(entry)
+        except KeyError:
+            raise RuntimeError('Called end_get_diff on an entry which was not getting diff for')
+
+        self.reset_deadlines({entry}, next_updates_deadline())
+        assert entry not in self.possible_gaps, "gaps shouldn't be created while getting difference"
+
+    # endregion Creation, querying, and setting base state.
+
+    # region "Normal" updates flow (processing and detection of gaps).
+
+    # Process an update and return what should be done with it.
+    #
+    # Updates corresponding to entries for which their difference is currently being fetched
+    # will be ignored. While according to the [updates' documentation]:
+    #
+    # > Implementations [have] to postpone updates received via the socket while
+    # > filling gaps in the event and `Update` sequences, as well as avoid filling
+    # > gaps in the same sequence.
+    #
+    # In practice, these updates should have also been retrieved through getting difference.
+    #
+    # [updates documentation] https://core.telegram.org/api/updates
+    def process_updates(
+        self,
+        updates,
+        chat_hashes,
+        result,  # out list of updates; returns list of user, chat, or raise if gap
+    ):
+
+        # v1 has never sent updates produced by the client itself to the handlers.
+        # However proper update handling requires those to be processed.
+        # This is an ugly workaround for that.
+        self_outgoing = getattr(updates, '_self_outgoing', False)
+        real_result = result
+        result = []
+
+        date = getattr(updates, 'date', None)
+        seq = getattr(updates, 'seq', None)
+        seq_start = getattr(updates, 'seq_start', None)
+        users = getattr(updates, 'users', None) or []
+        chats = getattr(updates, 'chats', None) or []
+
+        if __debug__:
+            self._trace('Processing updates with seq = %r, seq_start = %r, date = %s: %s',
+                        seq, seq_start, date.isoformat() if date else None, updates)
+
+        if date is None:
+            # updatesTooLong is the only one with no date (we treat it as a gap)
+            self.try_begin_get_diff(ENTRY_ACCOUNT, 'received updatesTooLong')
+            raise GapError
+        if seq is None:
+            seq = NO_SEQ
+        if seq_start is None:
+            seq_start = seq
+
+        # updateShort is the only update which cannot be dispatched directly but doesn't have 'updates' field
+        updates = getattr(updates, 'updates', None) or [updates.update if isinstance(updates, tl.UpdateShort) else updates]
+
+        for u in updates:
+            u._self_outgoing = self_outgoing
+
+        # > For all the other [not `updates` or `updatesCombined`] `Updates` type constructors
+        # > there is no need to check `seq` or change a local state.
+        if seq_start != NO_SEQ:
+            if self.seq + 1 > seq_start:
+                # Skipping updates that were already handled
+                if __debug__:
+                    self._trace('Skipping updates as they should have already been handled')
+                return (users, chats)
+            elif self.seq + 1 < seq_start:
+                # Gap detected
+                self.try_begin_get_diff(ENTRY_ACCOUNT, 'detected gap')
+                raise GapError
+            # else apply
+
+        def _sort_gaps(update):
+            pts = PtsInfo.from_update(update)
+            return pts.pts - pts.pts_count if pts else 0
+
+        reset_deadlines = set()  # temporary buffer
+        any_pts_applied = [False]  # using a list to pass "by reference"
+
+        result.extend(filter(None, (
+            self.apply_pts_info(u, reset_deadlines=reset_deadlines, any_pts_applied=any_pts_applied)
+            # Telegram can send updates out of order (e.g. ReadChannelInbox first
+            # and then NewChannelMessage, both with the same pts, but the count is
+            # 0 and 1 respectively), so we sort them first.
+            for u in sorted(updates, key=_sort_gaps))))
+
+        # > If the updates were applied, local *Updates* state must be updated
+        # > with `seq` (unless it's 0) and `date` from the constructor.
+        #
+        # By "were applied", we assume it means "some other pts was applied".
+        # Updates which can be applied in any order, such as `UpdateChat`,
+        # should not cause `seq` to be updated (or upcoming updates such as
+        # `UpdateChatParticipant` could be missed).
+        if any_pts_applied[0]:
+            if __debug__:
+                self._trace('Updating seq as local pts was updated too')
+            if date != epoch():
+                self.date = date
+            if seq != NO_SEQ:
+                self.seq = seq
+
+        self.reset_deadlines(reset_deadlines, next_updates_deadline())
+
+        if self.possible_gaps:
+            if __debug__:
+                self._trace('Trying to re-apply %r possible gaps', len(self.possible_gaps))
+
+            # For each update in possible gaps, see if the gap has been resolved already.
+            for key in list(self.possible_gaps.keys()):
+                self.possible_gaps[key].updates.sort(key=_sort_gaps)
+
+                for _ in range(len(self.possible_gaps[key].updates)):
+                    update = self.possible_gaps[key].updates.pop(0)
+
+                    # If this fails to apply, it will get re-inserted at the end.
+                    # All should fail, so the order will be preserved (it would've cycled once).
+                    update = self.apply_pts_info(update, reset_deadlines=None)
+                    if update:
+                        result.append(update)
+                        if __debug__:
+                            self._trace('Resolved gap with %r: %s', PtsInfo.from_update(update), update)
+
+            # Clear now-empty gaps.
+            self.possible_gaps = {entry: gap for entry, gap in self.possible_gaps.items() if gap.updates}
+
+        real_result.extend(u for u in result if not u._self_outgoing)
+
+        return (users, chats)
+
+    # Tries to apply the input update if its `PtsInfo` follows the correct order.
+    #
+    # If the update can be applied, it is returned; otherwise, the update is stored in a
+    # possible gap (unless it was already handled or would be handled through getting
+    # difference) and `None` is returned.
+    def apply_pts_info(
+        self,
+        update,
+        *,
+        reset_deadlines,
+        any_pts_applied=[True],  # mutable default is fine as it's write-only
+    ):
+        # This update means we need to call getChannelDifference to get the updates from the channel
+        if isinstance(update, tl.UpdateChannelTooLong):
+            self.try_begin_get_diff(update.channel_id, 'received updateChannelTooLong')
+            return None
+
+        pts = PtsInfo.from_update(update)
+        if not pts:
+            # No pts means that the update can be applied in any order.
+            if __debug__:
+                self._trace('No pts in update, so it can be applied in any order: %s', update)
+            return update
+
+        # As soon as we receive an update of any form related to messages (has `PtsInfo`),
+        # the "no updates" period for that entry is reset.
+        #
+        # Build the `HashSet` to avoid calling `reset_deadline` more than once for the same entry.
+        #
+        # By the time this method returns, self.map will have an entry for which we can reset its deadline.
+        if reset_deadlines:
+            reset_deadlines.add(pts.entry)
+
+        if pts.entry in self.getting_diff_for:
+            # Note: early returning here also prevents gap from being inserted (which they should
+            # not be while getting difference).
+            if __debug__:
+                self._trace('Skipping update with %r as its difference is being fetched', pts)
+            return None
+
+        if pts.entry in self.map:
+            local_pts = self.map[pts.entry].pts
+            if local_pts + pts.pts_count > pts.pts:
+                # Ignore
+                if __debug__:
+                    self._trace('Skipping update since local pts %r > %r: %s', local_pts, pts, update)
+                return None
+            elif local_pts + pts.pts_count < pts.pts:
+                # Possible gap
+                # TODO store chats too?
+                if __debug__:
+                    self._trace('Possible gap since local pts %r < %r: %s', local_pts, pts, update)
+                if pts.entry not in self.possible_gaps:
+                    self.possible_gaps[pts.entry] = PossibleGap(
+                        deadline=get_running_loop().time() + POSSIBLE_GAP_TIMEOUT,
+                        updates=[]
+                    )
+
+                self.possible_gaps[pts.entry].updates.append(update)
+                return None
+            else:
+                # Apply
+                any_pts_applied[0] = True
+                if __debug__:
+                    self._trace('Applying update pts since local pts %r = %r: %s', local_pts, pts, update)
+
+        # In a channel, we may immediately receive:
+        # * ReadChannelInbox (pts = X, pts_count = 0)
+        # * NewChannelMessage (pts = X, pts_count = 1)
+        #
+        # Notice how both `pts` are the same. If they were to be applied out of order, the first
+        # one however would've triggered a gap because `local_pts` + `pts_count` of 0 would be
+        # less than `remote_pts`. So there is no risk by setting the `local_pts` to match the
+        # `remote_pts` here of missing the new message.
+        #
+        # The message would however be lost if we initialized the pts with the first one, since
+        # the second one would appear "already handled". To prevent this we set the pts to be
+        # one less when the count is 0 (which might be wrong and trigger a gap later on, but is
+        # unlikely). This will prevent us from losing updates in the unlikely scenario where these
+        # two updates arrive in different packets (and therefore couldn't be sorted beforehand).
+        if pts.entry in self.map:
+            self.map[pts.entry].pts = pts.pts
+        else:
+            # When a chat is migrated to a megagroup, the first update can be a `ReadChannelInbox`
+            # with `pts = 1, pts_count = 0` followed by a `NewChannelMessage` with `pts = 2, pts_count=1`.
+            # Note how the `pts` for the message is 2 and not 1 unlike the case described before!
+            # This is likely because the `pts` cannot be 0 (or it would fail with PERSISTENT_TIMESTAMP_EMPTY),
+            # which forces the first update to be 1. But if we got difference with 1 and the second update
+            # also used 1, we would miss it, so Telegram probably uses 2 to work around that.
+            self.map[pts.entry] = State(
+                pts=(pts.pts - (0 if pts.pts_count else 1)) or 1,
+                deadline=next_updates_deadline()
+            )
+
+        return update
+
+    # endregion "Normal" updates flow (processing and detection of gaps).
+
+    # region Getting and applying account difference.
+
+    # Return the request that needs to be made to get the difference, if any.
+    def get_difference(self):
+        for entry in (ENTRY_ACCOUNT, ENTRY_SECRET):
+            if entry in self.getting_diff_for:
+                if entry not in self.map:
+                    raise RuntimeError('Should not try to get difference for an entry without known state')
+
+                gd = fn.updates.GetDifferenceRequest(
+                    pts=self.map[ENTRY_ACCOUNT].pts,
+                    pts_total_limit=None,
+                    date=self.date,
+                    qts=self.map[ENTRY_SECRET].pts if ENTRY_SECRET in self.map else NO_SEQ,
+                )
+                if __debug__:
+                    self._trace('Requesting account difference %s', gd)
+                return gd
+
+        return None
+
+    # Similar to [`MessageBox::process_updates`], but using the result from getting difference.
+    def apply_difference(
+        self,
+        diff,
+        chat_hashes,
+    ):
+        if __debug__:
+            self._trace('Applying account difference %s', diff)
+
+        finish = None
+        result = None
+
+        if isinstance(diff, tl.updates.DifferenceEmpty):
+            finish = True
+            self.date = diff.date
+            self.seq = diff.seq
+            result = [], [], []
+        elif isinstance(diff, tl.updates.Difference):
+            finish = True
+            chat_hashes.extend(diff.users, diff.chats)
+            result = self.apply_difference_type(diff, chat_hashes)
+        elif isinstance(diff, tl.updates.DifferenceSlice):
+            finish = False
+            chat_hashes.extend(diff.users, diff.chats)
+            result = self.apply_difference_type(diff, chat_hashes)
+        elif isinstance(diff, tl.updates.DifferenceTooLong):
+            finish = True
+            self.map[ENTRY_ACCOUNT].pts = diff.pts  # the deadline will be reset once the diff ends
+            result = [], [], []
+
+        if finish:
+            account = ENTRY_ACCOUNT in self.getting_diff_for
+            secret = ENTRY_SECRET in self.getting_diff_for
+
+            if not account and not secret:
+                raise RuntimeError('Should not be applying the difference when neither account or secret was diff was active')
+
+            # Both may be active if both expired at the same time.
+            if account:
+                self.end_get_diff(ENTRY_ACCOUNT)
+            if secret:
+                self.end_get_diff(ENTRY_SECRET)
+
+        return result
+
+    def apply_difference_type(
+        self,
+        diff,
+        chat_hashes,
+    ):
+        state = getattr(diff, 'intermediate_state', None) or diff.state
+        self.set_state(state, reset=False)
+
+        # diff.other_updates can contain things like UpdateChannelTooLong and UpdateNewChannelMessage.
+        # We need to process those as if they were socket updates to discard any we have already handled.
+        updates = []
+        self.process_updates(tl.Updates(
+            updates=diff.other_updates,
+            users=diff.users,
+            chats=diff.chats,
+            date=epoch(),
+            seq=NO_SEQ,  # this way date is not used
+        ), chat_hashes, updates)
+
+        updates.extend(tl.UpdateNewMessage(
+            message=m,
+            pts=NO_SEQ,
+            pts_count=NO_SEQ,
+        ) for m in diff.new_messages)
+        updates.extend(tl.UpdateNewEncryptedMessage(
+            message=m,
+            qts=NO_SEQ,
+        ) for m in diff.new_encrypted_messages)
+
+        return updates, diff.users, diff.chats
+
+    def end_difference(self):
+        if __debug__:
+            self._trace('Ending account difference')
+
+        account = ENTRY_ACCOUNT in self.getting_diff_for
+        secret = ENTRY_SECRET in self.getting_diff_for
+
+        if not account and not secret:
+            raise RuntimeError('Should not be ending get difference when neither account or secret was diff was active')
+
+        # Both may be active if both expired at the same time.
+        if account:
+            self.end_get_diff(ENTRY_ACCOUNT)
+        if secret:
+            self.end_get_diff(ENTRY_SECRET)
+
+    # endregion Getting and applying account difference.
+
+    # region Getting and applying channel difference.
+
+    # Return the request that needs to be made to get a channel's difference, if any.
+    def get_channel_difference(
+        self,
+        chat_hashes,
+    ):
+        entry = next((id for id in self.getting_diff_for if isinstance(id, int)), None)
+        if not entry:
+            return None
+
+        packed = chat_hashes.get(entry)
+        if not packed:
+            # Cannot get channel difference as we're missing its hash
+            # TODO we should probably log this
+            self.end_get_diff(entry)
+            # Remove the outdated `pts` entry from the map so that the next update can correct
+            # it. Otherwise, it will spam that the access hash is missing.
+            self.map.pop(entry, None)
+            return None
+
+        state = self.map.get(entry)
+        if not state:
+            raise RuntimeError('Should not try to get difference for an entry without known state')
+
+        gd = fn.updates.GetChannelDifferenceRequest(
+            force=False,
+            channel=tl.InputChannel(packed.id, packed.hash),
+            filter=tl.ChannelMessagesFilterEmpty(),
+            pts=state.pts,
+            limit=BOT_CHANNEL_DIFF_LIMIT if chat_hashes.self_bot else USER_CHANNEL_DIFF_LIMIT
+        )
+        if __debug__:
+            self._trace('Requesting channel difference %s', gd)
+        return gd
+
+    # Similar to [`MessageBox::process_updates`], but using the result from getting difference.
+    def apply_channel_difference(
+        self,
+        request,
+        diff,
+        chat_hashes,
+    ):
+        entry = request.channel.channel_id
+        if __debug__:
+            self._trace('Applying channel difference for %r: %s', entry, diff)
+
+        self.possible_gaps.pop(entry, None)
+
+        if isinstance(diff, tl.updates.ChannelDifferenceEmpty):
+            assert diff.final
+            self.end_get_diff(entry)
+            self.map[entry].pts = diff.pts
+            return [], [], []
+        elif isinstance(diff, tl.updates.ChannelDifferenceTooLong):
+            assert diff.final
+            self.map[entry].pts = diff.dialog.pts
+            chat_hashes.extend(diff.users, diff.chats)
+            self.reset_channel_deadline(entry, diff.timeout)
+            # This `diff` has the "latest messages and corresponding chats", but it would
+            # be strange to give the user only partial changes of these when they would
+            # expect all updates to be fetched. Instead, nothing is returned.
+            return [], [], []
+        elif isinstance(diff, tl.updates.ChannelDifference):
+            if diff.final:
+                self.end_get_diff(entry)
+
+            self.map[entry].pts = diff.pts
+            chat_hashes.extend(diff.users, diff.chats)
+
+            updates = []
+            self.process_updates(tl.Updates(
+                updates=diff.other_updates,
+                users=diff.users,
+                chats=diff.chats,
+                date=epoch(),
+                seq=NO_SEQ,  # this way date is not used
+            ), chat_hashes, updates)
+
+            updates.extend(tl.UpdateNewChannelMessage(
+                message=m,
+                pts=NO_SEQ,
+                pts_count=NO_SEQ,
+            ) for m in diff.new_messages)
+            self.reset_channel_deadline(entry, None)
+
+            return updates, diff.users, diff.chats
+
+    def end_channel_difference(self, request, reason: PrematureEndReason, chat_hashes):
+        entry = request.channel.channel_id
+        if __debug__:
+            self._trace('Ending channel difference for %r because %s', entry, reason)
+
+        if reason == PrematureEndReason.TEMPORARY_SERVER_ISSUES:
+            # Temporary issues. End getting difference without updating the pts so we can retry later.
+            self.possible_gaps.pop(entry, None)
+            self.end_get_diff(entry)
+        elif reason == PrematureEndReason.BANNED:
+            # Banned in the channel. Forget its state since we can no longer fetch updates from it.
+            self.possible_gaps.pop(entry, None)
+            self.end_get_diff(entry)
+            del self.map[entry]
+        else:
+            raise RuntimeError('Unknown reason to end channel difference')
+
+    # endregion Getting and applying channel difference.

.venv2/Lib/site-packages/telethon/_updates/session.py

@@ -0,0 +1,195 @@
+from typing import Optional, Tuple
+from enum import IntEnum
+from ..tl.types import InputPeerUser, InputPeerChat, InputPeerChannel
+
+
+class SessionState:
+    """
+    Stores the information needed to fetch updates and about the current user.
+
+    * user_id: 64-bit number representing the user identifier.
+    * dc_id: 32-bit number relating to the datacenter identifier where the user is.
+    * bot: is the logged-in user a bot?
+    * pts: 64-bit number holding the state needed to fetch updates.
+    * qts: alternative 64-bit number holding the state needed to fetch updates.
+    * date: 64-bit number holding the date needed to fetch updates.
+    * seq: 64-bit-number holding the sequence number needed to fetch updates.
+    * takeout_id: 64-bit-number holding the identifier of the current takeout session.
+
+    Note that some of the numbers will only use 32 out of the 64 available bits.
+    However, for future-proofing reasons, we recommend you pretend they are 64-bit long.
+    """
+    __slots__ = ('user_id', 'dc_id', 'bot', 'pts', 'qts', 'date', 'seq', 'takeout_id')
+
+    def __init__(
+        self,
+        user_id: int,
+        dc_id: int,
+        bot: bool,
+        pts: int,
+        qts: int,
+        date: int,
+        seq: int,
+        takeout_id: Optional[int]
+    ):
+        self.user_id = user_id
+        self.dc_id = dc_id
+        self.bot = bot
+        self.pts = pts
+        self.qts = qts
+        self.date = date
+        self.seq = seq
+        self.takeout_id = takeout_id
+
+    def __repr__(self):
+        return repr({k: getattr(self, k) for k in self.__slots__})
+
+
+class ChannelState:
+    """
+    Stores the information needed to fetch updates from a channel.
+
+    * channel_id: 64-bit number representing the channel identifier.
+    * pts: 64-bit number holding the state needed to fetch updates.
+    """
+    __slots__ = ('channel_id', 'pts')
+
+    def __init__(
+        self,
+        channel_id: int,
+        pts: int,
+    ):
+        self.channel_id = channel_id
+        self.pts = pts
+
+    def __repr__(self):
+        return repr({k: getattr(self, k) for k in self.__slots__})
+
+
+class EntityType(IntEnum):
+    """
+    You can rely on the type value to be equal to the ASCII character one of:
+
+    * 'U' (85): this entity belongs to a :tl:`User` who is not a ``bot``.
+    * 'B' (66): this entity belongs to a :tl:`User` who is a ``bot``.
+    * 'G' (71): this entity belongs to a small group :tl:`Chat`.
+    * 'C' (67): this entity belongs to a standard broadcast :tl:`Channel`.
+    * 'M' (77): this entity belongs to a megagroup :tl:`Channel`.
+    * 'E' (69): this entity belongs to an "enormous" "gigagroup" :tl:`Channel`.
+    """
+    USER = ord('U')
+    BOT = ord('B')
+    GROUP = ord('G')
+    CHANNEL = ord('C')
+    MEGAGROUP = ord('M')
+    GIGAGROUP = ord('E')
+
+    def canonical(self):
+        """
+        Return the canonical version of this type.
+        """
+        return _canon_entity_types[self]
+
+
+_canon_entity_types = {
+    EntityType.USER: EntityType.USER,
+    EntityType.BOT: EntityType.USER,
+    EntityType.GROUP: EntityType.GROUP,
+    EntityType.CHANNEL: EntityType.CHANNEL,
+    EntityType.MEGAGROUP: EntityType.CHANNEL,
+    EntityType.GIGAGROUP: EntityType.CHANNEL,
+}
+
+
+class Entity:
+    """
+    Stores the information needed to use a certain user, chat or channel with the API.
+
+    * ty: 8-bit number indicating the type of the entity (of type `EntityType`).
+    * id: 64-bit number uniquely identifying the entity among those of the same type.
+    * hash: 64-bit signed number needed to use this entity with the API.
+
+    The string representation of this class is considered to be stable, for as long as
+    Telegram doesn't need to add more fields to the entities. It can also be converted
+    to bytes with ``bytes(entity)``, for a more compact representation.
+    """
+    __slots__ = ('ty', 'id', 'hash')
+
+    def __init__(
+        self,
+        ty: EntityType,
+        id: int,
+        hash: int
+    ):
+        self.ty = ty
+        self.id = id
+        self.hash = hash
+
+    @property
+    def is_user(self):
+        """
+        ``True`` if the entity is either a user or a bot.
+        """
+        return self.ty in (EntityType.USER, EntityType.BOT)
+
+    @property
+    def is_group(self):
+        """
+        ``True`` if the entity is a small group chat or `megagroup`_.
+
+        .. _megagroup: https://telegram.org/blog/supergroups5k
+        """
+        return self.ty in (EntityType.GROUP, EntityType.MEGAGROUP)
+
+    @property
+    def is_broadcast(self):
+        """
+        ``True`` if the entity is a broadcast channel or `broadcast group`_.
+
+        .. _broadcast group: https://telegram.org/blog/autodelete-inv2#groups-with-unlimited-members
+        """
+        return self.ty in (EntityType.CHANNEL, EntityType.GIGAGROUP)
+
+    @classmethod
+    def from_str(cls, string: str):
+        """
+        Convert the string into an `Entity`.
+        """
+        try:
+            ty, id, hash = string.split('.')
+            ty, id, hash = ord(ty), int(id), int(hash)
+        except AttributeError:
+            raise TypeError(f'expected str, got {string!r}') from None
+        except (TypeError, ValueError):
+            raise ValueError(f'malformed entity str (must be T.id.hash), got {string!r}') from None
+
+        return cls(EntityType(ty), id, hash)
+
+    @classmethod
+    def from_bytes(cls, blob):
+        """
+        Convert the bytes into an `Entity`.
+        """
+        try:
+            ty, id, hash = struct.unpack('<Bqq', blob)
+        except struct.error:
+            raise ValueError(f'malformed entity data, got {string!r}') from None
+
+        return cls(EntityType(ty), id, hash)
+
+    def __str__(self):
+        return f'{chr(self.ty)}.{self.id}.{self.hash}'
+
+    def __bytes__(self):
+        return struct.pack('<Bqq', self.ty, self.id, self.hash)
+
+    def _as_input_peer(self):
+        if self.is_user:
+            return InputPeerUser(self.id, self.hash)
+        elif self.ty == EntityType.GROUP:
+            return InputPeerChat(self.id)
+        else:
+            return InputPeerChannel(self.id, self.hash)
+
+    def __repr__(self):
+        return repr({k: getattr(self, k) for k in self.__slots__})

.venv2/Lib/site-packages/telethon/client/__init__.py

@@ -0,0 +1,25 @@
+"""
+This package defines clients as subclasses of others, and then a single
+`telethon.client.telegramclient.TelegramClient` which is subclass of them
+all to provide the final unified interface while the methods can live in
+different subclasses to be more maintainable.
+
+The ABC is `telethon.client.telegrambaseclient.TelegramBaseClient` and the
+first implementor is `telethon.client.users.UserMethods`, since calling
+requests require them to be resolved first, and that requires accessing
+entities (users).
+"""
+from .telegrambaseclient import TelegramBaseClient
+from .users import UserMethods  # Required for everything
+from .messageparse import MessageParseMethods  # Required for messages
+from .uploads import UploadMethods  # Required for messages to send files
+from .updates import UpdateMethods  # Required for buttons (register callbacks)
+from .buttons import ButtonMethods  # Required for messages to use buttons
+from .messages import MessageMethods
+from .chats import ChatMethods
+from .dialogs import DialogMethods
+from .downloads import DownloadMethods
+from .account import AccountMethods
+from .auth import AuthMethods
+from .bots import BotMethods
+from .telegramclient import TelegramClient

.venv2/Lib/site-packages/telethon/client/account.py

@@ -0,0 +1,243 @@
+import functools
+import inspect
+import typing
+
+from .users import _NOT_A_REQUEST
+from .. import helpers, utils
+from ..tl import functions, TLRequest
+
+if typing.TYPE_CHECKING:
+    from .telegramclient import TelegramClient
+
+
+# TODO Make use of :tl:`InvokeWithMessagesRange` somehow
+#      For that, we need to use :tl:`GetSplitRanges` first.
+class _TakeoutClient:
+    """
+    Proxy object over the client.
+    """
+    __PROXY_INTERFACE = ('__enter__', '__exit__', '__aenter__', '__aexit__')
+
+    def __init__(self, finalize, client, request):
+        # We use the name mangling for attributes to make them inaccessible
+        # from within the shadowed client object and to distinguish them from
+        # its own attributes where needed.
+        self.__finalize = finalize
+        self.__client = client
+        self.__request = request
+        self.__success = None
+
+    @property
+    def success(self):
+        return self.__success
+
+    @success.setter
+    def success(self, value):
+        self.__success = value
+
+    async def __aenter__(self):
+        # Enter/Exit behaviour is "overrode", we don't want to call start.
+        client = self.__client
+        if client.session.takeout_id is None:
+            client.session.takeout_id = (await client(self.__request)).id
+        elif self.__request is not None:
+            raise ValueError("Can't send a takeout request while another "
+                "takeout for the current session still not been finished yet.")
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        if self.__success is None and self.__finalize:
+            self.__success = exc_type is None
+
+        if self.__success is not None:
+            result = await self(functions.account.FinishTakeoutSessionRequest(
+                self.__success))
+            if not result:
+                raise ValueError("Failed to finish the takeout.")
+            self.session.takeout_id = None
+
+    __enter__ = helpers._sync_enter
+    __exit__ = helpers._sync_exit
+
+    async def __call__(self, request, ordered=False):
+        takeout_id = self.__client.session.takeout_id
+        if takeout_id is None:
+            raise ValueError('Takeout mode has not been initialized '
+                '(are you calling outside of "with"?)')
+
+        single = not utils.is_list_like(request)
+        requests = ((request,) if single else request)
+        wrapped = []
+        for r in requests:
+            if not isinstance(r, TLRequest):
+                raise _NOT_A_REQUEST()
+            await r.resolve(self, utils)
+            wrapped.append(functions.InvokeWithTakeoutRequest(takeout_id, r))
+
+        return await self.__client(
+            wrapped[0] if single else wrapped, ordered=ordered)
+
+    def __getattribute__(self, name):
+        # We access class via type() because __class__ will recurse infinitely.
+        # Also note that since we've name-mangled our own class attributes,
+        # they'll be passed to __getattribute__() as already decorated. For
+        # example, 'self.__client' will be passed as '_TakeoutClient__client'.
+        # https://docs.python.org/3/tutorial/classes.html#private-variables
+        if name.startswith('__') and name not in type(self).__PROXY_INTERFACE:
+            raise AttributeError  # force call of __getattr__
+
+        # Try to access attribute in the proxy object and check for the same
+        # attribute in the shadowed object (through our __getattr__) if failed.
+        return super().__getattribute__(name)
+
+    def __getattr__(self, name):
+        value = getattr(self.__client, name)
+        if inspect.ismethod(value):
+            # Emulate bound methods behavior by partially applying our proxy
+            # class as the self parameter instead of the client.
+            return functools.partial(
+                getattr(self.__client.__class__, name), self)
+
+        return value
+
+    def __setattr__(self, name, value):
+        if name.startswith('_{}__'.format(type(self).__name__.lstrip('_'))):
+            # This is our own name-mangled attribute, keep calm.
+            return super().__setattr__(name, value)
+        return setattr(self.__client, name, value)
+
+
+class AccountMethods:
+    def takeout(
+            self: 'TelegramClient',
+            finalize: bool = True,
+            *,
+            contacts: bool = None,
+            users: bool = None,
+            chats: bool = None,
+            megagroups: bool = None,
+            channels: bool = None,
+            files: bool = None,
+            max_file_size: bool = None) -> 'TelegramClient':
+        """
+        Returns a :ref:`telethon-client` which calls methods behind a takeout session.
+
+        It does so by creating a proxy object over the current client through
+        which making requests will use :tl:`InvokeWithTakeoutRequest` to wrap
+        them. In other words, returns the current client modified so that
+        requests are done as a takeout:
+
+        Some of the calls made through the takeout session will have lower
+        flood limits. This is useful if you want to export the data from
+        conversations or mass-download media, since the rate limits will
+        be lower. Only some requests will be affected, and you will need
+        to adjust the `wait_time` of methods like `client.iter_messages
+        <telethon.client.messages.MessageMethods.iter_messages>`.
+
+        By default, all parameters are `None`, and you need to enable those
+        you plan to use by setting them to either `True` or `False`.
+
+        You should ``except errors.TakeoutInitDelayError as e``, since this
+        exception will raise depending on the condition of the session. You
+        can then access ``e.seconds`` to know how long you should wait for
+        before calling the method again.
+
+        There's also a `success` property available in the takeout proxy
+        object, so from the `with` body you can set the boolean result that
+        will be sent back to Telegram. But if it's left `None` as by
+        default, then the action is based on the `finalize` parameter. If
+        it's `True` then the takeout will be finished, and if no exception
+        occurred during it, then `True` will be considered as a result.
+        Otherwise, the takeout will not be finished and its ID will be
+        preserved for future usage as `client.session.takeout_id
+        <telethon.sessions.abstract.Session.takeout_id>`.
+
+        Arguments
+            finalize (`bool`):
+                Whether the takeout session should be finalized upon
+                exit or not.
+
+            contacts (`bool`):
+                Set to `True` if you plan on downloading contacts.
+
+            users (`bool`):
+                Set to `True` if you plan on downloading information
+                from users and their private conversations with you.
+
+            chats (`bool`):
+                Set to `True` if you plan on downloading information
+                from small group chats, such as messages and media.
+
+            megagroups (`bool`):
+                Set to `True` if you plan on downloading information
+                from megagroups (channels), such as messages and media.
+
+            channels (`bool`):
+                Set to `True` if you plan on downloading information
+                from broadcast channels, such as messages and media.
+
+            files (`bool`):
+                Set to `True` if you plan on downloading media and
+                you don't only wish to export messages.
+
+            max_file_size (`int`):
+                The maximum file size, in bytes, that you plan
+                to download for each message with media.
+
+        Example
+            .. code-block:: python
+
+                from telethon import errors
+
+                try:
+                    async with client.takeout() as takeout:
+                        await client.get_messages('me')  # normal call
+                        await takeout.get_messages('me')  # wrapped through takeout (less limits)
+
+                        async for message in takeout.iter_messages(chat, wait_time=0):
+                            ...  # Do something with the message
+
+                except errors.TakeoutInitDelayError as e:
+                    print('Must wait', e.seconds, 'before takeout')
+        """
+        request_kwargs = dict(
+            contacts=contacts,
+            message_users=users,
+            message_chats=chats,
+            message_megagroups=megagroups,
+            message_channels=channels,
+            files=files,
+            file_max_size=max_file_size
+        )
+        arg_specified = (arg is not None for arg in request_kwargs.values())
+
+        if self.session.takeout_id is None or any(arg_specified):
+            request = functions.account.InitTakeoutSessionRequest(
+                **request_kwargs)
+        else:
+            request = None
+
+        return _TakeoutClient(finalize, self, request)
+
+    async def end_takeout(self: 'TelegramClient', success: bool) -> bool:
+        """
+        Finishes the current takeout session.
+
+        Arguments
+            success (`bool`):
+                Whether the takeout completed successfully or not.
+
+        Returns
+            `True` if the operation was successful, `False` otherwise.
+
+        Example
+            .. code-block:: python
+
+                await client.end_takeout(success=False)
+        """
+        try:
+            async with _TakeoutClient(True, self, None) as takeout:
+                takeout.success = success
+        except ValueError:
+            return False
+        return True

.venv2/Lib/site-packages/telethon/client/auth.py

@@ -0,0 +1,665 @@
+import getpass
+import inspect
+import os
+import sys
+import typing
+import warnings
+
+from .. import utils, helpers, errors, password as pwd_mod
+from ..tl import types, functions, custom
+from .._updates import SessionState
+
+if typing.TYPE_CHECKING:
+    from .telegramclient import TelegramClient
+
+
+class AuthMethods:
+
+    # region Public methods
+
+    def start(
+            self: 'TelegramClient',
+            phone: typing.Callable[[], str] = lambda: input('Please enter your phone (or bot token): '),
+            password: typing.Callable[[], str] = lambda: getpass.getpass('Please enter your password: '),
+            *,
+            bot_token: str = None,
+            force_sms: bool = False,
+            code_callback: typing.Callable[[], typing.Union[str, int]] = None,
+            first_name: str = 'New User',
+            last_name: str = '',
+            max_attempts: int = 3) -> 'TelegramClient':
+        """
+        Starts the client (connects and logs in if necessary).
+
+        By default, this method will be interactive (asking for
+        user input if needed), and will handle 2FA if enabled too.
+
+        If the event loop is already running, this method returns a
+        coroutine that you should await on your own code; otherwise
+        the loop is ran until said coroutine completes.
+
+        Arguments
+            phone (`str` | `int` | `callable`):
+                The phone (or callable without arguments to get it)
+                to which the code will be sent. If a bot-token-like
+                string is given, it will be used as such instead.
+                The argument may be a coroutine.
+
+            password (`str`, `callable`, optional):
+                The password for 2 Factor Authentication (2FA).
+                This is only required if it is enabled in your account.
+                The argument may be a coroutine.
+
+            bot_token (`str`):
+                Bot Token obtained by `@BotFather <https://t.me/BotFather>`_
+                to log in as a bot. Cannot be specified with ``phone`` (only
+                one of either allowed).
+
+            force_sms (`bool`, optional):
+                Whether to force sending the code request as SMS.
+                This only makes sense when signing in with a `phone`.
+
+            code_callback (`callable`, optional):
+                A callable that will be used to retrieve the Telegram
+                login code. Defaults to `input()`.
+                The argument may be a coroutine.
+
+            first_name (`str`, optional):
+                The first name to be used if signing up. This has no
+                effect if the account already exists and you sign in.
+
+            last_name (`str`, optional):
+                Similar to the first name, but for the last. Optional.
+
+            max_attempts (`int`, optional):
+                How many times the code/password callback should be
+                retried or switching between signing in and signing up.
+
+        Returns
+            This `TelegramClient`, so initialization
+            can be chained with ``.start()``.
+
+        Example
+            .. code-block:: python
+
+                client = TelegramClient('anon', api_id, api_hash)
+
+                # Starting as a bot account
+                await client.start(bot_token=bot_token)
+
+                # Starting as a user account
+                await client.start(phone)
+                # Please enter the code you received: 12345
+                # Please enter your password: *******
+                # (You are now logged in)
+
+                # Starting using a context manager (this calls start()):
+                with client:
+                    pass
+        """
+        if code_callback is None:
+            def code_callback():
+                return input('Please enter the code you received: ')
+        elif not callable(code_callback):
+            raise ValueError(
+                'The code_callback parameter needs to be a callable '
+                'function that returns the code you received by Telegram.'
+            )
+
+        if not phone and not bot_token:
+            raise ValueError('No phone number or bot token provided.')
+
+        if phone and bot_token and not callable(phone):
+            raise ValueError('Both a phone and a bot token provided, '
+                             'must only provide one of either')
+
+        coro = self._start(
+            phone=phone,
+            password=password,
+            bot_token=bot_token,
+            force_sms=force_sms,
+            code_callback=code_callback,
+            first_name=first_name,
+            last_name=last_name,
+            max_attempts=max_attempts
+        )
+        return (
+            coro if self.loop.is_running()
+            else self.loop.run_until_complete(coro)
+        )
+
+    async def _start(
+            self: 'TelegramClient', phone, password, bot_token, force_sms,
+            code_callback, first_name, last_name, max_attempts):
+        if not self.is_connected():
+            await self.connect()
+
+        # Rather than using `is_user_authorized`, use `get_me`. While this is
+        # more expensive and needs to retrieve more data from the server, it
+        # enables the library to warn users trying to login to a different
+        # account. See #1172.
+        me = await self.get_me()
+        if me is not None:
+            # The warnings here are on a best-effort and may fail.
+            if bot_token:
+                # bot_token's first part has the bot ID, but it may be invalid
+                # so don't try to parse as int (instead cast our ID to string).
+                if bot_token[:bot_token.find(':')] != str(me.id):
+                    warnings.warn(
+                        'the session already had an authorized user so it did '
+                        'not login to the bot account using the provided '
+                        'bot_token (it may not be using the user you expect)'
+                    )
+            elif phone and not callable(phone) and utils.parse_phone(phone) != me.phone:
+                warnings.warn(
+                    'the session already had an authorized user so it did '
+                    'not login to the user account using the provided '
+                    'phone (it may not be using the user you expect)'
+                )
+
+            return self
+
+        if not bot_token:
+            # Turn the callable into a valid phone number (or bot token)
+            while callable(phone):
+                value = phone()
+                if inspect.isawaitable(value):
+                    value = await value
+
+                if ':' in value:
+                    # Bot tokens have 'user_id:access_hash' format
+                    bot_token = value
+                    break
+
+                phone = utils.parse_phone(value) or phone
+
+        if bot_token:
+            await self.sign_in(bot_token=bot_token)
+            return self
+
+        me = None
+        attempts = 0
+        two_step_detected = False
+
+        await self.send_code_request(phone, force_sms=force_sms)
+        while attempts < max_attempts:
+            try:
+                value = code_callback()
+                if inspect.isawaitable(value):
+                    value = await value
+
+                # Since sign-in with no code works (it sends the code)
+                # we must double-check that here. Else we'll assume we
+                # logged in, and it will return None as the User.
+                if not value:
+                    raise errors.PhoneCodeEmptyError(request=None)
+
+                # Raises SessionPasswordNeededError if 2FA enabled
+                me = await self.sign_in(phone, code=value)
+                break
+            except errors.SessionPasswordNeededError:
+                two_step_detected = True
+                break
+            except (errors.PhoneCodeEmptyError,
+                    errors.PhoneCodeExpiredError,
+                    errors.PhoneCodeHashEmptyError,
+                    errors.PhoneCodeInvalidError):
+                print('Invalid code. Please try again.', file=sys.stderr)
+
+            attempts += 1
+        else:
+            raise RuntimeError(
+                '{} consecutive sign-in attempts failed. Aborting'
+                .format(max_attempts)
+            )
+
+        if two_step_detected:
+            if not password:
+                raise ValueError(
+                    "Two-step verification is enabled for this account. "
+                    "Please provide the 'password' argument to 'start()'."
+                )
+
+            if callable(password):
+                for _ in range(max_attempts):
+                    try:
+                        value = password()
+                        if inspect.isawaitable(value):
+                            value = await value
+
+                        me = await self.sign_in(phone=phone, password=value)
+                        break
+                    except errors.PasswordHashInvalidError:
+                        print('Invalid password. Please try again',
+                              file=sys.stderr)
+                else:
+                    raise errors.PasswordHashInvalidError(request=None)
+            else:
+                me = await self.sign_in(phone=phone, password=password)
+
+        # We won't reach here if any step failed (exit by exception)
+        signed, name = 'Signed in successfully as ', utils.get_display_name(me)
+        tos = '; remember to not break the ToS or you will risk an account ban!'
+        try:
+            print(signed, name, tos, sep='')
+        except UnicodeEncodeError:
+            # Some terminals don't support certain characters
+            print(signed, name.encode('utf-8', errors='ignore')
+                              .decode('ascii', errors='ignore'), tos, sep='')
+
+        return self
+
+    def _parse_phone_and_hash(self, phone, phone_hash):
+        """
+        Helper method to both parse and validate phone and its hash.
+        """
+        phone = utils.parse_phone(phone) or self._phone
+        if not phone:
+            raise ValueError(
+                'Please make sure to call send_code_request first.'
+            )
+
+        phone_hash = phone_hash or self._phone_code_hash.get(phone, None)
+        if not phone_hash:
+            raise ValueError('You also need to provide a phone_code_hash.')
+
+        return phone, phone_hash
+
+    async def sign_in(
+            self: 'TelegramClient',
+            phone: str = None,
+            code: typing.Union[str, int] = None,
+            *,
+            password: str = None,
+            bot_token: str = None,
+            phone_code_hash: str = None) -> 'typing.Union[types.User, types.auth.SentCode]':
+        """
+        Logs in to Telegram to an existing user or bot account.
+
+        You should only use this if you are not authorized yet.
+
+        This method will send the code if it's not provided.
+
+        .. note::
+
+            In most cases, you should simply use `start()` and not this method.
+
+        Arguments
+            phone (`str` | `int`):
+                The phone to send the code to if no code was provided,
+                or to override the phone that was previously used with
+                these requests.
+
+            code (`str` | `int`):
+                The code that Telegram sent. Note that if you have sent this
+                code through the application itself it will immediately
+                expire. If you want to send the code, obfuscate it somehow.
+                If you're not doing any of this you can ignore this note.
+
+            password (`str`):
+                2FA password, should be used if a previous call raised
+                ``SessionPasswordNeededError``.
+
+            bot_token (`str`):
+                Used to sign in as a bot. Not all requests will be available.
+                This should be the hash the `@BotFather <https://t.me/BotFather>`_
+                gave you.
+
+            phone_code_hash (`str`, optional):
+                The hash returned by `send_code_request`. This can be left as
+                `None` to use the last hash known for the phone to be used.
+
+        Returns
+            The signed in user, or the information about
+            :meth:`send_code_request`.
+
+        Example
+            .. code-block:: python
+
+                phone = '+34 123 123 123'
+                await client.sign_in(phone)  # send code
+
+                code = input('enter code: ')
+                await client.sign_in(phone, code)
+        """
+        me = await self.get_me()
+        if me:
+            return me
+
+        if phone and not code and not password:
+            return await self.send_code_request(phone)
+        elif code:
+            phone, phone_code_hash = \
+                self._parse_phone_and_hash(phone, phone_code_hash)
+
+            # May raise PhoneCodeEmptyError, PhoneCodeExpiredError,
+            # PhoneCodeHashEmptyError or PhoneCodeInvalidError.
+            request = functions.auth.SignInRequest(
+                phone, phone_code_hash, str(code)
+            )
+        elif password:
+            pwd = await self(functions.account.GetPasswordRequest())
+            request = functions.auth.CheckPasswordRequest(
+                pwd_mod.compute_check(pwd, password)
+            )
+        elif bot_token:
+            request = functions.auth.ImportBotAuthorizationRequest(
+                flags=0, bot_auth_token=bot_token,
+                api_id=self.api_id, api_hash=self.api_hash
+            )
+        else:
+            raise ValueError(
+                'You must provide a phone and a code the first time, '
+                'and a password only if an RPCError was raised before.'
+            )
+
+        try:
+            result = await self(request)
+        except errors.PhoneCodeExpiredError:
+            self._phone_code_hash.pop(phone, None)
+            raise
+
+        if isinstance(result, types.auth.AuthorizationSignUpRequired):
+            # Emulate pre-layer 104 behaviour
+            self._tos = result.terms_of_service
+            raise errors.PhoneNumberUnoccupiedError(request=request)
+
+        return await self._on_login(result.user)
+
+    async def sign_up(
+            self: 'TelegramClient',
+            code: typing.Union[str, int],
+            first_name: str,
+            last_name: str = '',
+            *,
+            phone: str = None,
+            phone_code_hash: str = None) -> 'types.User':
+        """
+        This method can no longer be used, and will immediately raise a ``ValueError``.
+        See `issue #4050 <https://github.com/LonamiWebs/Telethon/issues/4050>`_ for context.
+        """
+        raise ValueError('Third-party applications cannot sign up for Telegram. See https://github.com/LonamiWebs/Telethon/issues/4050 for details')
+
+    async def _on_login(self, user):
+        """
+        Callback called whenever the login or sign up process completes.
+
+        Returns the input user parameter.
+        """
+        self._mb_entity_cache.set_self_user(user.id, user.bot, user.access_hash)
+        self._authorized = True
+
+        state = await self(functions.updates.GetStateRequest())
+        self._message_box.load(SessionState(0, 0, 0, state.pts, state.qts, int(state.date.timestamp()), state.seq, 0), [])
+
+        return user
+
+    async def send_code_request(
+            self: 'TelegramClient',
+            phone: str,
+            *,
+            force_sms: bool = False,
+            _retry_count: int = 0) -> 'types.auth.SentCode':
+        """
+        Sends the Telegram code needed to login to the given phone number.
+
+        Arguments
+            phone (`str` | `int`):
+                The phone to which the code will be sent.
+
+            force_sms (`bool`, optional):
+                Whether to force sending as SMS. This has been deprecated.
+                See `issue #4050 <https://github.com/LonamiWebs/Telethon/issues/4050>`_ for context.
+
+        Returns
+            An instance of :tl:`SentCode`.
+
+        Example
+            .. code-block:: python
+
+                phone = '+34 123 123 123'
+                sent = await client.send_code_request(phone)
+                print(sent)
+        """
+        if force_sms:
+            warnings.warn('force_sms has been deprecated and no longer works')
+            force_sms = False
+
+        result = None
+        phone = utils.parse_phone(phone) or self._phone
+        phone_hash = self._phone_code_hash.get(phone)
+
+        if not phone_hash:
+            try:
+                result = await self(functions.auth.SendCodeRequest(
+                    phone, self.api_id, self.api_hash, types.CodeSettings()))
+            except errors.AuthRestartError:
+                if _retry_count > 2:
+                    raise
+                return await self.send_code_request(
+                    phone, force_sms=force_sms, _retry_count=_retry_count+1)
+
+            # TODO figure out when/if/how this can happen
+            if isinstance(result, types.auth.SentCodeSuccess):
+                raise RuntimeError('logged in right after sending the code')
+
+            # If we already sent a SMS, do not resend the code (hash may be empty)
+            if isinstance(result.type, types.auth.SentCodeTypeSms):
+                force_sms = False
+
+            # phone_code_hash may be empty, if it is, do not save it (#1283)
+            if result.phone_code_hash:
+                self._phone_code_hash[phone] = phone_hash = result.phone_code_hash
+        else:
+            force_sms = True
+
+        self._phone = phone
+
+        if force_sms:
+            try:
+                result = await self(
+                    functions.auth.ResendCodeRequest(phone, phone_hash))
+            except errors.PhoneCodeExpiredError:
+                if _retry_count > 2:
+                    raise
+                self._phone_code_hash.pop(phone, None)
+                self._log[__name__].info(
+                    "Phone code expired in ResendCodeRequest, requesting a new code"
+                )
+                return await self.send_code_request(
+                    phone, force_sms=False, _retry_count=_retry_count+1)
+
+            if isinstance(result, types.auth.SentCodeSuccess):
+                raise RuntimeError('logged in right after resending the code')
+
+            self._phone_code_hash[phone] = result.phone_code_hash
+
+        return result
+
+    async def qr_login(self: 'TelegramClient', ignored_ids: typing.List[int] = None) -> custom.QRLogin:
+        """
+        Initiates the QR login procedure.
+
+        Note that you must be connected before invoking this, as with any
+        other request.
+
+        It is up to the caller to decide how to present the code to the user,
+        whether it's the URL, using the token bytes directly, or generating
+        a QR code and displaying it by other means.
+
+        See the documentation for `QRLogin` to see how to proceed after this.
+
+        Arguments
+            ignored_ids (List[`int`]):
+                List of already logged-in user IDs, to prevent logging in
+                twice with the same user.
+
+        Returns
+            An instance of `QRLogin`.
+
+        Example
+            .. code-block:: python
+
+                def display_url_as_qr(url):
+                    pass  # do whatever to show url as a qr to the user
+
+                qr_login = await client.qr_login()
+                display_url_as_qr(qr_login.url)
+
+                # Important! You need to wait for the login to complete!
+                await qr_login.wait()
+
+                # If you have 2FA enabled, `wait` will raise `telethon.errors.SessionPasswordNeededError`.
+                # You should except that error and call `sign_in` with the password if this happens.
+        """
+        qr_login = custom.QRLogin(self, ignored_ids or [])
+        await qr_login.recreate()
+        return qr_login
+
+    async def log_out(self: 'TelegramClient') -> bool:
+        """
+        Logs out Telegram and deletes the current ``*.session`` file.
+
+        The client is unusable after logging out and a new instance should be created.
+
+        Returns
+            `True` if the operation was successful.
+
+        Example
+            .. code-block:: python
+
+                # Note: you will need to login again!
+                await client.log_out()
+        """
+        try:
+            await self(functions.auth.LogOutRequest())
+        except errors.RPCError:
+            return False
+
+        self._mb_entity_cache.set_self_user(None, None, None)
+        self._authorized = False
+
+        await self.disconnect()
+        self.session.delete()
+        self.session = None
+        return True
+
+    async def edit_2fa(
+            self: 'TelegramClient',
+            current_password: str = None,
+            new_password: str = None,
+            *,
+            hint: str = '',
+            email: str = None,
+            email_code_callback: typing.Callable[[int], str] = None) -> bool:
+        """
+        Changes the 2FA settings of the logged in user.
+
+        Review carefully the parameter explanations before using this method.
+
+        Note that this method may be *incredibly* slow depending on the
+        prime numbers that must be used during the process to make sure
+        that everything is safe.
+
+        Has no effect if both current and new password are omitted.
+
+        Arguments
+            current_password (`str`, optional):
+                The current password, to authorize changing to ``new_password``.
+                Must be set if changing existing 2FA settings.
+                Must **not** be set if 2FA is currently disabled.
+                Passing this by itself will remove 2FA (if correct).
+
+            new_password (`str`, optional):
+                The password to set as 2FA.
+                If 2FA was already enabled, ``current_password`` **must** be set.
+                Leaving this blank or `None` will remove the password.
+
+            hint (`str`, optional):
+                Hint to be displayed by Telegram when it asks for 2FA.
+                Leaving unspecified is highly discouraged.
+                Has no effect if ``new_password`` is not set.
+
+            email (`str`, optional):
+                Recovery and verification email. If present, you must also
+                set `email_code_callback`, else it raises ``ValueError``.
+
+            email_code_callback (`callable`, optional):
+                If an email is provided, a callback that returns the code sent
+                to it must also be set. This callback may be asynchronous.
+                It should return a string with the code. The length of the
+                code will be passed to the callback as an input parameter.
+
+                If the callback returns an invalid code, it will raise
+                ``CodeInvalidError``.
+
+        Returns
+            `True` if successful, `False` otherwise.
+
+        Example
+            .. code-block:: python
+
+                # Setting a password for your account which didn't have
+                await client.edit_2fa(new_password='I_<3_Telethon')
+
+                # Removing the password
+                await client.edit_2fa(current_password='I_<3_Telethon')
+        """
+        if new_password is None and current_password is None:
+            return False
+
+        if email and not callable(email_code_callback):
+            raise ValueError('email present without email_code_callback')
+
+        pwd = await self(functions.account.GetPasswordRequest())
+        pwd.new_algo.salt1 += os.urandom(32)
+        assert isinstance(pwd, types.account.Password)
+        if not pwd.has_password and current_password:
+            current_password = None
+
+        if current_password:
+            password = pwd_mod.compute_check(pwd, current_password)
+        else:
+            password = types.InputCheckPasswordEmpty()
+
+        if new_password:
+            new_password_hash = pwd_mod.compute_digest(
+                pwd.new_algo, new_password)
+        else:
+            new_password_hash = b''
+
+        try:
+            await self(functions.account.UpdatePasswordSettingsRequest(
+                password=password,
+                new_settings=types.account.PasswordInputSettings(
+                    new_algo=pwd.new_algo,
+                    new_password_hash=new_password_hash,
+                    hint=hint,
+                    email=email,
+                    new_secure_settings=None
+                )
+            ))
+        except errors.EmailUnconfirmedError as e:
+            code = email_code_callback(e.code_length)
+            if inspect.isawaitable(code):
+                code = await code
+
+            code = str(code)
+            await self(functions.account.ConfirmPasswordEmailRequest(code))
+
+        return True
+
+    # endregion
+
+    # region with blocks
+
+    async def __aenter__(self):
+        return await self.start()
+
+    async def __aexit__(self, *args):
+        await self.disconnect()
+
+    __enter__ = helpers._sync_enter
+    __exit__ = helpers._sync_exit
+
+    # endregion

.venv2/Lib/site-packages/telethon/client/bots.py

@@ -0,0 +1,72 @@
+import typing
+
+from .. import hints
+from ..tl import types, functions, custom
+
+if typing.TYPE_CHECKING:
+    from .telegramclient import TelegramClient
+
+
+class BotMethods:
+    async def inline_query(
+            self: 'TelegramClient',
+            bot: 'hints.EntityLike',
+            query: str,
+            *,
+            entity: 'hints.EntityLike' = None,
+            offset: str = None,
+            geo_point: 'types.GeoPoint' = None) -> custom.InlineResults:
+        """
+        Makes an inline query to the specified bot (``@vote New Poll``).
+
+        Arguments
+            bot (`entity`):
+                The bot entity to which the inline query should be made.
+
+            query (`str`):
+                The query that should be made to the bot.
+
+            entity (`entity`, optional):
+                The entity where the inline query is being made from. Certain
+                bots use this to display different results depending on where
+                it's used, such as private chats, groups or channels.
+
+                If specified, it will also be the default entity where the
+                message will be sent after clicked. Otherwise, the "empty
+                peer" will be used, which some bots may not handle correctly.
+
+            offset (`str`, optional):
+                The string offset to use for the bot.
+
+            geo_point (:tl:`GeoPoint`, optional)
+                The geo point location information to send to the bot
+                for localised results. Available under some bots.
+
+        Returns
+            A list of `custom.InlineResult
+            <telethon.tl.custom.inlineresult.InlineResult>`.
+
+        Example
+            .. code-block:: python
+
+                # Make an inline query to @like
+                results = await client.inline_query('like', 'Do you like Telethon?')
+
+                # Send the first result to some chat
+                message = await results[0].click('TelethonOffTopic')
+        """
+        bot = await self.get_input_entity(bot)
+        if entity:
+            peer = await self.get_input_entity(entity)
+        else:
+            peer = types.InputPeerEmpty()
+
+        result = await self(functions.messages.GetInlineBotResultsRequest(
+            bot=bot,
+            peer=peer,
+            query=query,
+            offset=offset or '',
+            geo_point=geo_point
+        ))
+
+        return custom.InlineResults(self, result, entity=peer if entity else None)

.venv2/Lib/site-packages/telethon/client/buttons.py

@@ -0,0 +1,96 @@
+import typing
+
+from .. import utils, hints
+from ..tl import types, custom
+
+
+class ButtonMethods:
+    @staticmethod
+    def build_reply_markup(
+            buttons: 'typing.Optional[hints.MarkupLike]',
+            inline_only: bool = False) -> 'typing.Optional[types.TypeReplyMarkup]':
+        """
+        Builds a :tl:`ReplyInlineMarkup` or :tl:`ReplyKeyboardMarkup` for
+        the given buttons.
+
+        Does nothing if either no buttons are provided or the provided
+        argument is already a reply markup.
+
+        You should consider using this method if you are going to reuse
+        the markup very often. Otherwise, it is not necessary.
+
+        This method is **not** asynchronous (don't use ``await`` on it).
+
+        Arguments
+            buttons (`hints.MarkupLike`):
+                The button, list of buttons, array of buttons or markup
+                to convert into a markup.
+
+            inline_only (`bool`, optional):
+                Whether the buttons **must** be inline buttons only or not.
+
+        Example
+            .. code-block:: python
+
+                from telethon import Button
+
+                markup = client.build_reply_markup(Button.inline('hi'))
+                # later
+                await client.send_message(chat, 'click me', buttons=markup)
+        """
+        if buttons is None:
+            return None
+
+        try:
+            if buttons.SUBCLASS_OF_ID == 0xe2e10ef2:
+                return buttons  # crc32(b'ReplyMarkup'):
+        except AttributeError:
+            pass
+
+        if not utils.is_list_like(buttons):
+            buttons = [[buttons]]
+        elif not buttons or not utils.is_list_like(buttons[0]):
+            buttons = [buttons]
+
+        is_inline = False
+        is_normal = False
+        resize = None
+        single_use = None
+        selective = None
+
+        rows = []
+        for row in buttons:
+            current = []
+            for button in row:
+                if isinstance(button, custom.Button):
+                    if button.resize is not None:
+                        resize = button.resize
+                    if button.single_use is not None:
+                        single_use = button.single_use
+                    if button.selective is not None:
+                        selective = button.selective
+
+                    button = button.button
+                elif isinstance(button, custom.MessageButton):
+                    button = button.button
+
+                inline = custom.Button._is_inline(button)
+                is_inline |= inline
+                is_normal |= not inline
+
+                if button.SUBCLASS_OF_ID == 0xbad74a3:
+                    # 0xbad74a3 == crc32(b'KeyboardButton')
+                    current.append(button)
+
+            if current:
+                rows.append(types.KeyboardButtonRow(current))
+
+        if inline_only and is_normal:
+            raise ValueError('You cannot use non-inline buttons here')
+        elif is_inline == is_normal and is_normal:
+            raise ValueError('You cannot mix inline with normal buttons')
+        elif is_inline:
+            return types.ReplyInlineMarkup(rows)
+        # elif is_normal:
+        return types.ReplyKeyboardMarkup(
+            rows, resize=resize, single_use=single_use, selective=selective)

.venv2/Lib/site-packages/telethon/client/dialogs.py

@@ -0,0 +1,610 @@
+import asyncio
+import inspect
+import itertools
+import typing
+
+from .. import helpers, utils, hints, errors
+from ..requestiter import RequestIter
+from ..tl import types, functions, custom
+
+_MAX_CHUNK_SIZE = 100
+
+if typing.TYPE_CHECKING:
+    from .telegramclient import TelegramClient
+
+
+def _dialog_message_key(peer, message_id):
+    """
+    Get the key to get messages from a dialog.
+
+    We cannot just use the message ID because channels share message IDs,
+    and the peer ID is required to distinguish between them. But it is not
+    necessary in small group chats and private chats.
+    """
+    return (peer.channel_id if isinstance(peer, types.PeerChannel) else None), message_id
+
+
+class _DialogsIter(RequestIter):
+    async def _init(
+            self, offset_date, offset_id, offset_peer, ignore_pinned, ignore_migrated, folder
+    ):
+        self.request = functions.messages.GetDialogsRequest(
+            offset_date=offset_date,
+            offset_id=offset_id,
+            offset_peer=offset_peer,
+            limit=1,
+            hash=0,
+            exclude_pinned=ignore_pinned,
+            folder_id=folder
+        )
+
+        if self.limit <= 0:
+            # Special case, get a single dialog and determine count
+            dialogs = await self.client(self.request)
+            self.total = getattr(dialogs, 'count', len(dialogs.dialogs))
+            raise StopAsyncIteration
+
+        self.seen = set()
+        self.offset_date = offset_date
+        self.ignore_migrated = ignore_migrated
+
+    async def _load_next_chunk(self):
+        self.request.limit = min(self.left, _MAX_CHUNK_SIZE)
+        r = await self.client(self.request)
+
+        self.total = getattr(r, 'count', len(r.dialogs))
+
+        entities = {utils.get_peer_id(x): x
+                    for x in itertools.chain(r.users, r.chats)
+                    if not isinstance(x, (types.UserEmpty, types.ChatEmpty))}
+
+        self.client._mb_entity_cache.extend(r.users, r.chats)
+
+        messages = {}
+        for m in r.messages:
+            m._finish_init(self.client, entities, None)
+            messages[_dialog_message_key(m.peer_id, m.id)] = m
+
+        for d in r.dialogs:
+            # We check the offset date here because Telegram may ignore it
+            message = messages.get(_dialog_message_key(d.peer, d.top_message))
+            if self.offset_date:
+                date = getattr(message, 'date', None)
+                if not date or date.timestamp() > self.offset_date.timestamp():
+                    continue
+
+            peer_id = utils.get_peer_id(d.peer)
+            if peer_id not in self.seen:
+                self.seen.add(peer_id)
+                if peer_id not in entities:
+                    # > In which case can a UserEmpty appear in the list of banned members?
+                    # > In a very rare cases. This is possible but isn't an expected behavior.
+                    # Real world example: https://t.me/TelethonChat/271471
+                    continue
+
+                cd = custom.Dialog(self.client, d, entities, message)
+                if cd.dialog.pts:
+                    self.client._message_box.try_set_channel_state(
+                        utils.get_peer_id(d.peer, add_mark=False), cd.dialog.pts)
+
+                if not self.ignore_migrated or getattr(
+                        cd.entity, 'migrated_to', None) is None:
+                    self.buffer.append(cd)
+
+        if not self.buffer or len(r.dialogs) < self.request.limit\
+                or not isinstance(r, types.messages.DialogsSlice):
+            # Buffer being empty means all returned dialogs were skipped (due to offsets).
+            # Less than we requested means we reached the end, or
+            # we didn't get a DialogsSlice which means we got all.
+            return True
+
+        # We can't use `messages[-1]` as the offset ID / date.
+        # Why? Because pinned dialogs will mess with the order
+        # in this list. Instead, we find the last dialog which
+        # has a message, and use it as an offset.
+        last_message = next(filter(None, (
+            messages.get(_dialog_message_key(d.peer, d.top_message))
+            for d in reversed(r.dialogs)
+        )), None)
+
+        self.request.exclude_pinned = True
+        self.request.offset_id = last_message.id if last_message else 0
+        self.request.offset_date = last_message.date if last_message else None
+        self.request.offset_peer = self.buffer[-1].input_entity
+
+
+class _DraftsIter(RequestIter):
+    async def _init(self, entities, **kwargs):
+        if not entities:
+            r = await self.client(functions.messages.GetAllDraftsRequest())
+            items = r.updates
+        else:
+            peers = []
+            for entity in entities:
+                peers.append(types.InputDialogPeer(
+                    await self.client.get_input_entity(entity)))
+
+            r = await self.client(functions.messages.GetPeerDialogsRequest(peers))
+            items = r.dialogs
+
+        # TODO Maybe there should be a helper method for this?
+        entities = {utils.get_peer_id(x): x
+                    for x in itertools.chain(r.users, r.chats)}
+
+        self.buffer.extend(
+            custom.Draft(self.client, entities[utils.get_peer_id(d.peer)], d.draft)
+            for d in items
+        )
+
+    async def _load_next_chunk(self):
+        return []
+
+
+class DialogMethods:
+
+    # region Public methods
+
+    def iter_dialogs(
+            self: 'TelegramClient',
+            limit: float = None,
+            *,
+            offset_date: 'hints.DateLike' = None,
+            offset_id: int = 0,
+            offset_peer: 'hints.EntityLike' = types.InputPeerEmpty(),
+            ignore_pinned: bool = False,
+            ignore_migrated: bool = False,
+            folder: int = None,
+            archived: bool = None
+    ) -> _DialogsIter:
+        """
+        Iterator over the dialogs (open conversations/subscribed channels).
+
+        The order is the same as the one seen in official applications
+        (first pinned, them from those with the most recent message to
+        those with the oldest message).
+
+        Arguments
+            limit (`int` | `None`):
+                How many dialogs to be retrieved as maximum. Can be set to
+                `None` to retrieve all dialogs. Note that this may take
+                whole minutes if you have hundreds of dialogs, as Telegram
+                will tell the library to slow down through a
+                ``FloodWaitError``.
+
+            offset_date (`datetime`, optional):
+                The offset date to be used.
+
+            offset_id (`int`, optional):
+                The message ID to be used as an offset.
+
+            offset_peer (:tl:`InputPeer`, optional):
+                The peer to be used as an offset.
+
+            ignore_pinned (`bool`, optional):
+                Whether pinned dialogs should be ignored or not.
+                When set to `True`, these won't be yielded at all.
+
+            ignore_migrated (`bool`, optional):
+                Whether :tl:`Chat` that have ``migrated_to`` a :tl:`Channel`
+                should be included or not. By default all the chats in your
+                dialogs are returned, but setting this to `True` will ignore
+                (i.e. skip) them in the same way official applications do.
+
+            folder (`int`, optional):
+                The folder from which the dialogs should be retrieved.
+
+                If left unspecified, all dialogs (including those from
+                folders) will be returned.
+
+                If set to ``0``, all dialogs that don't belong to any
+                folder will be returned.
+
+                If set to a folder number like ``1``, only those from
+                said folder will be returned.
+
+                By default Telegram assigns the folder ID ``1`` to
+                archived chats, so you should use that if you need
+                to fetch the archived dialogs.
+
+            archived (`bool`, optional):
+                Alias for `folder`. If unspecified, all will be returned,
+                `False` implies ``folder=0`` and `True` implies ``folder=1``.
+        Yields
+            Instances of `Dialog <telethon.tl.custom.dialog.Dialog>`.
+
+        Example
+            .. code-block:: python
+
+                # Print all dialog IDs and the title, nicely formatted
+                async for dialog in client.iter_dialogs():
+                    print('{:>14}: {}'.format(dialog.id, dialog.title))
+        """
+        if archived is not None:
+            folder = 1 if archived else 0
+
+        return _DialogsIter(
+            self,
+            limit,
+            offset_date=offset_date,
+            offset_id=offset_id,
+            offset_peer=offset_peer,
+            ignore_pinned=ignore_pinned,
+            ignore_migrated=ignore_migrated,
+            folder=folder
+        )
+
+    async def get_dialogs(self: 'TelegramClient', *args, **kwargs) -> 'hints.TotalList':
+        """
+        Same as `iter_dialogs()`, but returns a
+        `TotalList <telethon.helpers.TotalList>` instead.
+
+        Example
+            .. code-block:: python
+
+                # Get all open conversation, print the title of the first
+                dialogs = await client.get_dialogs()
+                first = dialogs[0]
+                print(first.title)
+
+                # Use the dialog somewhere else
+                await client.send_message(first, 'hi')
+
+                # Getting only non-archived dialogs (both equivalent)
+                non_archived = await client.get_dialogs(folder=0)
+                non_archived = await client.get_dialogs(archived=False)
+
+                # Getting only archived dialogs (both equivalent)
+                archived = await client.get_dialogs(folder=1)
+                archived = await client.get_dialogs(archived=True)
+        """
+        return await self.iter_dialogs(*args, **kwargs).collect()
+
+    get_dialogs.__signature__ = inspect.signature(iter_dialogs)
+
+    def iter_drafts(
+            self: 'TelegramClient',
+            entity: 'hints.EntitiesLike' = None
+    ) -> _DraftsIter:
+        """
+        Iterator over draft messages.
+
+        The order is unspecified.
+
+        Arguments
+            entity (`hints.EntitiesLike`, optional):
+                The entity or entities for which to fetch the draft messages.
+                If left unspecified, all draft messages will be returned.
+
+        Yields
+            Instances of `Draft <telethon.tl.custom.draft.Draft>`.
+
+        Example
+            .. code-block:: python
+
+                # Clear all drafts
+                async for draft in client.get_drafts():
+                    await draft.delete()
+
+                # Getting the drafts with 'bot1' and 'bot2'
+                async for draft in client.iter_drafts(['bot1', 'bot2']):
+                    print(draft.text)
+        """
+        if entity and not utils.is_list_like(entity):
+            entity = (entity,)
+
+        # TODO Passing a limit here makes no sense
+        return _DraftsIter(self, None, entities=entity)
+
+    async def get_drafts(
+            self: 'TelegramClient',
+            entity: 'hints.EntitiesLike' = None
+    ) -> 'hints.TotalList':
+        """
+        Same as `iter_drafts()`, but returns a list instead.
+
+        Example
+            .. code-block:: python
+
+                # Get drafts, print the text of the first
+                drafts = await client.get_drafts()
+                print(drafts[0].text)
+
+                # Get the draft in your chat
+                draft = await client.get_drafts('me')
+                print(drafts.text)
+        """
+        items = await self.iter_drafts(entity).collect()
+        if not entity or utils.is_list_like(entity):
+            return items
+        else:
+            return items[0]
+
+    async def edit_folder(
+            self: 'TelegramClient',
+            entity: 'hints.EntitiesLike' = None,
+            folder: typing.Union[int, typing.Sequence[int]] = None,
+            *,
+            unpack=None
+    ) -> types.Updates:
+        """
+        Edits the folder used by one or more dialogs to archive them.
+
+        Arguments
+            entity (entities):
+                The entity or list of entities to move to the desired
+                archive folder.
+
+            folder (`int`):
+                The folder to which the dialog should be archived to.
+
+                If you want to "archive" a dialog, use ``folder=1``.
+
+                If you want to "un-archive" it, use ``folder=0``.
+
+                You may also pass a list with the same length as
+                `entities` if you want to control where each entity
+                will go.
+
+            unpack (`int`, optional):
+                If you want to unpack an archived folder, set this
+                parameter to the folder number that you want to
+                delete.
+
+                When you unpack a folder, all the dialogs inside are
+                moved to the folder number 0.
+
+                You can only use this parameter if the other two
+                are not set.
+
+        Returns
+            The :tl:`Updates` object that the request produces.
+
+        Example
+            .. code-block:: python
+
+                # Archiving the first 5 dialogs
+                dialogs = await client.get_dialogs(5)
+                await client.edit_folder(dialogs, 1)
+
+                # Un-archiving the third dialog (archiving to folder 0)
+                await client.edit_folder(dialog[2], 0)
+
+                # Moving the first dialog to folder 0 and the second to 1
+                dialogs = await client.get_dialogs(2)
+                await client.edit_folder(dialogs, [0, 1])
+
+                # Un-archiving all dialogs
+                await client.edit_folder(unpack=1)
+        """
+        if (entity is None) == (unpack is None):
+            raise ValueError('You can only set either entities or unpack, not both')
+
+        if unpack is not None:
+            return await self(functions.folders.DeleteFolderRequest(
+                folder_id=unpack
+            ))
+
+        if not utils.is_list_like(entity):
+            entities = [await self.get_input_entity(entity)]
+        else:
+            entities = await asyncio.gather(
+                *(self.get_input_entity(x) for x in entity))
+
+        if folder is None:
+            raise ValueError('You must specify a folder')
+        elif not utils.is_list_like(folder):
+            folder = [folder] * len(entities)
+        elif len(entities) != len(folder):
+            raise ValueError('Number of folders does not match number of entities')
+
+        return await self(functions.folders.EditPeerFoldersRequest([
+            types.InputFolderPeer(x, folder_id=y)
+            for x, y in zip(entities, folder)
+        ]))
+
+    async def delete_dialog(
+            self: 'TelegramClient',
+            entity: 'hints.EntityLike',
+            *,
+            revoke: bool = False
+    ):
+        """
+        Deletes a dialog (leaves a chat or channel).
+
+        This method can be used as a user and as a bot. However,
+        bots will only be able to use it to leave groups and channels
+        (trying to delete a private conversation will do nothing).
+
+        See also `Dialog.delete() <telethon.tl.custom.dialog.Dialog.delete>`.
+
+        Arguments
+            entity (entities):
+                The entity of the dialog to delete. If it's a chat or
+                channel, you will leave it. Note that the chat itself
+                is not deleted, only the dialog, because you left it.
+
+            revoke (`bool`, optional):
+                On private chats, you may revoke the messages from
+                the other peer too. By default, it's `False`. Set
+                it to `True` to delete the history for both.
+
+                This makes no difference for bot accounts, who can
+                only leave groups and channels.
+
+        Returns
+            The :tl:`Updates` object that the request produces,
+            or nothing for private conversations.
+
+        Example
+            .. code-block:: python
+
+                # Deleting the first dialog
+                dialogs = await client.get_dialogs(5)
+                await client.delete_dialog(dialogs[0])
+
+                # Leaving a channel by username
+                await client.delete_dialog('username')
+        """
+        # If we have enough information (`Dialog.delete` gives it to us),
+        # then we know we don't have to kick ourselves in deactivated chats.
+        if isinstance(entity, types.Chat):
+            deactivated = entity.deactivated
+        else:
+            deactivated = False
+
+        entity = await self.get_input_entity(entity)
+        ty = helpers._entity_type(entity)
+        if ty == helpers._EntityType.CHANNEL:
+            return await self(functions.channels.LeaveChannelRequest(entity))
+
+        if ty == helpers._EntityType.CHAT and not deactivated:
+            try:
+                result = await self(functions.messages.DeleteChatUserRequest(
+                    entity.chat_id, types.InputUserSelf(), revoke_history=revoke
+                ))
+            except errors.PeerIdInvalidError:
+                # Happens if we didn't have the deactivated information
+                result = None
+        else:
+            result = None
+
+        if not await self.is_bot():
+            await self(functions.messages.DeleteHistoryRequest(entity, 0, revoke=revoke))
+
+        return result
+
+    def conversation(
+            self: 'TelegramClient',
+            entity: 'hints.EntityLike',
+            *,
+            timeout: float = 60,
+            total_timeout: float = None,
+            max_messages: int = 100,
+            exclusive: bool = True,
+            replies_are_responses: bool = True) -> custom.Conversation:
+        """
+        Creates a `Conversation <telethon.tl.custom.conversation.Conversation>`
+        with the given entity.
+
+        .. note::
+
+            This Conversation API has certain shortcomings, such as lacking
+            persistence, poor interaction with other event handlers, and
+            overcomplicated usage for anything beyond the simplest case.
+
+            If you plan to interact with a bot without handlers, this works
+            fine, but when running a bot yourself, you may instead prefer
+            to follow the advice from https://stackoverflow.com/a/62246569/.
+
+        This is not the same as just sending a message to create a "dialog"
+        with them, but rather a way to easily send messages and await for
+        responses or other reactions. Refer to its documentation for more.
+
+        Arguments
+            entity (`entity`):
+                The entity with which a new conversation should be opened.
+
+            timeout (`int` | `float`, optional):
+                The default timeout (in seconds) *per action* to be used. You
+                may also override this timeout on a per-method basis. By
+                default each action can take up to 60 seconds (the value of
+                this timeout).
+
+            total_timeout (`int` | `float`, optional):
+                The total timeout (in seconds) to use for the whole
+                conversation. This takes priority over per-action
+                timeouts. After these many seconds pass, subsequent
+                actions will result in ``asyncio.TimeoutError``.
+
+            max_messages (`int`, optional):
+                The maximum amount of messages this conversation will
+                remember. After these many messages arrive in the
+                specified chat, subsequent actions will result in
+                ``ValueError``.
+
+            exclusive (`bool`, optional):
+                By default, conversations are exclusive within a single
+                chat. That means that while a conversation is open in a
+                chat, you can't open another one in the same chat, unless
+                you disable this flag.
+
+                If you try opening an exclusive conversation for
+                a chat where it's already open, it will raise
+                ``AlreadyInConversationError``.
+
+            replies_are_responses (`bool`, optional):
+                Whether replies should be treated as responses or not.
+
+                If the setting is enabled, calls to `conv.get_response
+                <telethon.tl.custom.conversation.Conversation.get_response>`
+                and a subsequent call to `conv.get_reply
+                <telethon.tl.custom.conversation.Conversation.get_reply>`
+                will return different messages, otherwise they may return
+                the same message.
+
+                Consider the following scenario with one outgoing message,
+                1, and two incoming messages, the second one replying::
+
+                                        Hello! <1
+                    2> (reply to 1) Hi!
+                    3> (reply to 1) How are you?
+
+                And the following code:
+
+                .. code-block:: python
+
+                    async with client.conversation(chat) as conv:
+                        msg1 = await conv.send_message('Hello!')
+                        msg2 = await conv.get_response()
+                        msg3 = await conv.get_reply()
+
+                With the setting enabled, ``msg2`` will be ``'Hi!'`` and
+                ``msg3`` be ``'How are you?'`` since replies are also
+                responses, and a response was already returned.
+
+                With the setting disabled, both ``msg2`` and ``msg3`` will
+                be ``'Hi!'`` since one is a response and also a reply.
+
+        Returns
+            A `Conversation <telethon.tl.custom.conversation.Conversation>`.
+
+        Example
+            .. code-block:: python
+
+                # <you> denotes outgoing messages you sent
+                # <usr> denotes incoming response messages
+                with bot.conversation(chat) as conv:
+                    # <you> Hi!
+                    conv.send_message('Hi!')
+
+                    # <usr> Hello!
+                    hello = conv.get_response()
+
+                    # <you> Please tell me your name
+                    conv.send_message('Please tell me your name')
+
+                    # <usr> ?
+                    name = conv.get_response().raw_text
+
+                    while not any(x.isalpha() for x in name):
+                        # <you> Your name didn't have any letters! Try again
+                        conv.send_message("Your name didn't have any letters! Try again")
+
+                        # <usr> Human
+                        name = conv.get_response().raw_text
+
+                    # <you> Thanks Human!
+                    conv.send_message('Thanks {}!'.format(name))
+        """
+        return custom.Conversation(
+            self,
+            entity,
+            timeout=timeout,
+            total_timeout=total_timeout,
+            max_messages=max_messages,
+            exclusive=exclusive,
+            replies_are_responses=replies_are_responses
+
+        )
+
+    # endregion

.venv2/Lib/site-packages/telethon/client/messageparse.py

@@ -0,0 +1,233 @@
+import itertools
+import re
+import typing
+
+from .. import helpers, utils
+from ..tl import types
+
+if typing.TYPE_CHECKING:
+    from .telegramclient import TelegramClient
+
+
+class MessageParseMethods:
+
+    # region Public properties
+
+    @property
+    def parse_mode(self: 'TelegramClient'):
+        """
+        This property is the default parse mode used when sending messages.
+        Defaults to `telethon.extensions.markdown`. It will always
+        be either `None` or an object with ``parse`` and ``unparse``
+        methods.
+
+        When setting a different value it should be one of:
+
+        * Object with ``parse`` and ``unparse`` methods.
+        * A ``callable`` to act as the parse method.
+        * A `str` indicating the ``parse_mode``. For Markdown ``'md'``
+          or ``'markdown'`` may be used. For HTML, ``'htm'`` or ``'html'``
+          may be used.
+
+        The ``parse`` method should be a function accepting a single
+        parameter, the text to parse, and returning a tuple consisting
+        of ``(parsed message str, [MessageEntity instances])``.
+
+        The ``unparse`` method should be the inverse of ``parse`` such
+        that ``assert text == unparse(*parse(text))``.
+
+        See :tl:`MessageEntity` for allowed message entities.
+
+        Example
+            .. code-block:: python
+
+                # Disabling default formatting
+                client.parse_mode = None
+
+                # Enabling HTML as the default format
+                client.parse_mode = 'html'
+        """
+        return self._parse_mode
+
+    @parse_mode.setter
+    def parse_mode(self: 'TelegramClient', mode: str):
+        self._parse_mode = utils.sanitize_parse_mode(mode)
+
+    # endregion
+
+    # region Private methods
+
+    async def _replace_with_mention(self: 'TelegramClient', entities, i, user):
+        """
+        Helper method to replace ``entities[i]`` to mention ``user``,
+        or do nothing if it can't be found.
+        """
+        try:
+            entities[i] = types.InputMessageEntityMentionName(
+                entities[i].offset, entities[i].length,
+                await self.get_input_entity(user)
+            )
+            return True
+        except (ValueError, TypeError):
+            return False
+
+    async def _parse_message_text(self: 'TelegramClient', message, parse_mode):
+        """
+        Returns a (parsed message, entities) tuple depending on ``parse_mode``.
+        """
+        if parse_mode == ():
+            parse_mode = self._parse_mode
+        else:
+            parse_mode = utils.sanitize_parse_mode(parse_mode)
+
+        if not parse_mode:
+            return message, []
+
+        original_message = message
+        message, msg_entities = parse_mode.parse(message)
+        if original_message and not message and not msg_entities:
+            raise ValueError("Failed to parse message")
+
+        for i in reversed(range(len(msg_entities))):
+            e = msg_entities[i]
+            if not e.length:
+                # 0-length MessageEntity is no longer valid #3884.
+                # Because the user can provide their own parser (with reasonable 0-length
+                # entities), strip them here rather than fixing the built-in parsers.
+                del msg_entities[i]
+            elif isinstance(e, types.MessageEntityTextUrl):
+                m = re.match(r'^@|\+|tg://user\?id=(\d+)', e.url)
+                if m:
+                    user = int(m.group(1)) if m.group(1) else e.url
+                    is_mention = await self._replace_with_mention(msg_entities, i, user)
+                    if not is_mention:
+                        del msg_entities[i]
+            elif isinstance(e, (types.MessageEntityMentionName,
+                                types.InputMessageEntityMentionName)):
+                is_mention = await self._replace_with_mention(msg_entities, i, e.user_id)
+                if not is_mention:
+                    del msg_entities[i]
+
+        return message, msg_entities
+
+    def _get_response_message(self: 'TelegramClient', request, result, input_chat):
+        """
+        Extracts the response message known a request and Update result.
+        The request may also be the ID of the message to match.
+
+        If ``request is None`` this method returns ``{id: message}``.
+
+        If ``request.random_id`` is a list, this method returns a list too.
+        """
+        if isinstance(result, types.UpdateShort):
+            updates = [result.update]
+            entities = {}
+        elif isinstance(result, (types.Updates, types.UpdatesCombined)):
+            updates = result.updates
+            entities = {utils.get_peer_id(x): x
+                        for x in
+                        itertools.chain(result.users, result.chats)}
+        else:
+            return None
+
+        random_to_id = {}
+        id_to_message = {}
+        for update in updates:
+            if isinstance(update, types.UpdateMessageID):
+                random_to_id[update.random_id] = update.id
+
+            elif isinstance(update, (
+                    types.UpdateNewChannelMessage, types.UpdateNewMessage)):
+                update.message._finish_init(self, entities, input_chat)
+
+                # Pinning a message with `updatePinnedMessage` seems to
+                # always produce a service message we can't map so return
+                # it directly. The same happens for kicking users.
+                #
+                # It could also be a list (e.g. when sending albums).
+                #
+                # TODO this method is getting messier and messier as time goes on
+                if hasattr(request, 'random_id') or utils.is_list_like(request):
+                    id_to_message[update.message.id] = update.message
+                else:
+                    return update.message
+
+            elif (isinstance(update, types.UpdateEditMessage)
+                  and helpers._entity_type(request.peer) != helpers._EntityType.CHANNEL):
+                update.message._finish_init(self, entities, input_chat)
+
+                # Live locations use `sendMedia` but Telegram responds with
+                # `updateEditMessage`, which means we won't have `id` field.
+                if hasattr(request, 'random_id'):
+                    id_to_message[update.message.id] = update.message
+                elif request.id == update.message.id:
+                    return update.message
+
+            elif (isinstance(update, types.UpdateEditChannelMessage)
+                  and utils.get_peer_id(request.peer) ==
+                  utils.get_peer_id(update.message.peer_id)):
+                if request.id == update.message.id:
+                    update.message._finish_init(self, entities, input_chat)
+                    return update.message
+
+            elif isinstance(update, types.UpdateNewScheduledMessage):
+                update.message._finish_init(self, entities, input_chat)
+                # Scheduled IDs may collide with normal IDs. However, for a
+                # single request there *shouldn't* be a mix between "some
+                # scheduled and some not".
+                id_to_message[update.message.id] = update.message
+
+            elif isinstance(update, types.UpdateMessagePoll):
+                if request.media.poll.id == update.poll_id:
+                    m = types.Message(
+                        id=request.id,
+                        peer_id=utils.get_peer(request.peer),
+                        media=types.MessageMediaPoll(
+                            poll=update.poll,
+                            results=update.results
+                        )
+                    )
+                    m._finish_init(self, entities, input_chat)
+                    return m
+
+        if request is None:
+            return id_to_message
+
+        random_id = request if isinstance(request, (int, list)) else getattr(request, 'random_id', None)
+        if random_id is None:
+            # Can happen when pinning a message does not actually produce a service message.
+            self._log[__name__].warning(
+                'No random_id in %s to map to, returning None message for %s', request, result)
+            return None
+
+        if not utils.is_list_like(random_id):
+            msg = id_to_message.get(random_to_id.get(random_id))
+
+            if not msg:
+                self._log[__name__].warning(
+                    'Request %s had missing message mapping %s', request, result)
+
+            return msg
+
+        try:
+            return [id_to_message[random_to_id[rnd]] for rnd in random_id]
+        except KeyError:
+            # Sometimes forwards fail (`MESSAGE_ID_INVALID` if a message gets
+            # deleted or `WORKER_BUSY_TOO_LONG_RETRY` if there are issues at
+            # Telegram), in which case we get some "missing" message mappings.
+            # Log them with the hope that we can better work around them.
+            #
+            # This also happens when trying to forward messages that can't
+            # be forwarded because they don't exist (0, service, deleted)
+            # among others which could be (like deleted or existing).
+            self._log[__name__].warning(
+                'Request %s had missing message mappings %s', request, result)
+
+        return [
+            id_to_message.get(random_to_id[rnd])
+            if rnd in random_to_id
+            else None
+            for rnd in random_id
+        ]
+
+    # endregion

.venv2/Lib/site-packages/telethon/client/telegrambaseclient.py

@@ -0,0 +1,951 @@
+import abc
+import re
+import asyncio
+import collections
+import logging
+import platform
+import time
+import typing
+import datetime
+
+from .. import version, helpers, __name__ as __base_name__
+from ..crypto import rsa
+from ..extensions import markdown
+from ..network import MTProtoSender, Connection, ConnectionTcpFull, TcpMTProxy
+from ..sessions import Session, SQLiteSession, MemorySession
+from ..tl import functions, types
+from ..tl.alltlobjects import LAYER
+from .._updates import MessageBox, EntityCache as MbEntityCache, SessionState, ChannelState, Entity, EntityType
+
+DEFAULT_DC_ID = 2
+DEFAULT_IPV4_IP = '149.154.167.51'
+DEFAULT_IPV6_IP = '2001:67c:4e8:f002::a'
+DEFAULT_PORT = 443
+
+if typing.TYPE_CHECKING:
+    from .telegramclient import TelegramClient
+
+_base_log = logging.getLogger(__base_name__)
+
+
+# In seconds, how long to wait before disconnecting a exported sender.
+_DISCONNECT_EXPORTED_AFTER = 60
+
+
+class _ExportState:
+    def __init__(self):
+        # ``n`` is the amount of borrows a given sender has;
+        # once ``n`` reaches ``0``, disconnect the sender after a while.
+        self._n = 0
+        self._zero_ts = 0
+        self._connected = False
+
+    def add_borrow(self):
+        self._n += 1
+        self._connected = True
+
+    def add_return(self):
+        self._n -= 1
+        assert self._n >= 0, 'returned sender more than it was borrowed'
+        if self._n == 0:
+            self._zero_ts = time.time()
+
+    def should_disconnect(self):
+        return (self._n == 0
+                and self._connected
+                and (time.time() - self._zero_ts) > _DISCONNECT_EXPORTED_AFTER)
+
+    def need_connect(self):
+        return not self._connected
+
+    def mark_disconnected(self):
+        assert self.should_disconnect(), 'marked as disconnected when it was borrowed'
+        self._connected = False
+
+
+# TODO How hard would it be to support both `trio` and `asyncio`?
+class TelegramBaseClient(abc.ABC):
+    """
+    This is the abstract base class for the client. It defines some
+    basic stuff like connecting, switching data center, etc, and
+    leaves the `__call__` unimplemented.
+
+    Arguments
+        session (`str` | `telethon.sessions.abstract.Session`, `None`):
+            The file name of the session file to be used if a string is
+            given (it may be a full path), or the Session instance to be
+            used otherwise. If it's `None`, the session will not be saved,
+            and you should call :meth:`.log_out()` when you're done.
+
+            Note that if you pass a string it will be a file in the current
+            working directory, although you can also pass absolute paths.
+
+            The session file contains enough information for you to login
+            without re-sending the code, so if you have to enter the code
+            more than once, maybe you're changing the working directory,
+            renaming or removing the file, or using random names.
+
+        api_id (`int` | `str`):
+            The API ID you obtained from https://my.telegram.org.
+
+        api_hash (`str`):
+            The API hash you obtained from https://my.telegram.org.
+
+        connection (`telethon.network.connection.common.Connection`, optional):
+            The connection instance to be used when creating a new connection
+            to the servers. It **must** be a type.
+
+            Defaults to `telethon.network.connection.tcpfull.ConnectionTcpFull`.
+
+        use_ipv6 (`bool`, optional):
+            Whether to connect to the servers through IPv6 or not.
+            By default this is `False` as IPv6 support is not
+            too widespread yet.
+
+        proxy (`tuple` | `list` | `dict`, optional):
+            An iterable consisting of the proxy info. If `connection` is
+            one of `MTProxy`, then it should contain MTProxy credentials:
+            ``('hostname', port, 'secret')``. Otherwise, it's meant to store
+            function parameters for PySocks, like ``(type, 'hostname', port)``.
+            See https://github.com/Anorov/PySocks#usage-1 for more.
+
+        local_addr (`str` | `tuple`, optional):
+            Local host address (and port, optionally) used to bind the socket to locally.
+            You only need to use this if you have multiple network cards and
+            want to use a specific one.
+
+        timeout (`int` | `float`, optional):
+            The timeout in seconds to be used when connecting.
+            This is **not** the timeout to be used when ``await``'ing for
+            invoked requests, and you should use ``asyncio.wait`` or
+            ``asyncio.wait_for`` for that.
+
+        request_retries (`int` | `None`, optional):
+            How many times a request should be retried. Request are retried
+            when Telegram is having internal issues (due to either
+            ``errors.ServerError`` or ``errors.RpcCallFailError``),
+            when there is a ``errors.FloodWaitError`` less than
+            `flood_sleep_threshold`, or when there's a migrate error.
+
+            May take a negative or `None` value for infinite retries, but
+            this is not recommended, since some requests can always trigger
+            a call fail (such as searching for messages).
+
+        connection_retries (`int` | `None`, optional):
+            How many times the reconnection should retry, either on the
+            initial connection or when Telegram disconnects us. May be
+            set to a negative or `None` value for infinite retries, but
+            this is not recommended, since the program can get stuck in an
+            infinite loop.
+
+        retry_delay (`int` | `float`, optional):
+            The delay in seconds to sleep between automatic reconnections.
+
+        auto_reconnect (`bool`, optional):
+            Whether reconnection should be retried `connection_retries`
+            times automatically if Telegram disconnects us or not.
+
+        sequential_updates (`bool`, optional):
+            By default every incoming update will create a new task, so
+            you can handle several updates in parallel. Some scripts need
+            the order in which updates are processed to be sequential, and
+            this setting allows them to do so.
+
+            If set to `True`, incoming updates will be put in a queue
+            and processed sequentially. This means your event handlers
+            should *not* perform long-running operations since new
+            updates are put inside of an unbounded queue.
+
+        flood_sleep_threshold (`int` | `float`, optional):
+            The threshold below which the library should automatically
+            sleep on flood wait and slow mode wait errors (inclusive). For instance, if a
+            ``FloodWaitError`` for 17s occurs and `flood_sleep_threshold`
+            is 20s, the library will ``sleep`` automatically. If the error
+            was for 21s, it would ``raise FloodWaitError`` instead. Values
+            larger than a day (like ``float('inf')``) will be changed to a day.
+
+        raise_last_call_error (`bool`, optional):
+            When API calls fail in a way that causes Telethon to retry
+            automatically, should the RPC error of the last attempt be raised
+            instead of a generic ValueError. This is mostly useful for
+            detecting when Telegram has internal issues.
+
+        device_model (`str`, optional):
+            "Device model" to be sent when creating the initial connection.
+            Defaults to 'PC (n)bit' derived from ``platform.uname().machine``, or its direct value if unknown.
+
+        system_version (`str`, optional):
+            "System version" to be sent when creating the initial connection.
+            Defaults to ``platform.uname().release`` stripped of everything ahead of -.
+
+        app_version (`str`, optional):
+            "App version" to be sent when creating the initial connection.
+            Defaults to `telethon.version.__version__`.
+
+        lang_code (`str`, optional):
+            "Language code" to be sent when creating the initial connection.
+            Defaults to ``'en'``.
+
+        system_lang_code (`str`, optional):
+            "System lang code"  to be sent when creating the initial connection.
+            Defaults to `lang_code`.
+
+        loop (`asyncio.AbstractEventLoop`, optional):
+            Asyncio event loop to use. Defaults to `asyncio.get_running_loop()`.
+            This argument is ignored.
+
+        base_logger (`str` | `logging.Logger`, optional):
+            Base logger name or instance to use.
+            If a `str` is given, it'll be passed to `logging.getLogger()`. If a
+            `logging.Logger` is given, it'll be used directly. If something
+            else or nothing is given, the default logger will be used.
+
+        receive_updates (`bool`, optional):
+            Whether the client will receive updates or not. By default, updates
+            will be received from Telegram as they occur.
+
+            Turning this off means that Telegram will not send updates at all
+            so event handlers, conversations, and QR login will not work.
+            However, certain scripts don't need updates, so this will reduce
+            the amount of bandwidth used.
+
+        entity_cache_limit (`int`, optional):
+            How many users, chats and channels to keep in the in-memory cache
+            at most. This limit is checked against when processing updates.
+
+            When this limit is reached or exceeded, all entities that are not
+            required for update handling will be flushed to the session file.
+
+            Note that this implies that there is a lower bound to the amount
+            of entities that must be kept in memory.
+
+            Setting this limit too low will cause the library to attempt to
+            flush entities to the session file even if no entities can be
+            removed from the in-memory cache, which will degrade performance.
+    """
+
+    # Current TelegramClient version
+    __version__ = version.__version__
+
+    # Cached server configuration (with .dc_options), can be "global"
+    _config = None
+    _cdn_config = None
+
+    # region Initialization
+
+    def __init__(
+            self: 'TelegramClient',
+            session: 'typing.Union[str, Session]',
+            api_id: int,
+            api_hash: str,
+            *,
+            connection: 'typing.Type[Connection]' = ConnectionTcpFull,
+            use_ipv6: bool = False,
+            proxy: typing.Union[tuple, dict] = None,
+            local_addr: typing.Union[str, tuple] = None,
+            timeout: int = 10,
+            request_retries: int = 5,
+            connection_retries: int = 5,
+            retry_delay: int = 1,
+            auto_reconnect: bool = True,
+            sequential_updates: bool = False,
+            flood_sleep_threshold: int = 60,
+            raise_last_call_error: bool = False,
+            device_model: str = None,
+            system_version: str = None,
+            app_version: str = None,
+            lang_code: str = 'en',
+            system_lang_code: str = 'en',
+            loop: asyncio.AbstractEventLoop = None,
+            base_logger: typing.Union[str, logging.Logger] = None,
+            receive_updates: bool = True,
+            catch_up: bool = False,
+            entity_cache_limit: int = 5000
+    ):
+        if not api_id or not api_hash:
+            raise ValueError(
+                "Your API ID or Hash cannot be empty or None. "
+                "Refer to telethon.rtfd.io for more information.")
+
+        self._use_ipv6 = use_ipv6
+
+        if isinstance(base_logger, str):
+            base_logger = logging.getLogger(base_logger)
+        elif not isinstance(base_logger, logging.Logger):
+            base_logger = _base_log
+
+        class _Loggers(dict):
+            def __missing__(self, key):
+                if key.startswith("telethon."):
+                    key = key.split('.', maxsplit=1)[1]
+
+                return base_logger.getChild(key)
+
+        self._log = _Loggers()
+
+        # Determine what session object we have
+        if isinstance(session, str) or session is None:
+            try:
+                session = SQLiteSession(session)
+            except ImportError:
+                import warnings
+                warnings.warn(
+                    'The sqlite3 module is not available under this '
+                    'Python installation and no custom session '
+                    'instance was given; using MemorySession.\n'
+                    'You will need to re-login every time unless '
+                    'you use another session storage'
+                )
+                session = MemorySession()
+        elif not isinstance(session, Session):
+            raise TypeError(
+                'The given session must be a str or a Session instance.'
+            )
+
+        # ':' in session.server_address is True if it's an IPv6 address
+        if (not session.server_address or
+                (':' in session.server_address) != use_ipv6):
+            session.set_dc(
+                DEFAULT_DC_ID,
+                DEFAULT_IPV6_IP if self._use_ipv6 else DEFAULT_IPV4_IP,
+                DEFAULT_PORT
+            )
+
+        self.flood_sleep_threshold = flood_sleep_threshold
+
+        # TODO Use AsyncClassWrapper(session)
+        # ChatGetter and SenderGetter can use the in-memory _mb_entity_cache
+        # to avoid network access and the need for await in session files.
+        #
+        # The session files only wants the entities to persist
+        # them to disk, and to save additional useful information.
+        # TODO Session should probably return all cached
+        #      info of entities, not just the input versions
+        self.session = session
+        self.api_id = int(api_id)
+        self.api_hash = api_hash
+
+        # Current proxy implementation requires `sock_connect`, and some
+        # event loops lack this method. If the current loop is missing it,
+        # bail out early and suggest an alternative.
+        #
+        # TODO A better fix is obviously avoiding the use of `sock_connect`
+        #
+        # See https://github.com/LonamiWebs/Telethon/issues/1337 for details.
+        if not callable(getattr(self.loop, 'sock_connect', None)):
+            raise TypeError(
+                'Event loop of type {} lacks `sock_connect`, which is needed to use proxies.\n\n'
+                'Change the event loop in use to use proxies:\n'
+                '# https://github.com/LonamiWebs/Telethon/issues/1337\n'
+                'import asyncio\n'
+                'asyncio.set_event_loop(asyncio.SelectorEventLoop())'.format(
+                    self.loop.__class__.__name__
+                )
+            )
+
+        if local_addr is not None:
+            if use_ipv6 is False and ':' in local_addr:
+                raise TypeError(
+                    'A local IPv6 address must only be used with `use_ipv6=True`.'
+                )
+            elif use_ipv6 is True and ':' not in local_addr:
+                raise TypeError(
+                    '`use_ipv6=True` must only be used with a local IPv6 address.'
+                )
+
+        self._raise_last_call_error = raise_last_call_error
+
+        self._request_retries = request_retries
+        self._connection_retries = connection_retries
+        self._retry_delay = retry_delay or 0
+        self._proxy = proxy
+        self._local_addr = local_addr
+        self._timeout = timeout
+        self._auto_reconnect = auto_reconnect
+
+        assert isinstance(connection, type)
+        self._connection = connection
+        init_proxy = None if not issubclass(connection, TcpMTProxy) else \
+            types.InputClientProxy(*connection.address_info(proxy))
+
+        # Used on connection. Capture the variables in a lambda since
+        # exporting clients need to create this InvokeWithLayerRequest.
+        system = platform.uname()
+
+        if system.machine in ('x86_64', 'AMD64'):
+            default_device_model = 'PC 64bit'
+        elif system.machine in ('i386','i686','x86'):
+            default_device_model = 'PC 32bit'
+        else:
+            default_device_model = system.machine
+        default_system_version = re.sub(r'-.+','',system.release)
+
+        self._init_request = functions.InitConnectionRequest(
+            api_id=self.api_id,
+            device_model=device_model or default_device_model or 'Unknown',
+            system_version=system_version or default_system_version or '1.0',
+            app_version=app_version or self.__version__,
+            lang_code=lang_code,
+            system_lang_code=system_lang_code,
+            lang_pack='',  # "langPacks are for official apps only"
+            query=None,
+            proxy=init_proxy
+        )
+
+        # Remember flood-waited requests to avoid making them again
+        self._flood_waited_requests = {}
+
+        # Cache ``{dc_id: (_ExportState, MTProtoSender)}`` for all borrowed senders
+        self._borrowed_senders = {}
+        self._borrow_sender_lock = asyncio.Lock()
+
+        self._loop = None  # only used as a sanity check
+        self._updates_error = None
+        self._updates_handle = None
+        self._keepalive_handle = None
+        self._last_request = time.time()
+        self._no_updates = not receive_updates
+
+        # Used for non-sequential updates, in order to terminate all pending tasks on disconnect.
+        self._sequential_updates = sequential_updates
+        self._event_handler_tasks = set()
+
+        self._authorized = None  # None = unknown, False = no, True = yes
+
+        # Some further state for subclasses
+        self._event_builders = []
+
+        # {chat_id: {Conversation}}
+        self._conversations = collections.defaultdict(set)
+
+        # Hack to workaround the fact Telegram may send album updates as
+        # different Updates when being sent from a different data center.
+        # {grouped_id: AlbumHack}
+        #
+        # FIXME: We don't bother cleaning this up because it's not really
+        #        worth it, albums are pretty rare and this only holds them
+        #        for a second at most.
+        self._albums = {}
+
+        # Default parse mode
+        self._parse_mode = markdown
+
+        # Some fields to easy signing in. Let {phone: hash} be
+        # a dictionary because the user may change their mind.
+        self._phone_code_hash = {}
+        self._phone = None
+        self._tos = None
+
+        # A place to store if channels are a megagroup or not (see `edit_admin`)
+        self._megagroup_cache = {}
+
+        # This is backported from v2 in a very ad-hoc way just to get proper update handling
+        self._catch_up = catch_up
+        self._updates_queue = asyncio.Queue()
+        self._message_box = MessageBox(self._log['messagebox'])
+        self._mb_entity_cache = MbEntityCache()  # required for proper update handling (to know when to getDifference)
+        self._entity_cache_limit = entity_cache_limit
+
+        self._sender = MTProtoSender(
+            self.session.auth_key,
+            loggers=self._log,
+            retries=self._connection_retries,
+            delay=self._retry_delay,
+            auto_reconnect=self._auto_reconnect,
+            connect_timeout=self._timeout,
+            auth_key_callback=self._auth_key_callback,
+            updates_queue=self._updates_queue,
+            auto_reconnect_callback=self._handle_auto_reconnect
+        )
+
+
+    # endregion
+
+    # region Properties
+
+    @property
+    def loop(self: 'TelegramClient') -> asyncio.AbstractEventLoop:
+        """
+        Property with the ``asyncio`` event loop used by this client.
+
+        Example
+            .. code-block:: python
+
+                # Download media in the background
+                task = client.loop.create_task(message.download_media())
+
+                # Do some work
+                ...
+
+                # Join the task (wait for it to complete)
+                await task
+        """
+        return helpers.get_running_loop()
+
+    @property
+    def disconnected(self: 'TelegramClient') -> asyncio.Future:
+        """
+        Property with a ``Future`` that resolves upon disconnection.
+
+        Example
+            .. code-block:: python
+
+                # Wait for a disconnection to occur
+                try:
+                    await client.disconnected
+                except OSError:
+                    print('Error on disconnect')
+        """
+        return self._sender.disconnected
+
+    @property
+    def flood_sleep_threshold(self):
+        return self._flood_sleep_threshold
+
+    @flood_sleep_threshold.setter
+    def flood_sleep_threshold(self, value):
+        # None -> 0, negative values don't really matter
+        self._flood_sleep_threshold = min(value or 0, 24 * 60 * 60)
+
+    # endregion
+
+    # region Connecting
+
+    async def connect(self: 'TelegramClient') -> None:
+        """
+        Connects to Telegram.
+
+        .. note::
+
+            Connect means connect and nothing else, and only one low-level
+            request is made to notify Telegram about which layer we will be
+            using.
+
+            Before Telegram sends you updates, you need to make a high-level
+            request, like `client.get_me() <telethon.client.users.UserMethods.get_me>`,
+            as described in https://core.telegram.org/api/updates.
+
+        Example
+            .. code-block:: python
+
+                try:
+                    await client.connect()
+                except OSError:
+                    print('Failed to connect')
+        """
+        if self.session is None:
+            raise ValueError('TelegramClient instance cannot be reused after logging out')
+
+        if self._loop is None:
+            self._loop = helpers.get_running_loop()
+        elif self._loop != helpers.get_running_loop():
+            raise RuntimeError('The asyncio event loop must not change after connection (see the FAQ for details)')
+
+        if not await self._sender.connect(self._connection(
+            self.session.server_address,
+            self.session.port,
+            self.session.dc_id,
+            loggers=self._log,
+            proxy=self._proxy,
+            local_addr=self._local_addr
+        )):
+            # We don't want to init or modify anything if we were already connected
+            return
+
+        self.session.auth_key = self._sender.auth_key
+        self.session.save()
+
+        try:
+            # See comment when saving entities to understand this hack
+            self_id = self.session.get_input_entity(0).access_hash
+            self_user = self.session.get_input_entity(self_id)
+            self._mb_entity_cache.set_self_user(self_id, None, self_user.access_hash)
+        except ValueError:
+            pass
+
+        if self._catch_up:
+            ss = SessionState(0, 0, False, 0, 0, 0, 0, None)
+            cs = []
+
+            for entity_id, state in self.session.get_update_states():
+                if entity_id == 0:
+                    # TODO current session doesn't store self-user info but adding that is breaking on downstream session impls
+                    ss = SessionState(0, 0, False, state.pts, state.qts, int(state.date.timestamp()), state.seq, None)
+                else:
+                    cs.append(ChannelState(entity_id, state.pts))
+
+            self._message_box.load(ss, cs)
+            for state in cs:
+                try:
+                    entity = self.session.get_input_entity(state.channel_id)
+                except ValueError:
+                    self._log[__name__].warning(
+                        'No access_hash in cache for channel %s, will not catch up', state.channel_id)
+                else:
+                    self._mb_entity_cache.put(Entity(EntityType.CHANNEL, entity.channel_id, entity.access_hash))
+
+        self._init_request.query = functions.help.GetConfigRequest()
+
+        req = self._init_request
+        if self._no_updates:
+            req = functions.InvokeWithoutUpdatesRequest(req)
+
+        await self._sender.send(functions.InvokeWithLayerRequest(LAYER, req))
+
+        if self._message_box.is_empty():
+            me = await self.get_me()
+            if me:
+                await self._on_login(me)  # also calls GetState to initialize the MessageBox
+
+        self._updates_handle = self.loop.create_task(self._update_loop())
+        self._keepalive_handle = self.loop.create_task(self._keepalive_loop())
+
+    def is_connected(self: 'TelegramClient') -> bool:
+        """
+        Returns `True` if the user has connected.
+
+        This method is **not** asynchronous (don't use ``await`` on it).
+
+        Example
+            .. code-block:: python
+
+                while client.is_connected():
+                    await asyncio.sleep(1)
+        """
+        sender = getattr(self, '_sender', None)
+        return sender and sender.is_connected()
+
+    def disconnect(self: 'TelegramClient'):
+        """
+        Disconnects from Telegram.
+
+        If the event loop is already running, this method returns a
+        coroutine that you should await on your own code; otherwise
+        the loop is ran until said coroutine completes.
+
+        Event handlers which are currently running will be cancelled before
+        this function returns (in order to properly clean-up their tasks).
+        In particular, this means that using ``disconnect`` in a handler
+        will cause code after the ``disconnect`` to never run. If this is
+        needed, consider spawning a separate task to do the remaining work.
+
+        Example
+            .. code-block:: python
+
+                # You don't need to use this if you used "with client"
+                await client.disconnect()
+        """
+        if self.loop.is_running():
+            # Disconnect may be called from an event handler, which would
+            # cancel itself during itself and never actually complete the
+            # disconnection. Shield the task to prevent disconnect itself
+            # from being cancelled. See issue #3942 for more details.
+            return asyncio.shield(self.loop.create_task(self._disconnect_coro()))
+        else:
+            try:
+                self.loop.run_until_complete(self._disconnect_coro())
+            except RuntimeError:
+                # Python 3.5.x complains when called from
+                # `__aexit__` and there were pending updates with:
+                #   "Event loop stopped before Future completed."
+                #
+                # However, it doesn't really make a lot of sense.
+                pass
+
+    def set_proxy(self: 'TelegramClient', proxy: typing.Union[tuple, dict]):
+        """
+        Changes the proxy which will be used on next (re)connection.
+
+        Method has no immediate effects if the client is currently connected.
+
+        The new proxy will take it's effect on the next reconnection attempt:
+            - on a call `await client.connect()` (after complete disconnect)
+            - on auto-reconnect attempt (e.g, after previous connection was lost)
+        """
+        init_proxy = None if not issubclass(self._connection, TcpMTProxy) else \
+            types.InputClientProxy(*self._connection.address_info(proxy))
+
+        self._init_request.proxy = init_proxy
+        self._proxy = proxy
+
+        # While `await client.connect()` passes new proxy on each new call,
+        # auto-reconnect attempts use already set up `_connection` inside
+        # the `_sender`, so the only way to change proxy between those
+        # is to directly inject parameters.
+
+        connection = getattr(self._sender, "_connection", None)
+        if connection:
+            if isinstance(connection, TcpMTProxy):
+                connection._ip = proxy[0]
+                connection._port = proxy[1]
+            else:
+                connection._proxy = proxy
+
+    def _save_states_and_entities(self: 'TelegramClient'):
+        entities = self._mb_entity_cache.get_all_entities()
+
+        # Piggy-back on an arbitrary TL type with users and chats so the session can understand to read the entities.
+        # It doesn't matter if we put users in the list of chats.
+        self.session.process_entities(types.contacts.ResolvedPeer(None, [e._as_input_peer() for e in entities], []))
+
+        # As a hack to not need to change the session files, save ourselves with ``id=0`` and ``access_hash`` of our ``id``.
+        # This way it is possible to determine our own ID by querying for 0. However, whether we're a bot is not saved.
+        if self._mb_entity_cache.self_id:
+            self.session.process_entities(types.contacts.ResolvedPeer(None, [types.InputPeerUser(0, self._mb_entity_cache.self_id)], []))
+
+        ss, cs = self._message_box.session_state()
+        self.session.set_update_state(0, types.updates.State(**ss, unread_count=0))
+        now = datetime.datetime.now()  # any datetime works; channels don't need it
+        for channel_id, pts in cs.items():
+            self.session.set_update_state(channel_id, types.updates.State(pts, 0, now, 0, unread_count=0))
+
+    async def _disconnect_coro(self: 'TelegramClient'):
+        if self.session is None:
+            return  # already logged out and disconnected
+
+        await self._disconnect()
+
+        # Also clean-up all exported senders because we're done with them
+        async with self._borrow_sender_lock:
+            for state, sender in self._borrowed_senders.values():
+                # Note that we're not checking for `state.should_disconnect()`.
+                # If the user wants to disconnect the client, ALL connections
+                # to Telegram (including exported senders) should be closed.
+                #
+                # Disconnect should never raise, so there's no try/except.
+                await sender.disconnect()
+                # Can't use `mark_disconnected` because it may be borrowed.
+                state._connected = False
+
+            # If any was borrowed
+            self._borrowed_senders.clear()
+
+        # trio's nurseries would handle this for us, but this is asyncio.
+        # All tasks spawned in the background should properly be terminated.
+        if self._event_handler_tasks:
+            for task in self._event_handler_tasks:
+                task.cancel()
+
+            await asyncio.wait(self._event_handler_tasks)
+            self._event_handler_tasks.clear()
+
+        self._save_states_and_entities()
+
+        self.session.close()
+
+    async def _disconnect(self: 'TelegramClient'):
+        """
+        Disconnect only, without closing the session. Used in reconnections
+        to different data centers, where we don't want to close the session
+        file; user disconnects however should close it since it means that
+        their job with the client is complete and we should clean it up all.
+        """
+        await self._sender.disconnect()
+        await helpers._cancel(self._log[__name__],
+                              updates_handle=self._updates_handle,
+                              keepalive_handle=self._keepalive_handle)
+
+    async def _switch_dc(self: 'TelegramClient', new_dc):
+        """
+        Permanently switches the current connection to the new data center.
+        """
+        self._log[__name__].info('Reconnecting to new data center %s', new_dc)
+        dc = await self._get_dc(new_dc)
+
+        self.session.set_dc(dc.id, dc.ip_address, dc.port)
+        # auth_key's are associated with a server, which has now changed
+        # so it's not valid anymore. Set to None to force recreating it.
+        self._sender.auth_key.key = None
+        self.session.auth_key = None
+        self.session.save()
+        await self._disconnect()
+        return await self.connect()
+
+    def _auth_key_callback(self: 'TelegramClient', auth_key):
+        """
+        Callback from the sender whenever it needed to generate a
+        new authorization key. This means we are not authorized.
+        """
+        self.session.auth_key = auth_key
+        self.session.save()
+
+    # endregion
+
+    # region Working with different connections/Data Centers
+
+    async def _get_dc(self: 'TelegramClient', dc_id, cdn=False):
+        """Gets the Data Center (DC) associated to 'dc_id'"""
+        cls = self.__class__
+        if not cls._config:
+            cls._config = await self(functions.help.GetConfigRequest())
+
+        if cdn and not self._cdn_config:
+            cls._cdn_config = await self(functions.help.GetCdnConfigRequest())
+            for pk in cls._cdn_config.public_keys:
+                rsa.add_key(pk.public_key)
+
+        try:
+            return next(
+                dc for dc in cls._config.dc_options
+                if dc.id == dc_id
+                and bool(dc.ipv6) == self._use_ipv6 and bool(dc.cdn) == cdn
+            )
+        except StopIteration:
+            self._log[__name__].warning(
+                'Failed to get DC %s (cdn = %s) with use_ipv6 = %s; retrying ignoring IPv6 check',
+                dc_id, cdn, self._use_ipv6
+            )
+            return next(
+                dc for dc in cls._config.dc_options
+                if dc.id == dc_id and bool(dc.cdn) == cdn
+            )
+
+    async def _create_exported_sender(self: 'TelegramClient', dc_id):
+        """
+        Creates a new exported `MTProtoSender` for the given `dc_id` and
+        returns it. This method should be used by `_borrow_exported_sender`.
+        """
+        # Thanks badoualy/kotlogram on /telegram/api/DefaultTelegramClient.kt
+        # for clearly showing how to export the authorization
+        dc = await self._get_dc(dc_id)
+        # Can't reuse self._sender._connection as it has its own seqno.
+        #
+        # If one were to do that, Telegram would reset the connection
+        # with no further clues.
+        sender = MTProtoSender(None, loggers=self._log)
+        await sender.connect(self._connection(
+            dc.ip_address,
+            dc.port,
+            dc.id,
+            loggers=self._log,
+            proxy=self._proxy,
+            local_addr=self._local_addr
+        ))
+        self._log[__name__].info('Exporting auth for new borrowed sender in %s', dc)
+        auth = await self(functions.auth.ExportAuthorizationRequest(dc_id))
+        self._init_request.query = functions.auth.ImportAuthorizationRequest(id=auth.id, bytes=auth.bytes)
+        req = functions.InvokeWithLayerRequest(LAYER, self._init_request)
+        await sender.send(req)
+        return sender
+
+    async def _borrow_exported_sender(self: 'TelegramClient', dc_id):
+        """
+        Borrows a connected `MTProtoSender` for the given `dc_id`.
+        If it's not cached, creates a new one if it doesn't exist yet,
+        and imports a freshly exported authorization key for it to be usable.
+
+        Once its job is over it should be `_return_exported_sender`.
+        """
+        async with self._borrow_sender_lock:
+            self._log[__name__].debug('Borrowing sender for dc_id %d', dc_id)
+            state, sender = self._borrowed_senders.get(dc_id, (None, None))
+
+            if state is None:
+                state = _ExportState()
+                sender = await self._create_exported_sender(dc_id)
+                sender.dc_id = dc_id
+                self._borrowed_senders[dc_id] = (state, sender)
+
+            elif state.need_connect():
+                dc = await self._get_dc(dc_id)
+                await sender.connect(self._connection(
+                    dc.ip_address,
+                    dc.port,
+                    dc.id,
+                    loggers=self._log,
+                    proxy=self._proxy,
+                    local_addr=self._local_addr
+                ))
+
+            state.add_borrow()
+            return sender
+
+    async def _return_exported_sender(self: 'TelegramClient', sender):
+        """
+        Returns a borrowed exported sender. If all borrows have
+        been returned, the sender is cleanly disconnected.
+        """
+        async with self._borrow_sender_lock:
+            self._log[__name__].debug('Returning borrowed sender for dc_id %d', sender.dc_id)
+            state, _ = self._borrowed_senders[sender.dc_id]
+            state.add_return()
+
+    async def _clean_exported_senders(self: 'TelegramClient'):
+        """
+        Cleans-up all unused exported senders by disconnecting them.
+        """
+        async with self._borrow_sender_lock:
+            for dc_id, (state, sender) in self._borrowed_senders.items():
+                if state.should_disconnect():
+                    self._log[__name__].info(
+                        'Disconnecting borrowed sender for DC %d', dc_id)
+
+                    # Disconnect should never raise
+                    await sender.disconnect()
+                    state.mark_disconnected()
+
+    async def _get_cdn_client(self: 'TelegramClient', cdn_redirect):
+        """Similar to ._borrow_exported_client, but for CDNs"""
+        # TODO Implement
+        raise NotImplementedError
+        session = self._exported_sessions.get(cdn_redirect.dc_id)
+        if not session:
+            dc = await self._get_dc(cdn_redirect.dc_id, cdn=True)
+            session = self.session.clone()
+            session.set_dc(dc.id, dc.ip_address, dc.port)
+            self._exported_sessions[cdn_redirect.dc_id] = session
+
+        self._log[__name__].info('Creating new CDN client')
+        client = TelegramBaseClient(
+            session, self.api_id, self.api_hash,
+            proxy=self._sender.connection.conn.proxy,
+            timeout=self._sender.connection.get_timeout()
+        )
+
+        # This will make use of the new RSA keys for this specific CDN.
+        #
+        # We won't be calling GetConfigRequest because it's only called
+        # when needed by ._get_dc, and also it's static so it's likely
+        # set already. Avoid invoking non-CDN methods by not syncing updates.
+        client.connect(_sync_updates=False)
+        return client
+
+    # endregion
+
+    # region Invoking Telegram requests
+
+    @abc.abstractmethod
+    def __call__(self: 'TelegramClient', request, ordered=False):
+        """
+        Invokes (sends) one or more MTProtoRequests and returns (receives)
+        their result.
+
+        Args:
+            request (`TLObject` | `list`):
+                The request or requests to be invoked.
+
+            ordered (`bool`, optional):
+                Whether the requests (if more than one was given) should be
+                executed sequentially on the server. They run in arbitrary
+                order by default.
+
+            flood_sleep_threshold (`int` | `None`, optional):
+                The flood sleep threshold to use for this request. This overrides
+                the default value stored in
+                `client.flood_sleep_threshold <telethon.client.telegrambaseclient.TelegramBaseClient.flood_sleep_threshold>`
+
+        Returns:
+            The result of the request (often a `TLObject`) or a list of
+            results if more than one request was given.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _update_loop(self: 'TelegramClient'):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def _handle_auto_reconnect(self: 'TelegramClient'):
+        raise NotImplementedError
+
+    # endregion

.venv2/Lib/site-packages/telethon/client/telegramclient.py

@@ -0,0 +1,13 @@
+from . import (
+    AccountMethods, AuthMethods, DownloadMethods, DialogMethods, ChatMethods,
+    BotMethods, MessageMethods, UploadMethods, ButtonMethods, UpdateMethods,
+    MessageParseMethods, UserMethods, TelegramBaseClient
+)
+
+
+class TelegramClient(
+    AccountMethods, AuthMethods, DownloadMethods, DialogMethods, ChatMethods,
+    BotMethods, MessageMethods, UploadMethods, ButtonMethods, UpdateMethods,
+    MessageParseMethods, UserMethods, TelegramBaseClient
+):
+    pass

.venv2/Lib/site-packages/telethon/client/updates.py

@@ -0,0 +1,698 @@
+import asyncio
+import inspect
+import itertools
+import random
+import sys
+import time
+import traceback
+import typing
+import logging
+import warnings
+from collections import deque
+import sqlite3
+
+from .. import events, utils, errors
+from ..events.common import EventBuilder, EventCommon
+from ..tl import types, functions
+from .._updates import GapError, PrematureEndReason
+from ..helpers import get_running_loop
+from ..version import __version__
+
+
+if typing.TYPE_CHECKING:
+    from .telegramclient import TelegramClient
+
+
+Callback = typing.Callable[[typing.Any], typing.Any]
+
+class UpdateMethods:
+
+    # region Public methods
+
+    async def _run_until_disconnected(self: 'TelegramClient'):
+        try:
+            # Make a high-level request to notify that we want updates
+            await self(functions.updates.GetStateRequest())
+            result = await self.disconnected
+            if self._updates_error is not None:
+                raise self._updates_error
+            return result
+        except KeyboardInterrupt:
+            pass
+        finally:
+            await self.disconnect()
+
+    async def set_receive_updates(self: 'TelegramClient', receive_updates):
+        """
+        Change the value of `receive_updates`.
+
+        This is an `async` method, because in order for Telegram to start
+        sending updates again, a request must be made.
+        """
+        self._no_updates = not receive_updates
+        if receive_updates:
+            await self(functions.updates.GetStateRequest())
+
+    def run_until_disconnected(self: 'TelegramClient'):
+        """
+        Runs the event loop until the library is disconnected.
+
+        It also notifies Telegram that we want to receive updates
+        as described in https://core.telegram.org/api/updates.
+        If an unexpected error occurs during update handling,
+        the client will disconnect and said error will be raised.
+
+        Manual disconnections can be made by calling `disconnect()
+        <telethon.client.telegrambaseclient.TelegramBaseClient.disconnect>`
+        or sending a ``KeyboardInterrupt`` (e.g. by pressing ``Ctrl+C`` on
+        the console window running the script).
+
+        If a disconnection error occurs (i.e. the library fails to reconnect
+        automatically), said error will be raised through here, so you have a
+        chance to ``except`` it on your own code.
+
+        If the loop is already running, this method returns a coroutine
+        that you should await on your own code.
+
+        .. note::
+
+            If you want to handle ``KeyboardInterrupt`` in your code,
+            simply run the event loop in your code too in any way, such as
+            ``loop.run_forever()`` or ``await client.disconnected`` (e.g.
+            ``loop.run_until_complete(client.disconnected)``).
+
+        Example
+            .. code-block:: python
+
+                # Blocks the current task here until a disconnection occurs.
+                #
+                # You will still receive updates, since this prevents the
+                # script from exiting.
+                await client.run_until_disconnected()
+        """
+        if self.loop.is_running():
+            return self._run_until_disconnected()
+        try:
+            return self.loop.run_until_complete(self._run_until_disconnected())
+        except KeyboardInterrupt:
+            pass
+        finally:
+            # No loop.run_until_complete; it's already syncified
+            self.disconnect()
+
+    def on(self: 'TelegramClient', event: EventBuilder):
+        """
+        Decorator used to `add_event_handler` more conveniently.
+
+
+        Arguments
+            event (`_EventBuilder` | `type`):
+                The event builder class or instance to be used,
+                for instance ``events.NewMessage``.
+
+        Example
+            .. code-block:: python
+
+                from telethon import TelegramClient, events
+                client = TelegramClient(...)
+
+                # Here we use client.on
+                @client.on(events.NewMessage)
+                async def handler(event):
+                    ...
+        """
+        def decorator(f):
+            self.add_event_handler(f, event)
+            return f
+
+        return decorator
+
+    def add_event_handler(
+            self: 'TelegramClient',
+            callback: Callback,
+            event: EventBuilder = None):
+        """
+        Registers a new event handler callback.
+
+        The callback will be called when the specified event occurs.
+
+        Arguments
+            callback (`callable`):
+                The callable function accepting one parameter to be used.
+
+                Note that if you have used `telethon.events.register` in
+                the callback, ``event`` will be ignored, and instead the
+                events you previously registered will be used.
+
+            event (`_EventBuilder` | `type`, optional):
+                The event builder class or instance to be used,
+                for instance ``events.NewMessage``.
+
+                If left unspecified, `telethon.events.raw.Raw` (the
+                :tl:`Update` objects with no further processing) will
+                be passed instead.
+
+        Example
+            .. code-block:: python
+
+                from telethon import TelegramClient, events
+                client = TelegramClient(...)
+
+                async def handler(event):
+                    ...
+
+                client.add_event_handler(handler, events.NewMessage)
+        """
+        builders = events._get_handlers(callback)
+        if builders is not None:
+            for event in builders:
+                self._event_builders.append((event, callback))
+            return
+
+        if isinstance(event, type):
+            event = event()
+        elif not event:
+            event = events.Raw()
+
+        self._event_builders.append((event, callback))
+
+    def remove_event_handler(
+            self: 'TelegramClient',
+            callback: Callback,
+            event: EventBuilder = None) -> int:
+        """
+        Inverse operation of `add_event_handler()`.
+
+        If no event is given, all events for this callback are removed.
+        Returns how many callbacks were removed.
+
+        Example
+            .. code-block:: python
+
+                @client.on(events.Raw)
+                @client.on(events.NewMessage)
+                async def handler(event):
+                    ...
+
+                # Removes only the "Raw" handling
+                # "handler" will still receive "events.NewMessage"
+                client.remove_event_handler(handler, events.Raw)
+
+                # "handler" will stop receiving anything
+                client.remove_event_handler(handler)
+        """
+        found = 0
+        if event and not isinstance(event, type):
+            event = type(event)
+
+        i = len(self._event_builders)
+        while i:
+            i -= 1
+            ev, cb = self._event_builders[i]
+            if cb == callback and (not event or isinstance(ev, event)):
+                del self._event_builders[i]
+                found += 1
+
+        return found
+
+    def list_event_handlers(self: 'TelegramClient')\
+            -> 'typing.Sequence[typing.Tuple[Callback, EventBuilder]]':
+        """
+        Lists all registered event handlers.
+
+        Returns
+            A list of pairs consisting of ``(callback, event)``.
+
+        Example
+            .. code-block:: python
+
+                @client.on(events.NewMessage(pattern='hello'))
+                async def on_greeting(event):
+                    '''Greets someone'''
+                    await event.reply('Hi')
+
+                for callback, event in client.list_event_handlers():
+                    print(id(callback), type(event))
+        """
+        return [(callback, event) for event, callback in self._event_builders]
+
+    async def catch_up(self: 'TelegramClient'):
+        """
+        "Catches up" on the missed updates while the client was offline.
+        You should call this method after registering the event handlers
+        so that the updates it loads can by processed by your script.
+
+        This can also be used to forcibly fetch new updates if there are any.
+
+        Example
+            .. code-block:: python
+
+                await client.catch_up()
+        """
+        await self._updates_queue.put(types.UpdatesTooLong())
+
+    # endregion
+
+    # region Private methods
+
+    async def _update_loop(self: 'TelegramClient'):
+        # If the MessageBox is not empty, the account had to be logged-in to fill in its state.
+        # This flag is used to propagate the "you got logged-out" error up (but getting logged-out
+        # can only happen if it was once logged-in).
+        was_once_logged_in = self._authorized is True or not self._message_box.is_empty()
+
+        self._updates_error = None
+        try:
+            if self._catch_up:
+                # User wants to catch up as soon as the client is up and running,
+                # so this is the best place to do it.
+                await self.catch_up()
+
+            updates_to_dispatch = deque()
+
+            while self.is_connected():
+                if updates_to_dispatch:
+                    if self._sequential_updates:
+                        await self._dispatch_update(updates_to_dispatch.popleft())
+                    else:
+                        while updates_to_dispatch:
+                            # TODO if _dispatch_update fails for whatever reason, it's not logged! this should be fixed
+                            task = self.loop.create_task(self._dispatch_update(updates_to_dispatch.popleft()))
+                            self._event_handler_tasks.add(task)
+                            task.add_done_callback(self._event_handler_tasks.discard)
+
+                    continue
+
+                if len(self._mb_entity_cache) >= self._entity_cache_limit:
+                    self._log[__name__].info(
+                        'In-memory entity cache limit reached (%s/%s), flushing to session',
+                        len(self._mb_entity_cache),
+                        self._entity_cache_limit
+                    )
+                    self._save_states_and_entities()
+                    self._mb_entity_cache.retain(lambda id: id == self._mb_entity_cache.self_id or id in self._message_box.map)
+                    if len(self._mb_entity_cache) >= self._entity_cache_limit:
+                        warnings.warn('in-memory entities exceed entity_cache_limit after flushing; consider setting a larger limit')
+
+                    self._log[__name__].info(
+                        'In-memory entity cache at %s/%s after flushing to session',
+                        len(self._mb_entity_cache),
+                        self._entity_cache_limit
+                    )
+
+
+                get_diff = self._message_box.get_difference()
+                if get_diff:
+                    self._log[__name__].debug('Getting difference for account updates')
+                    try:
+                        diff = await self(get_diff)
+                    except (
+                        errors.ServerError,
+                        errors.TimedOutError,
+                        errors.FloodWaitError,
+                        ValueError
+                    ) as e:
+                        # Telegram is having issues
+                        self._log[__name__].info('Cannot get difference since Telegram is having issues: %s', type(e).__name__)
+                        self._message_box.end_difference()
+                        continue
+                    except (errors.UnauthorizedError, errors.AuthKeyError) as e:
+                        # Not logged in or broken authorization key, can't get difference
+                        self._log[__name__].info('Cannot get difference since the account is not logged in: %s', type(e).__name__)
+                        self._message_box.end_difference()
+                        if was_once_logged_in:
+                            self._updates_error = e
+                            await self.disconnect()
+                            break
+                        continue
+                    except (errors.TypeNotFoundError, sqlite3.OperationalError) as e:
+                        # User is likely doing weird things with their account or session and Telegram gets confused as to what layer they use
+                        self._log[__name__].warning('Cannot get difference since the account is likely misusing the session: %s', e)
+                        self._message_box.end_difference()
+                        self._updates_error = e
+                        await self.disconnect()
+                        break
+                    except OSError as e:
+                        # Network is likely down, but it's unclear for how long.
+                        # If disconnect is called this task will be cancelled along with the sleep.
+                        # If disconnect is not called, getting difference should be retried after a few seconds.
+                        self._log[__name__].info('Cannot get difference since the network is down: %s: %s', type(e).__name__, e)
+                        await asyncio.sleep(5)
+                        continue
+                    updates, users, chats = self._message_box.apply_difference(diff, self._mb_entity_cache)
+                    if updates:
+                        self._log[__name__].info('Got difference for account updates')
+
+                    updates_to_dispatch.extend(self._preprocess_updates(updates, users, chats))
+                    continue
+
+                get_diff = self._message_box.get_channel_difference(self._mb_entity_cache)
+                if get_diff:
+                    self._log[__name__].debug('Getting difference for channel %s updates', get_diff.channel.channel_id)
+                    try:
+                        diff = await self(get_diff)
+                    except (errors.UnauthorizedError, errors.AuthKeyError) as e:
+                        # Not logged in or broken authorization key, can't get difference
+                        self._log[__name__].warning(
+                            'Cannot get difference for channel %s since the account is not logged in: %s',
+                            get_diff.channel.channel_id, type(e).__name__
+                        )
+                        self._message_box.end_channel_difference(
+                            get_diff,
+                            PrematureEndReason.TEMPORARY_SERVER_ISSUES,
+                            self._mb_entity_cache
+                        )
+                        if was_once_logged_in:
+                            self._updates_error = e
+                            await self.disconnect()
+                            break
+                        continue
+                    except (errors.TypeNotFoundError, sqlite3.OperationalError) as e:
+                        self._log[__name__].warning(
+                            'Cannot get difference for channel %s since the account is likely misusing the session: %s',
+                            get_diff.channel.channel_id, e
+                        )
+                        self._message_box.end_channel_difference(
+                            get_diff,
+                            PrematureEndReason.TEMPORARY_SERVER_ISSUES,
+                            self._mb_entity_cache
+                        )
+                        self._updates_error = e
+                        await self.disconnect()
+                        break
+                    except (
+                        errors.PersistentTimestampOutdatedError,
+                        errors.PersistentTimestampInvalidError,
+                        errors.ServerError,
+                        errors.TimedOutError,
+                        errors.FloodWaitError,
+                        ValueError
+                    ) as e:
+                        # According to Telegram's docs:
+                        # "Channel internal replication issues, try again later (treat this like an RPC_CALL_FAIL)."
+                        # We can treat this as "empty difference" and not update the local pts.
+                        # Then this same call will be retried when another gap is detected or timeout expires.
+                        #
+                        # Another option would be to literally treat this like an RPC_CALL_FAIL and retry after a few
+                        # seconds, but if Telegram is having issues it's probably best to wait for it to send another
+                        # update (hinting it may be okay now) and retry then.
+                        #
+                        # This is a bit hacky because MessageBox doesn't really have a way to "not update" the pts.
+                        # Instead we manually extract the previously-known pts and use that.
+                        #
+                        # For PersistentTimestampInvalidError:
+                        # Somehow our pts is either too new or the server does not know about this.
+                        # We treat this as PersistentTimestampOutdatedError for now.
+                        # TODO investigate why/when this happens and if this is the proper solution
+                        self._log[__name__].warning(
+                            'Getting difference for channel updates %s caused %s;'
+                            ' ending getting difference prematurely until server issues are resolved',
+                            get_diff.channel.channel_id, type(e).__name__
+                        )
+                        self._message_box.end_channel_difference(
+                            get_diff,
+                            PrematureEndReason.TEMPORARY_SERVER_ISSUES,
+                            self._mb_entity_cache
+                        )
+                        continue
+                    except (errors.ChannelPrivateError, errors.ChannelInvalidError):
+                        # Timeout triggered a get difference, but we have been banned in the channel since then.
+                        # Because we can no longer fetch updates from this channel, we should stop keeping track
+                        # of it entirely.
+                        self._log[__name__].info(
+                            'Account is now banned in %d so we can no longer fetch updates from it',
+                            get_diff.channel.channel_id
+                        )
+                        self._message_box.end_channel_difference(
+                            get_diff,
+                            PrematureEndReason.BANNED,
+                            self._mb_entity_cache
+                        )
+                        continue
+                    except OSError as e:
+                        self._log[__name__].info(
+                            'Cannot get difference for channel %d since the network is down: %s: %s',
+                            get_diff.channel.channel_id, type(e).__name__, e
+                        )
+                        await asyncio.sleep(5)
+                        continue
+
+                    updates, users, chats = self._message_box.apply_channel_difference(get_diff, diff, self._mb_entity_cache)
+                    if updates:
+                        self._log[__name__].info('Got difference for channel %d updates', get_diff.channel.channel_id)
+
+                    updates_to_dispatch.extend(self._preprocess_updates(updates, users, chats))
+                    continue
+
+                deadline = self._message_box.check_deadlines()
+                deadline_delay = deadline - get_running_loop().time()
+                if deadline_delay > 0:
+                    # Don't bother sleeping and timing out if the delay is already 0 (pollutes the logs).
+                    try:
+                        updates = await asyncio.wait_for(self._updates_queue.get(), deadline_delay)
+                    except asyncio.TimeoutError:
+                        self._log[__name__].debug('Timeout waiting for updates expired')
+                        continue
+                else:
+                    continue
+
+                processed = []
+                try:
+                    users, chats = self._message_box.process_updates(updates, self._mb_entity_cache, processed)
+                except GapError:
+                    continue  # get(_channel)_difference will start returning requests
+
+                updates_to_dispatch.extend(self._preprocess_updates(processed, users, chats))
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            self._log[__name__].exception(f'Fatal error handling updates (this is a bug in Telethon v{__version__}, please report it)')
+            self._updates_error = e
+            await self.disconnect()
+
+    def _preprocess_updates(self, updates, users, chats):
+        self._mb_entity_cache.extend(users, chats)
+        entities = {utils.get_peer_id(x): x
+                    for x in itertools.chain(users, chats)}
+        for u in updates:
+            u._entities = entities
+        return updates
+
+    async def _keepalive_loop(self: 'TelegramClient'):
+        # Pings' ID don't really need to be secure, just "random"
+        rnd = lambda: random.randrange(-2**63, 2**63)
+        while self.is_connected():
+            try:
+                await asyncio.wait_for(
+                    self.disconnected, timeout=60
+                )
+                continue  # We actually just want to act upon timeout
+            except asyncio.TimeoutError:
+                pass
+            except asyncio.CancelledError:
+                return
+            except Exception:
+                continue  # Any disconnected exception should be ignored
+
+            # Check if we have any exported senders to clean-up periodically
+            await self._clean_exported_senders()
+
+            # Don't bother sending pings until the low-level connection is
+            # ready, otherwise a lot of pings will be batched to be sent upon
+            # reconnect, when we really don't care about that.
+            if not self._sender._transport_connected():
+                continue
+
+            # We also don't really care about their result.
+            # Just send them periodically.
+            try:
+                self._sender._keepalive_ping(rnd())
+            except (ConnectionError, asyncio.CancelledError):
+                return
+
+            # Entities and cached files are not saved when they are
+            # inserted because this is a rather expensive operation
+            # (default's sqlite3 takes ~0.1s to commit changes). Do
+            # it every minute instead. No-op if there's nothing new.
+            self._save_states_and_entities()
+
+            self.session.save()
+
+    async def _dispatch_update(self: 'TelegramClient', update):
+        # TODO only used for AlbumHack, and MessageBox is not really designed for this
+        others = None
+
+        if not self._mb_entity_cache.self_id:
+            # Some updates require our own ID, so we must make sure
+            # that the event builder has offline access to it. Calling
+            # `get_me()` will cache it under `self._mb_entity_cache`.
+            #
+            # It will return `None` if we haven't logged in yet which is
+            # fine, we will just retry next time anyway.
+            try:
+                await self.get_me(input_peer=True)
+            except OSError:
+                pass  # might not have connection
+
+        built = EventBuilderDict(self, update, others)
+        for conv_set in self._conversations.values():
+            for conv in conv_set:
+                ev = built[events.NewMessage]
+                if ev:
+                    conv._on_new_message(ev)
+
+                ev = built[events.MessageEdited]
+                if ev:
+                    conv._on_edit(ev)
+
+                ev = built[events.MessageRead]
+                if ev:
+                    conv._on_read(ev)
+
+                if conv._custom:
+                    await conv._check_custom(built)
+
+        for builder, callback in self._event_builders:
+            event = built[type(builder)]
+            if not event:
+                continue
+
+            if not builder.resolved:
+                await builder.resolve(self)
+
+            filter = builder.filter(event)
+            if inspect.isawaitable(filter):
+                filter = await filter
+            if not filter:
+                continue
+
+            try:
+                await callback(event)
+            except errors.AlreadyInConversationError:
+                name = getattr(callback, '__name__', repr(callback))
+                self._log[__name__].debug(
+                    'Event handler "%s" already has an open conversation, '
+                    'ignoring new one', name)
+            except events.StopPropagation:
+                name = getattr(callback, '__name__', repr(callback))
+                self._log[__name__].debug(
+                    'Event handler "%s" stopped chain of propagation '
+                    'for event %s.', name, type(event).__name__
+                )
+                break
+            except Exception as e:
+                if not isinstance(e, asyncio.CancelledError) or self.is_connected():
+                    name = getattr(callback, '__name__', repr(callback))
+                    self._log[__name__].exception('Unhandled exception on %s', name)
+
+    async def _dispatch_event(self: 'TelegramClient', event):
+        """
+        Dispatches a single, out-of-order event. Used by `AlbumHack`.
+        """
+        # We're duplicating a most logic from `_dispatch_update`, but all in
+        # the name of speed; we don't want to make it worse for all updates
+        # just because albums may need it.
+        for builder, callback in self._event_builders:
+            if isinstance(builder, events.Raw):
+                continue
+            if not isinstance(event, builder.Event):
+                continue
+
+            if not builder.resolved:
+                await builder.resolve(self)
+
+            filter = builder.filter(event)
+            if inspect.isawaitable(filter):
+                filter = await filter
+            if not filter:
+                continue
+
+            try:
+                await callback(event)
+            except errors.AlreadyInConversationError:
+                name = getattr(callback, '__name__', repr(callback))
+                self._log[__name__].debug(
+                    'Event handler "%s" already has an open conversation, '
+                    'ignoring new one', name)
+            except events.StopPropagation:
+                name = getattr(callback, '__name__', repr(callback))
+                self._log[__name__].debug(
+                    'Event handler "%s" stopped chain of propagation '
+                    'for event %s.', name, type(event).__name__
+                )
+                break
+            except Exception as e:
+                if not isinstance(e, asyncio.CancelledError) or self.is_connected():
+                    name = getattr(callback, '__name__', repr(callback))
+                    self._log[__name__].exception('Unhandled exception on %s', name)
+
+    async def _handle_auto_reconnect(self: 'TelegramClient'):
+        # TODO Catch-up
+        # For now we make a high-level request to let Telegram
+        # know we are still interested in receiving more updates.
+        try:
+            await self.get_me()
+        except Exception as e:
+            self._log[__name__].warning('Error executing high-level request '
+                                        'after reconnect: %s: %s', type(e), e)
+
+        return
+        try:
+            self._log[__name__].info(
+                'Asking for the current state after reconnect...')
+
+            # TODO consider:
+            # If there aren't many updates while the client is disconnected
+            # (I tried with up to 20), Telegram seems to send them without
+            # asking for them (via updates.getDifference).
+            #
+            # On disconnection, the library should probably set a "need
+            # difference" or "catching up" flag so that any new updates are
+            # ignored, and then the library should call updates.getDifference
+            # itself to fetch them.
+            #
+            # In any case (either there are too many updates and Telegram
+            # didn't send them, or there isn't a lot and Telegram sent them
+            # but we dropped them), we fetch the new difference to get all
+            # missed updates. I feel like this would be the best solution.
+
+            # If a disconnection occurs, the old known state will be
+            # the latest one we were aware of, so we can catch up since
+            # the most recent state we were aware of.
+            await self.catch_up()
+
+            self._log[__name__].info('Successfully fetched missed updates')
+        except errors.RPCError as e:
+            self._log[__name__].warning('Failed to get missed updates after '
+                                        'reconnect: %r', e)
+        except Exception:
+            self._log[__name__].exception(
+                'Unhandled exception while getting update difference after reconnect')
+
+    # endregion
+
+
+class EventBuilderDict:
+    """
+    Helper "dictionary" to return events from types and cache them.
+    """
+    def __init__(self, client: 'TelegramClient', update, others):
+        self.client = client
+        self.update = update
+        self.others = others
+
+    def __getitem__(self, builder):
+        try:
+            return self.__dict__[builder]
+        except KeyError:
+            event = self.__dict__[builder] = builder.build(
+                self.update, self.others, self.client._self_id)
+
+            if isinstance(event, EventCommon):
+                event.original_update = self.update
+                event._entities = self.update._entities
+                event._set_client(self.client)
+            elif event:
+                event._client = self.client
+
+            return event

.venv2/Lib/site-packages/telethon/client/uploads.py

@@ -0,0 +1,802 @@
+import hashlib
+import io
+import itertools
+import os
+import pathlib
+import re
+import typing
+from io import BytesIO
+
+from ..crypto import AES
+
+from .. import utils, helpers, hints
+from ..tl import types, functions, custom
+
+try:
+    import PIL
+    import PIL.Image
+except ImportError:
+    PIL = None
+
+
+if typing.TYPE_CHECKING:
+    from .telegramclient import TelegramClient
+
+
+class _CacheType:
+    """Like functools.partial but pretends to be the wrapped class."""
+    def __init__(self, cls):
+        self._cls = cls
+
+    def __call__(self, *args, **kwargs):
+        return self._cls(*args, file_reference=b'', **kwargs)
+
+    def __eq__(self, other):
+        return self._cls == other
+
+
+def _resize_photo_if_needed(
+        file, is_image, width=2560, height=2560, background=(255, 255, 255)):
+
+    # https://github.com/telegramdesktop/tdesktop/blob/12905f0dcb9d513378e7db11989455a1b764ef75/Telegram/SourceFiles/boxes/photo_crop_box.cpp#L254
+    if (not is_image
+            or PIL is None
+            or (isinstance(file, io.IOBase) and not file.seekable())):
+        return file
+
+    if isinstance(file, bytes):
+        file = io.BytesIO(file)
+
+    if isinstance(file, io.IOBase):
+        # Pillow seeks to 0 unconditionally later anyway
+        old_pos = file.tell()
+        file.seek(0, io.SEEK_END)
+        before = file.tell()
+    elif isinstance(file, str) and os.path.exists(file):
+        # Check if file exists as a path and if so, get its size on disk
+        before = os.path.getsize(file)
+    else:
+        # Would be weird...
+        before = None
+
+    try:
+        # Don't use a `with` block for `image`, or `file` would be closed.
+        # See https://github.com/LonamiWebs/Telethon/issues/1121 for more.
+        image = PIL.Image.open(file)
+        try:
+            kwargs = {'exif': image.info['exif']}
+        except KeyError:
+            kwargs = {}
+
+        # Check if image is within acceptable bounds, if so, check if the image is at or below 10 MB, or assume it isn't if size is None or 0
+        if image.width <= width and image.height <= height and (before <= 10000000 if before else False):
+            return file
+
+        image.thumbnail((width, height), PIL.Image.LANCZOS)
+
+        alpha_index = image.mode.find('A')
+        if alpha_index == -1:
+            # If the image mode doesn't have alpha
+            # channel then don't bother masking it away.
+            result = image
+        else:
+            # We could save the resized image with the original format, but
+            # JPEG often compresses better -> smaller size -> faster upload
+            # We need to mask away the alpha channel ([3]), since otherwise
+            # IOError is raised when trying to save alpha channels in JPEG.
+            result = PIL.Image.new('RGB', image.size, background)
+            result.paste(image, mask=image.split()[alpha_index])
+
+        buffer = io.BytesIO()
+        result.save(buffer, 'JPEG', progressive=True, **kwargs)
+        buffer.seek(0)
+        buffer.name = 'a.jpg'
+        return buffer
+    except IOError:
+        return file
+    finally:
+        # The original position might matter
+        if isinstance(file, io.IOBase):
+            file.seek(old_pos)
+
+
+class UploadMethods:
+
+    # region Public methods
+
+    async def send_file(
+            self: 'TelegramClient',
+            entity: 'hints.EntityLike',
+            file: 'typing.Union[hints.FileLike, typing.Sequence[hints.FileLike]]',
+            *,
+            caption: typing.Union[str, typing.Sequence[str]] = None,
+            force_document: bool = False,
+            file_size: int = None,
+            clear_draft: bool = False,
+            progress_callback: 'hints.ProgressCallback' = None,
+            reply_to: 'hints.MessageIDLike' = None,
+            attributes: 'typing.Sequence[types.TypeDocumentAttribute]' = None,
+            thumb: 'hints.FileLike' = None,
+            allow_cache: bool = True,
+            parse_mode: str = (),
+            formatting_entities: typing.Optional[typing.List[types.TypeMessageEntity]] = None,
+            voice_note: bool = False,
+            video_note: bool = False,
+            buttons: typing.Optional['hints.MarkupLike'] = None,
+            silent: bool = None,
+            background: bool = None,
+            supports_streaming: bool = False,
+            schedule: 'hints.DateLike' = None,
+            comment_to: 'typing.Union[int, types.Message]' = None,
+            ttl: int = None,
+            nosound_video: bool = None,
+            **kwargs) -> 'types.Message':
+        """
+        Sends message with the given file to the specified entity.
+
+        .. note::
+
+            If the ``hachoir3`` package (``hachoir`` module) is installed,
+            it will be used to determine metadata from audio and video files.
+
+            If the ``pillow`` package is installed and you are sending a photo,
+            it will be resized to fit within the maximum dimensions allowed
+            by Telegram to avoid ``errors.PhotoInvalidDimensionsError``. This
+            cannot be done if you are sending :tl:`InputFile`, however.
+
+        Arguments
+            entity (`entity`):
+                Who will receive the file.
+
+            file (`str` | `bytes` | `file` | `media`):
+                The file to send, which can be one of:
+
+                * A local file path to an in-disk file. The file name
+                  will be the path's base name.
+
+                * A `bytes` byte array with the file's data to send
+                  (for example, by using ``text.encode('utf-8')``).
+                  A default file name will be used.
+
+                * A bytes `io.IOBase` stream over the file to send
+                  (for example, by using ``open(file, 'rb')``).
+                  Its ``.name`` property will be used for the file name,
+                  or a default if it doesn't have one.
+
+                * An external URL to a file over the internet. This will
+                  send the file as "external" media, and Telegram is the
+                  one that will fetch the media and send it.
+
+                * A Bot API-like ``file_id``. You can convert previously
+                  sent media to file IDs for later reusing with
+                  `telethon.utils.pack_bot_file_id`.
+
+                * A handle to an existing file (for example, if you sent a
+                  message with media before, you can use its ``message.media``
+                  as a file here).
+
+                * A handle to an uploaded file (from `upload_file`).
+
+                * A :tl:`InputMedia` instance. For example, if you want to
+                  send a dice use :tl:`InputMediaDice`, or if you want to
+                  send a contact use :tl:`InputMediaContact`.
+
+                To send an album, you should provide a list in this parameter.
+
+                If a list or similar is provided, the files in it will be
+                sent as an album in the order in which they appear, sliced
+                in chunks of 10 if more than 10 are given.
+
+            caption (`str`, optional):
+                Optional caption for the sent media message. When sending an
+                album, the caption may be a list of strings, which will be
+                assigned to the files pairwise.
+
+            force_document (`bool`, optional):
+                If left to `False` and the file is a path that ends with
+                the extension of an image file or a video file, it will be
+                sent as such. Otherwise always as a document.
+
+            file_size (`int`, optional):
+                The size of the file to be uploaded if it needs to be uploaded,
+                which will be determined automatically if not specified.
+
+                If the file size can't be determined beforehand, the entire
+                file will be read in-memory to find out how large it is.
+
+            clear_draft (`bool`, optional):
+                Whether the existing draft should be cleared or not.
+
+            progress_callback (`callable`, optional):
+                A callback function accepting two parameters:
+                ``(sent bytes, total)``.
+
+            reply_to (`int` | `Message <telethon.tl.custom.message.Message>`):
+                Same as `reply_to` from `send_message`.
+
+            attributes (`list`, optional):
+                Optional attributes that override the inferred ones, like
+                :tl:`DocumentAttributeFilename` and so on.
+
+            thumb (`str` | `bytes` | `file`, optional):
+                Optional JPEG thumbnail (for documents). **Telegram will
+                ignore this parameter** unless you pass a ``.jpg`` file!
+
+                The file must also be small in dimensions and in disk size.
+                Successful thumbnails were files below 20kB and 320x320px.
+                Width/height and dimensions/size ratios may be important.
+                For Telegram to accept a thumbnail, you must provide the
+                dimensions of the underlying media through ``attributes=``
+                with :tl:`DocumentAttributesVideo` or by installing the
+                optional ``hachoir`` dependency.
+
+
+            allow_cache (`bool`, optional):
+                This parameter currently does nothing, but is kept for
+                backward-compatibility (and it may get its use back in
+                the future).
+
+            parse_mode (`object`, optional):
+                See the `TelegramClient.parse_mode
+                <telethon.client.messageparse.MessageParseMethods.parse_mode>`
+                property for allowed values. Markdown parsing will be used by
+                default.
+
+            formatting_entities (`list`, optional):
+                A list of message formatting entities. When provided, the ``parse_mode`` is ignored.
+
+            voice_note (`bool`, optional):
+                If `True` the audio will be sent as a voice note.
+
+            video_note (`bool`, optional):
+                If `True` the video will be sent as a video note,
+                also known as a round video message.
+
+            buttons (`list`, `custom.Button <telethon.tl.custom.button.Button>`, :tl:`KeyboardButton`):
+                The matrix (list of lists), row list or button to be shown
+                after sending the message. This parameter will only work if
+                you have signed in as a bot. You can also pass your own
+                :tl:`ReplyMarkup` here.
+
+            silent (`bool`, optional):
+                Whether the message should notify people with sound or not.
+                Defaults to `False` (send with a notification sound unless
+                the person has the chat muted). Set it to `True` to alter
+                this behaviour.
+
+            background (`bool`, optional):
+                Whether the message should be send in background.
+
+            supports_streaming (`bool`, optional):
+                Whether the sent video supports streaming or not. Note that
+                Telegram only recognizes as streamable some formats like MP4,
+                and others like AVI or MKV will not work. You should convert
+                these to MP4 before sending if you want them to be streamable.
+                Unsupported formats will result in ``VideoContentTypeError``.
+
+            schedule (`hints.DateLike`, optional):
+                If set, the file won't send immediately, and instead
+                it will be scheduled to be automatically sent at a later
+                time.
+
+            comment_to (`int` | `Message <telethon.tl.custom.message.Message>`, optional):
+                Similar to ``reply_to``, but replies in the linked group of a
+                broadcast channel instead (effectively leaving a "comment to"
+                the specified message).
+
+                This parameter takes precedence over ``reply_to``. If there is
+                no linked chat, `telethon.errors.sgIdInvalidError` is raised.
+
+            ttl (`int`. optional):
+                The Time-To-Live of the file (also known as "self-destruct timer"
+                or "self-destructing media"). If set, files can only be viewed for
+                a short period of time before they disappear from the message
+                history automatically.
+
+                The value must be at least 1 second, and at most 60 seconds,
+                otherwise Telegram will ignore this parameter.
+
+                Not all types of media can be used with this parameter, such
+                as text documents, which will fail with ``TtlMediaInvalidError``.
+
+            nosound_video (`bool`, optional):
+                Only applicable when sending a video file without an audio
+                track. If set to ``True``, the video will be displayed in
+                Telegram as a video. If set to ``False``, Telegram will attempt
+                to display the video as an animated gif. (It may still display
+                as a video due to other factors.) The value is ignored if set
+                on non-video files. This is set to ``True`` for albums, as gifs
+                cannot be sent in albums.
+
+        Returns
+            The `Message <telethon.tl.custom.message.Message>` (or messages)
+            containing the sent file, or messages if a list of them was passed.
+
+        Example
+            .. code-block:: python
+
+                # Normal files like photos
+                await client.send_file(chat, '/my/photos/me.jpg', caption="It's me!")
+                # or
+                await client.send_message(chat, "It's me!", file='/my/photos/me.jpg')
+
+                # Voice notes or round videos
+                await client.send_file(chat, '/my/songs/song.mp3', voice_note=True)
+                await client.send_file(chat, '/my/videos/video.mp4', video_note=True)
+
+                # Custom thumbnails
+                await client.send_file(chat, '/my/documents/doc.txt', thumb='photo.jpg')
+
+                # Only documents
+                await client.send_file(chat, '/my/photos/photo.png', force_document=True)
+
+                # Albums
+                await client.send_file(chat, [
+                    '/my/photos/holiday1.jpg',
+                    '/my/photos/holiday2.jpg',
+                    '/my/drawings/portrait.png'
+                ])
+
+                # Printing upload progress
+                def callback(current, total):
+                    print('Uploaded', current, 'out of', total,
+                          'bytes: {:.2%}'.format(current / total))
+
+                await client.send_file(chat, file, progress_callback=callback)
+
+                # Dices, including dart and other future emoji
+                from telethon.tl import types
+                await client.send_file(chat, types.InputMediaDice(''))
+                await client.send_file(chat, types.InputMediaDice('🎯'))
+
+                # Contacts
+                await client.send_file(chat, types.InputMediaContact(
+                    phone_number='+34 123 456 789',
+                    first_name='Example',
+                    last_name='',
+                    vcard=''
+                ))
+        """
+        # TODO Properly implement allow_cache to reuse the sha256 of the file
+        # i.e. `None` was used
+        if not file:
+            raise TypeError('Cannot use {!r} as file'.format(file))
+
+        if not caption:
+            caption = ''
+
+        entity = await self.get_input_entity(entity)
+        if comment_to is not None:
+            entity, reply_to = await self._get_comment_data(entity, comment_to)
+        else:
+            reply_to = utils.get_message_id(reply_to)
+
+        # First check if the user passed an iterable, in which case
+        # we may want to send grouped.
+        if utils.is_list_like(file):
+            sent_count = 0
+            used_callback = None if not progress_callback else (
+                lambda s, t: progress_callback(sent_count + s, len(file))
+            )
+
+            if utils.is_list_like(caption):
+                captions = caption
+            else:
+                captions = [caption]
+
+            result = []
+            while file:
+                result += await self._send_album(
+                    entity, file[:10], caption=captions[:10],
+                    progress_callback=used_callback, reply_to=reply_to,
+                    parse_mode=parse_mode, silent=silent, schedule=schedule,
+                    supports_streaming=supports_streaming, clear_draft=clear_draft,
+                    force_document=force_document, background=background,
+                )
+                file = file[10:]
+                captions = captions[10:]
+                sent_count += 10
+
+            return result
+
+        if formatting_entities is not None:
+            msg_entities = formatting_entities
+        else:
+            caption, msg_entities =\
+                await self._parse_message_text(caption, parse_mode)
+
+        file_handle, media, image = await self._file_to_media(
+            file, force_document=force_document,
+            file_size=file_size,
+            progress_callback=progress_callback,
+            attributes=attributes,  allow_cache=allow_cache, thumb=thumb,
+            voice_note=voice_note, video_note=video_note,
+            supports_streaming=supports_streaming, ttl=ttl,
+            nosound_video=nosound_video,
+        )
+
+        # e.g. invalid cast from :tl:`MessageMediaWebPage`
+        if not media:
+            raise TypeError('Cannot use {!r} as file'.format(file))
+
+        markup = self.build_reply_markup(buttons)
+        reply_to = None if reply_to is None else types.InputReplyToMessage(reply_to)
+        request = functions.messages.SendMediaRequest(
+            entity, media, reply_to=reply_to, message=caption,
+            entities=msg_entities, reply_markup=markup, silent=silent,
+            schedule_date=schedule, clear_draft=clear_draft,
+            background=background
+        )
+        return self._get_response_message(request, await self(request), entity)
+
+    async def _send_album(self: 'TelegramClient', entity, files, caption='',
+                          progress_callback=None, reply_to=None,
+                          parse_mode=(), silent=None, schedule=None,
+                          supports_streaming=None, clear_draft=None,
+                          force_document=False, background=None, ttl=None):
+        """Specialized version of .send_file for albums"""
+        # We don't care if the user wants to avoid cache, we will use it
+        # anyway. Why? The cached version will be exactly the same thing
+        # we need to produce right now to send albums (uploadMedia), and
+        # cache only makes a difference for documents where the user may
+        # want the attributes used on them to change.
+        #
+        # In theory documents can be sent inside the albums but they appear
+        # as different messages (not inside the album), and the logic to set
+        # the attributes/avoid cache is already written in .send_file().
+        entity = await self.get_input_entity(entity)
+        if not utils.is_list_like(caption):
+            caption = (caption,)
+
+        captions = []
+        for c in reversed(caption):  # Pop from the end (so reverse)
+            captions.append(await self._parse_message_text(c or '', parse_mode))
+
+        reply_to = utils.get_message_id(reply_to)
+
+        used_callback = None if not progress_callback else (
+            # use an integer when sent matches total, to easily determine a file has been fully sent
+            lambda s, t: progress_callback(sent_count + 1 if s == t else sent_count + s / t, len(files))
+        )
+
+        # Need to upload the media first, but only if they're not cached yet
+        media = []
+        for sent_count, file in enumerate(files):
+            # Albums want :tl:`InputMedia` which, in theory, includes
+            # :tl:`InputMediaUploadedPhoto`. However, using that will
+            # make it `raise MediaInvalidError`, so we need to upload
+            # it as media and then convert that to :tl:`InputMediaPhoto`.
+            fh, fm, _ = await self._file_to_media(
+                file, supports_streaming=supports_streaming,
+                force_document=force_document, ttl=ttl,
+                progress_callback=used_callback, nosound_video=True)
+            if isinstance(fm, (types.InputMediaUploadedPhoto, types.InputMediaPhotoExternal)):
+                r = await self(functions.messages.UploadMediaRequest(
+                    entity, media=fm
+                ))
+
+                fm = utils.get_input_media(r.photo)
+            elif isinstance(fm, types.InputMediaUploadedDocument):
+                r = await self(functions.messages.UploadMediaRequest(
+                    entity, media=fm
+                ))
+
+                fm = utils.get_input_media(
+                   r.document, supports_streaming=supports_streaming)
+
+            if captions:
+                caption, msg_entities = captions.pop()
+            else:
+                caption, msg_entities = '', None
+            media.append(types.InputSingleMedia(
+                fm,
+                message=caption,
+                entities=msg_entities
+                # random_id is autogenerated
+            ))
+
+        # Now we can construct the multi-media request
+        request = functions.messages.SendMultiMediaRequest(
+            entity, reply_to=None if reply_to is None else types.InputReplyToMessage(reply_to), multi_media=media,
+            silent=silent, schedule_date=schedule, clear_draft=clear_draft,
+            background=background
+        )
+        result = await self(request)
+
+        random_ids = [m.random_id for m in media]
+        return self._get_response_message(random_ids, result, entity)
+
+    async def upload_file(
+            self: 'TelegramClient',
+            file: 'hints.FileLike',
+            *,
+            part_size_kb: float = None,
+            file_size: int = None,
+            file_name: str = None,
+            use_cache: type = None,
+            key: bytes = None,
+            iv: bytes = None,
+            progress_callback: 'hints.ProgressCallback' = None) -> 'types.TypeInputFile':
+        """
+        Uploads a file to Telegram's servers, without sending it.
+
+        .. note::
+
+            Generally, you want to use `send_file` instead.
+
+        This method returns a handle (an instance of :tl:`InputFile` or
+        :tl:`InputFileBig`, as required) which can be later used before
+        it expires (they are usable during less than a day).
+
+        Uploading a file will simply return a "handle" to the file stored
+        remotely in the Telegram servers, which can be later used on. This
+        will **not** upload the file to your own chat or any chat at all.
+
+        Arguments
+            file (`str` | `bytes` | `file`):
+                The path of the file, byte array, or stream that will be sent.
+                Note that if a byte array or a stream is given, a filename
+                or its type won't be inferred, and it will be sent as an
+                "unnamed application/octet-stream".
+
+            part_size_kb (`int`, optional):
+                Chunk size when uploading files. The larger, the less
+                requests will be made (up to 512KB maximum).
+
+            file_size (`int`, optional):
+                The size of the file to be uploaded, which will be determined
+                automatically if not specified.
+
+                If the file size can't be determined beforehand, the entire
+                file will be read in-memory to find out how large it is.
+
+            file_name (`str`, optional):
+                The file name which will be used on the resulting InputFile.
+                If not specified, the name will be taken from the ``file``
+                and if this is not a `str`, it will be ``"unnamed"``.
+
+            use_cache (`type`, optional):
+                This parameter currently does nothing, but is kept for
+                backward-compatibility (and it may get its use back in
+                the future).
+
+            key ('bytes', optional):
+                In case of an encrypted upload (secret chats) a key is supplied
+
+            iv ('bytes', optional):
+                In case of an encrypted upload (secret chats) an iv is supplied
+
+            progress_callback (`callable`, optional):
+                A callback function accepting two parameters:
+                ``(sent bytes, total)``.
+
+                When sending an album, the callback will receive a number
+                between 0 and the amount of files as the "sent" parameter,
+                and the amount of files as the "total". Note that the first
+                parameter will be a floating point number to indicate progress
+                within a file (e.g. ``2.5`` means it has sent 50% of the third
+                file, because it's between 2 and 3).
+
+        Returns
+            :tl:`InputFileBig` if the file size is larger than 10MB,
+            `InputSizedFile <telethon.tl.custom.inputsizedfile.InputSizedFile>`
+            (subclass of :tl:`InputFile`) otherwise.
+
+        Example
+            .. code-block:: python
+
+                # Photos as photo and document
+                file = await client.upload_file('photo.jpg')
+                await client.send_file(chat, file)                       # sends as photo
+                await client.send_file(chat, file, force_document=True)  # sends as document
+
+                file.name = 'not a photo.jpg'
+                await client.send_file(chat, file, force_document=True)  # document, new name
+
+                # As song or as voice note
+                file = await client.upload_file('song.ogg')
+                await client.send_file(chat, file)                   # sends as song
+                await client.send_file(chat, file, voice_note=True)  # sends as voice note
+        """
+        if isinstance(file, (types.InputFile, types.InputFileBig)):
+            return file  # Already uploaded
+
+        pos = 0
+        async with helpers._FileStream(file, file_size=file_size) as stream:
+            # Opening the stream will determine the correct file size
+            file_size = stream.file_size
+
+            if not part_size_kb:
+                part_size_kb = utils.get_appropriated_part_size(file_size)
+
+            if part_size_kb > 512:
+                raise ValueError('The part size must be less or equal to 512KB')
+
+            part_size = int(part_size_kb * 1024)
+            if part_size % 1024 != 0:
+                raise ValueError(
+                    'The part size must be evenly divisible by 1024')
+
+            # Set a default file name if None was specified
+            file_id = helpers.generate_random_long()
+            if not file_name:
+                file_name = stream.name or str(file_id)
+
+            # If the file name lacks extension, add it if possible.
+            # Else Telegram complains with `PHOTO_EXT_INVALID_ERROR`
+            # even if the uploaded image is indeed a photo.
+            if not os.path.splitext(file_name)[-1]:
+                file_name += utils._get_extension(stream)
+
+            # Determine whether the file is too big (over 10MB) or not
+            # Telegram does make a distinction between smaller or larger files
+            is_big = file_size > 10 * 1024 * 1024
+            hash_md5 = hashlib.md5()
+
+            part_count = (file_size + part_size - 1) // part_size
+            self._log[__name__].info('Uploading file of %d bytes in %d chunks of %d',
+                                    file_size, part_count, part_size)
+
+            pos = 0
+            for part_index in range(part_count):
+                # Read the file by in chunks of size part_size
+                part = await helpers._maybe_await(stream.read(part_size))
+
+                if not isinstance(part, bytes):
+                    raise TypeError(
+                        'file descriptor returned {}, not bytes (you must '
+                        'open the file in bytes mode)'.format(type(part)))
+
+                # `file_size` could be wrong in which case `part` may not be
+                # `part_size` before reaching the end.
+                if len(part) != part_size and part_index < part_count - 1:
+                    raise ValueError(
+                        'read less than {} before reaching the end; either '
+                        '`file_size` or `read` are wrong'.format(part_size))
+
+                pos += len(part)
+
+                # Encryption part if needed
+                if key and iv:
+                    part = AES.encrypt_ige(part, key, iv)
+
+                if not is_big:
+                    # Bit odd that MD5 is only needed for small files and not
+                    # big ones with more chance for corruption, but that's
+                    # what Telegram wants.
+                    hash_md5.update(part)
+
+                # The SavePartRequest is different depending on whether
+                # the file is too large or not (over or less than 10MB)
+                if is_big:
+                    request = functions.upload.SaveBigFilePartRequest(
+                        file_id, part_index, part_count, part)
+                else:
+                    request = functions.upload.SaveFilePartRequest(
+                        file_id, part_index, part)
+
+                result = await self(request)
+                if result:
+                    self._log[__name__].debug('Uploaded %d/%d',
+                                              part_index + 1, part_count)
+                    if progress_callback:
+                        await helpers._maybe_await(progress_callback(pos, file_size))
+                else:
+                    raise RuntimeError(
+                        'Failed to upload file part {}.'.format(part_index))
+
+        if is_big:
+            return types.InputFileBig(file_id, part_count, file_name)
+        else:
+            return custom.InputSizedFile(
+                file_id, part_count, file_name, md5=hash_md5, size=file_size
+            )
+
+    # endregion
+
+    async def _file_to_media(
+            self, file, force_document=False, file_size=None,
+            progress_callback=None, attributes=None, thumb=None,
+            allow_cache=True, voice_note=False, video_note=False,
+            supports_streaming=False, mime_type=None, as_image=None,
+            ttl=None, nosound_video=None):
+        if not file:
+            return None, None, None
+
+        if isinstance(file, pathlib.Path):
+            file = str(file.absolute())
+
+        is_image = utils.is_image(file)
+        if as_image is None:
+            as_image = is_image and not force_document
+
+        # `aiofiles` do not base `io.IOBase` but do have `read`, so we
+        # just check for the read attribute to see if it's file-like.
+        if not isinstance(file, (str, bytes, types.InputFile, types.InputFileBig))\
+                and not hasattr(file, 'read'):
+            # The user may pass a Message containing media (or the media,
+            # or anything similar) that should be treated as a file. Try
+            # getting the input media for whatever they passed and send it.
+            #
+            # We pass all attributes since these will be used if the user
+            # passed :tl:`InputFile`, and all information may be relevant.
+            try:
+                return (None, utils.get_input_media(
+                    file,
+                    is_photo=as_image,
+                    attributes=attributes,
+                    force_document=force_document,
+                    voice_note=voice_note,
+                    video_note=video_note,
+                    supports_streaming=supports_streaming,
+                    ttl=ttl
+                ), as_image)
+            except TypeError:
+                # Can't turn whatever was given into media
+                return None, None, as_image
+
+        media = None
+        file_handle = None
+
+        if isinstance(file, (types.InputFile, types.InputFileBig)):
+            file_handle = file
+        elif not isinstance(file, str) or os.path.isfile(file):
+            file_handle = await self.upload_file(
+                _resize_photo_if_needed(file, as_image),
+                file_size=file_size,
+                progress_callback=progress_callback
+            )
+        elif re.match('https?://', file):
+            if as_image:
+                media = types.InputMediaPhotoExternal(file, ttl_seconds=ttl)
+            else:
+                media = types.InputMediaDocumentExternal(file, ttl_seconds=ttl)
+        else:
+            bot_file = utils.resolve_bot_file_id(file)
+            if bot_file:
+                media = utils.get_input_media(bot_file, ttl=ttl)
+
+        if media:
+            pass  # Already have media, don't check the rest
+        elif not file_handle:
+            raise ValueError(
+                'Failed to convert {} to media. Not an existing file, '
+                'an HTTP URL or a valid bot-API-like file ID'.format(file)
+            )
+        elif as_image:
+            media = types.InputMediaUploadedPhoto(file_handle, ttl_seconds=ttl)
+        else:
+            attributes, mime_type = utils.get_attributes(
+                file,
+                mime_type=mime_type,
+                attributes=attributes,
+                force_document=force_document and not is_image,
+                voice_note=voice_note,
+                video_note=video_note,
+                supports_streaming=supports_streaming,
+                thumb=thumb
+            )
+
+            if not thumb:
+                thumb = None
+            else:
+                if isinstance(thumb, pathlib.Path):
+                    thumb = str(thumb.absolute())
+                thumb = await self.upload_file(thumb, file_size=file_size)
+
+            # setting `nosound_video` to `True` doesn't affect videos with sound
+            # instead it prevents sending silent videos as GIFs
+            nosound_video = nosound_video if mime_type.split("/")[0] == 'video' else None
+
+            media = types.InputMediaUploadedDocument(
+                file=file_handle,
+                mime_type=mime_type,
+                attributes=attributes,
+                thumb=thumb,
+                force_file=force_document and not is_image,
+                ttl_seconds=ttl,
+                nosound_video=nosound_video
+            )
+        return file_handle, media, as_image
+
+    # endregion

.venv2/Lib/site-packages/telethon/client/users.py

@@ -0,0 +1,613 @@
+import asyncio
+import datetime
+import itertools
+import time
+import typing
+
+from .. import errors, helpers, utils, hints
+from ..errors import MultiError, RPCError
+from ..helpers import retry_range
+from ..tl import TLRequest, types, functions
+
+_NOT_A_REQUEST = lambda: TypeError('You can only invoke requests, not types!')
+
+if typing.TYPE_CHECKING:
+    from .telegramclient import TelegramClient
+
+
+def _fmt_flood(delay, request, *, early=False, td=datetime.timedelta):
+    return (
+        'Sleeping%s for %ds (%s) on %s flood wait',
+        ' early' if early else '',
+        delay,
+        td(seconds=delay),
+        request.__class__.__name__
+    )
+
+
+class UserMethods:
+    async def __call__(self: 'TelegramClient', request, ordered=False, flood_sleep_threshold=None):
+        return await self._call(self._sender, request, ordered=ordered)
+
+    async def _call(self: 'TelegramClient', sender, request, ordered=False, flood_sleep_threshold=None):
+        if self._loop is not None and self._loop != helpers.get_running_loop():
+            raise RuntimeError('The asyncio event loop must not change after connection (see the FAQ for details)')
+        # if the loop is None it will fail with a connection error later on
+
+        if flood_sleep_threshold is None:
+            flood_sleep_threshold = self.flood_sleep_threshold
+        requests = (request if utils.is_list_like(request) else (request,))
+        for r in requests:
+            if not isinstance(r, TLRequest):
+                raise _NOT_A_REQUEST()
+            await r.resolve(self, utils)
+
+            # Avoid making the request if it's already in a flood wait
+            if r.CONSTRUCTOR_ID in self._flood_waited_requests:
+                due = self._flood_waited_requests[r.CONSTRUCTOR_ID]
+                diff = round(due - time.time())
+                if diff <= 3:  # Flood waits below 3 seconds are "ignored"
+                    self._flood_waited_requests.pop(r.CONSTRUCTOR_ID, None)
+                elif diff <= flood_sleep_threshold:
+                    self._log[__name__].info(*_fmt_flood(diff, r, early=True))
+                    await asyncio.sleep(diff)
+                    self._flood_waited_requests.pop(r.CONSTRUCTOR_ID, None)
+                else:
+                    raise errors.FloodWaitError(request=r, capture=diff)
+
+            if self._no_updates:
+                r = functions.InvokeWithoutUpdatesRequest(r)
+
+        request_index = 0
+        last_error = None
+        self._last_request = time.time()
+
+        for attempt in retry_range(self._request_retries):
+            try:
+                future = sender.send(request, ordered=ordered)
+                if isinstance(future, list):
+                    results = []
+                    exceptions = []
+                    for f in future:
+                        try:
+                            result = await f
+                        except RPCError as e:
+                            exceptions.append(e)
+                            results.append(None)
+                            continue
+                        self.session.process_entities(result)
+                        exceptions.append(None)
+                        results.append(result)
+                        request_index += 1
+                    if any(x is not None for x in exceptions):
+                        raise MultiError(exceptions, results, requests)
+                    else:
+                        return results
+                else:
+                    result = await future
+                    self.session.process_entities(result)
+                    return result
+            except (errors.ServerError, errors.RpcCallFailError,
+                    errors.RpcMcgetFailError, errors.InterdcCallErrorError,
+                    errors.TimedOutError,
+                    errors.InterdcCallRichErrorError) as e:
+                last_error = e
+                self._log[__name__].warning(
+                    'Telegram is having internal issues %s: %s',
+                    e.__class__.__name__, e)
+
+                await asyncio.sleep(2)
+            except (errors.FloodWaitError, errors.SlowModeWaitError, errors.FloodTestPhoneWaitError) as e:
+                last_error = e
+                if utils.is_list_like(request):
+                    request = request[request_index]
+
+                # SLOW_MODE_WAIT is chat-specific, not request-specific
+                if not isinstance(e, errors.SlowModeWaitError):
+                    self._flood_waited_requests\
+                        [request.CONSTRUCTOR_ID] = time.time() + e.seconds
+
+                # In test servers, FLOOD_WAIT_0 has been observed, and sleeping for
+                # such a short amount will cause retries very fast leading to issues.
+                if e.seconds == 0:
+                    e.seconds = 1
+
+                if e.seconds <= self.flood_sleep_threshold:
+                    self._log[__name__].info(*_fmt_flood(e.seconds, request))
+                    await asyncio.sleep(e.seconds)
+                else:
+                    raise
+            except (errors.PhoneMigrateError, errors.NetworkMigrateError,
+                    errors.UserMigrateError) as e:
+                last_error = e
+                self._log[__name__].info('Phone migrated to %d', e.new_dc)
+                should_raise = isinstance(e, (
+                    errors.PhoneMigrateError, errors.NetworkMigrateError
+                ))
+                if should_raise and await self.is_user_authorized():
+                    raise
+                await self._switch_dc(e.new_dc)
+
+        if self._raise_last_call_error and last_error is not None:
+            raise last_error
+        raise ValueError('Request was unsuccessful {} time(s)'
+                         .format(attempt))
+
+    # region Public methods
+
+    async def get_me(self: 'TelegramClient', input_peer: bool = False) \
+            -> 'typing.Union[types.User, types.InputPeerUser]':
+        """
+        Gets "me", the current :tl:`User` who is logged in.
+
+        If the user has not logged in yet, this method returns `None`.
+
+        Arguments
+            input_peer (`bool`, optional):
+                Whether to return the :tl:`InputPeerUser` version or the normal
+                :tl:`User`. This can be useful if you just need to know the ID
+                of yourself.
+
+        Returns
+            Your own :tl:`User`.
+
+        Example
+            .. code-block:: python
+
+                me = await client.get_me()
+                print(me.username)
+        """
+        if input_peer and self._mb_entity_cache.self_id:
+            return self._mb_entity_cache.get(self._mb_entity_cache.self_id)._as_input_peer()
+
+        try:
+            me = (await self(
+                functions.users.GetUsersRequest([types.InputUserSelf()])))[0]
+
+            if not self._mb_entity_cache.self_id:
+                self._mb_entity_cache.set_self_user(me.id, me.bot, me.access_hash)
+
+            return utils.get_input_peer(me, allow_self=False) if input_peer else me
+        except errors.UnauthorizedError:
+            return None
+
+    @property
+    def _self_id(self: 'TelegramClient') -> typing.Optional[int]:
+        """
+        Returns the ID of the logged-in user, if known.
+
+        This property is used in every update, and some like `updateLoginToken`
+        occur prior to login, so it gracefully handles when no ID is known yet.
+        """
+        return self._mb_entity_cache.self_id
+
+    async def is_bot(self: 'TelegramClient') -> bool:
+        """
+        Return `True` if the signed-in user is a bot, `False` otherwise.
+
+        Example
+            .. code-block:: python
+
+                if await client.is_bot():
+                    print('Beep')
+                else:
+                    print('Hello')
+        """
+        if self._mb_entity_cache.self_bot is None:
+            await self.get_me(input_peer=True)
+
+        return self._mb_entity_cache.self_bot
+
+    async def is_user_authorized(self: 'TelegramClient') -> bool:
+        """
+        Returns `True` if the user is authorized (logged in).
+
+        Example
+            .. code-block:: python
+
+                if not await client.is_user_authorized():
+                    await client.send_code_request(phone)
+                    code = input('enter code: ')
+                    await client.sign_in(phone, code)
+        """
+        if self._authorized is None:
+            try:
+                # Any request that requires authorization will work
+                await self(functions.updates.GetStateRequest())
+                self._authorized = True
+            except errors.RPCError:
+                self._authorized = False
+
+        return self._authorized
+
+    async def get_entity(
+            self: 'TelegramClient',
+            entity: 'hints.EntitiesLike') -> 'hints.Entity':
+        """
+        Turns the given entity into a valid Telegram :tl:`User`, :tl:`Chat`
+        or :tl:`Channel`. You can also pass a list or iterable of entities,
+        and they will be efficiently fetched from the network.
+
+        Arguments
+            entity (`str` | `int` | :tl:`Peer` | :tl:`InputPeer`):
+                If a username is given, **the username will be resolved** making
+                an API call every time. Resolving usernames is an expensive
+                operation and will start hitting flood waits around 50 usernames
+                in a short period of time.
+
+                If you want to get the entity for a *cached* username, you should
+                first `get_input_entity(username) <get_input_entity>` which will
+                use the cache), and then use `get_entity` with the result of the
+                previous call.
+
+                Similar limits apply to invite links, and you should use their
+                ID instead.
+
+                Using phone numbers (from people in your contact list), exact
+                names, integer IDs or :tl:`Peer` rely on a `get_input_entity`
+                first, which in turn needs the entity to be in cache, unless
+                a :tl:`InputPeer` was passed.
+
+                Unsupported types will raise ``TypeError``.
+
+                If the entity can't be found, ``ValueError`` will be raised.
+
+        Returns
+            :tl:`User`, :tl:`Chat` or :tl:`Channel` corresponding to the
+            input entity. A list will be returned if more than one was given.
+
+        Example
+            .. code-block:: python
+
+                from telethon import utils
+
+                me = await client.get_entity('me')
+                print(utils.get_display_name(me))
+
+                chat = await client.get_input_entity('username')
+                async for message in client.iter_messages(chat):
+                    ...
+
+                # Note that you could have used the username directly, but it's
+                # good to use get_input_entity if you will reuse it a lot.
+                async for message in client.iter_messages('username'):
+                    ...
+
+                # Note that for this to work the phone number must be in your contacts
+                some_id = await client.get_peer_id('+34123456789')
+        """
+        single = not utils.is_list_like(entity)
+        if single:
+            entity = (entity,)
+
+        # Group input entities by string (resolve username),
+        # input users (get users), input chat (get chats) and
+        # input channels (get channels) to get the most entities
+        # in the less amount of calls possible.
+        inputs = []
+        for x in entity:
+            if isinstance(x, str):
+                inputs.append(x)
+            else:
+                inputs.append(await self.get_input_entity(x))
+
+        lists = {
+            helpers._EntityType.USER: [],
+            helpers._EntityType.CHAT: [],
+            helpers._EntityType.CHANNEL: [],
+        }
+        for x in inputs:
+            try:
+                lists[helpers._entity_type(x)].append(x)
+            except TypeError:
+                pass
+
+        users = lists[helpers._EntityType.USER]
+        chats = lists[helpers._EntityType.CHAT]
+        channels = lists[helpers._EntityType.CHANNEL]
+        if users:
+            # GetUsersRequest has a limit of 200 per call
+            tmp = []
+            while users:
+                curr, users = users[:200], users[200:]
+                tmp.extend(await self(functions.users.GetUsersRequest(curr)))
+            users = tmp
+        if chats:  # TODO Handle chats slice?
+            chats = (await self(
+                functions.messages.GetChatsRequest([x.chat_id for x in chats]))).chats
+        if channels:
+            channels = (await self(
+                functions.channels.GetChannelsRequest(channels))).chats
+
+        # Merge users, chats and channels into a single dictionary
+        id_entity = {
+            # `get_input_entity` might've guessed the type from a non-marked ID,
+            # so the only way to match that with the input is by not using marks here.
+            utils.get_peer_id(x, add_mark=False): x
+            for x in itertools.chain(users, chats, channels)
+        }
+
+        # We could check saved usernames and put them into the users,
+        # chats and channels list from before. While this would reduce
+        # the amount of ResolveUsername calls, it would fail to catch
+        # username changes.
+        result = []
+        for x in inputs:
+            if isinstance(x, str):
+                result.append(await self._get_entity_from_string(x))
+            elif not isinstance(x, types.InputPeerSelf):
+                result.append(id_entity[utils.get_peer_id(x, add_mark=False)])
+            else:
+                result.append(next(
+                    u for u in id_entity.values()
+                    if isinstance(u, types.User) and u.is_self
+                ))
+
+        return result[0] if single else result
+
+    async def get_input_entity(
+            self: 'TelegramClient',
+            peer: 'hints.EntityLike') -> 'types.TypeInputPeer':
+        """
+        Turns the given entity into its input entity version.
+
+        Most requests use this kind of :tl:`InputPeer`, so this is the most
+        suitable call to make for those cases. **Generally you should let the
+        library do its job** and don't worry about getting the input entity
+        first, but if you're going to use an entity often, consider making the
+        call:
+
+        Arguments
+            entity (`str` | `int` | :tl:`Peer` | :tl:`InputPeer`):
+                If a username or invite link is given, **the library will
+                use the cache**. This means that it's possible to be using
+                a username that *changed* or an old invite link (this only
+                happens if an invite link for a small group chat is used
+                after it was upgraded to a mega-group).
+
+                If the username or ID from the invite link is not found in
+                the cache, it will be fetched. The same rules apply to phone
+                numbers (``'+34 123456789'``) from people in your contact list.
+
+                If an exact name is given, it must be in the cache too. This
+                is not reliable as different people can share the same name
+                and which entity is returned is arbitrary, and should be used
+                only for quick tests.
+
+                If a positive integer ID is given, the entity will be searched
+                in cached users, chats or channels, without making any call.
+
+                If a negative integer ID is given, the entity will be searched
+                exactly as either a chat (prefixed with ``-``) or as a channel
+                (prefixed with ``-100``).
+
+                If a :tl:`Peer` is given, it will be searched exactly in the
+                cache as either a user, chat or channel.
+
+                If the given object can be turned into an input entity directly,
+                said operation will be done.
+
+                Unsupported types will raise ``TypeError``.
+
+                If the entity can't be found, ``ValueError`` will be raised.
+
+        Returns
+            :tl:`InputPeerUser`, :tl:`InputPeerChat` or :tl:`InputPeerChannel`
+            or :tl:`InputPeerSelf` if the parameter is ``'me'`` or ``'self'``.
+
+            If you need to get the ID of yourself, you should use
+            `get_me` with ``input_peer=True``) instead.
+
+        Example
+            .. code-block:: python
+
+                # If you're going to use "username" often in your code
+                # (make a lot of calls), consider getting its input entity
+                # once, and then using the "user" everywhere instead.
+                user = await client.get_input_entity('username')
+
+                # The same applies to IDs, chats or channels.
+                chat = await client.get_input_entity(-123456789)
+        """
+        # Short-circuit if the input parameter directly maps to an InputPeer
+        try:
+            return utils.get_input_peer(peer)
+        except TypeError:
+            pass
+
+        # Next in priority is having a peer (or its ID) cached in-memory
+        try:
+            # 0x2d45687 == crc32(b'Peer')
+            if isinstance(peer, int) or peer.SUBCLASS_OF_ID == 0x2d45687:
+                return self._mb_entity_cache.get(utils.get_peer_id(peer, add_mark=False))._as_input_peer()
+        except AttributeError:
+            pass
+
+        # Then come known strings that take precedence
+        if peer in ('me', 'self'):
+            return types.InputPeerSelf()
+
+        # No InputPeer, cached peer, or known string. Fetch from disk cache
+        try:
+            return self.session.get_input_entity(peer)
+        except ValueError:
+            pass
+
+        # Only network left to try
+        if isinstance(peer, str):
+            return utils.get_input_peer(
+                await self._get_entity_from_string(peer))
+
+        # If we're a bot and the user has messaged us privately users.getUsers
+        # will work with access_hash = 0. Similar for channels.getChannels.
+        # If we're not a bot but the user is in our contacts, it seems to work
+        # regardless. These are the only two special-cased requests.
+        peer = utils.get_peer(peer)
+        if isinstance(peer, types.PeerUser):
+            users = await self(functions.users.GetUsersRequest([
+                types.InputUser(peer.user_id, access_hash=0)]))
+            if users and not isinstance(users[0], types.UserEmpty):
+                # If the user passed a valid ID they expect to work for
+                # channels but would be valid for users, we get UserEmpty.
+                # Avoid returning the invalid empty input peer for that.
+                #
+                # We *could* try to guess if it's a channel first, and if
+                # it's not, work as a chat and try to validate it through
+                # another request, but that becomes too much work.
+                return utils.get_input_peer(users[0])
+        elif isinstance(peer, types.PeerChat):
+            return types.InputPeerChat(peer.chat_id)
+        elif isinstance(peer, types.PeerChannel):
+            try:
+                channels = await self(functions.channels.GetChannelsRequest([
+                    types.InputChannel(peer.channel_id, access_hash=0)]))
+                return utils.get_input_peer(channels.chats[0])
+            except errors.ChannelInvalidError:
+                pass
+
+        raise ValueError(
+            'Could not find the input entity for {} ({}). Please read https://'
+            'docs.telethon.dev/en/stable/concepts/entities.html to'
+            ' find out more details.'
+            .format(peer, type(peer).__name__)
+        )
+
+    async def _get_peer(self: 'TelegramClient', peer: 'hints.EntityLike'):
+        i, cls = utils.resolve_id(await self.get_peer_id(peer))
+        return cls(i)
+
+    async def get_peer_id(
+            self: 'TelegramClient',
+            peer: 'hints.EntityLike',
+            add_mark: bool = True) -> int:
+        """
+        Gets the ID for the given entity.
+
+        This method needs to be ``async`` because `peer` supports usernames,
+        invite-links, phone numbers (from people in your contact list), etc.
+
+        If ``add_mark is False``, then a positive ID will be returned
+        instead. By default, bot-API style IDs (signed) are returned.
+
+        Example
+            .. code-block:: python
+
+                print(await client.get_peer_id('me'))
+        """
+        if isinstance(peer, int):
+            return utils.get_peer_id(peer, add_mark=add_mark)
+
+        try:
+            if peer.SUBCLASS_OF_ID not in (0x2d45687, 0xc91c90b6):
+                # 0x2d45687, 0xc91c90b6 == crc32(b'Peer') and b'InputPeer'
+                peer = await self.get_input_entity(peer)
+        except AttributeError:
+            peer = await self.get_input_entity(peer)
+
+        if isinstance(peer, types.InputPeerSelf):
+            peer = await self.get_me(input_peer=True)
+
+        return utils.get_peer_id(peer, add_mark=add_mark)
+
+    # endregion
+
+    # region Private methods
+
+    async def _get_entity_from_string(self: 'TelegramClient', string):
+        """
+        Gets a full entity from the given string, which may be a phone or
+        a username, and processes all the found entities on the session.
+        The string may also be a user link, or a channel/chat invite link.
+
+        This method has the side effect of adding the found users to the
+        session database, so it can be queried later without API calls,
+        if this option is enabled on the session.
+
+        Returns the found entity, or raises TypeError if not found.
+        """
+        phone = utils.parse_phone(string)
+        if phone:
+            try:
+                for user in (await self(
+                        functions.contacts.GetContactsRequest(0))).users:
+                    if user.phone == phone:
+                        return user
+            except errors.BotMethodInvalidError:
+                raise ValueError('Cannot get entity by phone number as a '
+                                 'bot (try using integer IDs, not strings)')
+        elif string.lower() in ('me', 'self'):
+            return await self.get_me()
+        else:
+            username, is_join_chat = utils.parse_username(string)
+            if is_join_chat:
+                invite = await self(
+                    functions.messages.CheckChatInviteRequest(username))
+
+                if isinstance(invite, types.ChatInvite):
+                    raise ValueError(
+                        'Cannot get entity from a channel (or group) '
+                        'that you are not part of. Join the group and retry'
+                    )
+                elif isinstance(invite, types.ChatInviteAlready):
+                    return invite.chat
+            elif username:
+                try:
+                    result = await self(
+                        functions.contacts.ResolveUsernameRequest(username))
+                except errors.UsernameNotOccupiedError as e:
+                    raise ValueError('No user has "{}" as username'
+                                     .format(username)) from e
+
+                try:
+                    pid = utils.get_peer_id(result.peer, add_mark=False)
+                    if isinstance(result.peer, types.PeerUser):
+                        return next(x for x in result.users if x.id == pid)
+                    else:
+                        return next(x for x in result.chats if x.id == pid)
+                except StopIteration:
+                    pass
+            try:
+                # Nobody with this username, maybe it's an exact name/title
+                return await self.get_entity(
+                    self.session.get_input_entity(string))
+            except ValueError:
+                pass
+
+        raise ValueError(
+            'Cannot find any entity corresponding to "{}"'.format(string)
+        )
+
+    async def _get_input_dialog(self: 'TelegramClient', dialog):
+        """
+        Returns a :tl:`InputDialogPeer`. This is a bit tricky because
+        it may or not need access to the client to convert what's given
+        into an input entity.
+        """
+        try:
+            if dialog.SUBCLASS_OF_ID == 0xa21c9795:  # crc32(b'InputDialogPeer')
+                dialog.peer = await self.get_input_entity(dialog.peer)
+                return dialog
+            elif dialog.SUBCLASS_OF_ID == 0xc91c90b6:  # crc32(b'InputPeer')
+                return types.InputDialogPeer(dialog)
+        except AttributeError:
+            pass
+
+        return types.InputDialogPeer(await self.get_input_entity(dialog))
+
+    async def _get_input_notify(self: 'TelegramClient', notify):
+        """
+        Returns a :tl:`InputNotifyPeer`. This is a bit tricky because
+        it may or not need access to the client to convert what's given
+        into an input entity.
+        """
+        try:
+            if notify.SUBCLASS_OF_ID == 0x58981615:
+                if isinstance(notify, types.InputNotifyPeer):
+                    notify.peer = await self.get_input_entity(notify.peer)
+                return notify
+        except AttributeError:
+            pass
+
+        return types.InputNotifyPeer(await self.get_input_entity(notify))
+
+    # endregion

.venv2/Lib/site-packages/telethon/crypto/__init__.py

@@ -0,0 +1,10 @@
+"""
+This module contains several utilities regarding cryptographic purposes,
+such as the AES IGE mode used by Telegram, the authorization key bound with
+their data centers, and so on.
+"""
+from .aes import AES
+from .aesctr import AESModeCTR
+from .authkey import AuthKey
+from .factorization import Factorization
+from .cdndecrypter import CdnDecrypter

.venv2/Lib/site-packages/telethon/crypto/aes.py

@@ -0,0 +1,111 @@
+"""
+AES IGE implementation in Python.
+
+If available, cryptg will be used instead, otherwise
+if available, libssl will be used instead, otherwise
+the Python implementation will be used.
+"""
+import os
+import pyaes
+import logging
+from . import libssl
+
+
+__log__ = logging.getLogger(__name__)
+
+
+try:
+    import cryptg
+    __log__.info('cryptg detected, it will be used for encryption')
+except ImportError:
+    cryptg = None
+    if libssl.encrypt_ige and libssl.decrypt_ige:
+        __log__.info('libssl detected, it will be used for encryption')
+    else:
+        __log__.info('cryptg module not installed and libssl not found, '
+                     'falling back to (slower) Python encryption')
+
+
+class AES:
+    """
+    Class that servers as an interface to encrypt and decrypt
+    text through the AES IGE mode.
+    """
+    @staticmethod
+    def decrypt_ige(cipher_text, key, iv):
+        """
+        Decrypts the given text in 16-bytes blocks by using the
+        given key and 32-bytes initialization vector.
+        """
+        if cryptg:
+            return cryptg.decrypt_ige(cipher_text, key, iv)
+        if libssl.decrypt_ige:
+            return libssl.decrypt_ige(cipher_text, key, iv)
+
+        iv1 = iv[:len(iv) // 2]
+        iv2 = iv[len(iv) // 2:]
+
+        aes = pyaes.AES(key)
+
+        plain_text = []
+        blocks_count = len(cipher_text) // 16
+
+        cipher_text_block = [0] * 16
+        for block_index in range(blocks_count):
+            for i in range(16):
+                cipher_text_block[i] = \
+                    cipher_text[block_index * 16 + i] ^ iv2[i]
+
+            plain_text_block = aes.decrypt(cipher_text_block)
+
+            for i in range(16):
+                plain_text_block[i] ^= iv1[i]
+
+            iv1 = cipher_text[block_index * 16:block_index * 16 + 16]
+            iv2 = plain_text_block
+
+            plain_text.extend(plain_text_block)
+
+        return bytes(plain_text)
+
+    @staticmethod
+    def encrypt_ige(plain_text, key, iv):
+        """
+        Encrypts the given text in 16-bytes blocks by using the
+        given key and 32-bytes initialization vector.
+        """
+        padding = len(plain_text) % 16
+        if padding:
+            plain_text += os.urandom(16 - padding)
+
+        if cryptg:
+            return cryptg.encrypt_ige(plain_text, key, iv)
+        if libssl.encrypt_ige:
+            return libssl.encrypt_ige(plain_text, key, iv)
+
+        iv1 = iv[:len(iv) // 2]
+        iv2 = iv[len(iv) // 2:]
+
+        aes = pyaes.AES(key)
+
+        cipher_text = []
+        blocks_count = len(plain_text) // 16
+
+        for block_index in range(blocks_count):
+            plain_text_block = list(
+                plain_text[block_index * 16:block_index * 16 + 16]
+            )
+            for i in range(16):
+                plain_text_block[i] ^= iv1[i]
+
+            cipher_text_block = aes.encrypt(plain_text_block)
+
+            for i in range(16):
+                cipher_text_block[i] ^= iv2[i]
+
+            iv1 = cipher_text_block
+            iv2 = plain_text[block_index * 16:block_index * 16 + 16]
+
+            cipher_text.extend(cipher_text_block)
+
+        return bytes(cipher_text)

.venv2/Lib/site-packages/telethon/crypto/aesctr.py

@@ -0,0 +1,42 @@
+"""
+This module holds the AESModeCTR wrapper class.
+"""
+import pyaes
+
+
+class AESModeCTR:
+    """Wrapper around pyaes.AESModeOfOperationCTR mode with custom IV"""
+    # TODO Maybe make a pull request to pyaes to support iv on CTR
+
+    def __init__(self, key, iv):
+        """
+        Initializes the AES CTR mode with the given key/iv pair.
+
+        :param key: the key to be used as bytes.
+        :param iv: the bytes initialization vector. Must have a length of 16.
+        """
+        # TODO Use libssl if available
+        assert isinstance(key, bytes)
+        self._aes = pyaes.AESModeOfOperationCTR(key)
+
+        assert isinstance(iv, bytes)
+        assert len(iv) == 16
+        self._aes._counter._counter = list(iv)
+
+    def encrypt(self, data):
+        """
+        Encrypts the given plain text through AES CTR.
+
+        :param data: the plain text to be encrypted.
+        :return: the encrypted cipher text.
+        """
+        return self._aes.encrypt(data)
+
+    def decrypt(self, data):
+        """
+        Decrypts the given cipher text through AES CTR
+
+        :param data: the cipher text to be decrypted.
+        :return: the decrypted plain text.
+        """
+        return self._aes.decrypt(data)

.venv2/Lib/site-packages/telethon/crypto/authkey.py

@@ -0,0 +1,63 @@
+"""
+This module holds the AuthKey class.
+"""
+import struct
+from hashlib import sha1
+
+from ..extensions import BinaryReader
+
+
+class AuthKey:
+    """
+    Represents an authorization key, used to encrypt and decrypt
+    messages sent to Telegram's data centers.
+    """
+    def __init__(self, data):
+        """
+        Initializes a new authorization key.
+
+        :param data: the data in bytes that represent this auth key.
+        """
+        self.key = data
+
+    @property
+    def key(self):
+        return self._key
+
+    @key.setter
+    def key(self, value):
+        if not value:
+            self._key = self.aux_hash = self.key_id = None
+            return
+
+        if isinstance(value, type(self)):
+            self._key, self.aux_hash, self.key_id = \
+                value._key, value.aux_hash, value.key_id
+            return
+
+        self._key = value
+        with BinaryReader(sha1(self._key).digest()) as reader:
+            self.aux_hash = reader.read_long(signed=False)
+            reader.read(4)
+            self.key_id = reader.read_long(signed=False)
+
+    # TODO This doesn't really fit here, it's only used in authentication
+    def calc_new_nonce_hash(self, new_nonce, number):
+        """
+        Calculates the new nonce hash based on the current attributes.
+
+        :param new_nonce: the new nonce to be hashed.
+        :param number: number to prepend before the hash.
+        :return: the hash for the given new nonce.
+        """
+        new_nonce = new_nonce.to_bytes(32, 'little', signed=True)
+        data = new_nonce + struct.pack('<BQ', number, self.aux_hash)
+
+        # Calculates the message key from the given data
+        return int.from_bytes(sha1(data).digest()[4:20], 'little', signed=True)
+
+    def __bool__(self):
+        return bool(self._key)
+
+    def __eq__(self, other):
+        return isinstance(other, type(self)) and other.key == self._key

.venv2/Lib/site-packages/telethon/crypto/cdndecrypter.py

@@ -0,0 +1,105 @@
+"""
+This module holds the CdnDecrypter utility class.
+"""
+from hashlib import sha256
+
+from ..tl.functions.upload import GetCdnFileRequest, ReuploadCdnFileRequest
+from ..tl.types.upload import CdnFileReuploadNeeded, CdnFile
+from ..crypto import AESModeCTR
+from ..errors import CdnFileTamperedError
+
+
+class CdnDecrypter:
+    """
+    Used when downloading a file results in a 'FileCdnRedirect' to
+    both prepare the redirect, decrypt the file as it downloads, and
+    ensure the file hasn't been tampered. https://core.telegram.org/cdn
+    """
+    def __init__(self, cdn_client, file_token, cdn_aes, cdn_file_hashes):
+        """
+        Initializes the CDN decrypter.
+
+        :param cdn_client: a client connected to a CDN.
+        :param file_token: the token of the file to be used.
+        :param cdn_aes: the AES CTR used to decrypt the file.
+        :param cdn_file_hashes: the hashes the decrypted file must match.
+        """
+        self.client = cdn_client
+        self.file_token = file_token
+        self.cdn_aes = cdn_aes
+        self.cdn_file_hashes = cdn_file_hashes
+
+    @staticmethod
+    async def prepare_decrypter(client, cdn_client, cdn_redirect):
+        """
+        Prepares a new CDN decrypter.
+
+        :param client: a TelegramClient connected to the main servers.
+        :param cdn_client: a new client connected to the CDN.
+        :param cdn_redirect: the redirect file object that caused this call.
+        :return: (CdnDecrypter, first chunk file data)
+        """
+        cdn_aes = AESModeCTR(
+            key=cdn_redirect.encryption_key,
+            # 12 first bytes of the IV..4 bytes of the offset (0, big endian)
+            iv=cdn_redirect.encryption_iv[:12] + bytes(4)
+        )
+
+        # We assume that cdn_redirect.cdn_file_hashes are ordered by offset,
+        # and that there will be enough of these to retrieve the whole file.
+        decrypter = CdnDecrypter(
+            cdn_client, cdn_redirect.file_token,
+            cdn_aes, cdn_redirect.cdn_file_hashes
+        )
+
+        cdn_file = await cdn_client(GetCdnFileRequest(
+            file_token=cdn_redirect.file_token,
+            offset=cdn_redirect.cdn_file_hashes[0].offset,
+            limit=cdn_redirect.cdn_file_hashes[0].limit
+        ))
+        if isinstance(cdn_file, CdnFileReuploadNeeded):
+            # We need to use the original client here
+            await client(ReuploadCdnFileRequest(
+                file_token=cdn_redirect.file_token,
+                request_token=cdn_file.request_token
+            ))
+
+            # We want to always return a valid upload.CdnFile
+            cdn_file = decrypter.get_file()
+        else:
+            cdn_file.bytes = decrypter.cdn_aes.encrypt(cdn_file.bytes)
+            cdn_hash = decrypter.cdn_file_hashes.pop(0)
+            decrypter.check(cdn_file.bytes, cdn_hash)
+
+        return decrypter, cdn_file
+
+    def get_file(self):
+        """
+        Calls GetCdnFileRequest and decrypts its bytes.
+        Also ensures that the file hasn't been tampered.
+
+        :return: the CdnFile result.
+        """
+        if self.cdn_file_hashes:
+            cdn_hash = self.cdn_file_hashes.pop(0)
+            cdn_file = self.client(GetCdnFileRequest(
+                self.file_token, cdn_hash.offset, cdn_hash.limit
+            ))
+            cdn_file.bytes = self.cdn_aes.encrypt(cdn_file.bytes)
+            self.check(cdn_file.bytes, cdn_hash)
+        else:
+            cdn_file = CdnFile(bytes(0))
+
+        return cdn_file
+
+    @staticmethod
+    def check(data, cdn_hash):
+        """
+        Checks the integrity of the given data.
+        Raises CdnFileTamperedError if the integrity check fails.
+
+        :param data: the data to be hashed.
+        :param cdn_hash: the expected hash.
+        """
+        if sha256(data).digest() != cdn_hash.hash:
+            raise CdnFileTamperedError()

.venv2/Lib/site-packages/telethon/crypto/factorization.py

@@ -0,0 +1,67 @@
+"""
+This module holds a fast Factorization class.
+"""
+from random import randint
+
+
+class Factorization:
+    """
+    Simple module to factorize large numbers really quickly.
+    """
+    @classmethod
+    def factorize(cls, pq):
+        """
+        Factorizes the given large integer.
+
+        Implementation from https://comeoncodeon.wordpress.com/2010/09/18/pollard-rho-brent-integer-factorization/.
+
+        :param pq: the prime pair pq.
+        :return: a tuple containing the two factors p and q.
+        """
+        if pq % 2 == 0:
+            return 2, pq // 2
+
+        y, c, m = randint(1, pq - 1), randint(1, pq - 1), randint(1, pq - 1)
+        g = r = q = 1
+        x = ys = 0
+
+        while g == 1:
+            x = y
+            for i in range(r):
+                y = (pow(y, 2, pq) + c) % pq
+
+            k = 0
+            while k < r and g == 1:
+                ys = y
+                for i in range(min(m, r - k)):
+                    y = (pow(y, 2, pq) + c) % pq
+                    q = q * (abs(x - y)) % pq
+
+                g = cls.gcd(q, pq)
+                k += m
+
+            r *= 2
+
+        if g == pq:
+            while True:
+                ys = (pow(ys, 2, pq) + c) % pq
+                g = cls.gcd(abs(x - ys), pq)
+                if g > 1:
+                    break
+
+        p, q = g, pq // g
+        return (p, q) if p < q else (q, p)
+
+    @staticmethod
+    def gcd(a, b):
+        """
+        Calculates the Greatest Common Divisor.
+
+        :param a: the first number.
+        :param b: the second number.
+        :return: GCD(a, b)
+        """
+        while b:
+            a, b = b, a % b
+
+        return a

.venv2/Lib/site-packages/telethon/crypto/libssl.py

@@ -0,0 +1,140 @@
+"""
+Helper module around the system's libssl library if available for IGE mode.
+"""
+import ctypes
+import ctypes.util
+import platform
+import sys
+try:
+    import ctypes.macholib.dyld
+except ImportError:
+    pass
+import logging
+import os
+
+__log__ = logging.getLogger(__name__)
+
+
+def _find_ssl_lib():
+    lib = ctypes.util.find_library('ssl')
+    # macOS 10.15 segfaults on  unversioned crypto libraries.
+    # We therefore pin the current stable version here
+    # Credit for fix goes to Sarah Harvey (@worldwise001)
+    # https://www.shh.sh/2020/01/04/python-abort-trap-6.html
+    if sys.platform == 'darwin':
+        release, _version_info, _machine = platform.mac_ver()
+        ver, major, *_ = release.split('.')
+        # macOS 10.14 "mojave" is the last known major release
+        # to support unversioned libssl.dylib. Anything above
+        # needs specific versions
+        if int(ver) > 10 or int(ver) == 10 and int(major) > 14:
+            lib = (
+                ctypes.util.find_library('libssl.46') or
+                ctypes.util.find_library('libssl.44') or
+                ctypes.util.find_library('libssl.42')
+            )
+    if not lib:
+        raise OSError('no library called "ssl" found')
+
+    # First, let ctypes try to handle it itself.
+    try:
+        libssl = ctypes.cdll.LoadLibrary(lib)
+    except OSError:
+        pass
+    else:
+        return libssl
+
+    # This is a best-effort attempt at finding the full real path of lib.
+    #
+    # Unfortunately ctypes doesn't tell us *where* it finds the library,
+    # so we have to do that ourselves.
+    try:
+        # This is not documented, so it could fail. Be on the safe side.
+        paths = ctypes.macholib.dyld.DEFAULT_LIBRARY_FALLBACK
+    except AttributeError:
+        paths = [
+            os.path.expanduser("~/lib"),
+            "/usr/local/lib",
+            "/lib",
+            "/usr/lib",
+        ]
+
+    for path in paths:
+        if os.path.isdir(path):
+            for root, _, files in os.walk(path):
+                if lib in files:
+                    # Manually follow symbolic links on *nix systems.
+                    # Fix for https://github.com/LonamiWebs/Telethon/issues/1167
+                    lib = os.path.realpath(os.path.join(root, lib))
+                    return ctypes.cdll.LoadLibrary(lib)
+    else:
+        raise OSError('no absolute path for "%s" and cannot load by name' % lib)
+
+
+try:
+    _libssl = _find_ssl_lib()
+except OSError as e:
+    # See https://github.com/LonamiWebs/Telethon/issues/1167
+    # Sometimes `find_library` returns improper filenames.
+    __log__.info('Failed to load SSL library: %s (%s)', type(e), e)
+    _libssl = None
+
+if not _libssl:
+    decrypt_ige = None
+    encrypt_ige = None
+else:
+    # https://github.com/openssl/openssl/blob/master/include/openssl/aes.h
+    AES_ENCRYPT = ctypes.c_int(1)
+    AES_DECRYPT = ctypes.c_int(0)
+    AES_MAXNR = 14
+
+    class AES_KEY(ctypes.Structure):
+        """Helper class representing an AES key"""
+        _fields_ = [
+            ('rd_key', ctypes.c_uint32 * (4 * (AES_MAXNR + 1))),
+            ('rounds', ctypes.c_uint),
+        ]
+
+    def decrypt_ige(cipher_text, key, iv):
+        aes_key = AES_KEY()
+        key_len = ctypes.c_int(8 * len(key))
+        key = (ctypes.c_ubyte * len(key))(*key)
+        iv = (ctypes.c_ubyte * len(iv))(*iv)
+
+        in_len = ctypes.c_size_t(len(cipher_text))
+        in_ptr = (ctypes.c_ubyte * len(cipher_text))(*cipher_text)
+        out_ptr = (ctypes.c_ubyte * len(cipher_text))()
+
+        _libssl.AES_set_decrypt_key(key, key_len, ctypes.byref(aes_key))
+        _libssl.AES_ige_encrypt(
+            ctypes.byref(in_ptr),
+            ctypes.byref(out_ptr),
+            in_len,
+            ctypes.byref(aes_key),
+            ctypes.byref(iv),
+            AES_DECRYPT
+        )
+
+        return bytes(out_ptr)
+
+    def encrypt_ige(plain_text, key, iv):
+        aes_key = AES_KEY()
+        key_len = ctypes.c_int(8 * len(key))
+        key = (ctypes.c_ubyte * len(key))(*key)
+        iv = (ctypes.c_ubyte * len(iv))(*iv)
+
+        in_len = ctypes.c_size_t(len(plain_text))
+        in_ptr = (ctypes.c_ubyte * len(plain_text))(*plain_text)
+        out_ptr = (ctypes.c_ubyte * len(plain_text))()
+
+        _libssl.AES_set_encrypt_key(key, key_len, ctypes.byref(aes_key))
+        _libssl.AES_ige_encrypt(
+            ctypes.byref(in_ptr),
+            ctypes.byref(out_ptr),
+            in_len,
+            ctypes.byref(aes_key),
+            ctypes.byref(iv),
+            AES_ENCRYPT
+        )
+
+        return bytes(out_ptr)

.venv2/Lib/site-packages/telethon/crypto/rsa.py

@@ -0,0 +1,165 @@
+"""
+This module holds several utilities regarding RSA and server fingerprints.
+"""
+import os
+import struct
+from hashlib import sha1
+try:
+    import rsa
+    import rsa.core
+except ImportError:
+    rsa = None
+    raise ImportError('Missing module "rsa", please install via pip.')
+
+from ..tl import TLObject
+
+
+# {fingerprint: (Crypto.PublicKey.RSA._RSAobj, old)} dictionary
+_server_keys = {}
+
+
+def get_byte_array(integer):
+    """Return the variable length bytes corresponding to the given int"""
+    # Operate in big endian (unlike most of Telegram API) since:
+    # > "...pq is a representation of a natural number
+    #    (in binary *big endian* format)..."
+    # > "...current value of dh_prime equals
+    #    (in *big-endian* byte order)..."
+    # Reference: https://core.telegram.org/mtproto/auth_key
+    return int.to_bytes(
+        integer,
+        (integer.bit_length() + 8 - 1) // 8,  # 8 bits per byte,
+        byteorder='big',
+        signed=False
+    )
+
+
+def _compute_fingerprint(key):
+    """
+    Given a RSA key, computes its fingerprint like Telegram does.
+
+    :param key: the Crypto.RSA key.
+    :return: its 8-bytes-long fingerprint.
+    """
+    n = TLObject.serialize_bytes(get_byte_array(key.n))
+    e = TLObject.serialize_bytes(get_byte_array(key.e))
+    # Telegram uses the last 8 bytes as the fingerprint
+    return struct.unpack('<q', sha1(n + e).digest()[-8:])[0]
+
+
+def add_key(pub, *, old):
+    """Adds a new public key to be used when encrypting new data is needed"""
+    global _server_keys
+    key = rsa.PublicKey.load_pkcs1(pub)
+    _server_keys[_compute_fingerprint(key)] = (key, old)
+
+
+def encrypt(fingerprint, data, *, use_old=False):
+    """
+    Encrypts the given data known the fingerprint to be used
+    in the way Telegram requires us to do so (sha1(data) + data + padding)
+
+    :param fingerprint: the fingerprint of the RSA key.
+    :param data: the data to be encrypted.
+    :param use_old: whether old keys should be used.
+    :return:
+        the cipher text, or None if no key matching this fingerprint is found.
+    """
+    global _server_keys
+    key, old = _server_keys.get(fingerprint, [None, None])
+    if (not key) or (old and not use_old):
+        return None
+
+    # len(sha1.digest) is always 20, so we're left with 255 - 20 - x padding
+    to_encrypt = sha1(data).digest() + data + os.urandom(235 - len(data))
+
+    # rsa module rsa.encrypt adds 11 bits for padding which we don't want
+    # rsa module uses rsa.transform.bytes2int(to_encrypt), easier way:
+    payload = int.from_bytes(to_encrypt, 'big')
+    encrypted = rsa.core.encrypt_int(payload, key.e, key.n)
+    # rsa module uses transform.int2bytes(encrypted, keylength), easier:
+    block = encrypted.to_bytes(256, 'big')
+    return block
+
+
+# Add default keys
+# https://github.com/DrKLO/Telegram/blob/a724d96e9c008b609fe188d122aa2922e40de5fc/TMessagesProj/jni/tgnet/Handshake.cpp#L356-L436
+for pub in (
+        '''-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAruw2yP/BCcsJliRoW5eBVBVle9dtjJw+OYED160Wybum9SXtBBLX
+riwt4rROd9csv0t0OHCaTmRqBcQ0J8fxhN6/cpR1GWgOZRUAiQxoMnlt0R93LCX/
+j1dnVa/gVbCjdSxpbrfY2g2L4frzjJvdl84Kd9ORYjDEAyFnEA7dD556OptgLQQ2
+e2iVNq8NZLYTzLp5YpOdO1doK+ttrltggTCy5SrKeLoCPPbOgGsdxJxyz5KKcZnS
+Lj16yE5HvJQn0CNpRdENvRUXe6tBP78O39oJ8BTHp9oIjd6XWXAsp2CvK45Ol8wF
+XGF710w9lwCGNbmNxNYhtIkdqfsEcwR5JwIDAQAB
+-----END RSA PUBLIC KEY-----''',
+
+        '''-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAvfLHfYH2r9R70w8prHblWt/nDkh+XkgpflqQVcnAfSuTtO05lNPs
+pQmL8Y2XjVT4t8cT6xAkdgfmmvnvRPOOKPi0OfJXoRVylFzAQG/j83u5K3kRLbae
+7fLccVhKZhY46lvsueI1hQdLgNV9n1cQ3TDS2pQOCtovG4eDl9wacrXOJTG2990V
+jgnIKNA0UMoP+KF03qzryqIt3oTvZq03DyWdGK+AZjgBLaDKSnC6qD2cFY81UryR
+WOab8zKkWAnhw2kFpcqhI0jdV5QaSCExvnsjVaX0Y1N0870931/5Jb9ICe4nweZ9
+kSDF/gip3kWLG0o8XQpChDfyvsqB9OLV/wIDAQAB
+-----END RSA PUBLIC KEY-----''',
+
+        '''-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAs/ditzm+mPND6xkhzwFIz6J/968CtkcSE/7Z2qAJiXbmZ3UDJPGr
+zqTDHkO30R8VeRM/Kz2f4nR05GIFiITl4bEjvpy7xqRDspJcCFIOcyXm8abVDhF+
+th6knSU0yLtNKuQVP6voMrnt9MV1X92LGZQLgdHZbPQz0Z5qIpaKhdyA8DEvWWvS
+Uwwc+yi1/gGaybwlzZwqXYoPOhwMebzKUk0xW14htcJrRrq+PXXQbRzTMynseCoP
+Ioke0dtCodbA3qQxQovE16q9zz4Otv2k4j63cz53J+mhkVWAeWxVGI0lltJmWtEY
+K6er8VqqWot3nqmWMXogrgRLggv/NbbooQIDAQAB
+-----END RSA PUBLIC KEY-----''',
+
+        '''-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAvmpxVY7ld/8DAjz6F6q05shjg8/4p6047bn6/m8yPy1RBsvIyvuD
+uGnP/RzPEhzXQ9UJ5Ynmh2XJZgHoE9xbnfxL5BXHplJhMtADXKM9bWB11PU1Eioc
+3+AXBB8QiNFBn2XI5UkO5hPhbb9mJpjA9Uhw8EdfqJP8QetVsI/xrCEbwEXe0xvi
+fRLJbY08/Gp66KpQvy7g8w7VB8wlgePexW3pT13Ap6vuC+mQuJPyiHvSxjEKHgqe
+Pji9NP3tJUFQjcECqcm0yV7/2d0t/pbCm+ZH1sadZspQCEPPrtbkQBlvHb4OLiIW
+PGHKSMeRFvp3IWcmdJqXahxLCUS1Eh6MAQIDAQAB
+-----END RSA PUBLIC KEY-----''',
+
+):
+    add_key(pub, old=False)
+
+
+for pub in (
+        '''-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAwVACPi9w23mF3tBkdZz+zwrzKOaaQdr01vAbU4E1pvkfj4sqDsm6
+lyDONS789sVoD/xCS9Y0hkkC3gtL1tSfTlgCMOOul9lcixlEKzwKENj1Yz/s7daS
+an9tqw3bfUV/nqgbhGX81v/+7RFAEd+RwFnK7a+XYl9sluzHRyVVaTTveB2GazTw
+Efzk2DWgkBluml8OREmvfraX3bkHZJTKX4EQSjBbbdJ2ZXIsRrYOXfaA+xayEGB+
+8hdlLmAjbCVfaigxX0CDqWeR1yFL9kwd9P0NsZRPsmoqVwMbMu7mStFai6aIhc3n
+Slv8kg9qv1m6XHVQY3PnEw+QQtqSIXklHwIDAQAB
+-----END RSA PUBLIC KEY-----''',
+
+        '''-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAxq7aeLAqJR20tkQQMfRn+ocfrtMlJsQ2Uksfs7Xcoo77jAid0bRt
+ksiVmT2HEIJUlRxfABoPBV8wY9zRTUMaMA654pUX41mhyVN+XoerGxFvrs9dF1Ru
+vCHbI02dM2ppPvyytvvMoefRoL5BTcpAihFgm5xCaakgsJ/tH5oVl74CdhQw8J5L
+xI/K++KJBUyZ26Uba1632cOiq05JBUW0Z2vWIOk4BLysk7+U9z+SxynKiZR3/xdi
+XvFKk01R3BHV+GUKM2RYazpS/P8v7eyKhAbKxOdRcFpHLlVwfjyM1VlDQrEZxsMp
+NTLYXb6Sce1Uov0YtNx5wEowlREH1WOTlwIDAQAB
+-----END RSA PUBLIC KEY-----''',
+
+        '''-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAsQZnSWVZNfClk29RcDTJQ76n8zZaiTGuUsi8sUhW8AS4PSbPKDm+
+DyJgdHDWdIF3HBzl7DHeFrILuqTs0vfS7Pa2NW8nUBwiaYQmPtwEa4n7bTmBVGsB
+1700/tz8wQWOLUlL2nMv+BPlDhxq4kmJCyJfgrIrHlX8sGPcPA4Y6Rwo0MSqYn3s
+g1Pu5gOKlaT9HKmE6wn5Sut6IiBjWozrRQ6n5h2RXNtO7O2qCDqjgB2vBxhV7B+z
+hRbLbCmW0tYMDsvPpX5M8fsO05svN+lKtCAuz1leFns8piZpptpSCFn7bWxiA9/f
+x5x17D7pfah3Sy2pA+NDXyzSlGcKdaUmwQIDAQAB
+-----END RSA PUBLIC KEY-----''',
+
+        '''-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAwqjFW0pi4reKGbkc9pK83Eunwj/k0G8ZTioMMPbZmW99GivMibwa
+xDM9RDWabEMyUtGoQC2ZcDeLWRK3W8jMP6dnEKAlvLkDLfC4fXYHzFO5KHEqF06i
+qAqBdmI1iBGdQv/OQCBcbXIWCGDY2AsiqLhlGQfPOI7/vvKc188rTriocgUtoTUc
+/n/sIUzkgwTqRyvWYynWARWzQg0I9olLBBC2q5RQJJlnYXZwyTL3y9tdb7zOHkks
+WV9IMQmZmyZh/N7sMbGWQpt4NMchGpPGeJ2e5gHBjDnlIf2p1yZOYeUYrdbwcS0t
+UiggS4UeE8TzIuXFQxw7fzEIlmhIaq3FnwIDAQAB
+-----END RSA PUBLIC KEY-----''',
+):
+    add_key(pub, old=True)

.venv2/Lib/site-packages/telethon/custom.py

@@ -0,0 +1 @@
+from .tl.custom import *

.venv2/Lib/site-packages/telethon/errors/__init__.py

@@ -0,0 +1,46 @@
+"""
+This module holds all the base and automatically generated errors that the
+Telegram API has. See telethon_generator/errors.json for more.
+"""
+import re
+
+from .common import (
+    ReadCancelledError, TypeNotFoundError, InvalidChecksumError,
+    InvalidBufferError, AuthKeyNotFound, SecurityError, CdnFileTamperedError,
+    AlreadyInConversationError, BadMessageError, MultiError
+)
+
+# This imports the base errors too, as they're imported there
+from .rpcbaseerrors import *
+from .rpcerrorlist import *
+
+
+def rpc_message_to_error(rpc_error, request):
+    """
+    Converts a Telegram's RPC Error to a Python error.
+
+    :param rpc_error: the RpcError instance.
+    :param request: the request that caused this error.
+    :return: the RPCError as a Python exception that represents this error.
+    """
+    # Try to get the error by direct look-up, otherwise regex
+    # Case-insensitive, for things like "timeout" which don't conform.
+    cls = rpc_errors_dict.get(rpc_error.error_message.upper(), None)
+    if cls:
+        return cls(request=request)
+
+    for msg_regex, cls in rpc_errors_re:
+        m = re.match(msg_regex, rpc_error.error_message)
+        if m:
+            capture = int(m.group(1)) if m.groups() else None
+            return cls(request=request, capture=capture)
+
+    # Some errors are negative:
+    # * -500 for "No workers running",
+    # * -503 for "Timeout"
+    #
+    # We treat them as if they were positive, so -500 will be treated
+    # as a `ServerError`, etc.
+    cls = base_errors.get(abs(rpc_error.error_code), RPCError)
+    return cls(request=request, message=rpc_error.error_message,
+               code=rpc_error.error_code)

.venv2/Lib/site-packages/telethon/errors/common.py

@@ -0,0 +1,180 @@
+"""Errors not related to the Telegram API itself"""
+import struct
+import textwrap
+
+from ..tl import TLRequest
+
+
+class ReadCancelledError(Exception):
+    """Occurs when a read operation was cancelled."""
+    def __init__(self):
+        super().__init__('The read operation was cancelled.')
+
+
+class TypeNotFoundError(Exception):
+    """
+    Occurs when a type is not found, for example,
+    when trying to read a TLObject with an invalid constructor code.
+    """
+    def __init__(self, invalid_constructor_id, remaining):
+        super().__init__(
+            'Could not find a matching Constructor ID for the TLObject '
+            'that was supposed to be read with ID {:08x}. See the FAQ '
+            'for more details. '
+            'Remaining bytes: {!r}'.format(invalid_constructor_id, remaining))
+
+        self.invalid_constructor_id = invalid_constructor_id
+        self.remaining = remaining
+
+
+class InvalidChecksumError(Exception):
+    """
+    Occurs when using the TCP full mode and the checksum of a received
+    packet doesn't match the expected checksum.
+    """
+    def __init__(self, checksum, valid_checksum):
+        super().__init__(
+            'Invalid checksum ({} when {} was expected). '
+            'This packet should be skipped.'
+            .format(checksum, valid_checksum))
+
+        self.checksum = checksum
+        self.valid_checksum = valid_checksum
+
+
+class InvalidBufferError(BufferError):
+    """
+    Occurs when the buffer is invalid, and may contain an HTTP error code.
+    For instance, 404 means "forgotten/broken authorization key", while
+    """
+    def __init__(self, payload):
+        self.payload = payload
+        if len(payload) == 4:
+            self.code = -struct.unpack('<i', payload)[0]
+            super().__init__(
+                'Invalid response buffer (HTTP code {})'.format(self.code))
+        else:
+            self.code = None
+            super().__init__(
+                'Invalid response buffer (too short {})'.format(self.payload))
+
+
+class AuthKeyNotFound(Exception):
+    """
+    The server claims it doesn't know about the authorization key (session
+    file) currently being used. This might be because it either has never
+    seen this authorization key, or it used to know about the authorization
+    key but has forgotten it, either temporarily or permanently (possibly
+    due to server errors).
+
+    If the issue persists, you may need to recreate the session file and login
+    again. This is not done automatically because it is not possible to know
+    if the issue is temporary or permanent.
+    """
+    def __init__(self):
+        super().__init__(textwrap.dedent(self.__class__.__doc__))
+
+
+class SecurityError(Exception):
+    """
+    Generic security error, mostly used when generating a new AuthKey.
+    """
+    def __init__(self, *args):
+        if not args:
+            args = ['A security check failed.']
+        super().__init__(*args)
+
+
+class CdnFileTamperedError(SecurityError):
+    """
+    Occurs when there's a hash mismatch between the decrypted CDN file
+    and its expected hash.
+    """
+    def __init__(self):
+        super().__init__(
+            'The CDN file has been altered and its download cancelled.'
+        )
+
+
+class AlreadyInConversationError(Exception):
+    """
+    Occurs when another exclusive conversation is opened in the same chat.
+    """
+    def __init__(self):
+        super().__init__(
+            'Cannot open exclusive conversation in a '
+            'chat that already has one open conversation'
+        )
+
+
+class BadMessageError(Exception):
+    """Occurs when handling a bad_message_notification."""
+    ErrorMessages = {
+        16:
+        'msg_id too low (most likely, client time is wrong it would be '
+        'worthwhile to synchronize it using msg_id notifications and re-send '
+        'the original message with the "correct" msg_id or wrap it in a '
+        'container with a new msg_id if the original message had waited too '
+        'long on the client to be transmitted).',
+        17:
+        'msg_id too high (similar to the previous case, the client time has '
+        'to be synchronized, and the message re-sent with the correct msg_id).',
+        18:
+        'Incorrect two lower order msg_id bits (the server expects client '
+        'message msg_id to be divisible by 4).',
+        19:
+        'Container msg_id is the same as msg_id of a previously received '
+        'message (this must never happen).',
+        20:
+        'Message too old, and it cannot be verified whether the server has '
+        'received a message with this msg_id or not.',
+        32:
+        'msg_seqno too low (the server has already received a message with a '
+        'lower msg_id but with either a higher or an equal and odd seqno).',
+        33:
+        'msg_seqno too high (similarly, there is a message with a higher '
+        'msg_id but with either a lower or an equal and odd seqno).',
+        34:
+        'An even msg_seqno expected (irrelevant message), but odd received.',
+        35:
+        'Odd msg_seqno expected (relevant message), but even received.',
+        48:
+        'Incorrect server salt (in this case, the bad_server_salt response '
+        'is received with the correct salt, and the message is to be re-sent '
+        'with it).',
+        64:
+        'Invalid container.'
+    }
+
+    def __init__(self, request, code):
+        super().__init__(request, self.ErrorMessages.get(
+            code,
+            'Unknown error code (this should not happen): {}.'.format(code)))
+
+        self.code = code
+
+
+class MultiError(Exception):
+    """Exception container for multiple `TLRequest`'s."""
+
+    def __new__(cls, exceptions, result, requests):
+        if len(result) != len(exceptions) != len(requests):
+            raise ValueError(
+                'Need result, exception and request for each error')
+        for e, req in zip(exceptions, requests):
+            if not isinstance(e, BaseException) and e is not None:
+                raise TypeError(
+                    "Expected an exception object, not '%r'" % e
+                )
+            if not isinstance(req, TLRequest):
+                raise TypeError(
+                    "Expected TLRequest object, not '%r'" % req
+                )
+
+        if len(exceptions) == 1:
+            return exceptions[0]
+        self = BaseException.__new__(cls)
+        self.exceptions = list(exceptions)
+        self.results = list(result)
+        self.requests = list(requests)
+        return self

.venv2/Lib/site-packages/telethon/errors/rpcbaseerrors.py

@@ -0,0 +1,131 @@
+from ..tl import functions
+
+_NESTS_QUERY = (
+    functions.InvokeAfterMsgRequest,
+    functions.InvokeAfterMsgsRequest,
+    functions.InitConnectionRequest,
+    functions.InvokeWithLayerRequest,
+    functions.InvokeWithoutUpdatesRequest,
+    functions.InvokeWithMessagesRangeRequest,
+    functions.InvokeWithTakeoutRequest,
+)
+
+class RPCError(Exception):
+    """Base class for all Remote Procedure Call errors."""
+    code = None
+    message = None
+
+    def __init__(self, request, message, code=None):
+        super().__init__('RPCError {}: {}{}'.format(
+            code or self.code, message, self._fmt_request(request)))
+
+        self.request = request
+        self.code = code
+        self.message = message
+
+    @staticmethod
+    def _fmt_request(request):
+        n = 0
+        reason = ''
+        while isinstance(request, _NESTS_QUERY):
+            n += 1
+            reason += request.__class__.__name__ + '('
+            request = request.query
+        reason += request.__class__.__name__ + ')' * n
+
+        return ' (caused by {})'.format(reason)
+
+    def __reduce__(self):
+        return type(self), (self.request, self.message, self.code)
+
+
+class InvalidDCError(RPCError):
+    """
+    The request must be repeated, but directed to a different data center.
+    """
+    code = 303
+    message = 'ERROR_SEE_OTHER'
+
+
+class BadRequestError(RPCError):
+    """
+    The query contains errors. In the event that a request was created
+    using a form and contains user generated data, the user should be
+    notified that the data must be corrected before the query is repeated.
+    """
+    code = 400
+    message = 'BAD_REQUEST'
+
+
+class UnauthorizedError(RPCError):
+    """
+    There was an unauthorized attempt to use functionality available only
+    to authorized users.
+    """
+    code = 401
+    message = 'UNAUTHORIZED'
+
+
+class ForbiddenError(RPCError):
+    """
+    Privacy violation. For example, an attempt to write a message to
+    someone who has blacklisted the current user.
+    """
+    code = 403
+    message = 'FORBIDDEN'
+
+
+class NotFoundError(RPCError):
+    """
+    An attempt to invoke a non-existent object, such as a method.
+    """
+    code = 404
+    message = 'NOT_FOUND'
+
+
+class AuthKeyError(RPCError):
+    """
+    Errors related to invalid authorization key, like
+    AUTH_KEY_DUPLICATED which can cause the connection to fail.
+    """
+    code = 406
+    message = 'AUTH_KEY'
+
+
+class FloodError(RPCError):
+    """
+    The maximum allowed number of attempts to invoke the given method
+    with the given input parameters has been exceeded. For example, in an
+    attempt to request a large number of text messages (SMS) for the same
+    phone number.
+    """
+    code = 420
+    message = 'FLOOD'
+
+
+class ServerError(RPCError):
+    """
+    An internal server error occurred while a request was being processed
+    for example, there was a disruption while accessing a database or file
+    storage.
+    """
+    code = 500  # Also witnessed as -500
+    message = 'INTERNAL'
+
+
+class TimedOutError(RPCError):
+    """
+    Clicking the inline buttons of bots that never (or take to long to)
+    call ``answerCallbackQuery`` will result in this "special" RPCError.
+    """
+    code = 503  # Only witnessed as -503
+    message = 'Timeout'
+
+
+BotTimeout = TimedOutError
+
+
+base_errors = {x.code: x for x in (
+    InvalidDCError, BadRequestError, UnauthorizedError, ForbiddenError,
+    NotFoundError, AuthKeyError, FloodError, ServerError, TimedOutError
+)}

.venv2/Lib/site-packages/telethon/events/__init__.py

@@ -0,0 +1,140 @@
+from .raw import Raw
+from .album import Album
+from .chataction import ChatAction
+from .messagedeleted import MessageDeleted
+from .messageedited import MessageEdited
+from .messageread import MessageRead
+from .newmessage import NewMessage
+from .userupdate import UserUpdate
+from .callbackquery import CallbackQuery
+from .inlinequery import InlineQuery
+
+
+_HANDLERS_ATTRIBUTE = '__tl.handlers'
+
+
+class StopPropagation(Exception):
+    """
+    If this exception is raised in any of the handlers for a given event,
+    it will stop the execution of all other registered event handlers.
+    It can be seen as the ``StopIteration`` in a for loop but for events.
+
+    Example usage:
+
+        >>> from telethon import TelegramClient, events
+        >>> client = TelegramClient(...)
+        >>>
+        >>> @client.on(events.NewMessage)
+        ... async def delete(event):
+        ...     await event.delete()
+        ...     # No other event handler will have a chance to handle this event
+        ...     raise StopPropagation
+        ...
+        >>> @client.on(events.NewMessage)
+        ... async def _(event):
+        ...     # Will never be reached, because it is the second handler
+        ...     pass
+    """
+    # For some reason Sphinx wants the silly >>> or
+    # it will show warnings and look bad when generated.
+    pass
+
+
+def register(event=None):
+    """
+    Decorator method to *register* event handlers. This is the client-less
+    `add_event_handler()
+    <telethon.client.updates.UpdateMethods.add_event_handler>` variant.
+
+    Note that this method only registers callbacks as handlers,
+    and does not attach them to any client. This is useful for
+    external modules that don't have access to the client, but
+    still want to define themselves as a handler. Example:
+
+    >>> from telethon import events
+    >>> @events.register(events.NewMessage)
+    ... async def handler(event):
+    ...     ...
+    ...
+    >>> # (somewhere else)
+    ...
+    >>> from telethon import TelegramClient
+    >>> client = TelegramClient(...)
+    >>> client.add_event_handler(handler)
+
+    Remember that you can use this as a non-decorator
+    through ``register(event)(callback)``.
+
+    Args:
+        event (`_EventBuilder` | `type`):
+            The event builder class or instance to be used,
+            for instance ``events.NewMessage``.
+    """
+    if isinstance(event, type):
+        event = event()
+    elif not event:
+        event = Raw()
+
+    def decorator(callback):
+        handlers = getattr(callback, _HANDLERS_ATTRIBUTE, [])
+        handlers.append(event)
+        setattr(callback, _HANDLERS_ATTRIBUTE, handlers)
+        return callback
+
+    return decorator
+
+
+def unregister(callback, event=None):
+    """
+    Inverse operation of `register` (though not a decorator). Client-less
+    `remove_event_handler
+    <telethon.client.updates.UpdateMethods.remove_event_handler>`
+    variant. **Note that this won't remove handlers from the client**,
+    because it simply can't, so you would generally use this before
+    adding the handlers to the client.
+
+    This method is here for symmetry. You will rarely need to
+    unregister events, since you can simply just not add them
+    to any client.
+
+    If no event is given, all events for this callback are removed.
+    Returns how many callbacks were removed.
+    """
+    found = 0
+    if event and not isinstance(event, type):
+        event = type(event)
+
+    handlers = getattr(callback, _HANDLERS_ATTRIBUTE, [])
+    handlers.append((event, callback))
+    i = len(handlers)
+    while i:
+        i -= 1
+        ev = handlers[i]
+        if not event or isinstance(ev, event):
+            del handlers[i]
+            found += 1
+
+    return found
+
+
+def is_handler(callback):
+    """
+    Returns `True` if the given callback is an
+    event handler (i.e. you used `register` on it).
+    """
+    return hasattr(callback, _HANDLERS_ATTRIBUTE)
+
+
+def list(callback):
+    """
+    Returns a list containing the registered event
+    builders inside the specified callback handler.
+    """
+    return getattr(callback, _HANDLERS_ATTRIBUTE, [])[:]
+
+
+def _get_handlers(callback):
+    """
+    Like ``list`` but returns `None` if the callback was never registered.
+    """
+    return getattr(callback, _HANDLERS_ATTRIBUTE, None)

.venv2/Lib/site-packages/telethon/events/album.py

@@ -0,0 +1,343 @@
+import asyncio
+import time
+import weakref
+
+from .common import EventBuilder, EventCommon, name_inner_event
+from .. import utils
+from ..tl import types
+from ..tl.custom.sendergetter import SenderGetter
+
+_IGNORE_MAX_SIZE = 100  # len()
+_IGNORE_MAX_AGE = 5  # seconds
+
+# IDs to ignore, and when they were added. If it grows too large, we will
+# remove old entries. Although it should generally not be bigger than 10,
+# it may be possible some updates are not processed and thus not removed.
+_IGNORE_DICT = {}
+
+
+_HACK_DELAY = 0.5
+
+
+class AlbumHack:
+    """
+    When receiving an album from a different data-center, they will come in
+    separate `Updates`, so we need to temporarily remember them for a while
+    and only after produce the event.
+
+    Of course events are not designed for this kind of wizardy, so this is
+    a dirty hack that gets the job done.
+
+    When cleaning up the code base we may want to figure out a better way
+    to do this, or just leave the album problem to the users; the update
+    handling code is bad enough as it is.
+    """
+    def __init__(self, client, event):
+        # It's probably silly to use a weakref here because this object is
+        # very short-lived but might as well try to do "the right thing".
+        self._client = weakref.ref(client)
+        self._event = event  # parent event
+        self._due = client.loop.time() + _HACK_DELAY
+
+        client.loop.create_task(self.deliver_event())
+
+    def extend(self, messages):
+        client = self._client()
+        if client:  # weakref may be dead
+            self._event.messages.extend(messages)
+            self._due = client.loop.time() + _HACK_DELAY
+
+    async def deliver_event(self):
+        while True:
+            client = self._client()
+            if client is None:
+                return  # weakref is dead, nothing to deliver
+
+            diff = self._due - client.loop.time()
+            if diff <= 0:
+                # We've hit our due time, deliver event. It won't respect
+                # sequential updates but fixing that would just worsen this.
+                await client._dispatch_event(self._event)
+                return
+
+            del client  # Clear ref and sleep until our due time
+            await asyncio.sleep(diff)
+
+
+@name_inner_event
+class Album(EventBuilder):
+    """
+    Occurs whenever you receive an album. This event only exists
+    to ease dealing with an unknown amount of messages that belong
+    to the same album.
+
+    Example
+        .. code-block:: python
+
+            from telethon import events
+
+            @client.on(events.Album)
+            async def handler(event):
+                # Counting how many photos or videos the album has
+                print('Got an album with', len(event), 'items')
+
+                # Forwarding the album as a whole to some chat
+                event.forward_to(chat)
+
+                # Printing the caption
+                print(event.text)
+
+                # Replying to the fifth item in the album
+                await event.messages[4].reply('Cool!')
+    """
+
+    def __init__(
+            self, chats=None, *, blacklist_chats=False, func=None):
+        super().__init__(chats, blacklist_chats=blacklist_chats, func=func)
+
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        # TODO normally we'd only check updates if they come with other updates
+        # but MessageBox is not designed for this so others will always be None.
+        # In essence we always rely on AlbumHack rather than returning early if not others.
+        others = [update]
+
+        if isinstance(update,
+                      (types.UpdateNewMessage, types.UpdateNewChannelMessage)):
+            if not isinstance(update.message, types.Message):
+                return  # We don't care about MessageService's here
+
+            group = update.message.grouped_id
+            if group is None:
+                return  # It must be grouped
+
+            # Check whether we are supposed to skip this update, and
+            # if we do also remove it from the ignore list since we
+            # won't need to check against it again.
+            if _IGNORE_DICT.pop(id(update), None):
+                return
+
+            # Check if the ignore list is too big, and if it is clean it
+            # TODO time could technically go backwards; time is not monotonic
+            now = time.time()
+            if len(_IGNORE_DICT) > _IGNORE_MAX_SIZE:
+                for i in [i for i, t in _IGNORE_DICT.items() if now - t > _IGNORE_MAX_AGE]:
+                    del _IGNORE_DICT[i]
+
+            # Add the other updates to the ignore list
+            for u in others:
+                if u is not update:
+                    _IGNORE_DICT[id(u)] = now
+
+            # Figure out which updates share the same group and use those
+            return cls.Event([
+                u.message for u in others
+                if (isinstance(u, (types.UpdateNewMessage, types.UpdateNewChannelMessage))
+                    and isinstance(u.message, types.Message)
+                    and u.message.grouped_id == group)
+            ])
+
+    def filter(self, event):
+        # Albums with less than two messages require a few hacks to work.
+        if len(event.messages) > 1:
+            return super().filter(event)
+
+    class Event(EventCommon, SenderGetter):
+        """
+        Represents the event of a new album.
+
+        Members:
+            messages (Sequence[`Message <telethon.tl.custom.message.Message>`]):
+                The list of messages belonging to the same album.
+        """
+        def __init__(self, messages):
+            message = messages[0]
+            super().__init__(chat_peer=message.peer_id,
+                             msg_id=message.id, broadcast=bool(message.post))
+            SenderGetter.__init__(self, message.sender_id)
+            self.messages = messages
+
+        def _set_client(self, client):
+            super()._set_client(client)
+            self._sender, self._input_sender = utils._get_entity_pair(
+                self.sender_id, self._entities, client._mb_entity_cache)
+
+            for msg in self.messages:
+                msg._finish_init(client, self._entities, None)
+
+            if len(self.messages) == 1:
+                # This will require hacks to be a proper album event
+                hack = client._albums.get(self.grouped_id)
+                if hack is None:
+                    client._albums[self.grouped_id] = AlbumHack(client, self)
+                else:
+                    hack.extend(self.messages)
+
+        @property
+        def grouped_id(self):
+            """
+            The shared ``grouped_id`` between all the messages.
+            """
+            return self.messages[0].grouped_id
+
+        @property
+        def text(self):
+            """
+            The message text of the first photo with a caption,
+            formatted using the client's default parse mode.
+            """
+            return next((m.text for m in self.messages if m.text), '')
+
+        @property
+        def raw_text(self):
+            """
+            The raw message text of the first photo
+            with a caption, ignoring any formatting.
+            """
+            return next((m.raw_text for m in self.messages if m.raw_text), '')
+
+        @property
+        def is_reply(self):
+            """
+            `True` if the album is a reply to some other message.
+
+            Remember that you can access the ID of the message
+            this one is replying to through `reply_to_msg_id`,
+            and the `Message` object with `get_reply_message()`.
+            """
+            # Each individual message in an album all reply to the same message
+            return self.messages[0].is_reply
+
+        @property
+        def forward(self):
+            """
+            The `Forward <telethon.tl.custom.forward.Forward>`
+            information for the first message in the album if it was forwarded.
+            """
+            # Each individual message in an album all reply to the same message
+            return self.messages[0].forward
+
+        # endregion Public Properties
+
+        # region Public Methods
+
+        async def get_reply_message(self):
+            """
+            The `Message <telethon.tl.custom.message.Message>`
+            that this album is replying to, or `None`.
+
+            The result will be cached after its first use.
+            """
+            return await self.messages[0].get_reply_message()
+
+        async def respond(self, *args, **kwargs):
+            """
+            Responds to the album (not as a reply). Shorthand for
+            `telethon.client.messages.MessageMethods.send_message`
+            with ``entity`` already set.
+            """
+            return await self.messages[0].respond(*args, **kwargs)
+
+        async def reply(self, *args, **kwargs):
+            """
+            Replies to the first photo in the album (as a reply). Shorthand
+            for `telethon.client.messages.MessageMethods.send_message`
+            with both ``entity`` and ``reply_to`` already set.
+            """
+            return await self.messages[0].reply(*args, **kwargs)
+
+        async def forward_to(self, *args, **kwargs):
+            """
+            Forwards the entire album. Shorthand for
+            `telethon.client.messages.MessageMethods.forward_messages`
+            with both ``messages`` and ``from_peer`` already set.
+            """
+            if self._client:
+                kwargs['messages'] = self.messages
+                kwargs['from_peer'] = await self.get_input_chat()
+                return await self._client.forward_messages(*args, **kwargs)
+
+        async def edit(self, *args, **kwargs):
+            """
+            Edits the first caption or the message, or the first messages'
+            caption if no caption is set, iff it's outgoing. Shorthand for
+            `telethon.client.messages.MessageMethods.edit_message`
+            with both ``entity`` and ``message`` already set.
+
+            Returns `None` if the message was incoming,
+            or the edited `Message` otherwise.
+
+            .. note::
+
+                This is different from `client.edit_message
+                <telethon.client.messages.MessageMethods.edit_message>`
+                and **will respect** the previous state of the message.
+                For example, if the message didn't have a link preview,
+                the edit won't add one by default, and you should force
+                it by setting it to `True` if you want it.
+
+                This is generally the most desired and convenient behaviour,
+                and will work for link previews and message buttons.
+            """
+            for msg in self.messages:
+                if msg.raw_text:
+                    return await msg.edit(*args, **kwargs)
+
+            return await self.messages[0].edit(*args, **kwargs)
+
+        async def delete(self, *args, **kwargs):
+            """
+            Deletes the entire album. You're responsible for checking whether
+            you have the permission to do so, or to except the error otherwise.
+            Shorthand for
+            `telethon.client.messages.MessageMethods.delete_messages` with
+            ``entity`` and ``message_ids`` already set.
+            """
+            if self._client:
+                return await self._client.delete_messages(
+                    await self.get_input_chat(), self.messages,
+                    *args, **kwargs
+                )
+
+        async def mark_read(self):
+            """
+            Marks the entire album as read. Shorthand for
+            `client.send_read_acknowledge()
+            <telethon.client.messages.MessageMethods.send_read_acknowledge>`
+            with both ``entity`` and ``message`` already set.
+            """
+            if self._client:
+                await self._client.send_read_acknowledge(
+                    await self.get_input_chat(), max_id=self.messages[-1].id)
+
+        async def pin(self, *, notify=False):
+            """
+            Pins the first photo in the album. Shorthand for
+            `telethon.client.messages.MessageMethods.pin_message`
+            with both ``entity`` and ``message`` already set.
+            """
+            return await self.messages[0].pin(notify=notify)
+
+        def __len__(self):
+            """
+            Return the amount of messages in the album.
+
+            Equivalent to ``len(self.messages)``.
+            """
+            return len(self.messages)
+
+        def __iter__(self):
+            """
+            Iterate over the messages in the album.
+
+            Equivalent to ``iter(self.messages)``.
+            """
+            return iter(self.messages)
+
+        def __getitem__(self, n):
+            """
+            Access the n'th message in the album.
+
+            Equivalent to ``event.messages[n]``.
+            """
+            return self.messages[n]

.venv2/Lib/site-packages/telethon/events/callbackquery.py

@@ -0,0 +1,346 @@
+import re
+import struct
+
+from .common import EventBuilder, EventCommon, name_inner_event
+from .. import utils
+from ..tl import types, functions
+from ..tl.custom.sendergetter import SenderGetter
+
+
+@name_inner_event
+class CallbackQuery(EventBuilder):
+    """
+    Occurs whenever you sign in as a bot and a user
+    clicks one of the inline buttons on your messages.
+
+    Note that the `chats` parameter will **not** work with normal
+    IDs or peers if the clicked inline button comes from a "via bot"
+    message. The `chats` parameter also supports checking against the
+    `chat_instance` which should be used for inline callbacks.
+
+    Args:
+        data (`bytes`, `str`, `callable`, optional):
+            If set, the inline button payload data must match this data.
+            A UTF-8 string can also be given, a regex or a callable. For
+            instance, to check against ``'data_1'`` and ``'data_2'`` you
+            can use ``re.compile(b'data_')``.
+
+        pattern (`bytes`, `str`, `callable`, `Pattern`, optional):
+            If set, only buttons with payload matching this pattern will be handled.
+            You can specify a regex-like string which will be matched
+            against the payload data, a callable function that returns `True`
+            if a the payload data is acceptable, or a compiled regex pattern.
+
+    Example
+        .. code-block:: python
+
+            from telethon import events, Button
+
+            # Handle all callback queries and check data inside the handler
+            @client.on(events.CallbackQuery)
+            async def handler(event):
+                if event.data == b'yes':
+                    await event.answer('Correct answer!')
+
+            # Handle only callback queries with data being b'no'
+            @client.on(events.CallbackQuery(data=b'no'))
+            async def handler(event):
+                # Pop-up message with alert
+                await event.answer('Wrong answer!', alert=True)
+
+            # Send a message with buttons users can click
+            async def main():
+                await client.send_message(user, 'Yes or no?', buttons=[
+                    Button.inline('Yes!', b'yes'),
+                    Button.inline('Nope', b'no')
+                ])
+    """
+    def __init__(
+            self, chats=None, *, blacklist_chats=False, func=None, data=None, pattern=None):
+        super().__init__(chats, blacklist_chats=blacklist_chats, func=func)
+
+        if data and pattern:
+            raise ValueError("Only pass either data or pattern not both.")
+
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+        if isinstance(pattern, str):
+            pattern = pattern.encode('utf-8')
+
+        match = data if data else pattern
+
+        if isinstance(match, bytes):
+            self.match = data if data else re.compile(pattern).match
+        elif not match or callable(match):
+            self.match = match
+        elif hasattr(match, 'match') and callable(match.match):
+            if not isinstance(getattr(match, 'pattern', b''), bytes):
+                match = re.compile(match.pattern.encode('utf-8'),
+                                   match.flags & (~re.UNICODE))
+
+            self.match = match.match
+        else:
+            raise TypeError('Invalid data or pattern type given')
+
+        self._no_check = all(x is None for x in (
+            self.chats, self.func, self.match,
+        ))
+
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        if isinstance(update, types.UpdateBotCallbackQuery):
+            return cls.Event(update, update.peer, update.msg_id)
+        elif isinstance(update, types.UpdateInlineBotCallbackQuery):
+            # See https://github.com/LonamiWebs/Telethon/pull/1005
+            # The long message ID is actually just msg_id + peer_id
+            mid, pid = struct.unpack('<ii', struct.pack('<q', update.msg_id.id))
+            peer = types.PeerChannel(-pid) if pid < 0 else types.PeerUser(pid)
+            return cls.Event(update, peer, mid)
+
+    def filter(self, event):
+        # We can't call super().filter(...) because it ignores chat_instance
+        if self._no_check:
+            return event
+
+        if self.chats is not None:
+            inside = event.query.chat_instance in self.chats
+            if event.chat_id:
+                inside |= event.chat_id in self.chats
+
+            if inside == self.blacklist_chats:
+                return
+
+        if self.match:
+            if callable(self.match):
+                event.data_match = event.pattern_match = self.match(event.query.data)
+                if not event.data_match:
+                    return
+            elif event.query.data != self.match:
+                return
+
+        if self.func:
+            # Return the result of func directly as it may need to be awaited
+            return self.func(event)
+        return True
+
+    class Event(EventCommon, SenderGetter):
+        """
+        Represents the event of a new callback query.
+
+        Members:
+            query (:tl:`UpdateBotCallbackQuery`):
+                The original :tl:`UpdateBotCallbackQuery`.
+
+            data_match (`obj`, optional):
+                The object returned by the ``data=`` parameter
+                when creating the event builder, if any. Similar
+                to ``pattern_match`` for the new message event.
+
+            pattern_match (`obj`, optional):
+                Alias for ``data_match``.
+        """
+        def __init__(self, query, peer, msg_id):
+            super().__init__(peer, msg_id=msg_id)
+            SenderGetter.__init__(self, query.user_id)
+            self.query = query
+            self.data_match = None
+            self.pattern_match = None
+            self._message = None
+            self._answered = False
+
+        def _set_client(self, client):
+            super()._set_client(client)
+            self._sender, self._input_sender = utils._get_entity_pair(
+                self.sender_id, self._entities, client._mb_entity_cache)
+
+        @property
+        def id(self):
+            """
+            Returns the query ID. The user clicking the inline
+            button is the one who generated this random ID.
+            """
+            return self.query.query_id
+
+        @property
+        def message_id(self):
+            """
+            Returns the message ID to which the clicked inline button belongs.
+            """
+            return self._message_id
+
+        @property
+        def data(self):
+            """
+            Returns the data payload from the original inline button.
+            """
+            return self.query.data
+
+        @property
+        def chat_instance(self):
+            """
+            Unique identifier for the chat where the callback occurred.
+            Useful for high scores in games.
+            """
+            return self.query.chat_instance
+
+        async def get_message(self):
+            """
+            Returns the message to which the clicked inline button belongs.
+            """
+            if self._message is not None:
+                return self._message
+
+            try:
+                chat = await self.get_input_chat() if self.is_channel else None
+                self._message = await self._client.get_messages(
+                    chat, ids=self._message_id)
+            except ValueError:
+                return
+
+            return self._message
+
+        async def _refetch_sender(self):
+            self._sender = self._entities.get(self.sender_id)
+            if not self._sender:
+                return
+
+            self._input_sender = utils.get_input_peer(self._chat)
+            if not getattr(self._input_sender, 'access_hash', True):
+                # getattr with True to handle the InputPeerSelf() case
+                try:
+                    self._input_sender = self._client._mb_entity_cache.get(
+                        utils.resolve_id(self._sender_id)[0])._as_input_peer()
+                except AttributeError:
+                    m = await self.get_message()
+                    if m:
+                        self._sender = m._sender
+                        self._input_sender = m._input_sender
+
+        async def answer(
+                self, message=None, cache_time=0, *, url=None, alert=False):
+            """
+            Answers the callback query (and stops the loading circle).
+
+            Args:
+                message (`str`, optional):
+                    The toast message to show feedback to the user.
+
+                cache_time (`int`, optional):
+                    For how long this result should be cached on
+                    the user's client. Defaults to 0 for no cache.
+
+                url (`str`, optional):
+                    The URL to be opened in the user's client. Note that
+                    the only valid URLs are those of games your bot has,
+                    or alternatively a 't.me/your_bot?start=xyz' parameter.
+
+                alert (`bool`, optional):
+                    Whether an alert (a pop-up dialog) should be used
+                    instead of showing a toast. Defaults to `False`.
+            """
+            if self._answered:
+                return
+
+            self._answered = True
+            return await self._client(
+                functions.messages.SetBotCallbackAnswerRequest(
+                    query_id=self.query.query_id,
+                    cache_time=cache_time,
+                    alert=alert,
+                    message=message,
+                    url=url
+                )
+            )
+
+        @property
+        def via_inline(self):
+            """
+            Whether this callback was generated from an inline button sent
+            via an inline query or not. If the bot sent the message itself
+            with buttons, and one of those is clicked, this will be `False`.
+            If a user sent the message coming from an inline query to the
+            bot, and one of those is clicked, this will be `True`.
+
+            If it's `True`, it's likely that the bot is **not** in the
+            chat, so methods like `respond` or `delete` won't work (but
+            `edit` will always work).
+            """
+            return isinstance(self.query, types.UpdateInlineBotCallbackQuery)
+
+        async def respond(self, *args, **kwargs):
+            """
+            Responds to the message (not as a reply). Shorthand for
+            `telethon.client.messages.MessageMethods.send_message` with
+            ``entity`` already set.
+
+            This method also creates a task to `answer` the callback.
+
+            This method will likely fail if `via_inline` is `True`.
+            """
+            self._client.loop.create_task(self.answer())
+            return await self._client.send_message(
+                await self.get_input_chat(), *args, **kwargs)
+
+        async def reply(self, *args, **kwargs):
+            """
+            Replies to the message (as a reply). Shorthand for
+            `telethon.client.messages.MessageMethods.send_message` with
+            both ``entity`` and ``reply_to`` already set.
+
+            This method also creates a task to `answer` the callback.
+
+            This method will likely fail if `via_inline` is `True`.
+            """
+            self._client.loop.create_task(self.answer())
+            kwargs['reply_to'] = self.query.msg_id
+            return await self._client.send_message(
+                await self.get_input_chat(), *args, **kwargs)
+
+        async def edit(self, *args, **kwargs):
+            """
+            Edits the message. Shorthand for
+            `telethon.client.messages.MessageMethods.edit_message` with
+            the ``entity`` set to the correct :tl:`InputBotInlineMessageID` or :tl:`InputBotInlineMessageID64`.
+
+            Returns `True` if the edit was successful.
+
+            This method also creates a task to `answer` the callback.
+
+            .. note::
+
+                This method won't respect the previous message unlike
+                `Message.edit <telethon.tl.custom.message.Message.edit>`,
+                since the message object is normally not present.
+            """
+            self._client.loop.create_task(self.answer())
+            if isinstance(self.query.msg_id, (types.InputBotInlineMessageID, types.InputBotInlineMessageID64)):
+                return await self._client.edit_message(
+                    self.query.msg_id, *args, **kwargs
+                )
+            else:
+                return await self._client.edit_message(
+                    await self.get_input_chat(), self.query.msg_id,
+                    *args, **kwargs
+                )
+
+        async def delete(self, *args, **kwargs):
+            """
+            Deletes the message. Shorthand for
+            `telethon.client.messages.MessageMethods.delete_messages` with
+            ``entity`` and ``message_ids`` already set.
+
+            If you need to delete more than one message at once, don't use
+            this `delete` method. Use a
+            `telethon.client.telegramclient.TelegramClient` instance directly.
+
+            This method also creates a task to `answer` the callback.
+
+            This method will likely fail if `via_inline` is `True`.
+            """
+            self._client.loop.create_task(self.answer())
+            if isinstance(self.query.msg_id, (types.InputBotInlineMessageID, types.InputBotInlineMessageID64)):
+                raise TypeError('Inline messages cannot be deleted as there is no API request available to do so')
+            return await self._client.delete_messages(
+                await self.get_input_chat(), [self.query.msg_id],
+                *args, **kwargs
+            )

.venv2/Lib/site-packages/telethon/events/chataction.py

@@ -0,0 +1,458 @@
+from .common import EventBuilder, EventCommon, name_inner_event
+from .. import utils
+from ..tl import types
+
+
+@name_inner_event
+class ChatAction(EventBuilder):
+    """
+    Occurs on certain chat actions:
+
+    * Whenever a new chat is created.
+    * Whenever a chat's title or photo is changed or removed.
+    * Whenever a new message is pinned.
+    * Whenever a user scores in a game.
+    * Whenever a user joins or is added to the group.
+    * Whenever a user is removed or leaves a group if it has
+      less than 50 members or the removed user was a bot.
+
+    Note that "chat" refers to "small group, megagroup and broadcast
+    channel", whereas "group" refers to "small group and megagroup" only.
+
+    Example
+        .. code-block:: python
+
+            from telethon import events
+
+            @client.on(events.ChatAction)
+            async def handler(event):
+                # Welcome every new user
+                if event.user_joined:
+                    await event.reply('Welcome to the group!')
+    """
+
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        # Rely on specific pin updates for unpins, but otherwise ignore them
+        # for new pins (we'd rather handle the new service message with pin,
+        # so that we can act on that message').
+        if isinstance(update, types.UpdatePinnedChannelMessages) and not update.pinned:
+            return cls.Event(types.PeerChannel(update.channel_id),
+                             pin_ids=update.messages,
+                             pin=update.pinned)
+
+        elif isinstance(update, types.UpdatePinnedMessages) and not update.pinned:
+            return cls.Event(update.peer,
+                             pin_ids=update.messages,
+                             pin=update.pinned)
+
+        elif isinstance(update, types.UpdateChatParticipantAdd):
+            return cls.Event(types.PeerChat(update.chat_id),
+                             added_by=update.inviter_id or True,
+                             users=update.user_id)
+
+        elif isinstance(update, types.UpdateChatParticipantDelete):
+            return cls.Event(types.PeerChat(update.chat_id),
+                             kicked_by=True,
+                             users=update.user_id)
+
+        # UpdateChannel is sent if we leave a channel, and the update._entities
+        # set by _process_update would let us make some guesses. However it's
+        # better not to rely on this. Rely only in MessageActionChatDeleteUser.
+
+        elif (isinstance(update, (
+                types.UpdateNewMessage, types.UpdateNewChannelMessage))
+              and isinstance(update.message, types.MessageService)):
+            msg = update.message
+            action = update.message.action
+            if isinstance(action, types.MessageActionChatJoinedByLink):
+                return cls.Event(msg,
+                                 added_by=True,
+                                 users=msg.from_id)
+            elif isinstance(action, types.MessageActionChatAddUser):
+                # If a user adds itself, it means they joined via the public chat username
+                added_by = ([msg.sender_id] == action.users) or msg.from_id
+                return cls.Event(msg,
+                                 added_by=added_by,
+                                 users=action.users)
+            elif isinstance(action, types.MessageActionChatDeleteUser):
+                return cls.Event(msg,
+                                 kicked_by=utils.get_peer_id(msg.from_id) if msg.from_id else True,
+                                 users=action.user_id)
+            elif isinstance(action, types.MessageActionChatCreate):
+                return cls.Event(msg,
+                                 users=action.users,
+                                 created=True,
+                                 new_title=action.title)
+            elif isinstance(action, types.MessageActionChannelCreate):
+                return cls.Event(msg,
+                                 created=True,
+                                 users=msg.from_id,
+                                 new_title=action.title)
+            elif isinstance(action, types.MessageActionChatEditTitle):
+                return cls.Event(msg,
+                                 users=msg.from_id,
+                                 new_title=action.title)
+            elif isinstance(action, types.MessageActionChatEditPhoto):
+                return cls.Event(msg,
+                                 users=msg.from_id,
+                                 new_photo=action.photo)
+            elif isinstance(action, types.MessageActionChatDeletePhoto):
+                return cls.Event(msg,
+                                 users=msg.from_id,
+                                 new_photo=True)
+            elif isinstance(action, types.MessageActionPinMessage) and msg.reply_to:
+                return cls.Event(msg,
+                                 pin_ids=[msg.reply_to_msg_id])
+            elif isinstance(action, types.MessageActionGameScore):
+                return cls.Event(msg,
+                                 new_score=action.score)
+
+        elif isinstance(update, types.UpdateChannelParticipant) \
+                and bool(update.new_participant) != bool(update.prev_participant):
+            # If members are hidden, bots will receive this update instead,
+            # as there won't be a service message. Promotions and demotions
+            # seem to have both new and prev participant, which are ignored
+            # by this event.
+            return cls.Event(types.PeerChannel(update.channel_id),
+                             users=update.user_id,
+                             added_by=update.actor_id if update.new_participant else None,
+                             kicked_by=update.actor_id if update.prev_participant else None)
+
+    class Event(EventCommon):
+        """
+        Represents the event of a new chat action.
+
+        Members:
+            action_message  (`MessageAction <https://tl.telethon.dev/types/message_action.html>`_):
+                The message invoked by this Chat Action.
+
+            new_pin (`bool`):
+                `True` if there is a new pin.
+
+            new_photo (`bool`):
+                `True` if there's a new chat photo (or it was removed).
+
+            photo (:tl:`Photo`, optional):
+                The new photo (or `None` if it was removed).
+
+            user_added (`bool`):
+                `True` if the user was added by some other.
+
+            user_joined (`bool`):
+                `True` if the user joined on their own.
+
+            user_left (`bool`):
+                `True` if the user left on their own.
+
+            user_kicked (`bool`):
+                `True` if the user was kicked by some other.
+
+            created (`bool`, optional):
+                `True` if this chat was just created.
+
+            new_title (`str`, optional):
+                The new title string for the chat, if applicable.
+
+            new_score (`str`, optional):
+                The new score string for the game, if applicable.
+
+            unpin (`bool`):
+                `True` if the existing pin gets unpinned.
+        """
+
+        def __init__(self, where, new_photo=None,
+                     added_by=None, kicked_by=None, created=None,
+                     users=None, new_title=None, pin_ids=None, pin=None, new_score=None):
+            if isinstance(where, types.MessageService):
+                self.action_message = where
+                where = where.peer_id
+            else:
+                self.action_message = None
+
+            # TODO needs some testing (can there be more than one id, and do they follow pin order?)
+            #      same in get_pinned_message
+            super().__init__(chat_peer=where, msg_id=pin_ids[0] if pin_ids else None)
+
+            self.new_pin = pin_ids is not None
+            self._pin_ids = pin_ids
+            self._pinned_messages = None
+
+            self.new_photo = new_photo is not None
+            self.photo = \
+                new_photo if isinstance(new_photo, types.Photo) else None
+
+            self._added_by = None
+            self._kicked_by = None
+            self.user_added = self.user_joined = self.user_left = \
+                self.user_kicked = self.unpin = False
+
+            if added_by is True:
+                self.user_joined = True
+            elif added_by:
+                self.user_added = True
+                self._added_by = added_by
+
+            # If `from_id` was not present (it's `True`) or the affected
+            # user was "kicked by itself", then it left. Else it was kicked.
+            if kicked_by is True or (users is not None and kicked_by == users):
+                self.user_left = True
+            elif kicked_by:
+                self.user_kicked = True
+                self._kicked_by = kicked_by
+
+            self.created = bool(created)
+
+            if isinstance(users, list):
+                self._user_ids = [utils.get_peer_id(u) for u in users]
+            elif users:
+                self._user_ids = [utils.get_peer_id(users)]
+            else:
+                self._user_ids = []
+
+            self._users = None
+            self._input_users = None
+            self.new_title = new_title
+            self.new_score = new_score
+            self.unpin = not pin
+
+        def _set_client(self, client):
+            super()._set_client(client)
+            if self.action_message:
+                self.action_message._finish_init(client, self._entities, None)
+
+        async def respond(self, *args, **kwargs):
+            """
+            Responds to the chat action message (not as a reply). Shorthand for
+            `telethon.client.messages.MessageMethods.send_message` with
+            ``entity`` already set.
+            """
+            return await self._client.send_message(
+                await self.get_input_chat(), *args, **kwargs)
+
+        async def reply(self, *args, **kwargs):
+            """
+            Replies to the chat action message (as a reply). Shorthand for
+            `telethon.client.messages.MessageMethods.send_message` with
+            both ``entity`` and ``reply_to`` already set.
+
+            Has the same effect as `respond` if there is no message.
+            """
+            if not self.action_message:
+                return await self.respond(*args, **kwargs)
+
+            kwargs['reply_to'] = self.action_message.id
+            return await self._client.send_message(
+                await self.get_input_chat(), *args, **kwargs)
+
+        async def delete(self, *args, **kwargs):
+            """
+            Deletes the chat action message. You're responsible for checking
+            whether you have the permission to do so, or to except the error
+            otherwise. Shorthand for
+            `telethon.client.messages.MessageMethods.delete_messages` with
+            ``entity`` and ``message_ids`` already set.
+
+            Does nothing if no message action triggered this event.
+            """
+            if not self.action_message:
+                return
+
+            return await self._client.delete_messages(
+                await self.get_input_chat(), [self.action_message],
+                *args, **kwargs
+            )
+
+        async def get_pinned_message(self):
+            """
+            If ``new_pin`` is `True`, this returns the `Message
+            <telethon.tl.custom.message.Message>` object that was pinned.
+            """
+            if self._pinned_messages is None:
+                await self.get_pinned_messages()
+
+            if self._pinned_messages:
+                return self._pinned_messages[0]
+
+        async def get_pinned_messages(self):
+            """
+            If ``new_pin`` is `True`, this returns a `list` of `Message
+            <telethon.tl.custom.message.Message>` objects that were pinned.
+            """
+            if not self._pin_ids:
+                return self._pin_ids  # either None or empty list
+
+            chat = await self.get_input_chat()
+            if chat:
+                self._pinned_messages = await self._client.get_messages(
+                    self._input_chat, ids=self._pin_ids)
+
+            return self._pinned_messages
+
+        @property
+        def added_by(self):
+            """
+            The user who added ``users``, if applicable (`None` otherwise).
+            """
+            if self._added_by and not isinstance(self._added_by, types.User):
+                aby = self._entities.get(utils.get_peer_id(self._added_by))
+                if aby:
+                    self._added_by = aby
+
+            return self._added_by
+
+        async def get_added_by(self):
+            """
+            Returns `added_by` but will make an API call if necessary.
+            """
+            if not self.added_by and self._added_by:
+                self._added_by = await self._client.get_entity(self._added_by)
+
+            return self._added_by
+
+        @property
+        def kicked_by(self):
+            """
+            The user who kicked ``users``, if applicable (`None` otherwise).
+            """
+            if self._kicked_by and not isinstance(self._kicked_by, types.User):
+                kby = self._entities.get(utils.get_peer_id(self._kicked_by))
+                if kby:
+                    self._kicked_by = kby
+
+            return self._kicked_by
+
+        async def get_kicked_by(self):
+            """
+            Returns `kicked_by` but will make an API call if necessary.
+            """
+            if not self.kicked_by and self._kicked_by:
+                self._kicked_by = await self._client.get_entity(self._kicked_by)
+
+            return self._kicked_by
+
+        @property
+        def user(self):
+            """
+            The first user that takes part in this action. For example, who joined.
+
+            Might be `None` if the information can't be retrieved or
+            there is no user taking part.
+            """
+            if self.users:
+                return self._users[0]
+
+        async def get_user(self):
+            """
+            Returns `user` but will make an API call if necessary.
+            """
+            if self.users or await self.get_users():
+                return self._users[0]
+
+        @property
+        def input_user(self):
+            """
+            Input version of the ``self.user`` property.
+            """
+            if self.input_users:
+                return self._input_users[0]
+
+        async def get_input_user(self):
+            """
+            Returns `input_user` but will make an API call if necessary.
+            """
+            if self.input_users or await self.get_input_users():
+                return self._input_users[0]
+
+        @property
+        def user_id(self):
+            """
+            Returns the marked signed ID of the first user, if any.
+            """
+            if self._user_ids:
+                return self._user_ids[0]
+
+        @property
+        def users(self):
+            """
+            A list of users that take part in this action. For example, who joined.
+
+            Might be empty if the information can't be retrieved or there
+            are no users taking part.
+            """
+            if not self._user_ids:
+                return []
+
+            if self._users is None:
+                self._users = [
+                    self._entities[user_id]
+                    for user_id in self._user_ids
+                    if user_id in self._entities
+                ]
+
+            return self._users
+
+        async def get_users(self):
+            """
+            Returns `users` but will make an API call if necessary.
+            """
+            if not self._user_ids:
+                return []
+
+            # Note: we access the property first so that it fills if needed
+            if (self.users is None or len(self._users) != len(self._user_ids)) and self.action_message:
+                await self.action_message._reload_message()
+                self._users = [
+                    u for u in self.action_message.action_entities
+                    if isinstance(u, (types.User, types.UserEmpty))]
+
+            return self._users
+
+        @property
+        def input_users(self):
+            """
+            Input version of the ``self.users`` property.
+            """
+            if self._input_users is None and self._user_ids:
+                self._input_users = []
+                for user_id in self._user_ids:
+                    # First try to get it from our entities
+                    try:
+                        self._input_users.append(utils.get_input_peer(self._entities[user_id]))
+                        continue
+                    except (KeyError, TypeError):
+                        pass
+
+                    # If missing, try from the entity cache
+                    try:
+                        self._input_users.append(self._client._mb_entity_cache.get(
+                            utils.resolve_id(user_id)[0])._as_input_peer())
+                        continue
+                    except AttributeError:
+                        pass
+
+            return self._input_users or []
+
+        async def get_input_users(self):
+            """
+            Returns `input_users` but will make an API call if necessary.
+            """
+            if not self._user_ids:
+                return []
+
+            # Note: we access the property first so that it fills if needed
+            if (self.input_users is None or len(self._input_users) != len(self._user_ids)) and self.action_message:
+                self._input_users = [
+                    utils.get_input_peer(u)
+                    for u in self.action_message.action_entities
+                    if isinstance(u, (types.User, types.UserEmpty))]
+
+            return self._input_users or []
+
+        @property
+        def user_ids(self):
+            """
+            Returns the marked signed ID of the users, if any.
+            """
+            if self._user_ids:
+                return self._user_ids[:]

.venv2/Lib/site-packages/telethon/events/common.py

@@ -0,0 +1,186 @@
+import abc
+import asyncio
+import warnings
+
+from .. import utils
+from ..tl import TLObject, types
+from ..tl.custom.chatgetter import ChatGetter
+
+
+async def _into_id_set(client, chats):
+    """Helper util to turn the input chat or chats into a set of IDs."""
+    if chats is None:
+        return None
+
+    if not utils.is_list_like(chats):
+        chats = (chats,)
+
+    result = set()
+    for chat in chats:
+        if isinstance(chat, int):
+            if chat < 0:
+                result.add(chat)  # Explicitly marked IDs are negative
+            else:
+                result.update({  # Support all valid types of peers
+                    utils.get_peer_id(types.PeerUser(chat)),
+                    utils.get_peer_id(types.PeerChat(chat)),
+                    utils.get_peer_id(types.PeerChannel(chat)),
+                })
+        elif isinstance(chat, TLObject) and chat.SUBCLASS_OF_ID == 0x2d45687:
+            # 0x2d45687 == crc32(b'Peer')
+            result.add(utils.get_peer_id(chat))
+        else:
+            chat = await client.get_input_entity(chat)
+            if isinstance(chat, types.InputPeerSelf):
+                chat = await client.get_me(input_peer=True)
+            result.add(utils.get_peer_id(chat))
+
+    return result
+
+
+class EventBuilder(abc.ABC):
+    """
+    The common event builder, with builtin support to filter per chat.
+
+    Args:
+        chats (`entity`, optional):
+            May be one or more entities (username/peer/etc.), preferably IDs.
+            By default, only matching chats will be handled.
+
+        blacklist_chats (`bool`, optional):
+            Whether to treat the chats as a blacklist instead of
+            as a whitelist (default). This means that every chat
+            will be handled *except* those specified in ``chats``
+            which will be ignored if ``blacklist_chats=True``.
+
+        func (`callable`, optional):
+            A callable (async or not) function that should accept the event as input
+            parameter, and return a value indicating whether the event
+            should be dispatched or not (any truthy value will do, it
+            does not need to be a `bool`). It works like a custom filter:
+
+            .. code-block:: python
+
+                @client.on(events.NewMessage(func=lambda e: e.is_private))
+                async def handler(event):
+                    pass  # code here
+    """
+    def __init__(self, chats=None, *, blacklist_chats=False, func=None):
+        self.chats = chats
+        self.blacklist_chats = bool(blacklist_chats)
+        self.resolved = False
+        self.func = func
+        self._resolve_lock = None
+
+    @classmethod
+    @abc.abstractmethod
+    def build(cls, update, others=None, self_id=None):
+        """
+        Builds an event for the given update if possible, or returns None.
+
+        `others` are the rest of updates that came in the same container
+        as the current `update`.
+
+        `self_id` should be the current user's ID, since it is required
+        for some events which lack this information but still need it.
+        """
+        # TODO So many parameters specific to only some update types seems dirty
+
+    async def resolve(self, client):
+        """Helper method to allow event builders to be resolved before usage"""
+        if self.resolved:
+            return
+
+        if not self._resolve_lock:
+            self._resolve_lock = asyncio.Lock()
+
+        async with self._resolve_lock:
+            if not self.resolved:
+                await self._resolve(client)
+                self.resolved = True
+
+    async def _resolve(self, client):
+        self.chats = await _into_id_set(client, self.chats)
+
+    def filter(self, event):
+        """
+        Returns a truthy value if the event passed the filter and should be
+        used, or falsy otherwise. The return value may need to be awaited.
+
+        The events must have been resolved before this can be called.
+        """
+        if not self.resolved:
+            return
+
+        if self.chats is not None:
+            # Note: the `event.chat_id` property checks if it's `None` for us
+            inside = event.chat_id in self.chats
+            if inside == self.blacklist_chats:
+                # If this chat matches but it's a blacklist ignore.
+                # If it doesn't match but it's a whitelist ignore.
+                return
+
+        if not self.func:
+            return True
+
+        # Return the result of func directly as it may need to be awaited
+        return self.func(event)
+
+
+class EventCommon(ChatGetter, abc.ABC):
+    """
+    Intermediate class with common things to all events.
+
+    Remember that this class implements `ChatGetter
+    <telethon.tl.custom.chatgetter.ChatGetter>` which
+    means you have access to all chat properties and methods.
+
+    In addition, you can access the `original_update`
+    field which contains the original :tl:`Update`.
+    """
+    _event_name = 'Event'
+
+    def __init__(self, chat_peer=None, msg_id=None, broadcast=None):
+        super().__init__(chat_peer, broadcast=broadcast)
+        self._entities = {}
+        self._client = None
+        self._message_id = msg_id
+        self.original_update = None
+
+    def _set_client(self, client):
+        """
+        Setter so subclasses can act accordingly when the client is set.
+        """
+        self._client = client
+        if self._chat_peer:
+            self._chat, self._input_chat = utils._get_entity_pair(
+                self.chat_id, self._entities, client._mb_entity_cache)
+        else:
+            self._chat = self._input_chat = None
+
+    @property
+    def client(self):
+        """
+        The `telethon.TelegramClient` that created this event.
+        """
+        return self._client
+
+    def __str__(self):
+        return TLObject.pretty_format(self.to_dict())
+
+    def stringify(self):
+        return TLObject.pretty_format(self.to_dict(), indent=0)
+
+    def to_dict(self):
+        d = {k: v for k, v in self.__dict__.items() if k[0] != '_'}
+        d['_'] = self._event_name
+        return d
+
+
+def name_inner_event(cls):
+    """Decorator to rename cls.Event 'Event' as 'cls.Event'"""
+    if hasattr(cls, 'Event'):
+        cls.Event._event_name = '{}.Event'.format(cls.__name__)
+    else:
+        warnings.warn('Class {} does not have a inner Event'.format(cls))
+    return cls

.venv2/Lib/site-packages/telethon/events/inlinequery.py

@@ -0,0 +1,247 @@
+import inspect
+import re
+
+import asyncio
+
+from .common import EventBuilder, EventCommon, name_inner_event
+from .. import utils, helpers
+from ..tl import types, functions, custom
+from ..tl.custom.sendergetter import SenderGetter
+
+
+@name_inner_event
+class InlineQuery(EventBuilder):
+    """
+    Occurs whenever you sign in as a bot and a user
+    sends an inline query such as ``@bot query``.
+
+    Args:
+        users (`entity`, optional):
+            May be one or more entities (username/peer/etc.), preferably IDs.
+            By default, only inline queries from these users will be handled.
+
+        blacklist_users (`bool`, optional):
+            Whether to treat the users as a blacklist instead of
+            as a whitelist (default). This means that every chat
+            will be handled *except* those specified in ``users``
+            which will be ignored if ``blacklist_users=True``.
+
+        pattern (`str`, `callable`, `Pattern`, optional):
+            If set, only queries matching this pattern will be handled.
+            You can specify a regex-like string which will be matched
+            against the message, a callable function that returns `True`
+            if a message is acceptable, or a compiled regex pattern.
+
+    Example
+        .. code-block:: python
+
+            from telethon import events
+
+            @client.on(events.InlineQuery)
+            async def handler(event):
+                builder = event.builder
+
+                # Two options (convert user text to UPPERCASE or lowercase)
+                await event.answer([
+                    builder.article('UPPERCASE', text=event.text.upper()),
+                    builder.article('lowercase', text=event.text.lower()),
+                ])
+    """
+    def __init__(
+            self, users=None, *, blacklist_users=False, func=None, pattern=None):
+        super().__init__(users, blacklist_chats=blacklist_users, func=func)
+
+        if isinstance(pattern, str):
+            self.pattern = re.compile(pattern).match
+        elif not pattern or callable(pattern):
+            self.pattern = pattern
+        elif hasattr(pattern, 'match') and callable(pattern.match):
+            self.pattern = pattern.match
+        else:
+            raise TypeError('Invalid pattern type given')
+
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        if isinstance(update, types.UpdateBotInlineQuery):
+            return cls.Event(update)
+
+    def filter(self, event):
+        if self.pattern:
+            match = self.pattern(event.text)
+            if not match:
+                return
+            event.pattern_match = match
+
+        return super().filter(event)
+
+    class Event(EventCommon, SenderGetter):
+        """
+        Represents the event of a new callback query.
+
+        Members:
+            query (:tl:`UpdateBotInlineQuery`):
+                The original :tl:`UpdateBotInlineQuery`.
+
+                Make sure to access the `text` property of the query if
+                you want the text rather than the actual query object.
+
+            pattern_match (`obj`, optional):
+                The resulting object from calling the passed ``pattern``
+                function, which is ``re.compile(...).match`` by default.
+        """
+        def __init__(self, query):
+            super().__init__(chat_peer=types.PeerUser(query.user_id))
+            SenderGetter.__init__(self, query.user_id)
+            self.query = query
+            self.pattern_match = None
+            self._answered = False
+
+        def _set_client(self, client):
+            super()._set_client(client)
+            self._sender, self._input_sender = utils._get_entity_pair(
+                self.sender_id, self._entities, client._mb_entity_cache)
+
+        @property
+        def id(self):
+            """
+            Returns the unique identifier for the query ID.
+            """
+            return self.query.query_id
+
+        @property
+        def text(self):
+            """
+            Returns the text the user used to make the inline query.
+            """
+            return self.query.query
+
+        @property
+        def offset(self):
+            """
+            The string the user's client used as an offset for the query.
+            This will either be empty or equal to offsets passed to `answer`.
+            """
+            return self.query.offset
+
+        @property
+        def geo(self):
+            """
+            If the user location is requested when using inline mode
+            and the user's device is able to send it, this will return
+            the :tl:`GeoPoint` with the position of the user.
+            """
+            return self.query.geo
+
+        @property
+        def builder(self):
+            """
+            Returns a new `InlineBuilder
+            <telethon.tl.custom.inlinebuilder.InlineBuilder>` instance.
+            """
+            return custom.InlineBuilder(self._client)
+
+        async def answer(
+                self, results=None, cache_time=0, *,
+                gallery=False, next_offset=None, private=False,
+                switch_pm=None, switch_pm_param=''):
+            """
+            Answers the inline query with the given results.
+
+            See the documentation for `builder` to know what kind of answers
+            can be given.
+
+            Args:
+                results (`list`, optional):
+                    A list of :tl:`InputBotInlineResult` to use.
+                    You should use `builder` to create these:
+
+                    .. code-block:: python
+
+                        builder = inline.builder
+                        r1 = builder.article('Be nice', text='Have a nice day')
+                        r2 = builder.article('Be bad', text="I don't like you")
+                        await inline.answer([r1, r2])
+
+                    You can send up to 50 results as documented in
+                    https://core.telegram.org/bots/api#answerinlinequery.
+                    Sending more will raise ``ResultsTooMuchError``,
+                    and you should consider using `next_offset` to
+                    paginate them.
+
+                cache_time (`int`, optional):
+                    For how long this result should be cached on
+                    the user's client. Defaults to 0 for no cache.
+
+                gallery (`bool`, optional):
+                    Whether the results should show as a gallery (grid) or not.
+
+                next_offset (`str`, optional):
+                    The offset the client will send when the user scrolls the
+                    results and it repeats the request.
+
+                private (`bool`, optional):
+                    Whether the results should be cached by Telegram
+                    (not private) or by the user's client (private).
+
+                switch_pm (`str`, optional):
+                    If set, this text will be shown in the results
+                    to allow the user to switch to private messages.
+
+                switch_pm_param (`str`, optional):
+                    Optional parameter to start the bot with if
+                    `switch_pm` was used.
+
+            Example:
+
+                .. code-block:: python
+
+                    @bot.on(events.InlineQuery)
+                    async def handler(event):
+                        builder = event.builder
+
+                        rev_text = event.text[::-1]
+                        await event.answer([
+                            builder.article('Reverse text', text=rev_text),
+                            builder.photo('/path/to/photo.jpg')
+                        ])
+            """
+            if self._answered:
+                return
+
+            if results:
+                futures = [self._as_future(x) for x in results]
+
+                await asyncio.wait(futures)
+
+                # All futures will be in the `done` *set* that `wait` returns.
+                #
+                # Precisely because it's a `set` and not a `list`, it
+                # will not preserve the order, but since all futures
+                # completed we can use our original, ordered `list`.
+                results = [x.result() for x in futures]
+            else:
+                results = []
+
+            if switch_pm:
+                switch_pm = types.InlineBotSwitchPM(switch_pm, switch_pm_param)
+
+            return await self._client(
+                functions.messages.SetInlineBotResultsRequest(
+                    query_id=self.query.query_id,
+                    results=results,
+                    cache_time=cache_time,
+                    gallery=gallery,
+                    next_offset=next_offset,
+                    private=private,
+                    switch_pm=switch_pm
+                )
+            )
+
+        @staticmethod
+        def _as_future(obj):
+            if inspect.isawaitable(obj):
+                return asyncio.ensure_future(obj)
+
+            f = helpers.get_running_loop().create_future()
+            f.set_result(obj)
+            return f

.venv2/Lib/site-packages/telethon/events/messagedeleted.py

@@ -0,0 +1,57 @@
+from .common import EventBuilder, EventCommon, name_inner_event
+from ..tl import types
+
+
+@name_inner_event
+class MessageDeleted(EventBuilder):
+    """
+    Occurs whenever a message is deleted. Note that this event isn't 100%
+    reliable, since Telegram doesn't always notify the clients that a message
+    was deleted.
+
+    .. important::
+
+        Telegram **does not** send information about *where* a message
+        was deleted if it occurs in private conversations with other users
+        or in small group chats, because message IDs are *unique* and you
+        can identify the chat with the message ID alone if you saved it
+        previously.
+
+        Telethon **does not** save information of where messages occur,
+        so it cannot know in which chat a message was deleted (this will
+        only work in channels, where the channel ID *is* present).
+
+        This means that the ``chats=`` parameter will not work reliably,
+        unless you intend on working with channels and super-groups only.
+
+    Example
+        .. code-block:: python
+
+            from telethon import events
+
+            @client.on(events.MessageDeleted)
+            async def handler(event):
+                # Log all deleted message IDs
+                for msg_id in event.deleted_ids:
+                    print('Message', msg_id, 'was deleted in', event.chat_id)
+    """
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        if isinstance(update, types.UpdateDeleteMessages):
+            return cls.Event(
+                deleted_ids=update.messages,
+                peer=None
+            )
+        elif isinstance(update, types.UpdateDeleteChannelMessages):
+            return cls.Event(
+                deleted_ids=update.messages,
+                peer=types.PeerChannel(update.channel_id)
+            )
+
+    class Event(EventCommon):
+        def __init__(self, deleted_ids, peer):
+            super().__init__(
+                chat_peer=peer, msg_id=(deleted_ids or [0])[0]
+            )
+            self.deleted_id = None if not deleted_ids else deleted_ids[0]
+            self.deleted_ids = deleted_ids

.venv2/Lib/site-packages/telethon/events/messageedited.py

@@ -0,0 +1,52 @@
+from .common import name_inner_event
+from .newmessage import NewMessage
+from ..tl import types
+
+
+@name_inner_event
+class MessageEdited(NewMessage):
+    """
+    Occurs whenever a message is edited. Just like `NewMessage
+    <telethon.events.newmessage.NewMessage>`, you should treat
+    this event as a `Message <telethon.tl.custom.message.Message>`.
+
+    .. warning::
+
+        On channels, `Message.out <telethon.tl.custom.message.Message>`
+        will be `True` if you sent the message originally, **not if
+        you edited it**! This can be dangerous if you run outgoing
+        commands on edits.
+
+        Some examples follow:
+
+        * You send a message "A", ``out is True``.
+        * You edit "A" to "B", ``out is True``.
+        * Someone else edits "B" to "C", ``out is True`` (**be careful!**).
+        * Someone sends "X", ``out is False``.
+        * Someone edits "X" to "Y", ``out is False``.
+        * You edit "Y" to "Z", ``out is False``.
+
+        Since there are useful cases where you need the right ``out``
+        value, the library cannot do anything automatically to help you.
+        Instead, consider using ``from_users='me'`` (it won't work in
+        broadcast channels at all since the sender is the channel and
+        not you).
+
+    Example
+        .. code-block:: python
+
+            from telethon import events
+
+            @client.on(events.MessageEdited)
+            async def handler(event):
+                # Log the date of new edits
+                print('Message', event.id, 'changed at', event.date)
+    """
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        if isinstance(update, (types.UpdateEditMessage,
+                               types.UpdateEditChannelMessage)):
+            return cls.Event(update.message)
+
+    class Event(NewMessage.Event):
+        pass  # Required if we want a different name for it

.venv2/Lib/site-packages/telethon/events/messageread.py

@@ -0,0 +1,143 @@
+from .common import EventBuilder, EventCommon, name_inner_event
+from .. import utils
+from ..tl import types
+
+
+@name_inner_event
+class MessageRead(EventBuilder):
+    """
+    Occurs whenever one or more messages are read in a chat.
+
+    Args:
+        inbox (`bool`, optional):
+            If this argument is `True`, then when you read someone else's
+            messages the event will be fired. By default (`False`) only
+            when messages you sent are read by someone else will fire it.
+
+    Example
+        .. code-block:: python
+
+            from telethon import events
+
+            @client.on(events.MessageRead)
+            async def handler(event):
+                # Log when someone reads your messages
+                print('Someone has read all your messages until', event.max_id)
+
+            @client.on(events.MessageRead(inbox=True))
+            async def handler(event):
+                # Log when you read message in a chat (from your "inbox")
+                print('You have read messages until', event.max_id)
+    """
+    def __init__(
+            self, chats=None, *, blacklist_chats=False, func=None, inbox=False):
+        super().__init__(chats, blacklist_chats=blacklist_chats, func=func)
+        self.inbox = inbox
+
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        if isinstance(update, types.UpdateReadHistoryInbox):
+            return cls.Event(update.peer, update.max_id, False)
+        elif isinstance(update, types.UpdateReadHistoryOutbox):
+            return cls.Event(update.peer, update.max_id, True)
+        elif isinstance(update, types.UpdateReadChannelInbox):
+            return cls.Event(types.PeerChannel(update.channel_id),
+                             update.max_id, False)
+        elif isinstance(update, types.UpdateReadChannelOutbox):
+            return cls.Event(types.PeerChannel(update.channel_id),
+                             update.max_id, True)
+        elif isinstance(update, types.UpdateReadMessagesContents):
+            return cls.Event(message_ids=update.messages,
+                             contents=True)
+        elif isinstance(update, types.UpdateChannelReadMessagesContents):
+            return cls.Event(types.PeerChannel(update.channel_id),
+                             message_ids=update.messages,
+                             contents=True)
+
+    def filter(self, event):
+        if self.inbox == event.outbox:
+            return
+
+        return super().filter(event)
+
+    class Event(EventCommon):
+        """
+        Represents the event of one or more messages being read.
+
+        Members:
+            max_id (`int`):
+                Up to which message ID has been read. Every message
+                with an ID equal or lower to it have been read.
+
+            outbox (`bool`):
+                `True` if someone else has read your messages.
+
+            contents (`bool`):
+                `True` if what was read were the contents of a message.
+                This will be the case when e.g. you play a voice note.
+                It may only be set on ``inbox`` events.
+        """
+        def __init__(self, peer=None, max_id=None, out=False, contents=False,
+                     message_ids=None):
+            self.outbox = out
+            self.contents = contents
+            self._message_ids = message_ids or []
+            self._messages = None
+            self.max_id = max_id or max(message_ids or [], default=None)
+            super().__init__(peer, self.max_id)
+
+        @property
+        def inbox(self):
+            """
+            `True` if you have read someone else's messages.
+            """
+            return not self.outbox
+
+        @property
+        def message_ids(self):
+            """
+            The IDs of the messages **which contents'** were read.
+
+            Use :meth:`is_read` if you need to check whether a message
+            was read instead checking if it's in here.
+            """
+            return self._message_ids
+
+        async def get_messages(self):
+            """
+            Returns the list of `Message <telethon.tl.custom.message.Message>`
+            **which contents'** were read.
+
+            Use :meth:`is_read` if you need to check whether a message
+            was read instead checking if it's in here.
+            """
+            if self._messages is None:
+                chat = await self.get_input_chat()
+                if not chat:
+                    self._messages = []
+                else:
+                    self._messages = await self._client.get_messages(
+                        chat, ids=self._message_ids)
+
+            return self._messages
+
+        def is_read(self, message):
+            """
+            Returns `True` if the given message (or its ID) has been read.
+
+            If a list-like argument is provided, this method will return a
+            list of booleans indicating which messages have been read.
+            """
+            if utils.is_list_like(message):
+                return [(m if isinstance(m, int) else m.id) <= self.max_id
+                        for m in message]
+            else:
+                return (message if isinstance(message, int)
+                        else message.id) <= self.max_id
+
+        def __contains__(self, message):
+            """`True` if the message(s) are read message."""
+            if utils.is_list_like(message):
+                return all(self.is_read(message))
+            else:
+                return self.is_read(message)

.venv2/Lib/site-packages/telethon/events/newmessage.py

@@ -0,0 +1,223 @@
+import re
+
+from .common import EventBuilder, EventCommon, name_inner_event, _into_id_set
+from .. import utils
+from ..tl import types
+
+
+@name_inner_event
+class NewMessage(EventBuilder):
+    """
+    Occurs whenever a new text message or a message with media arrives.
+
+    Args:
+        incoming (`bool`, optional):
+            If set to `True`, only **incoming** messages will be handled.
+            Mutually exclusive with ``outgoing`` (can only set one of either).
+
+        outgoing (`bool`, optional):
+            If set to `True`, only **outgoing** messages will be handled.
+            Mutually exclusive with ``incoming`` (can only set one of either).
+
+        from_users (`entity`, optional):
+            Unlike `chats`, this parameter filters the *senders* of the
+            message. That is, only messages *sent by these users* will be
+            handled. Use `chats` if you want private messages with this/these
+            users. `from_users` lets you filter by messages sent by *one or
+            more* users across the desired chats (doesn't need a list).
+
+        forwards (`bool`, optional):
+            Whether forwarded messages should be handled or not. By default,
+            both forwarded and normal messages are included. If it's `True`
+            *only* forwards will be handled. If it's `False` only messages
+            that are *not* forwards will be handled.
+
+        pattern (`str`, `callable`, `Pattern`, optional):
+            If set, only messages matching this pattern will be handled.
+            You can specify a regex-like string which will be matched
+            against the message, a callable function that returns `True`
+            if a message is acceptable, or a compiled regex pattern.
+
+    Example
+        .. code-block:: python
+
+            import asyncio
+            from telethon import events
+
+            @client.on(events.NewMessage(pattern='(?i)hello.+'))
+            async def handler(event):
+                # Respond whenever someone says "Hello" and something else
+                await event.reply('Hey!')
+
+            @client.on(events.NewMessage(outgoing=True, pattern='!ping'))
+            async def handler(event):
+                # Say "!pong" whenever you send "!ping", then delete both messages
+                m = await event.respond('!pong')
+                await asyncio.sleep(5)
+                await client.delete_messages(event.chat_id, [event.id, m.id])
+    """
+    def __init__(self, chats=None, *, blacklist_chats=False, func=None,
+                 incoming=None, outgoing=None,
+                 from_users=None, forwards=None, pattern=None):
+        if incoming and outgoing:
+            incoming = outgoing = None  # Same as no filter
+        elif incoming is not None and outgoing is None:
+            outgoing = not incoming
+        elif outgoing is not None and incoming is None:
+            incoming = not outgoing
+        elif all(x is not None and not x for x in (incoming, outgoing)):
+            raise ValueError("Don't create an event handler if you "
+                             "don't want neither incoming nor outgoing!")
+
+        super().__init__(chats, blacklist_chats=blacklist_chats, func=func)
+        self.incoming = incoming
+        self.outgoing = outgoing
+        self.from_users = from_users
+        self.forwards = forwards
+        if isinstance(pattern, str):
+            self.pattern = re.compile(pattern).match
+        elif not pattern or callable(pattern):
+            self.pattern = pattern
+        elif hasattr(pattern, 'match') and callable(pattern.match):
+            self.pattern = pattern.match
+        else:
+            raise TypeError('Invalid pattern type given')
+
+        # Should we short-circuit? E.g. perform no check at all
+        self._no_check = all(x is None for x in (
+            self.chats, self.incoming, self.outgoing, self.pattern,
+            self.from_users, self.forwards, self.from_users, self.func
+        ))
+
+    async def _resolve(self, client):
+        await super()._resolve(client)
+        self.from_users = await _into_id_set(client, self.from_users)
+
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        if isinstance(update,
+                      (types.UpdateNewMessage, types.UpdateNewChannelMessage)):
+            if not isinstance(update.message, types.Message):
+                return  # We don't care about MessageService's here
+            event = cls.Event(update.message)
+        elif isinstance(update, types.UpdateShortMessage):
+            event = cls.Event(types.Message(
+                out=update.out,
+                mentioned=update.mentioned,
+                media_unread=update.media_unread,
+                silent=update.silent,
+                id=update.id,
+                peer_id=types.PeerUser(update.user_id),
+                from_id=types.PeerUser(self_id if update.out else update.user_id),
+                message=update.message,
+                date=update.date,
+                fwd_from=update.fwd_from,
+                via_bot_id=update.via_bot_id,
+                reply_to=update.reply_to,
+                entities=update.entities,
+                ttl_period=update.ttl_period
+            ))
+        elif isinstance(update, types.UpdateShortChatMessage):
+            event = cls.Event(types.Message(
+                out=update.out,
+                mentioned=update.mentioned,
+                media_unread=update.media_unread,
+                silent=update.silent,
+                id=update.id,
+                from_id=types.PeerUser(self_id if update.out else update.from_id),
+                peer_id=types.PeerChat(update.chat_id),
+                message=update.message,
+                date=update.date,
+                fwd_from=update.fwd_from,
+                via_bot_id=update.via_bot_id,
+                reply_to=update.reply_to,
+                entities=update.entities,
+                ttl_period=update.ttl_period
+            ))
+        else:
+            return
+
+        return event
+
+    def filter(self, event):
+        if self._no_check:
+            return event
+
+        if self.incoming and event.message.out:
+            return
+        if self.outgoing and not event.message.out:
+            return
+        if self.forwards is not None:
+            if bool(self.forwards) != bool(event.message.fwd_from):
+                return
+
+        if self.from_users is not None:
+            if event.message.sender_id not in self.from_users:
+                return
+
+        if self.pattern:
+            match = self.pattern(event.message.message or '')
+            if not match:
+                return
+            event.pattern_match = match
+
+        return super().filter(event)
+
+    class Event(EventCommon):
+        """
+        Represents the event of a new message. This event can be treated
+        to all effects as a `Message <telethon.tl.custom.message.Message>`,
+        so please **refer to its documentation** to know what you can do
+        with this event.
+
+        Members:
+            message (`Message <telethon.tl.custom.message.Message>`):
+                This is the only difference with the received
+                `Message <telethon.tl.custom.message.Message>`, and will
+                return the `telethon.tl.custom.message.Message` itself,
+                not the text.
+
+                See `Message <telethon.tl.custom.message.Message>` for
+                the rest of available members and methods.
+
+            pattern_match (`obj`):
+                The resulting object from calling the passed ``pattern`` function.
+                Here's an example using a string (defaults to regex match):
+
+                >>> from telethon import TelegramClient, events
+                >>> client = TelegramClient(...)
+                >>>
+                >>> @client.on(events.NewMessage(pattern=r'hi (\\w+)!'))
+                ... async def handler(event):
+                ...     # In this case, the result is a ``Match`` object
+                ...     # since the `str` pattern was converted into
+                ...     # the ``re.compile(pattern).match`` function.
+                ...     print('Welcomed', event.pattern_match.group(1))
+                ...
+                >>>
+        """
+        def __init__(self, message):
+            self.__dict__['_init'] = False
+            super().__init__(chat_peer=message.peer_id,
+                             msg_id=message.id, broadcast=bool(message.post))
+
+            self.pattern_match = None
+            self.message = message
+
+        def _set_client(self, client):
+            super()._set_client(client)
+            m = self.message
+            m._finish_init(client, self._entities, None)
+            self.__dict__['_init'] = True  # No new attributes can be set
+
+        def __getattr__(self, item):
+            if item in self.__dict__:
+                return self.__dict__[item]
+            else:
+                return getattr(self.message, item)
+
+        def __setattr__(self, name, value):
+            if not self.__dict__['_init'] or name in self.__dict__:
+                self.__dict__[name] = value
+            else:
+                setattr(self.message, name, value)

.venv2/Lib/site-packages/telethon/events/raw.py

@@ -0,0 +1,53 @@
+from .common import EventBuilder
+from .. import utils
+
+
+class Raw(EventBuilder):
+    """
+    Raw events are not actual events. Instead, they are the raw
+    :tl:`Update` object that Telegram sends. You normally shouldn't
+    need these.
+
+    Args:
+        types (`list` | `tuple` | `type`, optional):
+            The type or types that the :tl:`Update` instance must be.
+            Equivalent to ``if not isinstance(update, types): return``.
+
+    Example
+        .. code-block:: python
+
+            from telethon import events
+
+            @client.on(events.Raw)
+            async def handler(update):
+                # Print all incoming updates
+                print(update.stringify())
+    """
+    def __init__(self, types=None, *, func=None):
+        super().__init__(func=func)
+        if not types:
+            self.types = None
+        elif not utils.is_list_like(types):
+            if not isinstance(types, type):
+                raise TypeError('Invalid input type given: {}'.format(types))
+
+            self.types = types
+        else:
+            if not all(isinstance(x, type) for x in types):
+                raise TypeError('Invalid input types given: {}'.format(types))
+
+            self.types = tuple(types)
+
+    async def resolve(self, client):
+        self.resolved = True
+
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        return update
+
+    def filter(self, event):
+        if not self.types or isinstance(event, self.types):
+            if self.func:
+                # Return the result of func directly as it may need to be awaited
+                return self.func(event)
+            return event

.venv2/Lib/site-packages/telethon/events/userupdate.py

@@ -0,0 +1,310 @@
+import datetime
+import functools
+
+from .common import EventBuilder, EventCommon, name_inner_event
+from .. import utils
+from ..tl import types
+from ..tl.custom.sendergetter import SenderGetter
+
+
+# TODO Either the properties are poorly named or they should be
+#      different events, but that would be a breaking change.
+#
+# TODO There are more "user updates", but bundling them all up
+#      in a single place will make it annoying to use (since
+#      the user needs to check for the existence of `None`).
+#
+# TODO Handle UpdateUserBlocked, UpdateUserName, UpdateUserPhone, UpdateUser
+
+def _requires_action(function):
+    @functools.wraps(function)
+    def wrapped(self):
+        return None if self.action is None else function(self)
+
+    return wrapped
+
+
+def _requires_status(function):
+    @functools.wraps(function)
+    def wrapped(self):
+        return None if self.status is None else function(self)
+
+    return wrapped
+
+
+@name_inner_event
+class UserUpdate(EventBuilder):
+    """
+    Occurs whenever a user goes online, starts typing, etc.
+
+    Example
+        .. code-block:: python
+
+            from telethon import events
+
+            @client.on(events.UserUpdate)
+            async def handler(event):
+                # If someone is uploading, say something
+                if event.uploading:
+                    await client.send_message(event.user_id, 'What are you sending?')
+    """
+    @classmethod
+    def build(cls, update, others=None, self_id=None):
+        if isinstance(update, types.UpdateUserStatus):
+            return cls.Event(types.PeerUser(update.user_id),
+                             status=update.status)
+        elif isinstance(update, types.UpdateChannelUserTyping):
+            return cls.Event(update.from_id,
+                             chat_peer=types.PeerChannel(update.channel_id),
+                             typing=update.action)
+        elif isinstance(update, types.UpdateChatUserTyping):
+            return cls.Event(update.from_id,
+                             chat_peer=types.PeerChat(update.chat_id),
+                             typing=update.action)
+        elif isinstance(update, types.UpdateUserTyping):
+            return cls.Event(update.user_id,
+                             typing=update.action)
+
+    class Event(EventCommon, SenderGetter):
+        """
+        Represents the event of a user update
+        such as gone online, started typing, etc.
+
+        Members:
+            status (:tl:`UserStatus`, optional):
+                The user status if the update is about going online or offline.
+
+                You should check this attribute first before checking any
+                of the seen within properties, since they will all be `None`
+                if the status is not set.
+
+            action (:tl:`SendMessageAction`, optional):
+                The "typing" action if any the user is performing if any.
+
+                You should check this attribute first before checking any
+                of the typing properties, since they will all be `None`
+                if the action is not set.
+        """
+        def __init__(self, peer, *, status=None, chat_peer=None, typing=None):
+            super().__init__(chat_peer or peer)
+            SenderGetter.__init__(self, utils.get_peer_id(peer))
+
+            self.status = status
+            self.action = typing
+
+        def _set_client(self, client):
+            super()._set_client(client)
+            self._sender, self._input_sender = utils._get_entity_pair(
+                self.sender_id, self._entities, client._mb_entity_cache)
+
+        @property
+        def user(self):
+            """Alias for `sender <telethon.tl.custom.sendergetter.SenderGetter.sender>`."""
+            return self.sender
+
+        async def get_user(self):
+            """Alias for `get_sender <telethon.tl.custom.sendergetter.SenderGetter.get_sender>`."""
+            return await self.get_sender()
+
+        @property
+        def input_user(self):
+            """Alias for `input_sender <telethon.tl.custom.sendergetter.SenderGetter.input_sender>`."""
+            return self.input_sender
+
+        async def get_input_user(self):
+            """Alias for `get_input_sender <telethon.tl.custom.sendergetter.SenderGetter.get_input_sender>`."""
+            return await self.get_input_sender()
+
+        @property
+        def user_id(self):
+            """Alias for `sender_id <telethon.tl.custom.sendergetter.SenderGetter.sender_id>`."""
+            return self.sender_id
+
+        @property
+        @_requires_action
+        def typing(self):
+            """
+            `True` if the action is typing a message.
+            """
+            return isinstance(self.action, types.SendMessageTypingAction)
+
+        @property
+        @_requires_action
+        def uploading(self):
+            """
+            `True` if the action is uploading something.
+            """
+            return isinstance(self.action, (
+                types.SendMessageChooseContactAction,
+                types.SendMessageChooseStickerAction,
+                types.SendMessageUploadAudioAction,
+                types.SendMessageUploadDocumentAction,
+                types.SendMessageUploadPhotoAction,
+                types.SendMessageUploadRoundAction,
+                types.SendMessageUploadVideoAction
+            ))
+
+        @property
+        @_requires_action
+        def recording(self):
+            """
+            `True` if the action is recording something.
+            """
+            return isinstance(self.action, (
+                types.SendMessageRecordAudioAction,
+                types.SendMessageRecordRoundAction,
+                types.SendMessageRecordVideoAction
+            ))
+
+        @property
+        @_requires_action
+        def playing(self):
+            """
+            `True` if the action is playing a game.
+            """
+            return isinstance(self.action, types.SendMessageGamePlayAction)
+
+        @property
+        @_requires_action
+        def cancel(self):
+            """
+            `True` if the action was cancelling other actions.
+            """
+            return isinstance(self.action, types.SendMessageCancelAction)
+
+        @property
+        @_requires_action
+        def geo(self):
+            """
+            `True` if what's being uploaded is a geo.
+            """
+            return isinstance(self.action, types.SendMessageGeoLocationAction)
+
+        @property
+        @_requires_action
+        def audio(self):
+            """
+            `True` if what's being recorded/uploaded is an audio.
+            """
+            return isinstance(self.action, (
+                types.SendMessageRecordAudioAction,
+                types.SendMessageUploadAudioAction
+            ))
+
+        @property
+        @_requires_action
+        def round(self):
+            """
+            `True` if what's being recorded/uploaded is a round video.
+            """
+            return isinstance(self.action, (
+                types.SendMessageRecordRoundAction,
+                types.SendMessageUploadRoundAction
+            ))
+
+        @property
+        @_requires_action
+        def video(self):
+            """
+            `True` if what's being recorded/uploaded is an video.
+            """
+            return isinstance(self.action, (
+                types.SendMessageRecordVideoAction,
+                types.SendMessageUploadVideoAction
+            ))
+
+        @property
+        @_requires_action
+        def contact(self):
+            """
+            `True` if what's being uploaded (selected) is a contact.
+            """
+            return isinstance(self.action, types.SendMessageChooseContactAction)
+
+        @property
+        @_requires_action
+        def document(self):
+            """
+            `True` if what's being uploaded is document.
+            """
+            return isinstance(self.action, types.SendMessageUploadDocumentAction)
+
+        @property
+        @_requires_action
+        def sticker(self):
+            """
+            `True` if what's being uploaded is a sticker.
+            """
+            return isinstance(self.action, types.SendMessageChooseStickerAction)
+
+        @property
+        @_requires_action
+        def photo(self):
+            """
+            `True` if what's being uploaded is a photo.
+            """
+            return isinstance(self.action, types.SendMessageUploadPhotoAction)
+
+        @property
+        @_requires_status
+        def last_seen(self):
+            """
+            Exact `datetime.datetime` when the user was last seen if known.
+            """
+            if isinstance(self.status, types.UserStatusOffline):
+                return self.status.was_online
+
+        @property
+        @_requires_status
+        def until(self):
+            """
+            The `datetime.datetime` until when the user should appear online.
+            """
+            if isinstance(self.status, types.UserStatusOnline):
+                return self.status.expires
+
+        def _last_seen_delta(self):
+            if isinstance(self.status, types.UserStatusOffline):
+                return datetime.datetime.now(tz=datetime.timezone.utc) - self.status.was_online
+            elif isinstance(self.status, types.UserStatusOnline):
+                return datetime.timedelta(days=0)
+            elif isinstance(self.status, types.UserStatusRecently):
+                return datetime.timedelta(days=1)
+            elif isinstance(self.status, types.UserStatusLastWeek):
+                return datetime.timedelta(days=7)
+            elif isinstance(self.status, types.UserStatusLastMonth):
+                return datetime.timedelta(days=30)
+            else:
+                return datetime.timedelta(days=365)
+
+        @property
+        @_requires_status
+        def online(self):
+            """
+            `True` if the user is currently online,
+            """
+            return self._last_seen_delta() <= datetime.timedelta(days=0)
+
+        @property
+        @_requires_status
+        def recently(self):
+            """
+            `True` if the user was seen within a day.
+            """
+            return self._last_seen_delta() <= datetime.timedelta(days=1)
+
+        @property
+        @_requires_status
+        def within_weeks(self):
+            """
+            `True` if the user was seen within 7 days.
+            """
+            return self._last_seen_delta() <= datetime.timedelta(days=7)
+
+        @property
+        @_requires_status
+        def within_months(self):
+            """
+            `True` if the user was seen within 30 days.
+            """
+            return self._last_seen_delta() <= datetime.timedelta(days=30)

.venv2/Lib/site-packages/telethon/extensions/__init__.py

@@ -0,0 +1,6 @@
+"""
+Several extensions Python is missing, such as a proper class to handle a TCP
+communication with support for cancelling the operation, and a utility class
+to read arbitrary binary data in a more comfortable way, with int/strings/etc.
+"""
+from .binaryreader import BinaryReader

.venv2/Lib/site-packages/telethon/extensions/binaryreader.py

@@ -0,0 +1,185 @@
+"""
+This module contains the BinaryReader utility class.
+"""
+import os
+import time
+from datetime import datetime, timezone, timedelta
+from io import BytesIO
+from struct import unpack
+
+from ..errors import TypeNotFoundError
+from ..tl.alltlobjects import tlobjects
+from ..tl.core import core_objects
+
+_EPOCH_NAIVE = datetime(*time.gmtime(0)[:6])
+_EPOCH = _EPOCH_NAIVE.replace(tzinfo=timezone.utc)
+
+
+class BinaryReader:
+    """
+    Small utility class to read binary data.
+    """
+
+    def __init__(self, data):
+        self.stream = BytesIO(data)
+        self._last = None  # Should come in handy to spot -404 errors
+
+    # region Reading
+
+    # "All numbers are written as little endian."
+    # https://core.telegram.org/mtproto
+    def read_byte(self):
+        """Reads a single byte value."""
+        return self.read(1)[0]
+
+    def read_int(self, signed=True):
+        """Reads an integer (4 bytes) value."""
+        return int.from_bytes(self.read(4), byteorder='little', signed=signed)
+
+    def read_long(self, signed=True):
+        """Reads a long integer (8 bytes) value."""
+        return int.from_bytes(self.read(8), byteorder='little', signed=signed)
+
+    def read_float(self):
+        """Reads a real floating point (4 bytes) value."""
+        return unpack('<f', self.read(4))[0]
+
+    def read_double(self):
+        """Reads a real floating point (8 bytes) value."""
+        return unpack('<d', self.read(8))[0]
+
+    def read_large_int(self, bits, signed=True):
+        """Reads a n-bits long integer value."""
+        return int.from_bytes(
+            self.read(bits // 8), byteorder='little', signed=signed)
+
+    def read(self, length=-1):
+        """Read the given amount of bytes, or -1 to read all remaining."""
+        result = self.stream.read(length)
+        if (length >= 0) and (len(result) != length):
+            raise BufferError(
+                'No more data left to read (need {}, got {}: {}); last read {}'
+                .format(length, len(result), repr(result), repr(self._last))
+            )
+
+        self._last = result
+        return result
+
+    def get_bytes(self):
+        """Gets the byte array representing the current buffer as a whole."""
+        return self.stream.getvalue()
+
+    # endregion
+
+    # region Telegram custom reading
+
+    def tgread_bytes(self):
+        """
+        Reads a Telegram-encoded byte array, without the need of
+        specifying its length.
+        """
+        first_byte = self.read_byte()
+        if first_byte == 254:
+            length = self.read_byte() | (self.read_byte() << 8) | (
+                self.read_byte() << 16)
+            padding = length % 4
+        else:
+            length = first_byte
+            padding = (length + 1) % 4
+
+        data = self.read(length)
+        if padding > 0:
+            padding = 4 - padding
+            self.read(padding)
+
+        return data
+
+    def tgread_string(self):
+        """Reads a Telegram-encoded string."""
+        return str(self.tgread_bytes(), encoding='utf-8', errors='replace')
+
+    def tgread_bool(self):
+        """Reads a Telegram boolean value."""
+        value = self.read_int(signed=False)
+        if value == 0x997275b5:  # boolTrue
+            return True
+        elif value == 0xbc799737:  # boolFalse
+            return False
+        else:
+            raise RuntimeError('Invalid boolean code {}'.format(hex(value)))
+
+    def tgread_date(self):
+        """Reads and converts Unix time (used by Telegram)
+           into a Python datetime object.
+        """
+        value = self.read_int()
+        return _EPOCH + timedelta(seconds=value)
+
+    def tgread_object(self):
+        """Reads a Telegram object."""
+        constructor_id = self.read_int(signed=False)
+        clazz = tlobjects.get(constructor_id, None)
+        if clazz is None:
+            # The class was None, but there's still a
+            # chance of it being a manually parsed value like bool!
+            value = constructor_id
+            if value == 0x997275b5:  # boolTrue
+                return True
+            elif value == 0xbc799737:  # boolFalse
+                return False
+            elif value == 0x1cb5c415:  # Vector
+                return [self.tgread_object() for _ in range(self.read_int())]
+
+            clazz = core_objects.get(constructor_id, None)
+            if clazz is None:
+                # If there was still no luck, give up
+                self.seek(-4)  # Go back
+                pos = self.tell_position()
+                error = TypeNotFoundError(constructor_id, self.read())
+                self.set_position(pos)
+                raise error
+
+        return clazz.from_reader(self)
+
+    def tgread_vector(self):
+        """Reads a vector (a list) of Telegram objects."""
+        if 0x1cb5c415 != self.read_int(signed=False):
+            raise RuntimeError('Invalid constructor code, vector was expected')
+
+        count = self.read_int()
+        return [self.tgread_object() for _ in range(count)]
+
+    # endregion
+
+    def close(self):
+        """Closes the reader, freeing the BytesIO stream."""
+        self.stream.close()
+
+    # region Position related
+
+    def tell_position(self):
+        """Tells the current position on the stream."""
+        return self.stream.tell()
+
+    def set_position(self, position):
+        """Sets the current position on the stream."""
+        self.stream.seek(position)
+
+    def seek(self, offset):
+        """
+        Seeks the stream position given an offset from the current position.
+        The offset may be negative.
+        """
+        self.stream.seek(offset, os.SEEK_CUR)
+
+    # endregion
+
+    # region with block
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    # endregion

.venv2/Lib/site-packages/telethon/extensions/html.py

@@ -0,0 +1,195 @@
+"""
+Simple HTML -> Telegram entity parser.
+"""
+import struct
+from collections import deque
+from html import escape
+from html.parser import HTMLParser
+from typing import Iterable, Optional, Tuple, List
+
+from ..helpers import add_surrogate, del_surrogate, within_surrogate, strip_text
+from ..tl import TLObject
+from ..tl.types import (
+    MessageEntityBold, MessageEntityItalic, MessageEntityCode,
+    MessageEntityPre, MessageEntityEmail, MessageEntityUrl,
+    MessageEntityTextUrl, MessageEntityMentionName,
+    MessageEntityUnderline, MessageEntityStrike, MessageEntityBlockquote,
+    TypeMessageEntity
+)
+
+
+class HTMLToTelegramParser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.text = ''
+        self.entities = []
+        self._building_entities = {}
+        self._open_tags = deque()
+        self._open_tags_meta = deque()
+
+    def handle_starttag(self, tag, attrs):
+        self._open_tags.appendleft(tag)
+        self._open_tags_meta.appendleft(None)
+
+        attrs = dict(attrs)
+        EntityType = None
+        args = {}
+        if tag == 'strong' or tag == 'b':
+            EntityType = MessageEntityBold
+        elif tag == 'em' or tag == 'i':
+            EntityType = MessageEntityItalic
+        elif tag == 'u':
+            EntityType = MessageEntityUnderline
+        elif tag == 'del' or tag == 's':
+            EntityType = MessageEntityStrike
+        elif tag == 'blockquote':
+            EntityType = MessageEntityBlockquote
+        elif tag == 'code':
+            try:
+                # If we're in the middle of a <pre> tag, this <code> tag is
+                # probably intended for syntax highlighting.
+                #
+                # Syntax highlighting is set with
+                #     <code class='language-...'>codeblock</code>
+                # inside <pre> tags
+                pre = self._building_entities['pre']
+                try:
+                    pre.language = attrs['class'][len('language-'):]
+                except KeyError:
+                    pass
+            except KeyError:
+                EntityType = MessageEntityCode
+        elif tag == 'pre':
+            EntityType = MessageEntityPre
+            args['language'] = ''
+        elif tag == 'a':
+            try:
+                url = attrs['href']
+            except KeyError:
+                return
+            if url.startswith('mailto:'):
+                url = url[len('mailto:'):]
+                EntityType = MessageEntityEmail
+            else:
+                if self.get_starttag_text() == url:
+                    EntityType = MessageEntityUrl
+                else:
+                    EntityType = MessageEntityTextUrl
+                    args['url'] = del_surrogate(url)
+                    url = None
+            self._open_tags_meta.popleft()
+            self._open_tags_meta.appendleft(url)
+
+        if EntityType and tag not in self._building_entities:
+            self._building_entities[tag] = EntityType(
+                offset=len(self.text),
+                # The length will be determined when closing the tag.
+                length=0,
+                **args)
+
+    def handle_data(self, text):
+        previous_tag = self._open_tags[0] if len(self._open_tags) > 0 else ''
+        if previous_tag == 'a':
+            url = self._open_tags_meta[0]
+            if url:
+                text = url
+
+        for tag, entity in self._building_entities.items():
+            entity.length += len(text)
+
+        self.text += text
+
+    def handle_endtag(self, tag):
+        try:
+            self._open_tags.popleft()
+            self._open_tags_meta.popleft()
+        except IndexError:
+            pass
+        entity = self._building_entities.pop(tag, None)
+        if entity:
+            self.entities.append(entity)
+
+
+def parse(html: str) -> Tuple[str, List[TypeMessageEntity]]:
+    """
+    Parses the given HTML message and returns its stripped representation
+    plus a list of the MessageEntity's that were found.
+
+    :param html: the message with HTML to be parsed.
+    :return: a tuple consisting of (clean message, [message entities]).
+    """
+    if not html:
+        return html, []
+
+    parser = HTMLToTelegramParser()
+    parser.feed(add_surrogate(html))
+    text = strip_text(parser.text, parser.entities)
+    parser.entities.reverse()
+    parser.entities.sort(key=lambda entity: entity.offset)
+    return del_surrogate(text), parser.entities
+
+
+ENTITY_TO_FORMATTER = {
+    MessageEntityBold: ('<strong>', '</strong>'),
+    MessageEntityItalic: ('<em>', '</em>'),
+    MessageEntityCode: ('<code>', '</code>'),
+    MessageEntityUnderline: ('<u>', '</u>'),
+    MessageEntityStrike: ('<del>', '</del>'),
+    MessageEntityBlockquote: ('<blockquote>', '</blockquote>'),
+    MessageEntityPre: lambda e, _: (
+        "<pre>\n"
+        "    <code class='language-{}'>\n"
+        "        ".format(e.language), "{}\n"
+        "    </code>\n"
+        "</pre>"
+    ),
+    MessageEntityEmail: lambda _, t: ('<a href="mailto:{}">'.format(t), '</a>'),
+    MessageEntityUrl: lambda _, t: ('<a href="{}">'.format(t), '</a>'),
+    MessageEntityTextUrl: lambda e, _: ('<a href="{}">'.format(escape(e.url)), '</a>'),
+    MessageEntityMentionName: lambda e, _: ('<a href="tg://user?id={}">'.format(e.user_id), '</a>'),
+}
+
+
+def unparse(text: str, entities: Iterable[TypeMessageEntity]) -> str:
+    """
+    Performs the reverse operation to .parse(), effectively returning HTML
+    given a normal text and its MessageEntity's.
+
+    :param text: the text to be reconverted into HTML.
+    :param entities: the MessageEntity's applied to the text.
+    :return: a HTML representation of the combination of both inputs.
+    """
+    if not text:
+        return text
+    elif not entities:
+        return escape(text)
+
+    if isinstance(entities, TLObject):
+        entities = (entities,)
+
+    text = add_surrogate(text)
+    insert_at = []
+    for i, entity in enumerate(entities):
+        s = entity.offset
+        e = entity.offset + entity.length
+        delimiter = ENTITY_TO_FORMATTER.get(type(entity), None)
+        if delimiter:
+            if callable(delimiter):
+                delimiter = delimiter(entity, text[s:e])
+            insert_at.append((s, i, delimiter[0]))
+            insert_at.append((e, -i, delimiter[1]))
+
+    insert_at.sort(key=lambda t: (t[0], t[1]))
+    next_escape_bound = len(text)
+    while insert_at:
+        # Same logic as markdown.py
+        at, _, what = insert_at.pop()
+        while within_surrogate(text, at):
+            at += 1
+
+        text = text[:at] + what + escape(text[at:next_escape_bound]) + text[next_escape_bound:]
+        next_escape_bound = at
+
+    text = escape(text[:next_escape_bound]) + text[next_escape_bound:]
+
+    return del_surrogate(text)

.venv2/Lib/site-packages/telethon/extensions/markdown.py

@@ -0,0 +1,197 @@
+"""
+Simple markdown parser which does not support nesting. Intended primarily
+for use within the library, which attempts to handle emojies correctly,
+since they seem to count as two characters and it's a bit strange.
+"""
+import re
+import warnings
+
+from ..helpers import add_surrogate, del_surrogate, within_surrogate, strip_text
+from ..tl import TLObject
+from ..tl.types import (
+    MessageEntityBold, MessageEntityItalic, MessageEntityCode,
+    MessageEntityPre, MessageEntityTextUrl, MessageEntityMentionName,
+    MessageEntityStrike
+)
+
+DEFAULT_DELIMITERS = {
+    '**': MessageEntityBold,
+    '__': MessageEntityItalic,
+    '~~': MessageEntityStrike,
+    '`': MessageEntityCode,
+    '```': MessageEntityPre
+}
+
+DEFAULT_URL_RE = re.compile(r'\[([^\]]+)\]\(([^)]+)\)')
+DEFAULT_URL_FORMAT = '[{0}]({1})'
+
+
+def overlap(a, b, x, y):
+    return max(a, x) < min(b, y)
+
+
+def parse(message, delimiters=None, url_re=None):
+    """
+    Parses the given markdown message and returns its stripped representation
+    plus a list of the MessageEntity's that were found.
+
+    :param message: the message with markdown-like syntax to be parsed.
+    :param delimiters: the delimiters to be used, {delimiter: type}.
+    :param url_re: the URL bytes regex to be used. Must have two groups.
+    :return: a tuple consisting of (clean message, [message entities]).
+    """
+    if not message:
+        return message, []
+
+    if url_re is None:
+        url_re = DEFAULT_URL_RE
+    elif isinstance(url_re, str):
+        url_re = re.compile(url_re)
+
+    if not delimiters:
+        if delimiters is not None:
+            return message, []
+        delimiters = DEFAULT_DELIMITERS
+
+    # Build a regex to efficiently test all delimiters at once.
+    # Note that the largest delimiter should go first, we don't
+    # want ``` to be interpreted as a single back-tick in a code block.
+    delim_re = re.compile('|'.join('({})'.format(re.escape(k))
+                                   for k in sorted(delimiters, key=len, reverse=True)))
+
+    # Cannot use a for loop because we need to skip some indices
+    i = 0
+    result = []
+
+    # Work on byte level with the utf-16le encoding to get the offsets right.
+    # The offset will just be half the index we're at.
+    message = add_surrogate(message)
+    while i < len(message):
+        m = delim_re.match(message, pos=i)
+
+        # Did we find some delimiter here at `i`?
+        if m:
+            delim = next(filter(None, m.groups()))
+
+            # +1 to avoid matching right after (e.g. "****")
+            end = message.find(delim, i + len(delim) + 1)
+
+            # Did we find the earliest closing tag?
+            if end != -1:
+
+                # Remove the delimiter from the string
+                message = ''.join((
+                        message[:i],
+                        message[i + len(delim):end],
+                        message[end + len(delim):]
+                ))
+
+                # Check other affected entities
+                for ent in result:
+                    # If the end is after our start, it is affected
+                    if ent.offset + ent.length > i:
+                        # If the old start is also before ours, it is fully enclosed
+                        if ent.offset <= i:
+                            ent.length -= len(delim) * 2
+                        else:
+                            ent.length -= len(delim)
+
+                # Append the found entity
+                ent = delimiters[delim]
+                if ent == MessageEntityPre:
+                    result.append(ent(i, end - i - len(delim), ''))  # has 'lang'
+                else:
+                    result.append(ent(i, end - i - len(delim)))
+
+                # No nested entities inside code blocks
+                if ent in (MessageEntityCode, MessageEntityPre):
+                    i = end - len(delim)
+
+                continue
+
+        elif url_re:
+            m = url_re.match(message, pos=i)
+            if m:
+                # Replace the whole match with only the inline URL text.
+                message = ''.join((
+                    message[:m.start()],
+                    m.group(1),
+                    message[m.end():]
+                ))
+
+                delim_size = m.end() - m.start() - len(m.group())
+                for ent in result:
+                    # If the end is after our start, it is affected
+                    if ent.offset + ent.length > m.start():
+                        ent.length -= delim_size
+
+                result.append(MessageEntityTextUrl(
+                    offset=m.start(), length=len(m.group(1)),
+                    url=del_surrogate(m.group(2))
+                ))
+                i += len(m.group(1))
+                continue
+
+        i += 1
+
+    message = strip_text(message, result)
+    return del_surrogate(message), result
+
+
+def unparse(text, entities, delimiters=None, url_fmt=None):
+    """
+    Performs the reverse operation to .parse(), effectively returning
+    markdown-like syntax given a normal text and its MessageEntity's.
+
+    :param text: the text to be reconverted into markdown.
+    :param entities: the MessageEntity's applied to the text.
+    :return: a markdown-like text representing the combination of both inputs.
+    """
+    if not text or not entities:
+        return text
+
+    if not delimiters:
+        if delimiters is not None:
+            return text
+        delimiters = DEFAULT_DELIMITERS
+
+    if url_fmt is not None:
+        warnings.warn('url_fmt is deprecated')  # since it complicates everything *a lot*
+
+    if isinstance(entities, TLObject):
+        entities = (entities,)
+
+    text = add_surrogate(text)
+    delimiters = {v: k for k, v in delimiters.items()}
+    insert_at = []
+    for i, entity in enumerate(entities):
+        s = entity.offset
+        e = entity.offset + entity.length
+        delimiter = delimiters.get(type(entity), None)
+        if delimiter:
+            insert_at.append((s, i, delimiter))
+            insert_at.append((e, -i, delimiter))
+        else:
+            url = None
+            if isinstance(entity, MessageEntityTextUrl):
+                url = entity.url
+            elif isinstance(entity, MessageEntityMentionName):
+                url = 'tg://user?id={}'.format(entity.user_id)
+            if url:
+                insert_at.append((s, i, '['))
+                insert_at.append((e, -i, ']({})'.format(url)))
+
+    insert_at.sort(key=lambda t: (t[0], t[1]))
+    while insert_at:
+        at, _, what = insert_at.pop()
+
+        # If we are in the middle of a surrogate nudge the position by -1.
+        # Otherwise we would end up with malformed text and fail to encode.
+        # For example of bad input: "Hi \ud83d\ude1c"
+        # https://en.wikipedia.org/wiki/UTF-16#U+010000_to_U+10FFFF
+        while within_surrogate(text, at):
+            at += 1
+
+        text = text[:at] + what + text[at:]
+
+    return del_surrogate(text)

.venv2/Lib/site-packages/telethon/extensions/messagepacker.py

@@ -0,0 +1,111 @@
+import asyncio
+import collections
+import io
+import struct
+
+from ..tl import TLRequest
+from ..tl.core.messagecontainer import MessageContainer
+from ..tl.core.tlmessage import TLMessage
+
+
+class MessagePacker:
+    """
+    This class packs `RequestState` as outgoing `TLMessages`.
+
+    The purpose of this class is to support putting N `RequestState` into a
+    queue, and then awaiting for "packed" `TLMessage` in the other end. The
+    simplest case would be ``State -> TLMessage`` (1-to-1 relationship) but
+    for efficiency purposes it's ``States -> Container`` (N-to-1).
+
+    This addresses several needs: outgoing messages will be smaller, so the
+    encryption and network overhead also is smaller. It's also a central
+    point where outgoing requests are put, and where ready-messages are get.
+    """
+
+    def __init__(self, state, loggers):
+        self._state = state
+        self._deque = collections.deque()
+        self._ready = asyncio.Event()
+        self._log = loggers[__name__]
+
+    def append(self, state):
+        self._deque.append(state)
+        self._ready.set()
+
+    def extend(self, states):
+        self._deque.extend(states)
+        self._ready.set()
+
+    async def get(self):
+        """
+        Returns (batch, data) if one or more items could be retrieved.
+
+        If the cancellation occurs or only invalid items were in the
+        queue, (None, None) will be returned instead.
+        """
+        if not self._deque:
+            self._ready.clear()
+            await self._ready.wait()
+
+        buffer = io.BytesIO()
+        batch = []
+        size = 0
+
+        # Fill a new batch to return while the size is small enough,
+        # as long as we don't exceed the maximum length of messages.
+        while self._deque and len(batch) <= MessageContainer.MAXIMUM_LENGTH:
+            state = self._deque.popleft()
+            size += len(state.data) + TLMessage.SIZE_OVERHEAD
+
+            if size <= MessageContainer.MAXIMUM_SIZE:
+                state.msg_id = self._state.write_data_as_message(
+                    buffer, state.data, isinstance(state.request, TLRequest),
+                    after_id=state.after.msg_id if state.after else None
+                )
+                batch.append(state)
+                self._log.debug('Assigned msg_id = %d to %s (%x)',
+                                state.msg_id, state.request.__class__.__name__,
+                                id(state.request))
+                continue
+
+            if batch:
+                # Put the item back since it can't be sent in this batch
+                self._deque.appendleft(state)
+                break
+
+            # If a single message exceeds the maximum size, then the
+            # message payload cannot be sent. Telegram would forcibly
+            # close the connection; message would never be confirmed.
+            #
+            # We don't put the item back because it can never be sent.
+            # If we did, we would loop again and reach this same path.
+            # Setting the exception twice results in `InvalidStateError`
+            # and this method should never return with error, which we
+            # really want to avoid.
+            self._log.warning(
+                'Message payload for %s is too long (%d) and cannot be sent',
+                state.request.__class__.__name__, len(state.data)
+            )
+            state.future.set_exception(
+                ValueError('Request payload is too big'))
+
+            size = 0
+            continue
+
+        if not batch:
+            return None, None
+
+        if len(batch) > 1:
+            # Inlined code to pack several messages into a container
+            data = struct.pack(
+                '<Ii', MessageContainer.CONSTRUCTOR_ID, len(batch)
+            ) + buffer.getvalue()
+            buffer = io.BytesIO()
+            container_id = self._state.write_data_as_message(
+                buffer, data, content_related=False
+            )
+            for s in batch:
+                s.container_id = container_id
+
+        data = buffer.getvalue()
+        return batch, data

.venv2/Lib/site-packages/telethon/functions.py

@@ -0,0 +1 @@
+from .tl.functions import *

.venv2/Lib/site-packages/telethon/helpers.py

@@ -0,0 +1,434 @@
+"""Various helpers not related to the Telegram API itself"""
+import asyncio
+import io
+import enum
+import os
+import struct
+import inspect
+import logging
+import functools
+import sys
+from pathlib import Path
+from hashlib import sha1
+
+
+class _EntityType(enum.Enum):
+    USER = 0
+    CHAT = 1
+    CHANNEL = 2
+
+
+_log = logging.getLogger(__name__)
+
+
+# region Multiple utilities
+
+
+def generate_random_long(signed=True):
+    """Generates a random long integer (8 bytes), which is optionally signed"""
+    return int.from_bytes(os.urandom(8), signed=signed, byteorder='little')
+
+
+def ensure_parent_dir_exists(file_path):
+    """Ensures that the parent directory exists"""
+    parent = os.path.dirname(file_path)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+
+def add_surrogate(text):
+    return ''.join(
+        # SMP -> Surrogate Pairs (Telegram offsets are calculated with these).
+        # See https://en.wikipedia.org/wiki/Plane_(Unicode)#Overview for more.
+        ''.join(chr(y) for y in struct.unpack('<HH', x.encode('utf-16le')))
+        if (0x10000 <= ord(x) <= 0x10FFFF) else x for x in text
+    )
+
+
+def del_surrogate(text):
+    return text.encode('utf-16', 'surrogatepass').decode('utf-16')
+
+
+def within_surrogate(text, index, *, length=None):
+    """
+    `True` if ``index`` is within a surrogate (before and after it, not at!).
+    """
+    if length is None:
+        length = len(text)
+
+    return (
+            1 < index < len(text) and  # in bounds
+            '\ud800' <= text[index - 1] <= '\udbff' and  # previous is
+            '\ud800' <= text[index] <= '\udfff'  # current is
+    )
+
+
+def strip_text(text, entities):
+    """
+    Strips whitespace from the given surrogated text modifying the provided
+    entities, also removing any empty (0-length) entities.
+
+    This assumes that the length of entities is greater or equal to 0, and
+    that no entity is out of bounds.
+    """
+    if not entities:
+        return text.strip()
+
+    len_ori = len(text)
+    text = text.lstrip()
+    left_offset = len_ori - len(text)
+    text = text.rstrip()
+    len_final = len(text)
+
+    for i in reversed(range(len(entities))):
+        e = entities[i]
+        if e.length == 0:
+            del entities[i]
+            continue
+
+        if e.offset + e.length > left_offset:
+            if e.offset >= left_offset:
+                #  0 1|2 3 4 5       |       0 1|2 3 4 5
+                #     ^     ^        |          ^
+                #   lo(2)  o(5)      |      o(2)/lo(2)
+                e.offset -= left_offset
+                #     |0 1 2 3       |          |0 1 2 3
+                #           ^        |          ^
+                #     o=o-lo(3=5-2)  |    o=o-lo(0=2-2)
+            else:
+                # e.offset < left_offset and e.offset + e.length > left_offset
+                #  0 1 2 3|4 5 6 7 8 9 10
+                #   ^     ^           ^
+                #  o(1) lo(4)      o+l(1+9)
+                e.length = e.offset + e.length - left_offset
+                e.offset = 0
+                #         |0 1 2 3 4 5 6
+                #         ^           ^
+                #        o(0)  o+l=0+o+l-lo(6=0+6=0+1+9-4)
+        else:
+            # e.offset + e.length <= left_offset
+            #   0 1 2 3|4 5
+            #  ^       ^
+            # o(0)   o+l(4)
+            #        lo(4)
+            del entities[i]
+            continue
+
+        if e.offset + e.length <= len_final:
+            # |0 1 2 3 4 5 6 7 8 9
+            #   ^                 ^
+            #  o(1)       o+l(1+9)/lf(10)
+            continue
+        if e.offset >= len_final:
+            # |0 1 2 3 4
+            #           ^
+            #       o(5)/lf(5)
+            del entities[i]
+        else:
+            # e.offset < len_final and e.offset + e.length > len_final
+            # |0 1 2 3 4 5 (6) (7) (8) (9)
+            #   ^         ^           ^
+            #  o(1)     lf(6)      o+l(1+8)
+            e.length = len_final - e.offset
+            # |0 1 2 3 4 5
+            #   ^         ^
+            #  o(1) o+l=o+lf-o=lf(6=1+5=1+6-1)
+
+    return text
+
+
+def retry_range(retries, force_retry=True):
+    """
+    Generates an integer sequence starting from 1. If `retries` is
+    not a zero or a positive integer value, the sequence will be
+    infinite, otherwise it will end at `retries + 1`.
+    """
+
+    # We need at least one iteration even if the retries are 0
+    # when force_retry is True.
+    if force_retry and not (retries is None or retries < 0):
+        retries += 1
+
+    attempt = 0
+    while attempt != retries:
+        attempt += 1
+        yield attempt
+
+
+
+async def _maybe_await(value):
+    if inspect.isawaitable(value):
+        return await value
+    else:
+        return value
+
+
+async def _cancel(log, **tasks):
+    """
+    Helper to cancel one or more tasks gracefully, logging exceptions.
+    """
+    for name, task in tasks.items():
+        if not task:
+            continue
+
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+        except RuntimeError:
+            # Probably: RuntimeError: await wasn't used with future
+            #
+            # See: https://github.com/python/cpython/blob/12d3061c7819a73d891dcce44327410eaf0e1bc2/Lib/asyncio/futures.py#L265
+            #
+            # Happens with _asyncio.Task instances (in "Task cancelling" state)
+            # trying to SIGINT the program right during initial connection, on
+            # _recv_loop coroutine (but we're creating its task explicitly with
+            # a loop, so how can it bug out like this?).
+            #
+            # Since we're aware of this error there's no point in logging it.
+            # *May* be https://bugs.python.org/issue37172
+            pass
+        except AssertionError as e:
+            # In Python 3.6, the above RuntimeError is an AssertionError
+            # See https://github.com/python/cpython/blob/7df32f844efed33ca781a016017eab7050263b90/Lib/asyncio/futures.py#L328
+            if e.args != ("yield from wasn't used with future",):
+                log.exception('Unhandled exception from %s after cancelling '
+                              '%s (%s)', name, type(task), task)
+        except Exception:
+            log.exception('Unhandled exception from %s after cancelling '
+                          '%s (%s)', name, type(task), task)
+
+
+def _sync_enter(self):
+    """
+    Helps to cut boilerplate on async context
+    managers that offer synchronous variants.
+    """
+    if hasattr(self, 'loop'):
+        loop = self.loop
+    else:
+        loop = self._client.loop
+
+    if loop.is_running():
+        raise RuntimeError(
+            'You must use "async with" if the event loop '
+            'is running (i.e. you are inside an "async def")'
+        )
+
+    return loop.run_until_complete(self.__aenter__())
+
+
+def _sync_exit(self, *args):
+    if hasattr(self, 'loop'):
+        loop = self.loop
+    else:
+        loop = self._client.loop
+
+    return loop.run_until_complete(self.__aexit__(*args))
+
+
+def _entity_type(entity):
+    # This could be a `utils` method that just ran a few `isinstance` on
+    # `utils.get_peer(...)`'s result. However, there are *a lot* of auto
+    # casts going on, plenty of calls and temporary short-lived objects.
+    #
+    # So we just check if a string is in the class name.
+    # Still, assert that it's the right type to not return false results.
+    try:
+        if entity.SUBCLASS_OF_ID not in (
+                0x2d45687,  # crc32(b'Peer')
+                0xc91c90b6,  # crc32(b'InputPeer')
+                0xe669bf46,  # crc32(b'InputUser')
+                0x40f202fd,  # crc32(b'InputChannel')
+                0x2da17977,  # crc32(b'User')
+                0xc5af5d94,  # crc32(b'Chat')
+                0x1f4661b9,  # crc32(b'UserFull')
+                0xd49a2697,  # crc32(b'ChatFull')
+        ):
+            raise TypeError('{} does not have any entity type'.format(entity))
+    except AttributeError:
+        raise TypeError('{} is not a TLObject, cannot determine entity type'.format(entity))
+
+    name = entity.__class__.__name__
+    if 'User' in name:
+        return _EntityType.USER
+    elif 'Chat' in name:
+        return _EntityType.CHAT
+    elif 'Channel' in name:
+        return _EntityType.CHANNEL
+    elif 'Self' in name:
+        return _EntityType.USER
+
+    # 'Empty' in name or not found, we don't care, not a valid entity.
+    raise TypeError('{} does not have any entity type'.format(entity))
+
+# endregion
+
+# region Cryptographic related utils
+
+
+def generate_key_data_from_nonce(server_nonce, new_nonce):
+    """Generates the key data corresponding to the given nonce"""
+    server_nonce = server_nonce.to_bytes(16, 'little', signed=True)
+    new_nonce = new_nonce.to_bytes(32, 'little', signed=True)
+    hash1 = sha1(new_nonce + server_nonce).digest()
+    hash2 = sha1(server_nonce + new_nonce).digest()
+    hash3 = sha1(new_nonce + new_nonce).digest()
+
+    key = hash1 + hash2[:12]
+    iv = hash2[12:20] + hash3 + new_nonce[:4]
+    return key, iv
+
+
+# endregion
+
+# region Custom Classes
+
+
+class TotalList(list):
+    """
+    A list with an extra `total` property, which may not match its `len`
+    since the total represents the total amount of items *available*
+    somewhere else, not the items *in this list*.
+
+    Examples:
+
+        .. code-block:: python
+
+            # Telethon returns these lists in some cases (for example,
+            # only when a chunk is returned, but the "total" count
+            # is available).
+            result = await client.get_messages(chat, limit=10)
+
+            print(result.total)  # large number
+            print(len(result))  # 10
+            print(result[0])  # latest message
+
+            for x in result:  # show the 10 messages
+                print(x.text)
+
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.total = 0
+
+    def __str__(self):
+        return '[{}, total={}]'.format(
+            ', '.join(str(x) for x in self), self.total)
+
+    def __repr__(self):
+        return '[{}, total={}]'.format(
+            ', '.join(repr(x) for x in self), self.total)
+
+
+class _FileStream(io.IOBase):
+    """
+    Proxy around things that represent a file and need to be used as streams
+    which may or not need to be closed.
+
+    This will handle `pathlib.Path`, `str` paths, in-memory `bytes`, and
+    anything IO-like (including `aiofiles`).
+
+    It also provides access to the name and file size (also necessary).
+    """
+    def __init__(self, file, *, file_size=None):
+        if isinstance(file, Path):
+            file = str(file.absolute())
+
+        self._file = file
+        self._name = None
+        self._size = file_size
+        self._stream = None
+        self._close_stream = None
+
+    async def __aenter__(self):
+        if isinstance(self._file, str):
+            self._name = os.path.basename(self._file)
+            self._size = os.path.getsize(self._file)
+            self._stream = open(self._file, 'rb')
+            self._close_stream = True
+            return self
+
+        if isinstance(self._file, bytes):
+            self._size = len(self._file)
+            self._stream = io.BytesIO(self._file)
+            self._close_stream = True
+            return self
+
+        if not callable(getattr(self._file, 'read', None)):
+            raise TypeError('file description should have a `read` method')
+
+        self._name = getattr(self._file, 'name', None)
+        self._stream = self._file
+        self._close_stream = False
+
+        if self._size is None:
+            if callable(getattr(self._file, 'seekable', None)):
+                seekable = await _maybe_await(self._file.seekable())
+            else:
+                seekable = False
+
+            if seekable:
+                pos = await _maybe_await(self._file.tell())
+                await _maybe_await(self._file.seek(0, os.SEEK_END))
+                self._size = await _maybe_await(self._file.tell())
+                await _maybe_await(self._file.seek(pos, os.SEEK_SET))
+            else:
+                _log.warning(
+                    'Could not determine file size beforehand so the entire '
+                    'file will be read in-memory')
+
+                data = await _maybe_await(self._file.read())
+                self._size = len(data)
+                self._stream = io.BytesIO(data)
+                self._close_stream = True
+
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._close_stream and self._stream:
+            await _maybe_await(self._stream.close())
+
+    @property
+    def file_size(self):
+        return self._size
+
+    @property
+    def name(self):
+        return self._name
+
+    # Proxy all the methods. Doesn't need to be readable (makes multiline edits easier)
+    def read(self, *args, **kwargs): return self._stream.read(*args, **kwargs)
+    def readinto(self, *args, **kwargs): return self._stream.readinto(*args, **kwargs)
+    def write(self, *args, **kwargs): return self._stream.write(*args, **kwargs)
+    def fileno(self, *args, **kwargs): return self._stream.fileno(*args, **kwargs)
+    def flush(self, *args, **kwargs): return self._stream.flush(*args, **kwargs)
+    def isatty(self, *args, **kwargs): return self._stream.isatty(*args, **kwargs)
+    def readable(self, *args, **kwargs): return self._stream.readable(*args, **kwargs)
+    def readline(self, *args, **kwargs): return self._stream.readline(*args, **kwargs)
+    def readlines(self, *args, **kwargs): return self._stream.readlines(*args, **kwargs)
+    def seek(self, *args, **kwargs): return self._stream.seek(*args, **kwargs)
+    def seekable(self, *args, **kwargs): return self._stream.seekable(*args, **kwargs)
+    def tell(self, *args, **kwargs): return self._stream.tell(*args, **kwargs)
+    def truncate(self, *args, **kwargs): return self._stream.truncate(*args, **kwargs)
+    def writable(self, *args, **kwargs): return self._stream.writable(*args, **kwargs)
+    def writelines(self, *args, **kwargs): return self._stream.writelines(*args, **kwargs)
+
+    # close is special because it will be called by __del__ but we do NOT
+    # want to close the file unless we have to (we're just a wrapper).
+    # Instead, we do nothing (we should be used through the decorator which
+    # has its own mechanism to close the file correctly).
+    def close(self, *args, **kwargs):
+        pass
+
+# endregion
+
+def get_running_loop():
+    if sys.version_info >= (3, 7):
+        try:
+            return asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.get_event_loop_policy().get_event_loop()
+    else:
+        return asyncio.get_event_loop()

.venv2/Lib/site-packages/telethon/hints.py

@@ -0,0 +1,67 @@
+import datetime
+import typing
+
+from . import helpers
+from .tl import types, custom
+
+Phone = str
+Username = str
+PeerID = int
+Entity = typing.Union[types.User, types.Chat, types.Channel]
+FullEntity = typing.Union[types.UserFull, types.messages.ChatFull, types.ChatFull, types.ChannelFull]
+
+EntityLike = typing.Union[
+    Phone,
+    Username,
+    PeerID,
+    types.TypePeer,
+    types.TypeInputPeer,
+    Entity,
+    FullEntity
+]
+EntitiesLike = typing.Union[EntityLike, typing.Sequence[EntityLike]]
+
+ButtonLike = typing.Union[types.TypeKeyboardButton, custom.Button]
+MarkupLike = typing.Union[
+    types.TypeReplyMarkup,
+    ButtonLike,
+    typing.Sequence[ButtonLike],
+    typing.Sequence[typing.Sequence[ButtonLike]]
+]
+
+TotalList = helpers.TotalList
+
+DateLike = typing.Optional[typing.Union[float, datetime.datetime, datetime.date, datetime.timedelta]]
+
+LocalPath = str
+ExternalUrl = str
+BotFileID = str
+FileLike = typing.Union[
+    LocalPath,
+    ExternalUrl,
+    BotFileID,
+    bytes,
+    typing.BinaryIO,
+    types.TypeMessageMedia,
+    types.TypeInputFile,
+    types.TypeInputFileLocation
+]
+
+# Can't use `typing.Type` in Python 3.5.2
+# See https://github.com/python/typing/issues/266
+try:
+    OutFileLike = typing.Union[
+        str,
+        typing.Type[bytes],
+        typing.BinaryIO
+    ]
+except TypeError:
+    OutFileLike = typing.Union[
+        str,
+        typing.BinaryIO
+    ]
+
+MessageLike = typing.Union[str, types.Message]
+MessageIDLike = typing.Union[int, types.Message, types.TypeInputMessage]
+
+ProgressCallback = typing.Callable[[int, int], None]

.venv2/Lib/site-packages/telethon/network/__init__.py

@@ -0,0 +1,14 @@
+"""
+This module contains several classes regarding network, low level connection
+with Telegram's servers and the protocol used (TCP full, abridged, etc.).
+"""
+from .mtprotoplainsender import MTProtoPlainSender
+from .authenticator import do_authentication
+from .mtprotosender import MTProtoSender
+from .connection import (
+    Connection,
+    ConnectionTcpFull, ConnectionTcpIntermediate, ConnectionTcpAbridged,
+    ConnectionTcpObfuscated, ConnectionTcpMTProxyAbridged,
+    ConnectionTcpMTProxyIntermediate,
+    ConnectionTcpMTProxyRandomizedIntermediate, ConnectionHttp, TcpMTProxy
+)

.venv2/Lib/site-packages/telethon/network/authenticator.py

@@ -0,0 +1,212 @@
+"""
+This module contains several functions that authenticate the client machine
+with Telegram's servers, effectively creating an authorization key.
+"""
+import os
+import time
+from hashlib import sha1
+
+from ..tl.types import (
+    ResPQ, PQInnerData, ServerDHParamsFail, ServerDHParamsOk,
+    ServerDHInnerData, ClientDHInnerData, DhGenOk, DhGenRetry, DhGenFail
+)
+from .. import helpers
+from ..crypto import AES, AuthKey, Factorization, rsa
+from ..errors import SecurityError
+from ..extensions import BinaryReader
+from ..tl.functions import (
+    ReqPqMultiRequest, ReqDHParamsRequest, SetClientDHParamsRequest
+)
+
+
+async def do_authentication(sender):
+    """
+    Executes the authentication process with the Telegram servers.
+
+    :param sender: a connected `MTProtoPlainSender`.
+    :return: returns a (authorization key, time offset) tuple.
+    """
+    # Step 1 sending: PQ Request, endianness doesn't matter since it's random
+    nonce = int.from_bytes(os.urandom(16), 'big', signed=True)
+    res_pq = await sender.send(ReqPqMultiRequest(nonce))
+    assert isinstance(res_pq, ResPQ), 'Step 1 answer was %s' % res_pq
+
+    if res_pq.nonce != nonce:
+        raise SecurityError('Step 1 invalid nonce from server')
+
+    pq = get_int(res_pq.pq)
+
+    # Step 2 sending: DH Exchange
+    p, q = Factorization.factorize(pq)
+    p, q = rsa.get_byte_array(p), rsa.get_byte_array(q)
+    new_nonce = int.from_bytes(os.urandom(32), 'little', signed=True)
+
+    pq_inner_data = bytes(PQInnerData(
+        pq=rsa.get_byte_array(pq), p=p, q=q,
+        nonce=res_pq.nonce,
+        server_nonce=res_pq.server_nonce,
+        new_nonce=new_nonce
+    ))
+
+    # sha_digest + data + random_bytes
+    cipher_text, target_fingerprint = None, None
+    for fingerprint in res_pq.server_public_key_fingerprints:
+        cipher_text = rsa.encrypt(fingerprint, pq_inner_data)
+        if cipher_text is not None:
+            target_fingerprint = fingerprint
+            break
+
+    if cipher_text is None:
+        # Second attempt, but now we're allowed to use old keys
+        for fingerprint in res_pq.server_public_key_fingerprints:
+            cipher_text = rsa.encrypt(fingerprint, pq_inner_data, use_old=True)
+            if cipher_text is not None:
+                target_fingerprint = fingerprint
+                break
+
+    if cipher_text is None:
+        raise SecurityError(
+            'Step 2 could not find a valid key for fingerprints: {}'
+            .format(', '.join(
+                [str(f) for f in res_pq.server_public_key_fingerprints])
+            )
+        )
+
+    server_dh_params = await sender.send(ReqDHParamsRequest(
+        nonce=res_pq.nonce,
+        server_nonce=res_pq.server_nonce,
+        p=p, q=q,
+        public_key_fingerprint=target_fingerprint,
+        encrypted_data=cipher_text
+    ))
+
+    assert isinstance(
+        server_dh_params, (ServerDHParamsOk, ServerDHParamsFail)),\
+        'Step 2.1 answer was %s' % server_dh_params
+
+    if server_dh_params.nonce != res_pq.nonce:
+        raise SecurityError('Step 2 invalid nonce from server')
+
+    if server_dh_params.server_nonce != res_pq.server_nonce:
+        raise SecurityError('Step 2 invalid server nonce from server')
+
+    if isinstance(server_dh_params, ServerDHParamsFail):
+        nnh = int.from_bytes(
+            sha1(new_nonce.to_bytes(32, 'little', signed=True)).digest()[4:20],
+            'little', signed=True
+        )
+        if server_dh_params.new_nonce_hash != nnh:
+            raise SecurityError('Step 2 invalid DH fail nonce from server')
+
+    assert isinstance(server_dh_params, ServerDHParamsOk),\
+        'Step 2.2 answer was %s' % server_dh_params
+
+    # Step 3 sending: Complete DH Exchange
+    key, iv = helpers.generate_key_data_from_nonce(
+        res_pq.server_nonce, new_nonce
+    )
+    if len(server_dh_params.encrypted_answer) % 16 != 0:
+        # See PR#453
+        raise SecurityError('Step 3 AES block size mismatch')
+
+    plain_text_answer = AES.decrypt_ige(
+        server_dh_params.encrypted_answer, key, iv
+    )
+
+    with BinaryReader(plain_text_answer) as reader:
+        reader.read(20)  # hash sum
+        server_dh_inner = reader.tgread_object()
+        assert isinstance(server_dh_inner, ServerDHInnerData),\
+            'Step 3 answer was %s' % server_dh_inner
+
+    if server_dh_inner.nonce != res_pq.nonce:
+        raise SecurityError('Step 3 Invalid nonce in encrypted answer')
+
+    if server_dh_inner.server_nonce != res_pq.server_nonce:
+        raise SecurityError('Step 3 Invalid server nonce in encrypted answer')
+
+    dh_prime = get_int(server_dh_inner.dh_prime, signed=False)
+    g = server_dh_inner.g
+    g_a = get_int(server_dh_inner.g_a, signed=False)
+    time_offset = server_dh_inner.server_time - int(time.time())
+
+    b = get_int(os.urandom(256), signed=False)
+    g_b = pow(g, b, dh_prime)
+    gab = pow(g_a, b, dh_prime)
+
+    # IMPORTANT: Apart from the conditions on the Diffie-Hellman prime
+    # dh_prime and generator g, both sides are to check that g, g_a and
+    # g_b are greater than 1 and less than dh_prime - 1. We recommend
+    # checking that g_a and g_b are between 2^{2048-64} and
+    # dh_prime - 2^{2048-64} as well.
+    # (https://core.telegram.org/mtproto/auth_key#dh-key-exchange-complete)
+    if not (1 < g < (dh_prime - 1)):
+        raise SecurityError('g_a is not within (1, dh_prime - 1)')
+
+    if not (1 < g_a < (dh_prime - 1)):
+        raise SecurityError('g_a is not within (1, dh_prime - 1)')
+
+    if not (1 < g_b < (dh_prime - 1)):
+        raise SecurityError('g_b is not within (1, dh_prime - 1)')
+
+    safety_range = 2 ** (2048 - 64)
+    if not (safety_range <= g_a <= (dh_prime - safety_range)):
+        raise SecurityError('g_a is not within (2^{2048-64}, dh_prime - 2^{2048-64})')
+
+    if not (safety_range <= g_b <= (dh_prime - safety_range)):
+        raise SecurityError('g_b is not within (2^{2048-64}, dh_prime - 2^{2048-64})')
+
+    # Prepare client DH Inner Data
+    client_dh_inner = bytes(ClientDHInnerData(
+        nonce=res_pq.nonce,
+        server_nonce=res_pq.server_nonce,
+        retry_id=0,  # TODO Actual retry ID
+        g_b=rsa.get_byte_array(g_b)
+    ))
+
+    client_dh_inner_hashed = sha1(client_dh_inner).digest() + client_dh_inner
+
+    # Encryption
+    client_dh_encrypted = AES.encrypt_ige(client_dh_inner_hashed, key, iv)
+
+    # Prepare Set client DH params
+    dh_gen = await sender.send(SetClientDHParamsRequest(
+        nonce=res_pq.nonce,
+        server_nonce=res_pq.server_nonce,
+        encrypted_data=client_dh_encrypted,
+    ))
+
+    nonce_types = (DhGenOk, DhGenRetry, DhGenFail)
+    assert isinstance(dh_gen, nonce_types), 'Step 3.1 answer was %s' % dh_gen
+    name = dh_gen.__class__.__name__
+    if dh_gen.nonce != res_pq.nonce:
+        raise SecurityError('Step 3 invalid {} nonce from server'.format(name))
+
+    if dh_gen.server_nonce != res_pq.server_nonce:
+        raise SecurityError(
+            'Step 3 invalid {} server nonce from server'.format(name))
+
+    auth_key = AuthKey(rsa.get_byte_array(gab))
+    nonce_number = 1 + nonce_types.index(type(dh_gen))
+    new_nonce_hash = auth_key.calc_new_nonce_hash(new_nonce, nonce_number)
+
+    dh_hash = getattr(dh_gen, 'new_nonce_hash{}'.format(nonce_number))
+    if dh_hash != new_nonce_hash:
+        raise SecurityError('Step 3 invalid new nonce hash')
+
+    if not isinstance(dh_gen, DhGenOk):
+        raise AssertionError('Step 3.2 answer was %s' % dh_gen)
+
+    return auth_key, time_offset
+
+
+def get_int(byte_array, signed=True):
+    """
+    Gets the specified integer from its byte array.
+    This should be used by this module alone, as it works with big endian.
+
+    :param byte_array: the byte array representing th integer.
+    :param signed: whether the number is signed or not.
+    :return: the integer representing the given byte array.
+    """
+    return int.from_bytes(byte_array, byteorder='big', signed=signed)

.venv2/Lib/site-packages/telethon/network/connection/__init__.py

@@ -0,0 +1,12 @@
+from .connection import Connection
+from .tcpfull import ConnectionTcpFull
+from .tcpintermediate import ConnectionTcpIntermediate
+from .tcpabridged import ConnectionTcpAbridged
+from .tcpobfuscated import ConnectionTcpObfuscated
+from .tcpmtproxy import (
+    TcpMTProxy,
+    ConnectionTcpMTProxyAbridged,
+    ConnectionTcpMTProxyIntermediate,
+    ConnectionTcpMTProxyRandomizedIntermediate
+)
+from .http import ConnectionHttp

.venv2/Lib/site-packages/telethon/network/connection/connection.py

@@ -0,0 +1,434 @@
+import abc
+import asyncio
+import socket
+import sys
+
+try:
+    import ssl as ssl_mod
+except ImportError:
+    ssl_mod = None
+
+try:
+    import python_socks
+except ImportError:
+    python_socks = None
+
+from ...errors import InvalidChecksumError, InvalidBufferError
+from ... import helpers
+
+
+class Connection(abc.ABC):
+    """
+    The `Connection` class is a wrapper around ``asyncio.open_connection``.
+
+    Subclasses will implement different transport modes as atomic operations,
+    which this class eases doing since the exposed interface simply puts and
+    gets complete data payloads to and from queues.
+
+    The only error that will raise from send and receive methods is
+    ``ConnectionError``, which will raise when attempting to send if
+    the client is disconnected (includes remote disconnections).
+    """
+    # this static attribute should be redefined by `Connection` subclasses and
+    # should be one of `PacketCodec` implementations
+    packet_codec = None
+
+    def __init__(self, ip, port, dc_id, *, loggers, proxy=None, local_addr=None):
+        self._ip = ip
+        self._port = port
+        self._dc_id = dc_id  # only for MTProxy, it's an abstraction leak
+        self._log = loggers[__name__]
+        self._proxy = proxy
+        self._local_addr = local_addr
+        self._reader = None
+        self._writer = None
+        self._connected = False
+        self._send_task = None
+        self._recv_task = None
+        self._codec = None
+        self._obfuscation = None  # TcpObfuscated and MTProxy
+        self._send_queue = asyncio.Queue(1)
+        self._recv_queue = asyncio.Queue(1)
+
+    @staticmethod
+    def _wrap_socket_ssl(sock):
+        if ssl_mod is None:
+            raise RuntimeError(
+                'Cannot use proxy that requires SSL '
+                'without the SSL module being available'
+            )
+
+        return ssl_mod.wrap_socket(
+            sock,
+            do_handshake_on_connect=True,
+            ssl_version=ssl_mod.PROTOCOL_SSLv23,
+            ciphers='ADH-AES256-SHA')
+
+    @staticmethod
+    def _parse_proxy(proxy_type, addr, port, rdns=True, username=None, password=None):
+        if isinstance(proxy_type, str):
+            proxy_type = proxy_type.lower()
+
+        # Always prefer `python_socks` when available
+        if python_socks:
+            from python_socks import ProxyType
+
+            # We do the check for numerical values here
+            # to be backwards compatible with PySocks proxy format,
+            # (since socks.SOCKS5 == 2, socks.SOCKS4 == 1, socks.HTTP == 3)
+            if proxy_type == ProxyType.SOCKS5 or proxy_type == 2 or proxy_type == "socks5":
+                protocol = ProxyType.SOCKS5
+            elif proxy_type == ProxyType.SOCKS4 or proxy_type == 1 or proxy_type == "socks4":
+                protocol = ProxyType.SOCKS4
+            elif proxy_type == ProxyType.HTTP or proxy_type == 3 or proxy_type == "http":
+                protocol = ProxyType.HTTP
+            else:
+                raise ValueError("Unknown proxy protocol type: {}".format(proxy_type))
+
+            # This tuple must be compatible with `python_socks`' `Proxy.create()` signature
+            return protocol, addr, port, username, password, rdns
+
+        else:
+            from socks import SOCKS5, SOCKS4, HTTP
+
+            if proxy_type == 2 or proxy_type == "socks5":
+                protocol = SOCKS5
+            elif proxy_type == 1 or proxy_type == "socks4":
+                protocol = SOCKS4
+            elif proxy_type == 3 or proxy_type == "http":
+                protocol = HTTP
+            else:
+                raise ValueError("Unknown proxy protocol type: {}".format(proxy_type))
+
+            # This tuple must be compatible with `PySocks`' `socksocket.set_proxy()` signature
+            return protocol, addr, port, rdns, username, password
+
+    async def _proxy_connect(self, timeout=None, local_addr=None):
+        if isinstance(self._proxy, (tuple, list)):
+            parsed = self._parse_proxy(*self._proxy)
+        elif isinstance(self._proxy, dict):
+            parsed = self._parse_proxy(**self._proxy)
+        else:
+            raise TypeError("Proxy of unknown format: {}".format(type(self._proxy)))
+
+        # Always prefer `python_socks` when available
+        if python_socks:
+            # python_socks internal errors are not inherited from
+            # builtin IOError (just from Exception). Instead of adding those
+            # in exceptions clauses everywhere through the code, we
+            # rather monkey-patch them in place.
+
+            python_socks._errors.ProxyError = ConnectionError
+            python_socks._errors.ProxyConnectionError = ConnectionError
+            python_socks._errors.ProxyTimeoutError = ConnectionError
+
+            from python_socks.async_.asyncio import Proxy
+
+            proxy = Proxy.create(*parsed)
+
+            # WARNING: If `local_addr` is set we use manual socket creation, because,
+            # unfortunately, `Proxy.connect()` does not expose `local_addr`
+            # argument, so if we want to bind socket locally, we need to manually
+            # create, bind and connect socket, and then pass to `Proxy.connect()` method.
+
+            if local_addr is None:
+                sock = await proxy.connect(
+                    dest_host=self._ip,
+                    dest_port=self._port,
+                    timeout=timeout
+                )
+            else:
+                # Here we start manual setup of the socket.
+                # The `address` represents the proxy ip and proxy port,
+                # not the destination one (!), because the socket
+                # connects to the proxy server, not destination server.
+                # IPv family is also checked on proxy address.
+                if ':' in proxy.proxy_host:
+                    mode, address = socket.AF_INET6, (proxy.proxy_host, proxy.proxy_port, 0, 0)
+                else:
+                    mode, address = socket.AF_INET, (proxy.proxy_host, proxy.proxy_port)
+
+                # Create a non-blocking socket and bind it (if local address is specified).
+                sock = socket.socket(mode, socket.SOCK_STREAM)
+                sock.setblocking(False)
+                sock.bind(local_addr)
+
+                # Actual TCP connection is performed here.
+                await asyncio.wait_for(
+                    helpers.get_running_loop().sock_connect(sock=sock, address=address),
+                    timeout=timeout
+                )
+
+                # As our socket is already created and connected,
+                # this call sets the destination host/port and
+                # starts protocol negotiations with the proxy server.
+                sock = await proxy.connect(
+                    dest_host=self._ip,
+                    dest_port=self._port,
+                    timeout=timeout,
+                    _socket=sock
+                )
+
+        else:
+            import socks
+
+            # Here `address` represents destination address (not proxy), because of
+            # the `PySocks` implementation of the connection routine.
+            # IPv family is checked on proxy address, not destination address.
+            if ':' in parsed[1]:
+                mode, address = socket.AF_INET6, (self._ip, self._port, 0, 0)
+            else:
+                mode, address = socket.AF_INET, (self._ip, self._port)
+
+            # Setup socket, proxy, timeout and bind it (if necessary).
+            sock = socks.socksocket(mode, socket.SOCK_STREAM)
+            sock.set_proxy(*parsed)
+            sock.settimeout(timeout)
+
+            if local_addr is not None:
+                sock.bind(local_addr)
+
+            # Actual TCP connection and negotiation performed here.
+            await asyncio.wait_for(
+                helpers.get_running_loop().sock_connect(sock=sock, address=address),
+                timeout=timeout
+            )
+
+            sock.setblocking(False)
+
+        return sock
+
+    async def _connect(self, timeout=None, ssl=None):
+        if self._local_addr is not None:
+            # NOTE: If port is not specified, we use 0 port
+            # to notify the OS that port should be chosen randomly
+            # from the available ones.
+            if isinstance(self._local_addr, tuple) and len(self._local_addr) == 2:
+                local_addr = self._local_addr
+            elif isinstance(self._local_addr, str):
+                local_addr = (self._local_addr, 0)
+            else:
+                raise ValueError("Unknown local address format: {}".format(self._local_addr))
+        else:
+            local_addr = None
+
+        if not self._proxy:
+            self._reader, self._writer = await asyncio.wait_for(
+                asyncio.open_connection(
+                    host=self._ip,
+                    port=self._port,
+                    ssl=ssl,
+                    local_addr=local_addr
+                ), timeout=timeout)
+        else:
+            # Proxy setup, connection and negotiation is performed here.
+            sock = await self._proxy_connect(
+                timeout=timeout,
+                local_addr=local_addr
+            )
+
+            # Wrap socket in SSL context (if provided)
+            if ssl:
+                sock = self._wrap_socket_ssl(sock)
+
+            self._reader, self._writer = await asyncio.open_connection(sock=sock)
+
+        self._codec = self.packet_codec(self)
+        self._init_conn()
+        await self._writer.drain()
+
+    async def connect(self, timeout=None, ssl=None):
+        """
+        Establishes a connection with the server.
+        """
+        await self._connect(timeout=timeout, ssl=ssl)
+        self._connected = True
+
+        loop = helpers.get_running_loop()
+        self._send_task = loop.create_task(self._send_loop())
+        self._recv_task = loop.create_task(self._recv_loop())
+
+    async def disconnect(self):
+        """
+        Disconnects from the server, and clears
+        pending outgoing and incoming messages.
+        """
+        if not self._connected:
+            return
+
+        self._connected = False
+
+        await helpers._cancel(
+            self._log,
+            send_task=self._send_task,
+            recv_task=self._recv_task
+        )
+
+        if self._writer:
+            self._writer.close()
+            if sys.version_info >= (3, 7):
+                try:
+                    await asyncio.wait_for(self._writer.wait_closed(), timeout=10)
+                except asyncio.TimeoutError:
+                    # See issue #3917. For some users, this line was hanging indefinitely.
+                    # The hard timeout is not ideal (connection won't be properly closed),
+                    # but the code will at least be able to procceed.
+                    self._log.warning('Graceful disconnection timed out, forcibly ignoring cleanup')
+                except Exception as e:
+                    # Disconnecting should never raise. Seen:
+                    # * OSError: No route to host and
+                    # * OSError: [Errno 32] Broken pipe
+                    # * ConnectionResetError
+                    self._log.info('%s during disconnect: %s', type(e), e)
+
+    def send(self, data):
+        """
+        Sends a packet of data through this connection mode.
+
+        This method returns a coroutine.
+        """
+        if not self._connected:
+            raise ConnectionError('Not connected')
+
+        return self._send_queue.put(data)
+
+    async def recv(self):
+        """
+        Receives a packet of data through this connection mode.
+
+        This method returns a coroutine.
+        """
+        while self._connected:
+            result, err = await self._recv_queue.get()
+            if err:
+                raise err
+            if result:
+                return result
+
+        raise ConnectionError('Not connected')
+
+    async def _send_loop(self):
+        """
+        This loop is constantly popping items off the queue to send them.
+        """
+        try:
+            while self._connected:
+                self._send(await self._send_queue.get())
+                await self._writer.drain()
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            if isinstance(e, IOError):
+                self._log.info('The server closed the connection while sending')
+            else:
+                self._log.exception('Unexpected exception in the send loop')
+
+            await self.disconnect()
+
+    async def _recv_loop(self):
+        """
+        This loop is constantly putting items on the queue as they're read.
+        """
+        try:
+            while self._connected:
+                try:
+                    data = await self._recv()
+                except asyncio.CancelledError:
+                    break
+                except (IOError, asyncio.IncompleteReadError) as e:
+                    self._log.warning('Server closed the connection: %s', e)
+                    await self._recv_queue.put((None, e))
+                    await self.disconnect()
+                except InvalidChecksumError as e:
+                    self._log.warning('Server response had invalid checksum: %s', e)
+                    await self._recv_queue.put((None, e))
+                except InvalidBufferError as e:
+                    self._log.warning('Server response had invalid buffer: %s', e)
+                    await self._recv_queue.put((None, e))
+                except Exception as e:
+                    self._log.exception('Unexpected exception in the receive loop')
+                    await self._recv_queue.put((None, e))
+                    await self.disconnect()
+                else:
+                    await self._recv_queue.put((data, None))
+        finally:
+            await self.disconnect()
+
+
+    def _init_conn(self):
+        """
+        This method will be called after `connect` is called.
+        After this method finishes, the writer will be drained.
+
+        Subclasses should make use of this if they need to send
+        data to Telegram to indicate which connection mode will
+        be used.
+        """
+        if self._codec.tag:
+            self._writer.write(self._codec.tag)
+
+    def _send(self, data):
+        self._writer.write(self._codec.encode_packet(data))
+
+    async def _recv(self):
+        return await self._codec.read_packet(self._reader)
+
+    def __str__(self):
+        return '{}:{}/{}'.format(
+            self._ip, self._port,
+            self.__class__.__name__.replace('Connection', '')
+        )
+
+
+class ObfuscatedConnection(Connection):
+    """
+    Base class for "obfuscated" connections ("obfuscated2", "mtproto proxy")
+    """
+    """
+    This attribute should be redefined by subclasses
+    """
+    obfuscated_io = None
+
+    def _init_conn(self):
+        self._obfuscation = self.obfuscated_io(self)
+        self._writer.write(self._obfuscation.header)
+
+    def _send(self, data):
+        self._obfuscation.write(self._codec.encode_packet(data))
+
+    async def _recv(self):
+        return await self._codec.read_packet(self._obfuscation)
+
+
+class PacketCodec(abc.ABC):
+    """
+    Base class for packet codecs
+    """
+
+    """
+    This attribute should be re-defined by subclass to define if some
+    "magic bytes" should be sent to server right after connection is made to
+    signal which protocol will be used
+    """
+    tag = None
+
+    def __init__(self, connection):
+        """
+        Codec is created when connection is just made.
+        """
+        self._conn = connection
+
+    @abc.abstractmethod
+    def encode_packet(self, data):
+        """
+        Encodes single packet and returns encoded bytes.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def read_packet(self, reader):
+        """
+        Reads single packet from `reader` object that should have
+        `readexactly(n)` method.
+        """
+        raise NotImplementedError

.venv2/Lib/site-packages/telethon/network/connection/http.py

@@ -0,0 +1,39 @@
+import asyncio
+
+from .connection import Connection, PacketCodec
+
+
+SSL_PORT = 443
+
+
+class HttpPacketCodec(PacketCodec):
+    tag = None
+    obfuscate_tag = None
+
+    def encode_packet(self, data):
+        return ('POST /api HTTP/1.1\r\n'
+                'Host: {}:{}\r\n'
+                'Content-Type: application/x-www-form-urlencoded\r\n'
+                'Connection: keep-alive\r\n'
+                'Keep-Alive: timeout=100000, max=10000000\r\n'
+                'Content-Length: {}\r\n\r\n'
+                .format(self._conn._ip, self._conn._port, len(data))
+                .encode('ascii') + data)
+
+    async def read_packet(self, reader):
+        while True:
+            line = await reader.readline()
+            if not line or line[-1] != b'\n':
+                raise asyncio.IncompleteReadError(line, None)
+
+            if line.lower().startswith(b'content-length: '):
+                await reader.readexactly(2)
+                length = int(line[16:-2])
+                return await reader.readexactly(length)
+
+
+class ConnectionHttp(Connection):
+    packet_codec = HttpPacketCodec
+
+    async def connect(self, timeout=None, ssl=None):
+        await super().connect(timeout=timeout, ssl=self._port == SSL_PORT)

.venv2/Lib/site-packages/telethon/network/connection/tcpabridged.py

@@ -0,0 +1,33 @@
+import struct
+
+from .connection import Connection, PacketCodec
+
+
+class AbridgedPacketCodec(PacketCodec):
+    tag = b'\xef'
+    obfuscate_tag = b'\xef\xef\xef\xef'
+
+    def encode_packet(self, data):
+        length = len(data) >> 2
+        if length < 127:
+            length = struct.pack('B', length)
+        else:
+            length = b'\x7f' + int.to_bytes(length, 3, 'little')
+        return length + data
+
+    async def read_packet(self, reader):
+        length = struct.unpack('<B', await reader.readexactly(1))[0]
+        if length >= 127:
+            length = struct.unpack(
+                '<i', await reader.readexactly(3) + b'\0')[0]
+
+        return await reader.readexactly(length << 2)
+
+
+class ConnectionTcpAbridged(Connection):
+    """
+    This is the mode with the lowest overhead, as it will
+    only require 1 byte if the packet length is less than
+    508 bytes (127 << 2, which is very common).
+    """
+    packet_codec = AbridgedPacketCodec

.venv2/Lib/site-packages/telethon/network/connection/tcpfull.py

@@ -0,0 +1,55 @@
+import struct
+from zlib import crc32
+
+from .connection import Connection, PacketCodec
+from ...errors import InvalidChecksumError, InvalidBufferError
+
+
+class FullPacketCodec(PacketCodec):
+    tag = None
+
+    def __init__(self, connection):
+        super().__init__(connection)
+        self._send_counter = 0  # Important or Telegram won't reply
+
+    def encode_packet(self, data):
+        # https://core.telegram.org/mtproto#tcp-transport
+        # total length, sequence number, packet and checksum (CRC32)
+        length = len(data) + 12
+        data = struct.pack('<ii', length, self._send_counter) + data
+        crc = struct.pack('<I', crc32(data))
+        self._send_counter += 1
+        return data + crc
+
+    async def read_packet(self, reader):
+        packet_len_seq = await reader.readexactly(8)  # 4 and 4
+        packet_len, seq = struct.unpack('<ii', packet_len_seq)
+        if packet_len < 0 and seq < 0:
+            # It has been observed that the length and seq can be -429,
+            # followed by the body of 4 bytes also being -429.
+            # See https://github.com/LonamiWebs/Telethon/issues/4042.
+            body = await reader.readexactly(4)
+            raise InvalidBufferError(body)
+        elif packet_len < 8:
+            # Currently unknown why packet_len may be less than 8 but not negative.
+            # Attempting to `readexactly` with less than 0 fails without saying what
+            # the number was which is less helpful.
+            raise InvalidBufferError(packet_len_seq)
+
+        body = await reader.readexactly(packet_len - 8)
+        checksum = struct.unpack('<I', body[-4:])[0]
+        body = body[:-4]
+
+        valid_checksum = crc32(packet_len_seq + body)
+        if checksum != valid_checksum:
+            raise InvalidChecksumError(checksum, valid_checksum)
+
+        return body
+
+
+class ConnectionTcpFull(Connection):
+    """
+    Default Telegram mode. Sends 12 additional bytes and
+    needs to calculate the CRC value of the packet itself.
+    """
+    packet_codec = FullPacketCodec

.venv2/Lib/site-packages/telethon/network/connection/tcpintermediate.py

@@ -0,0 +1,46 @@
+import struct
+import random
+import os
+
+from .connection import Connection, PacketCodec
+
+
+class IntermediatePacketCodec(PacketCodec):
+    tag = b'\xee\xee\xee\xee'
+    obfuscate_tag = tag
+
+    def encode_packet(self, data):
+        return struct.pack('<i', len(data)) + data
+
+    async def read_packet(self, reader):
+        length = struct.unpack('<i', await reader.readexactly(4))[0]
+        return await reader.readexactly(length)
+
+
+class RandomizedIntermediatePacketCodec(IntermediatePacketCodec):
+    """
+    Data packets are aligned to 4bytes. This codec adds random bytes of size
+    from 0 to 3 bytes, which are ignored by decoder.
+    """
+    tag = None
+    obfuscate_tag = b'\xdd\xdd\xdd\xdd'
+
+    def encode_packet(self, data):
+        pad_size = random.randint(0, 3)
+        padding = os.urandom(pad_size)
+        return super().encode_packet(data + padding)
+
+    async def read_packet(self, reader):
+        packet_with_padding = await super().read_packet(reader)
+        pad_size = len(packet_with_padding) % 4
+        if pad_size > 0:
+            return packet_with_padding[:-pad_size]
+        return packet_with_padding
+
+
+class ConnectionTcpIntermediate(Connection):
+    """
+    Intermediate mode between `ConnectionTcpFull` and `ConnectionTcpAbridged`.
+    Always sends 4 extra bytes for the packet length.
+    """
+    packet_codec = IntermediatePacketCodec

.venv2/Lib/site-packages/telethon/network/connection/tcpmtproxy.py

@@ -0,0 +1,152 @@
+import asyncio
+import hashlib
+import os
+
+from .connection import ObfuscatedConnection
+from .tcpabridged import AbridgedPacketCodec
+from .tcpintermediate import (
+    IntermediatePacketCodec,
+    RandomizedIntermediatePacketCodec
+)
+
+from ...crypto import AESModeCTR
+
+
+class MTProxyIO:
+    """
+    It's very similar to tcpobfuscated.ObfuscatedIO, but the way
+    encryption keys, protocol tag and dc_id are encoded is different.
+    """
+    header = None
+
+    def __init__(self, connection):
+        self._reader = connection._reader
+        self._writer = connection._writer
+
+        (self.header,
+         self._encrypt,
+         self._decrypt) = self.init_header(
+             connection._secret, connection._dc_id, connection.packet_codec)
+
+    @staticmethod
+    def init_header(secret, dc_id, packet_codec):
+        # Validate
+        is_dd = (len(secret) == 17) and (secret[0] == 0xDD)
+        is_rand_codec = issubclass(
+            packet_codec, RandomizedIntermediatePacketCodec)
+        if is_dd and not is_rand_codec:
+            raise ValueError(
+                "Only RandomizedIntermediate can be used with dd-secrets")
+        secret = secret[1:] if is_dd else secret
+        if len(secret) != 16:
+            raise ValueError(
+                "MTProxy secret must be a hex-string representing 16 bytes")
+
+        # Obfuscated messages secrets cannot start with any of these
+        keywords = (b'PVrG', b'GET ', b'POST', b'\xee\xee\xee\xee')
+        while True:
+            random = os.urandom(64)
+            if (random[0] != 0xef and
+                    random[:4] not in keywords and
+                    random[4:4] != b'\0\0\0\0'):
+                break
+
+        random = bytearray(random)
+        random_reversed = random[55:7:-1]  # Reversed (8, len=48)
+
+        # Encryption has "continuous buffer" enabled
+        encrypt_key = hashlib.sha256(
+            bytes(random[8:40]) + secret).digest()
+        encrypt_iv = bytes(random[40:56])
+        decrypt_key = hashlib.sha256(
+            bytes(random_reversed[:32]) + secret).digest()
+        decrypt_iv = bytes(random_reversed[32:48])
+
+        encryptor = AESModeCTR(encrypt_key, encrypt_iv)
+        decryptor = AESModeCTR(decrypt_key, decrypt_iv)
+
+        random[56:60] = packet_codec.obfuscate_tag
+
+        dc_id_bytes = dc_id.to_bytes(2, "little", signed=True)
+        random = random[:60] + dc_id_bytes + random[62:]
+        random[56:64] = encryptor.encrypt(bytes(random))[56:64]
+        return (random, encryptor, decryptor)
+
+    async def readexactly(self, n):
+        return self._decrypt.encrypt(await self._reader.readexactly(n))
+
+    def write(self, data):
+        self._writer.write(self._encrypt.encrypt(data))
+
+
+class TcpMTProxy(ObfuscatedConnection):
+    """
+    Connector which allows user to connect to the Telegram via proxy servers
+    commonly known as MTProxy.
+    Implemented very ugly due to the leaky abstractions in Telethon networking
+    classes that should be refactored later (TODO).
+
+    .. warning::
+
+        The support for TcpMTProxy classes is **EXPERIMENTAL** and prone to
+        be changed. You shouldn't be using this class yet.
+    """
+    packet_codec = None
+    obfuscated_io = MTProxyIO
+
+    # noinspection PyUnusedLocal
+    def __init__(self, ip, port, dc_id, *, loggers, proxy=None, local_addr=None):
+        # connect to proxy's host and port instead of telegram's ones
+        proxy_host, proxy_port = self.address_info(proxy)
+        self._secret = bytes.fromhex(proxy[2])
+        super().__init__(
+            proxy_host, proxy_port, dc_id, loggers=loggers)
+
+    async def _connect(self, timeout=None, ssl=None):
+        await super()._connect(timeout=timeout, ssl=ssl)
+
+        # Wait for EOF for 2 seconds (or if _wait_for_data's definition
+        # is missing or different, just sleep for 2 seconds). This way
+        # we give the proxy a chance to close the connection if the current
+        # codec (which the proxy detects with the data we sent) cannot
+        # be used for this proxy. This is a work around for #1134.
+        # TODO Sleeping for N seconds may not be the best solution
+        # TODO This fix could be welcome for HTTP proxies as well
+        try:
+            await asyncio.wait_for(self._reader._wait_for_data('proxy'), 2)
+        except asyncio.TimeoutError:
+            pass
+        except Exception:
+            await asyncio.sleep(2)
+
+        if self._reader.at_eof():
+            await self.disconnect()
+            raise ConnectionError(
+                'Proxy closed the connection after sending initial payload')
+
+    @staticmethod
+    def address_info(proxy_info):
+        if proxy_info is None:
+            raise ValueError("No proxy info specified for MTProxy connection")
+        return proxy_info[:2]
+
+
+class ConnectionTcpMTProxyAbridged(TcpMTProxy):
+    """
+    Connect to proxy using abridged protocol
+    """
+    packet_codec = AbridgedPacketCodec
+
+
+class ConnectionTcpMTProxyIntermediate(TcpMTProxy):
+    """
+    Connect to proxy using intermediate protocol
+    """
+    packet_codec = IntermediatePacketCodec
+
+
+class ConnectionTcpMTProxyRandomizedIntermediate(TcpMTProxy):
+    """
+    Connect to proxy using randomized intermediate protocol (dd-secrets)
+    """
+    packet_codec = RandomizedIntermediatePacketCodec

.venv2/Lib/site-packages/telethon/network/connection/tcpobfuscated.py

@@ -0,0 +1,62 @@
+import os
+
+from .tcpabridged import AbridgedPacketCodec
+from .connection import ObfuscatedConnection
+
+from ...crypto import AESModeCTR
+
+
+class ObfuscatedIO:
+    header = None
+
+    def __init__(self, connection):
+        self._reader = connection._reader
+        self._writer = connection._writer
+
+        (self.header,
+         self._encrypt,
+         self._decrypt) = self.init_header(connection.packet_codec)
+
+    @staticmethod
+    def init_header(packet_codec):
+        # Obfuscated messages secrets cannot start with any of these
+        keywords = (b'PVrG', b'GET ', b'POST', b'\xee\xee\xee\xee')
+        while True:
+            random = os.urandom(64)
+            if (random[0] != 0xef and
+                    random[:4] not in keywords and
+                    random[4:8] != b'\0\0\0\0'):
+                break
+
+        random = bytearray(random)
+        random_reversed = random[55:7:-1]  # Reversed (8, len=48)
+
+        # Encryption has "continuous buffer" enabled
+        encrypt_key = bytes(random[8:40])
+        encrypt_iv = bytes(random[40:56])
+        decrypt_key = bytes(random_reversed[:32])
+        decrypt_iv = bytes(random_reversed[32:48])
+
+        encryptor = AESModeCTR(encrypt_key, encrypt_iv)
+        decryptor = AESModeCTR(decrypt_key, decrypt_iv)
+
+        random[56:60] = packet_codec.obfuscate_tag
+        random[56:64] = encryptor.encrypt(bytes(random))[56:64]
+        return (random, encryptor, decryptor)
+
+    async def readexactly(self, n):
+        return self._decrypt.encrypt(await self._reader.readexactly(n))
+
+    def write(self, data):
+        self._writer.write(self._encrypt.encrypt(data))
+
+
+class ConnectionTcpObfuscated(ObfuscatedConnection):
+    """
+    Mode that Telegram defines as "obfuscated2". Encodes the packet
+    just like `ConnectionTcpAbridged`, but encrypts every message with
+    a randomly generated key using the AES-CTR mode so the packets are
+    harder to discern.
+    """
+    obfuscated_io = ObfuscatedIO
+    packet_codec = AbridgedPacketCodec

.venv2/Lib/site-packages/telethon/network/mtprotoplainsender.py

@@ -0,0 +1,56 @@
+"""
+This module contains the class used to communicate with Telegram's servers
+in plain text, when no authorization key has been created yet.
+"""
+import struct
+
+from .mtprotostate import MTProtoState
+from ..errors import InvalidBufferError
+from ..extensions import BinaryReader
+
+
+class MTProtoPlainSender:
+    """
+    MTProto Mobile Protocol plain sender
+    (https://core.telegram.org/mtproto/description#unencrypted-messages)
+    """
+    def __init__(self, connection, *, loggers):
+        """
+        Initializes the MTProto plain sender.
+
+        :param connection: the Connection to be used.
+        """
+        self._state = MTProtoState(auth_key=None, loggers=loggers)
+        self._connection = connection
+
+    async def send(self, request):
+        """
+        Sends and receives the result for the given request.
+        """
+        body = bytes(request)
+        msg_id = self._state._get_new_msg_id()
+        await self._connection.send(
+            struct.pack('<qqi', 0, msg_id, len(body)) + body
+        )
+
+        body = await self._connection.recv()
+        if len(body) < 8:
+            raise InvalidBufferError(body)
+
+        with BinaryReader(body) as reader:
+            auth_key_id = reader.read_long()
+            assert auth_key_id == 0, 'Bad auth_key_id'
+
+            msg_id = reader.read_long()
+            assert msg_id != 0,  'Bad msg_id'
+            # ^ We should make sure that the read ``msg_id`` is greater
+            # than our own ``msg_id``. However, under some circumstances
+            # (bad system clock/working behind proxies) this seems to not
+            # be the case, which would cause endless assertion errors.
+
+            length = reader.read_int()
+            assert length > 0,  'Bad length'
+            # We could read length bytes and use those in a new reader to read
+            # the next TLObject without including the padding, but since the
+            # reader isn't used for anything else after this, it's unnecessary.
+            return reader.tgread_object()

.venv2/Lib/site-packages/telethon/network/mtprotosender.py

@@ -0,0 +1,914 @@
+import asyncio
+import collections
+import struct
+import datetime
+import time
+
+from . import authenticator
+from ..extensions.messagepacker import MessagePacker
+from .mtprotoplainsender import MTProtoPlainSender
+from .requeststate import RequestState
+from .mtprotostate import MTProtoState
+from ..tl.tlobject import TLRequest
+from .. import helpers, utils
+from ..errors import (
+    BadMessageError, InvalidBufferError, AuthKeyNotFound, SecurityError,
+    TypeNotFoundError, rpc_message_to_error
+)
+from ..extensions import BinaryReader
+from ..tl.core import RpcResult, MessageContainer, GzipPacked
+from ..tl.functions.auth import LogOutRequest
+from ..tl.functions import PingRequest, DestroySessionRequest, DestroyAuthKeyRequest
+from ..tl.types import (
+    MsgsAck, Pong, BadServerSalt, BadMsgNotification, FutureSalts,
+    MsgNewDetailedInfo, NewSessionCreated, MsgDetailedInfo, MsgsStateReq,
+    MsgsStateInfo, MsgsAllInfo, MsgResendReq, upload, DestroySessionOk, DestroySessionNone,
+    DestroyAuthKeyOk, DestroyAuthKeyNone, DestroyAuthKeyFail
+)
+from ..tl import types as _tl
+from ..crypto import AuthKey
+from ..helpers import retry_range
+
+
+class MTProtoSender:
+    """
+    MTProto Mobile Protocol sender
+    (https://core.telegram.org/mtproto/description).
+
+    This class is responsible for wrapping requests into `TLMessage`'s,
+    sending them over the network and receiving them in a safe manner.
+
+    Automatic reconnection due to temporary network issues is a concern
+    for this class as well, including retry of messages that could not
+    be sent successfully.
+
+    A new authorization key will be generated on connection if no other
+    key exists yet.
+    """
+    def __init__(self, auth_key, *, loggers,
+                 retries=5, delay=1, auto_reconnect=True, connect_timeout=None,
+                 auth_key_callback=None,
+                 updates_queue=None, auto_reconnect_callback=None):
+        self._connection = None
+        self._loggers = loggers
+        self._log = loggers[__name__]
+        self._retries = retries
+        self._delay = delay
+        self._auto_reconnect = auto_reconnect
+        self._connect_timeout = connect_timeout
+        self._auth_key_callback = auth_key_callback
+        self._updates_queue = updates_queue
+        self._auto_reconnect_callback = auto_reconnect_callback
+        self._connect_lock = asyncio.Lock()
+        self._ping = None
+
+        # Whether the user has explicitly connected or disconnected.
+        #
+        # If a disconnection happens for any other reason and it
+        # was *not* user action then the pending messages won't
+        # be cleared but on explicit user disconnection all the
+        # pending futures should be cancelled.
+        self._user_connected = False
+        self._reconnecting = False
+        self._disconnected = helpers.get_running_loop().create_future()
+        self._disconnected.set_result(None)
+
+        # We need to join the loops upon disconnection
+        self._send_loop_handle = None
+        self._recv_loop_handle = None
+
+        # Preserving the references of the AuthKey and state is important
+        self.auth_key = auth_key or AuthKey(None)
+        self._state = MTProtoState(self.auth_key, loggers=self._loggers)
+
+        # Outgoing messages are put in a queue and sent in a batch.
+        # Note that here we're also storing their ``_RequestState``.
+        self._send_queue = MessagePacker(self._state, loggers=self._loggers)
+
+        # Sent states are remembered until a response is received.
+        self._pending_state = {}
+
+        # Responses must be acknowledged, and we can also batch these.
+        self._pending_ack = set()
+
+        # Similar to pending_messages but only for the last acknowledges.
+        # These can't go in pending_messages because no acknowledge for them
+        # is received, but we may still need to resend their state on bad salts.
+        self._last_acks = collections.deque(maxlen=10)
+
+        # Jump table from response ID to method that handles it
+        self._handlers = {
+            RpcResult.CONSTRUCTOR_ID: self._handle_rpc_result,
+            MessageContainer.CONSTRUCTOR_ID: self._handle_container,
+            GzipPacked.CONSTRUCTOR_ID: self._handle_gzip_packed,
+            Pong.CONSTRUCTOR_ID: self._handle_pong,
+            BadServerSalt.CONSTRUCTOR_ID: self._handle_bad_server_salt,
+            BadMsgNotification.CONSTRUCTOR_ID: self._handle_bad_notification,
+            MsgDetailedInfo.CONSTRUCTOR_ID: self._handle_detailed_info,
+            MsgNewDetailedInfo.CONSTRUCTOR_ID: self._handle_new_detailed_info,
+            NewSessionCreated.CONSTRUCTOR_ID: self._handle_new_session_created,
+            MsgsAck.CONSTRUCTOR_ID: self._handle_ack,
+            FutureSalts.CONSTRUCTOR_ID: self._handle_future_salts,
+            MsgsStateReq.CONSTRUCTOR_ID: self._handle_state_forgotten,
+            MsgResendReq.CONSTRUCTOR_ID: self._handle_state_forgotten,
+            MsgsAllInfo.CONSTRUCTOR_ID: self._handle_msg_all,
+            DestroySessionOk.CONSTRUCTOR_ID: self._handle_destroy_session,
+            DestroySessionNone.CONSTRUCTOR_ID: self._handle_destroy_session,
+            DestroyAuthKeyOk.CONSTRUCTOR_ID: self._handle_destroy_auth_key,
+            DestroyAuthKeyNone.CONSTRUCTOR_ID: self._handle_destroy_auth_key,
+            DestroyAuthKeyFail.CONSTRUCTOR_ID: self._handle_destroy_auth_key,
+        }
+
+    # Public API
+
+    async def connect(self, connection):
+        """
+        Connects to the specified given connection using the given auth key.
+        """
+        async with self._connect_lock:
+            if self._user_connected:
+                self._log.info('User is already connected!')
+                return False
+
+            self._connection = connection
+            await self._connect()
+            self._user_connected = True
+            return True
+
+    def is_connected(self):
+        return self._user_connected
+
+    def _transport_connected(self):
+        return (
+            not self._reconnecting
+            and self._connection is not None
+            and self._connection._connected
+        )
+
+    async def disconnect(self):
+        """
+        Cleanly disconnects the instance from the network, cancels
+        all pending requests, and closes the send and receive loops.
+        """
+        await self._disconnect()
+
+    def send(self, request, ordered=False):
+        """
+        This method enqueues the given request to be sent. Its send
+        state will be saved until a response arrives, and a ``Future``
+        that will be resolved when the response arrives will be returned:
+
+        .. code-block:: python
+
+            async def method():
+                # Sending (enqueued for the send loop)
+                future = sender.send(request)
+                # Receiving (waits for the receive loop to read the result)
+                result = await future
+
+        Designed like this because Telegram may send the response at
+        any point, and it can send other items while one waits for it.
+        Once the response for this future arrives, it is set with the
+        received result, quite similar to how a ``receive()`` call
+        would otherwise work.
+
+        Since the receiving part is "built in" the future, it's
+        impossible to await receive a result that was never sent.
+        """
+        if not self._user_connected:
+            raise ConnectionError('Cannot send requests while disconnected')
+
+        if not utils.is_list_like(request):
+            try:
+                state = RequestState(request)
+            except struct.error as e:
+                # "struct.error: required argument is not an integer" is not
+                # very helpful; log the request to find out what wasn't int.
+                self._log.error('Request caused struct.error: %s: %s', e, request)
+                raise
+
+            self._send_queue.append(state)
+            return state.future
+        else:
+            states = []
+            futures = []
+            state = None
+            for req in request:
+                try:
+                    state = RequestState(req, after=ordered and state)
+                except struct.error as e:
+                    self._log.error('Request caused struct.error: %s: %s', e, request)
+                    raise
+
+                states.append(state)
+                futures.append(state.future)
+
+            self._send_queue.extend(states)
+            return futures
+
+    @property
+    def disconnected(self):
+        """
+        Future that resolves when the connection to Telegram
+        ends, either by user action or in the background.
+
+        Note that it may resolve in either a ``ConnectionError``
+        or any other unexpected error that could not be handled.
+        """
+        return asyncio.shield(self._disconnected)
+
+    # Private methods
+
+    async def _connect(self):
+        """
+        Performs the actual connection, retrying, generating the
+        authorization key if necessary, and starting the send and
+        receive loops.
+        """
+        self._log.info('Connecting to %s...', self._connection)
+
+        connected = False
+
+        for attempt in retry_range(self._retries):
+            if not connected:
+                connected = await self._try_connect(attempt)
+                if not connected:
+                    continue  # skip auth key generation until we're connected
+
+            if not self.auth_key:
+                try:
+                    if not await self._try_gen_auth_key(attempt):
+                        continue  # keep retrying until we have the auth key
+                except (IOError, asyncio.TimeoutError) as e:
+                    # Sometimes, specially during user-DC migrations,
+                    # Telegram may close the connection during auth_key
+                    # generation. If that's the case, we will need to
+                    # connect again.
+                    self._log.warning('Connection error %d during auth_key gen: %s: %s',
+                                      attempt, type(e).__name__, e)
+
+                    # Whatever the IOError was, make sure to disconnect so we can
+                    # reconnect cleanly after.
+                    await self._connection.disconnect()
+                    connected = False
+                    await asyncio.sleep(self._delay)
+                    continue  # next iteration we will try to reconnect
+
+            break  # all steps done, break retry loop
+        else:
+            if not connected:
+                raise ConnectionError('Connection to Telegram failed {} time(s)'.format(self._retries))
+
+            e = ConnectionError('auth_key generation failed {} time(s)'.format(self._retries))
+            await self._disconnect(error=e)
+            raise e
+
+        loop = helpers.get_running_loop()
+        self._log.debug('Starting send loop')
+        self._send_loop_handle = loop.create_task(self._send_loop())
+
+        self._log.debug('Starting receive loop')
+        self._recv_loop_handle = loop.create_task(self._recv_loop())
+
+        # _disconnected only completes after manual disconnection
+        # or errors after which the sender cannot continue such
+        # as failing to reconnect or any unexpected error.
+        if self._disconnected.done():
+            self._disconnected = loop.create_future()
+
+        self._log.info('Connection to %s complete!', self._connection)
+
+    async def _try_connect(self, attempt):
+        try:
+            self._log.debug('Connection attempt %d...', attempt)
+            await self._connection.connect(timeout=self._connect_timeout)
+            self._log.debug('Connection success!')
+            return True
+        except (IOError, asyncio.TimeoutError) as e:
+            self._log.warning('Attempt %d at connecting failed: %s: %s',
+                              attempt, type(e).__name__, e)
+            await asyncio.sleep(self._delay)
+            return False
+
+    async def _try_gen_auth_key(self, attempt):
+        plain = MTProtoPlainSender(self._connection, loggers=self._loggers)
+        try:
+            self._log.debug('New auth_key attempt %d...', attempt)
+            self.auth_key.key, self._state.time_offset = \
+                await authenticator.do_authentication(plain)
+
+            # This is *EXTREMELY* important since we don't control
+            # external references to the authorization key, we must
+            # notify whenever we change it. This is crucial when we
+            # switch to different data centers.
+            if self._auth_key_callback:
+                self._auth_key_callback(self.auth_key)
+
+            self._log.debug('auth_key generation success!')
+            return True
+        except (SecurityError, AssertionError) as e:
+            self._log.warning('Attempt %d at new auth_key failed: %s', attempt, e)
+            await asyncio.sleep(self._delay)
+            return False
+
+    async def _disconnect(self, error=None):
+        if self._connection is None:
+            self._log.info('Not disconnecting (already have no connection)')
+            return
+
+        self._log.info('Disconnecting from %s...', self._connection)
+        self._user_connected = False
+        try:
+            self._log.debug('Closing current connection...')
+            await self._connection.disconnect()
+        finally:
+            self._log.debug('Cancelling %d pending message(s)...', len(self._pending_state))
+            for state in self._pending_state.values():
+                if error and not state.future.done():
+                    state.future.set_exception(error)
+                else:
+                    state.future.cancel()
+
+            self._pending_state.clear()
+            await helpers._cancel(
+                self._log,
+                send_loop_handle=self._send_loop_handle,
+                recv_loop_handle=self._recv_loop_handle
+            )
+
+            self._log.info('Disconnection from %s complete!', self._connection)
+            self._connection = None
+
+        if self._disconnected and not self._disconnected.done():
+            if error:
+                self._disconnected.set_exception(error)
+            else:
+                self._disconnected.set_result(None)
+
+    async def _reconnect(self, last_error):
+        """
+        Cleanly disconnects and then reconnects.
+        """
+        self._log.info('Closing current connection to begin reconnect...')
+        await self._connection.disconnect()
+
+        await helpers._cancel(
+            self._log,
+            send_loop_handle=self._send_loop_handle,
+            recv_loop_handle=self._recv_loop_handle
+        )
+
+        # TODO See comment in `_start_reconnect`
+        # Perhaps this should be the last thing to do?
+        # But _connect() creates tasks which may run and,
+        # if they see that reconnecting is True, they will end.
+        # Perhaps that task creation should not belong in connect?
+        self._reconnecting = False
+
+        # Start with a clean state (and thus session ID) to avoid old msgs
+        self._state.reset()
+
+        retries = self._retries if self._auto_reconnect else 0
+
+        attempt = 0
+        ok = True
+        # We're already "retrying" to connect, so we don't want to force retries
+        for attempt in retry_range(retries, force_retry=False):
+            try:
+                await self._connect()
+            except (IOError, asyncio.TimeoutError) as e:
+                last_error = e
+                self._log.info('Failed reconnection attempt %d with %s',
+                               attempt, e.__class__.__name__)
+                await asyncio.sleep(self._delay)
+            except BufferError as e:
+                # TODO there should probably only be one place to except all these errors
+                if isinstance(e, InvalidBufferError) and e.code == 404:
+                    self._log.info('Server does not know about the current auth key; the session may need to be recreated')
+                    last_error = AuthKeyNotFound()
+                    ok = False
+                    break
+                else:
+                    self._log.warning('Invalid buffer %s', e)
+
+            except Exception as e:
+                last_error = e
+                self._log.exception('Unexpected exception reconnecting on '
+                                    'attempt %d', attempt)
+
+                await asyncio.sleep(self._delay)
+            else:
+                self._send_queue.extend(self._pending_state.values())
+                self._pending_state.clear()
+
+                if self._auto_reconnect_callback:
+                    helpers.get_running_loop().create_task(self._auto_reconnect_callback())
+
+                break
+        else:
+            ok = False
+
+        if not ok:
+            self._log.error('Automatic reconnection failed %d time(s)', attempt)
+            # There may be no error (e.g. automatic reconnection was turned off).
+            error = last_error.with_traceback(None) if last_error else None
+            await self._disconnect(error=error)
+
+    def _start_reconnect(self, error):
+        """Starts a reconnection in the background."""
+        if self._user_connected and not self._reconnecting:
+            # We set reconnecting to True here and not inside the new task
+            # because it may happen that send/recv loop calls this again
+            # while the new task hasn't had a chance to run yet. This race
+            # condition puts `self.connection` in a bad state with two calls
+            # to its `connect` without disconnecting, so it creates a second
+            # receive loop. There can't be two tasks receiving data from
+            # the reader, since that causes an error, and the library just
+            # gets stuck.
+            # TODO It still gets stuck? Investigate where and why.
+            self._reconnecting = True
+            helpers.get_running_loop().create_task(self._reconnect(error))
+
+    def _keepalive_ping(self, rnd_id):
+        """
+        Send a keep-alive ping. If a pong for the last ping was not received
+        yet, this means we're probably not connected.
+        """
+        # TODO this is ugly, update loop shouldn't worry about this, sender should
+        if self._ping is None:
+            self._ping = rnd_id
+            self.send(PingRequest(rnd_id))
+        else:
+            self._start_reconnect(None)
+
+    # Loops
+
+    async def _send_loop(self):
+        """
+        This loop is responsible for popping items off the send
+        queue, encrypting them, and sending them over the network.
+
+        Besides `connect`, only this method ever sends data.
+        """
+        while self._user_connected and not self._reconnecting:
+            if self._pending_ack:
+                ack = RequestState(MsgsAck(list(self._pending_ack)))
+                self._send_queue.append(ack)
+                self._last_acks.append(ack)
+                self._pending_ack.clear()
+
+            self._log.debug('Waiting for messages to send...')
+            # TODO Wait for the connection send queue to be empty?
+            # This means that while it's not empty we can wait for
+            # more messages to be added to the send queue.
+            batch, data = await self._send_queue.get()
+
+            if not data:
+                continue
+
+            self._log.debug('Encrypting %d message(s) in %d bytes for sending',
+                            len(batch), len(data))
+
+            data = self._state.encrypt_message_data(data)
+
+            # Whether sending succeeds or not, the popped requests are now
+            # pending because they're removed from the queue. If a reconnect
+            # occurs, they will be removed from pending state and re-enqueued
+            # so even if the network fails they won't be lost. If they were
+            # never re-enqueued, the future waiting for a response "locks".
+            for state in batch:
+                if not isinstance(state, list):
+                    if isinstance(state.request, TLRequest):
+                        self._pending_state[state.msg_id] = state
+                else:
+                    for s in state:
+                        if isinstance(s.request, TLRequest):
+                            self._pending_state[s.msg_id] = s
+
+            try:
+                await self._connection.send(data)
+            except IOError as e:
+                self._log.info('Connection closed while sending data')
+                self._start_reconnect(e)
+                return
+
+            self._log.debug('Encrypted messages put in a queue to be sent')
+
+    async def _recv_loop(self):
+        """
+        This loop is responsible for reading all incoming responses
+        from the network, decrypting and handling or dispatching them.
+
+        Besides `connect`, only this method ever receives data.
+        """
+        while self._user_connected and not self._reconnecting:
+            self._log.debug('Receiving items from the network...')
+            try:
+                body = await self._connection.recv()
+            except asyncio.CancelledError:
+                raise  # bypass except Exception
+            except (IOError, asyncio.IncompleteReadError) as e:
+                self._log.info('Connection closed while receiving data: %s', e)
+                self._start_reconnect(e)
+                return
+            except InvalidBufferError as e:
+                if e.code == 429:
+                    self._log.warning('Server indicated flood error at transport level: %s', e)
+                    await self._disconnect(error=e)
+                else:
+                    self._log.exception('Server sent invalid buffer')
+                    self._start_reconnect(e)
+                return
+            except Exception as e:
+                self._log.exception('Unhandled error while receiving data')
+                self._start_reconnect(e)
+                return
+
+            try:
+                message = self._state.decrypt_message_data(body)
+                if message is None:
+                    continue  # this message is to be ignored
+            except TypeNotFoundError as e:
+                # Received object which we don't know how to deserialize
+                self._log.info('Type %08x not found, remaining data %r',
+                               e.invalid_constructor_id, e.remaining)
+                continue
+            except SecurityError as e:
+                # A step while decoding had the incorrect data. This message
+                # should not be considered safe and it should be ignored.
+                self._log.warning('Security error while unpacking a '
+                                  'received message: %s', e)
+                continue
+            except BufferError as e:
+                if isinstance(e, InvalidBufferError) and e.code == 404:
+                    self._log.info('Server does not know about the current auth key; the session may need to be recreated')
+                    await self._disconnect(error=AuthKeyNotFound())
+                else:
+                    self._log.warning('Invalid buffer %s', e)
+                    self._start_reconnect(e)
+                return
+            except Exception as e:
+                self._log.exception('Unhandled error while decrypting data')
+                self._start_reconnect(e)
+                return
+
+            try:
+                await self._process_message(message)
+            except Exception:
+                self._log.exception('Unhandled error while processing msgs')
+
+    # Response Handlers
+
+    async def _process_message(self, message):
+        """
+        Adds the given message to the list of messages that must be
+        acknowledged and dispatches control to different ``_handle_*``
+        method based on its type.
+        """
+        self._pending_ack.add(message.msg_id)
+        handler = self._handlers.get(message.obj.CONSTRUCTOR_ID,
+                                     self._handle_update)
+        await handler(message)
+
+    def _pop_states(self, msg_id):
+        """
+        Pops the states known to match the given ID from pending messages.
+
+        This method should be used when the response isn't specific.
+        """
+        state = self._pending_state.pop(msg_id, None)
+        if state:
+            return [state]
+
+        to_pop = []
+        for state in self._pending_state.values():
+            if state.container_id == msg_id:
+                to_pop.append(state.msg_id)
+
+        if to_pop:
+            return [self._pending_state.pop(x) for x in to_pop]
+
+        for ack in self._last_acks:
+            if ack.msg_id == msg_id:
+                return [ack]
+
+        return []
+
+    async def _handle_rpc_result(self, message):
+        """
+        Handles the result for Remote Procedure Calls:
+
+            rpc_result#f35c6d01 req_msg_id:long result:bytes = RpcResult;
+
+        This is where the future results for sent requests are set.
+        """
+        rpc_result = message.obj
+        state = self._pending_state.pop(rpc_result.req_msg_id, None)
+        self._log.debug('Handling RPC result for message %d',
+                        rpc_result.req_msg_id)
+
+        if not state:
+            # TODO We should not get responses to things we never sent
+            # However receiving a File() with empty bytes is "common".
+            # See #658, #759 and #958. They seem to happen in a container
+            # which contain the real response right after.
+            #
+            # But, it might also happen that we get an *error* for no parent request.
+            # If that's the case attempting to read from body which is None would fail with:
+            # "BufferError: No more data left to read (need 4, got 0: b''); last read None".
+            # This seems to be particularly common for "RpcError(error_code=-500, error_message='No workers running')".
+            if rpc_result.error:
+                self._log.info('Received error without parent request: %s', rpc_result.error)
+            else:
+                try:
+                    with BinaryReader(rpc_result.body) as reader:
+                        if not isinstance(reader.tgread_object(), upload.File):
+                            raise ValueError('Not an upload.File')
+                except (TypeNotFoundError, ValueError):
+                    self._log.info('Received response without parent request: %s', rpc_result.body)
+            return
+
+        if rpc_result.error:
+            error = rpc_message_to_error(rpc_result.error, state.request)
+            self._send_queue.append(
+                RequestState(MsgsAck([state.msg_id])))
+
+            if not state.future.cancelled():
+                state.future.set_exception(error)
+        else:
+            try:
+                with BinaryReader(rpc_result.body) as reader:
+                    result = state.request.read_result(reader)
+            except Exception as e:
+                # e.g. TypeNotFoundError, should be propagated to caller
+                if not state.future.cancelled():
+                    state.future.set_exception(e)
+            else:
+                self._store_own_updates(result)
+                if not state.future.cancelled():
+                    state.future.set_result(result)
+
+    async def _handle_container(self, message):
+        """
+        Processes the inner messages of a container with many of them:
+
+            msg_container#73f1f8dc messages:vector<%Message> = MessageContainer;
+        """
+        self._log.debug('Handling container')
+        for inner_message in message.obj.messages:
+            await self._process_message(inner_message)
+
+    async def _handle_gzip_packed(self, message):
+        """
+        Unpacks the data from a gzipped object and processes it:
+
+            gzip_packed#3072cfa1 packed_data:bytes = Object;
+        """
+        self._log.debug('Handling gzipped data')
+        with BinaryReader(message.obj.data) as reader:
+            message.obj = reader.tgread_object()
+            await self._process_message(message)
+
+    async def _handle_update(self, message):
+        try:
+            assert message.obj.SUBCLASS_OF_ID == 0x8af52aac  # crc32(b'Updates')
+        except AssertionError:
+            self._log.warning(
+                'Note: %s is not an update, not dispatching it %s',
+                message.obj.__class__.__name__,
+                message.obj
+            )
+            return
+
+        self._log.debug('Handling update %s', message.obj.__class__.__name__)
+        self._updates_queue.put_nowait(message.obj)
+
+    def _store_own_updates(self, obj, *, _update_ids=frozenset((
+        _tl.UpdateShortMessage.CONSTRUCTOR_ID,
+        _tl.UpdateShortChatMessage.CONSTRUCTOR_ID,
+        _tl.UpdateShort.CONSTRUCTOR_ID,
+        _tl.UpdatesCombined.CONSTRUCTOR_ID,
+        _tl.Updates.CONSTRUCTOR_ID,
+        _tl.UpdateShortSentMessage.CONSTRUCTOR_ID,
+    )), _update_like_ids=frozenset((
+        _tl.messages.AffectedHistory.CONSTRUCTOR_ID,
+        _tl.messages.AffectedMessages.CONSTRUCTOR_ID,
+        _tl.messages.AffectedFoundMessages.CONSTRUCTOR_ID,
+    ))):
+        try:
+            if obj.CONSTRUCTOR_ID in _update_ids:
+                obj._self_outgoing = True  # flag to only process, but not dispatch these
+                self._updates_queue.put_nowait(obj)
+            elif obj.CONSTRUCTOR_ID in _update_like_ids:
+                # Ugly "hack" (?) - otherwise bots reliably detect gaps when deleting messages.
+                #
+                # Note: the `date` being `None` is used to check for `updatesTooLong`, so epoch
+                # is used instead. It is still not read, because `updateShort` has no `seq`.
+                #
+                # Some requests, such as `readHistory`, also return these types. But the `pts_count`
+                # seems to be zero, so while this will produce some bogus `updateDeleteMessages`,
+                # it's still one of the "cleaner" approaches to handling the new `pts`.
+                # `updateDeleteMessages` is probably the "least-invasive" update that can be used.
+                upd = _tl.UpdateShort(
+                    _tl.UpdateDeleteMessages([], obj.pts, obj.pts_count),
+                    datetime.datetime(*time.gmtime(0)[:6]).replace(tzinfo=datetime.timezone.utc)
+                )
+                upd._self_outgoing = True
+                self._updates_queue.put_nowait(upd)
+        except AttributeError:
+            pass
+
+    async def _handle_pong(self, message):
+        """
+        Handles pong results, which don't come inside a ``rpc_result``
+        but are still sent through a request:
+
+            pong#347773c5 msg_id:long ping_id:long = Pong;
+        """
+        pong = message.obj
+        self._log.debug('Handling pong for message %d', pong.msg_id)
+        if self._ping == pong.ping_id:
+            self._ping = None
+
+        state = self._pending_state.pop(pong.msg_id, None)
+        if state:
+            state.future.set_result(pong)
+
+    async def _handle_bad_server_salt(self, message):
+        """
+        Corrects the currently used server salt to use the right value
+        before enqueuing the rejected message to be re-sent:
+
+            bad_server_salt#edab447b bad_msg_id:long bad_msg_seqno:int
+            error_code:int new_server_salt:long = BadMsgNotification;
+        """
+        bad_salt = message.obj
+        self._log.debug('Handling bad salt for message %d', bad_salt.bad_msg_id)
+        self._state.salt = bad_salt.new_server_salt
+        states = self._pop_states(bad_salt.bad_msg_id)
+        self._send_queue.extend(states)
+
+        self._log.debug('%d message(s) will be resent', len(states))
+
+    async def _handle_bad_notification(self, message):
+        """
+        Adjusts the current state to be correct based on the
+        received bad message notification whenever possible:
+
+            bad_msg_notification#a7eff811 bad_msg_id:long bad_msg_seqno:int
+            error_code:int = BadMsgNotification;
+        """
+        bad_msg = message.obj
+        states = self._pop_states(bad_msg.bad_msg_id)
+
+        self._log.debug('Handling bad msg %s', bad_msg)
+        if bad_msg.error_code in (16, 17):
+            # Sent msg_id too low or too high (respectively).
+            # Use the current msg_id to determine the right time offset.
+            to = self._state.update_time_offset(
+                correct_msg_id=message.msg_id)
+            self._log.info('System clock is wrong, set time offset to %ds', to)
+        elif bad_msg.error_code == 32:
+            # msg_seqno too low, so just pump it up by some "large" amount
+            # TODO A better fix would be to start with a new fresh session ID
+            self._state._sequence += 64
+        elif bad_msg.error_code == 33:
+            # msg_seqno too high never seems to happen but just in case
+            self._state._sequence -= 16
+        else:
+            for state in states:
+                state.future.set_exception(
+                    BadMessageError(state.request, bad_msg.error_code))
+            return
+
+        # Messages are to be re-sent once we've corrected the issue
+        self._send_queue.extend(states)
+        self._log.debug('%d messages will be resent due to bad msg',
+                        len(states))
+
+    async def _handle_detailed_info(self, message):
+        """
+        Updates the current status with the received detailed information:
+
+            msg_detailed_info#276d3ec6 msg_id:long answer_msg_id:long
+            bytes:int status:int = MsgDetailedInfo;
+        """
+        # TODO https://goo.gl/VvpCC6
+        msg_id = message.obj.answer_msg_id
+        self._log.debug('Handling detailed info for message %d', msg_id)
+        self._pending_ack.add(msg_id)
+
+    async def _handle_new_detailed_info(self, message):
+        """
+        Updates the current status with the received detailed information:
+
+            msg_new_detailed_info#809db6df answer_msg_id:long
+            bytes:int status:int = MsgDetailedInfo;
+        """
+        # TODO https://goo.gl/G7DPsR
+        msg_id = message.obj.answer_msg_id
+        self._log.debug('Handling new detailed info for message %d', msg_id)
+        self._pending_ack.add(msg_id)
+
+    async def _handle_new_session_created(self, message):
+        """
+        Updates the current status with the received session information:
+
+            new_session_created#9ec20908 first_msg_id:long unique_id:long
+            server_salt:long = NewSession;
+        """
+        # TODO https://goo.gl/LMyN7A
+        self._log.debug('Handling new session created')
+        self._state.salt = message.obj.server_salt
+
+    async def _handle_ack(self, message):
+        """
+        Handles a server acknowledge about our messages. Normally
+        these can be ignored except in the case of ``auth.logOut``:
+
+            auth.logOut#5717da40 = Bool;
+
+        Telegram doesn't seem to send its result so we need to confirm
+        it manually. No other request is known to have this behaviour.
+
+        Since the ID of sent messages consisting of a container is
+        never returned (unless on a bad notification), this method
+        also removes containers messages when any of their inner
+        messages are acknowledged.
+        """
+        ack = message.obj
+        self._log.debug('Handling acknowledge for %s', str(ack.msg_ids))
+        for msg_id in ack.msg_ids:
+            state = self._pending_state.get(msg_id)
+            if state and isinstance(state.request, LogOutRequest):
+                del self._pending_state[msg_id]
+                if not state.future.cancelled():
+                    state.future.set_result(True)
+
+    async def _handle_future_salts(self, message):
+        """
+        Handles future salt results, which don't come inside a
+        ``rpc_result`` but are still sent through a request:
+
+            future_salts#ae500895 req_msg_id:long now:int
+            salts:vector<future_salt> = FutureSalts;
+        """
+        # TODO save these salts and automatically adjust to the
+        # correct one whenever the salt in use expires.
+        self._log.debug('Handling future salts for message %d', message.msg_id)
+        state = self._pending_state.pop(message.msg_id, None)
+        if state:
+            state.future.set_result(message.obj)
+
+    async def _handle_state_forgotten(self, message):
+        """
+        Handles both :tl:`MsgsStateReq` and :tl:`MsgResendReq` by
+        enqueuing a :tl:`MsgsStateInfo` to be sent at a later point.
+        """
+        self._send_queue.append(RequestState(MsgsStateInfo(
+            req_msg_id=message.msg_id, info=chr(1) * len(message.obj.msg_ids)
+        )))
+
+    async def _handle_msg_all(self, message):
+        """
+        Handles :tl:`MsgsAllInfo` by doing nothing (yet).
+        """
+
+    async def _handle_destroy_session(self, message):
+        """
+        Handles both :tl:`DestroySessionOk` and :tl:`DestroySessionNone`.
+        It behaves pretty much like handling an RPC result.
+        """
+        for msg_id, state in self._pending_state.items():
+            if isinstance(state.request, DestroySessionRequest)\
+                    and state.request.session_id == message.obj.session_id:
+                break
+        else:
+            return
+
+        del self._pending_state[msg_id]
+        if not state.future.cancelled():
+            state.future.set_result(message.obj)
+
+    async def _handle_destroy_auth_key(self, message):
+        """
+        Handles :tl:`DestroyAuthKeyFail`, :tl:`DestroyAuthKeyNone`, and :tl:`DestroyAuthKeyOk`.
+
+        :tl:`DestroyAuthKey` is not intended for users to use, but they still
+        might, and the response won't come in `rpc_result`, so thhat's worked
+        around here.
+        """
+        self._log.debug('Handling destroy auth key %s', message.obj)
+        for msg_id, state in list(self._pending_state.items()):
+            if isinstance(state.request, DestroyAuthKeyRequest):
+                del self._pending_state[msg_id]
+                if not state.future.cancelled():
+                    state.future.set_result(message.obj)
+
+        # If the auth key has been destroyed, that pretty much means the
+        # library can't continue as our auth key will no longer be found
+        # on the server.
+        # Even if the library didn't disconnect, the server would (and then
+        # the library would reconnect and learn about auth key being invalid).
+        if isinstance(message.obj, DestroyAuthKeyOk):
+            await self._disconnect(error=AuthKeyNotFound())

.venv2/Lib/site-packages/telethon/network/mtprotostate.py

@@ -0,0 +1,279 @@
+import os
+import struct
+import time
+from hashlib import sha256
+from collections import deque
+
+from ..crypto import AES
+from ..errors import SecurityError, InvalidBufferError
+from ..extensions import BinaryReader
+from ..tl.core import TLMessage
+from ..tl.tlobject import TLRequest
+from ..tl.functions import InvokeAfterMsgRequest
+from ..tl.core.gzippacked import GzipPacked
+from ..tl.types import BadServerSalt, BadMsgNotification
+
+
+# N is not  specified in https://core.telegram.org/mtproto/security_guidelines#checking-msg-id, but 500 is reasonable
+MAX_RECENT_MSG_IDS = 500
+
+MSG_TOO_NEW_DELTA = 30
+MSG_TOO_OLD_DELTA = 300
+
+# Something must be wrong if we ignore too many messages at the same time
+MAX_CONSECUTIVE_IGNORED = 10
+
+
+class _OpaqueRequest(TLRequest):
+    """
+    Wraps a serialized request into a type that can be serialized again.
+    """
+    def __init__(self, data: bytes):
+        self.data = data
+
+    def _bytes(self):
+        return self.data
+
+
+
+class MTProtoState:
+    """
+    `telethon.network.mtprotosender.MTProtoSender` needs to hold a state
+    in order to be able to encrypt and decrypt incoming/outgoing messages,
+    as well as generating the message IDs. Instances of this class hold
+    together all the required information.
+
+    It doesn't make sense to use `telethon.sessions.abstract.Session` for
+    the sender because the sender should *not* be concerned about storing
+    this information to disk, as one may create as many senders as they
+    desire to any other data center, or some CDN. Using the same session
+    for all these is not a good idea as each need their own authkey, and
+    the concept of "copying" sessions with the unnecessary entities or
+    updates state for these connections doesn't make sense.
+
+    While it would be possible to have a `MTProtoPlainState` that does no
+    encryption so that it was usable through the `MTProtoLayer` and thus
+    avoid the need for a `MTProtoPlainSender`, the `MTProtoLayer` is more
+    focused to efficiency and this state is also more advanced (since it
+    supports gzipping and invoking after other message IDs). There are too
+    many methods that would be needed to make it convenient to use for the
+    authentication process, at which point the `MTProtoPlainSender` is better.
+    """
+    def __init__(self, auth_key, loggers):
+        self.auth_key = auth_key
+        self._log = loggers[__name__]
+        self.time_offset = 0
+        self.salt = 0
+
+        self.id = self._sequence = self._last_msg_id = None
+        self._recent_remote_ids = deque(maxlen=MAX_RECENT_MSG_IDS)
+        self._highest_remote_id = 0
+        self._ignore_count = 0
+        self.reset()
+
+    def reset(self):
+        """
+        Resets the state.
+        """
+        # Session IDs can be random on every connection
+        self.id = struct.unpack('q', os.urandom(8))[0]
+        self._sequence = 0
+        self._last_msg_id = 0
+        self._recent_remote_ids.clear()
+        self._highest_remote_id = 0
+        self._ignore_count = 0
+
+    def update_message_id(self, message):
+        """
+        Updates the message ID to a new one,
+        used when the time offset changed.
+        """
+        message.msg_id = self._get_new_msg_id()
+
+    @staticmethod
+    def _calc_key(auth_key, msg_key, client):
+        """
+        Calculate the key based on Telegram guidelines for MTProto 2,
+        specifying whether it's the client or not. See
+        https://core.telegram.org/mtproto/description#defining-aes-key-and-initialization-vector
+        """
+        x = 0 if client else 8
+        sha256a = sha256(msg_key + auth_key[x: x + 36]).digest()
+        sha256b = sha256(auth_key[x + 40:x + 76] + msg_key).digest()
+
+        aes_key = sha256a[:8] + sha256b[8:24] + sha256a[24:32]
+        aes_iv = sha256b[:8] + sha256a[8:24] + sha256b[24:32]
+
+        return aes_key, aes_iv
+
+    def write_data_as_message(self, buffer, data, content_related,
+                              *, after_id=None):
+        """
+        Writes a message containing the given data into buffer.
+
+        Returns the message id.
+        """
+        msg_id = self._get_new_msg_id()
+        seq_no = self._get_seq_no(content_related)
+        if after_id is None:
+            body = GzipPacked.gzip_if_smaller(content_related, data)
+        else:
+            # The `RequestState` stores `bytes(request)`, not the request itself.
+            # `invokeAfterMsg` wants a `TLRequest` though, hence the wrapping.
+            body = GzipPacked.gzip_if_smaller(content_related,
+                bytes(InvokeAfterMsgRequest(after_id, _OpaqueRequest(data))))
+
+        buffer.write(struct.pack('<qii', msg_id, seq_no, len(body)))
+        buffer.write(body)
+        return msg_id
+
+    def encrypt_message_data(self, data):
+        """
+        Encrypts the given message data using the current authorization key
+        following MTProto 2.0 guidelines core.telegram.org/mtproto/description.
+        """
+        data = struct.pack('<qq', self.salt, self.id) + data
+        padding = os.urandom(-(len(data) + 12) % 16 + 12)
+
+        # Being substr(what, offset, length); x = 0 for client
+        # "msg_key_large = SHA256(substr(auth_key, 88+x, 32) + pt + padding)"
+        msg_key_large = sha256(
+            self.auth_key.key[88:88 + 32] + data + padding).digest()
+
+        # "msg_key = substr (msg_key_large, 8, 16)"
+        msg_key = msg_key_large[8:24]
+        aes_key, aes_iv = self._calc_key(self.auth_key.key, msg_key, True)
+
+        key_id = struct.pack('<Q', self.auth_key.key_id)
+        return (key_id + msg_key +
+                AES.encrypt_ige(data + padding, aes_key, aes_iv))
+
+    def decrypt_message_data(self, body):
+        """
+        Inverse of `encrypt_message_data` for incoming server messages.
+        """
+        now = time.time() + self.time_offset  # get the time as early as possible, even if other checks make it go unused
+
+        if len(body) < 8:
+            raise InvalidBufferError(body)
+
+        # TODO Check salt, session_id and sequence_number
+        key_id = struct.unpack('<Q', body[:8])[0]
+        if key_id != self.auth_key.key_id:
+            raise SecurityError('Server replied with an invalid auth key')
+
+        msg_key = body[8:24]
+        aes_key, aes_iv = self._calc_key(self.auth_key.key, msg_key, False)
+        body = AES.decrypt_ige(body[24:], aes_key, aes_iv)
+
+        # https://core.telegram.org/mtproto/security_guidelines
+        # Sections "checking sha256 hash" and "message length"
+        our_key = sha256(self.auth_key.key[96:96 + 32] + body)
+        if msg_key != our_key.digest()[8:24]:
+            raise SecurityError(
+                "Received msg_key doesn't match with expected one")
+
+        reader = BinaryReader(body)
+        reader.read_long()  # remote_salt
+        if reader.read_long() != self.id:
+            raise SecurityError('Server replied with a wrong session ID (see FAQ for details)')
+
+        remote_msg_id = reader.read_long()
+
+        if remote_msg_id % 2 != 1:
+            raise SecurityError('Server sent an even msg_id')
+
+        # Only perform the (somewhat expensive) check of duplicate if we did receive a lower ID
+        if remote_msg_id <= self._highest_remote_id and remote_msg_id in self._recent_remote_ids:
+            self._log.warning('Server resent the older message %d, ignoring', remote_msg_id)
+            self._count_ignored()
+            return None
+
+        remote_sequence = reader.read_int()
+        reader.read_int()  # msg_len for the inner object, padding ignored
+
+        # We could read msg_len bytes and use those in a new reader to read
+        # the next TLObject without including the padding, but since the
+        # reader isn't used for anything else after this, it's unnecessary.
+        obj = reader.tgread_object()
+
+        # "Certain client-to-server service messages containing data sent by the client to the
+        # server (for example, msg_id of a recent client query) may, nonetheless, be processed
+        # on the client even if the time appears to be "incorrect". This is especially true of
+        # messages to change server_salt and notifications about invalid time on the client."
+        #
+        # This means we skip the time check for certain types of messages.
+        if obj.CONSTRUCTOR_ID not in (BadServerSalt.CONSTRUCTOR_ID, BadMsgNotification.CONSTRUCTOR_ID):
+            remote_msg_time = remote_msg_id >> 32
+            time_delta = now - remote_msg_time
+
+            if time_delta > MSG_TOO_OLD_DELTA:
+                self._log.warning('Server sent a very old message with ID %d, ignoring (see FAQ for details)', remote_msg_id)
+                self._count_ignored()
+                return None
+
+            if -time_delta > MSG_TOO_NEW_DELTA:
+                self._log.warning('Server sent a very new message with ID %d, ignoring (see FAQ for details)', remote_msg_id)
+                self._count_ignored()
+                return None
+
+        self._recent_remote_ids.append(remote_msg_id)
+        self._highest_remote_id = remote_msg_id
+        self._ignore_count = 0
+
+        return TLMessage(remote_msg_id, remote_sequence, obj)
+
+    def _count_ignored(self):
+        # It's possible that ignoring a message "bricks" the connection,
+        # but this should not happen unless there's something else wrong.
+        self._ignore_count += 1
+        if self._ignore_count >= MAX_CONSECUTIVE_IGNORED:
+            raise SecurityError('Too many messages had to be ignored consecutively')
+
+    def _get_new_msg_id(self):
+        """
+        Generates a new unique message ID based on the current
+        time (in ms) since epoch, applying a known time offset.
+        """
+        now = time.time() + self.time_offset
+        nanoseconds = int((now - int(now)) * 1e+9)
+        new_msg_id = (int(now) << 32) | (nanoseconds << 2)
+
+        if self._last_msg_id >= new_msg_id:
+            new_msg_id = self._last_msg_id + 4
+
+        self._last_msg_id = new_msg_id
+        return new_msg_id
+
+    def update_time_offset(self, correct_msg_id):
+        """
+        Updates the time offset to the correct
+        one given a known valid message ID.
+        """
+        bad = self._get_new_msg_id()
+        old = self.time_offset
+
+        now = int(time.time())
+        correct = correct_msg_id >> 32
+        self.time_offset = correct - now
+
+        if self.time_offset != old:
+            self._last_msg_id = 0
+            self._log.debug(
+                'Updated time offset (old offset %d, bad %d, good %d, new %d)',
+                old, bad, correct_msg_id, self.time_offset
+            )
+
+        return self.time_offset
+
+    def _get_seq_no(self, content_related):
+        """
+        Generates the next sequence number depending on whether
+        it should be for a content-related query or not.
+        """
+        if content_related:
+            result = self._sequence * 2 + 1
+            self._sequence += 1
+            return result
+        else:
+            return self._sequence * 2

.venv2/Lib/site-packages/telethon/network/requeststate.py

@@ -0,0 +1,19 @@
+import asyncio
+
+
+class RequestState:
+    """
+    This request state holds several information relevant to sent messages,
+    in particular the message ID assigned to the request, the container ID
+    it belongs to, the request itself, the request as bytes, and the future
+    result that will eventually be resolved.
+    """
+    __slots__ = ('container_id', 'msg_id', 'request', 'data', 'future', 'after')
+
+    def __init__(self, request, after=None):
+        self.container_id = None
+        self.msg_id = None
+        self.request = request
+        self.data = bytes(request)
+        self.future = asyncio.Future()
+        self.after = after

.venv2/Lib/site-packages/telethon/password.py

@@ -0,0 +1,194 @@
+import hashlib
+import os
+
+from .crypto import factorization
+from .tl import types
+
+
+def check_prime_and_good_check(prime: int, g: int):
+    good_prime_bits_count = 2048
+    if prime < 0 or prime.bit_length() != good_prime_bits_count:
+        raise ValueError('bad prime count {}, expected {}'
+                         .format(prime.bit_length(), good_prime_bits_count))
+
+    # TODO This is awfully slow
+    if factorization.Factorization.factorize(prime)[0] != 1:
+        raise ValueError('given "prime" is not prime')
+
+    if g == 2:
+        if prime % 8 != 7:
+            raise ValueError('bad g {}, mod8 {}'.format(g, prime % 8))
+    elif g == 3:
+        if prime % 3 != 2:
+            raise ValueError('bad g {}, mod3 {}'.format(g, prime % 3))
+    elif g == 4:
+        pass
+    elif g == 5:
+        if prime % 5 not in (1, 4):
+            raise ValueError('bad g {}, mod5 {}'.format(g, prime % 5))
+    elif g == 6:
+        if prime % 24 not in (19, 23):
+            raise ValueError('bad g {}, mod24 {}'.format(g, prime % 24))
+    elif g == 7:
+        if prime % 7 not in (3, 5, 6):
+            raise ValueError('bad g {}, mod7 {}'.format(g, prime % 7))
+    else:
+        raise ValueError('bad g {}'.format(g))
+
+    prime_sub1_div2 = (prime - 1) // 2
+    if factorization.Factorization.factorize(prime_sub1_div2)[0] != 1:
+        raise ValueError('(prime - 1) // 2 is not prime')
+
+    # Else it's good
+
+
+def check_prime_and_good(prime_bytes: bytes, g: int):
+    good_prime = bytes((
+        0xC7, 0x1C, 0xAE, 0xB9, 0xC6, 0xB1, 0xC9, 0x04, 0x8E, 0x6C, 0x52, 0x2F, 0x70, 0xF1, 0x3F, 0x73,
+        0x98, 0x0D, 0x40, 0x23, 0x8E, 0x3E, 0x21, 0xC1, 0x49, 0x34, 0xD0, 0x37, 0x56, 0x3D, 0x93, 0x0F,
+        0x48, 0x19, 0x8A, 0x0A, 0xA7, 0xC1, 0x40, 0x58, 0x22, 0x94, 0x93, 0xD2, 0x25, 0x30, 0xF4, 0xDB,
+        0xFA, 0x33, 0x6F, 0x6E, 0x0A, 0xC9, 0x25, 0x13, 0x95, 0x43, 0xAE, 0xD4, 0x4C, 0xCE, 0x7C, 0x37,
+        0x20, 0xFD, 0x51, 0xF6, 0x94, 0x58, 0x70, 0x5A, 0xC6, 0x8C, 0xD4, 0xFE, 0x6B, 0x6B, 0x13, 0xAB,
+        0xDC, 0x97, 0x46, 0x51, 0x29, 0x69, 0x32, 0x84, 0x54, 0xF1, 0x8F, 0xAF, 0x8C, 0x59, 0x5F, 0x64,
+        0x24, 0x77, 0xFE, 0x96, 0xBB, 0x2A, 0x94, 0x1D, 0x5B, 0xCD, 0x1D, 0x4A, 0xC8, 0xCC, 0x49, 0x88,
+        0x07, 0x08, 0xFA, 0x9B, 0x37, 0x8E, 0x3C, 0x4F, 0x3A, 0x90, 0x60, 0xBE, 0xE6, 0x7C, 0xF9, 0xA4,
+        0xA4, 0xA6, 0x95, 0x81, 0x10, 0x51, 0x90, 0x7E, 0x16, 0x27, 0x53, 0xB5, 0x6B, 0x0F, 0x6B, 0x41,
+        0x0D, 0xBA, 0x74, 0xD8, 0xA8, 0x4B, 0x2A, 0x14, 0xB3, 0x14, 0x4E, 0x0E, 0xF1, 0x28, 0x47, 0x54,
+        0xFD, 0x17, 0xED, 0x95, 0x0D, 0x59, 0x65, 0xB4, 0xB9, 0xDD, 0x46, 0x58, 0x2D, 0xB1, 0x17, 0x8D,
+        0x16, 0x9C, 0x6B, 0xC4, 0x65, 0xB0, 0xD6, 0xFF, 0x9C, 0xA3, 0x92, 0x8F, 0xEF, 0x5B, 0x9A, 0xE4,
+        0xE4, 0x18, 0xFC, 0x15, 0xE8, 0x3E, 0xBE, 0xA0, 0xF8, 0x7F, 0xA9, 0xFF, 0x5E, 0xED, 0x70, 0x05,
+        0x0D, 0xED, 0x28, 0x49, 0xF4, 0x7B, 0xF9, 0x59, 0xD9, 0x56, 0x85, 0x0C, 0xE9, 0x29, 0x85, 0x1F,
+        0x0D, 0x81, 0x15, 0xF6, 0x35, 0xB1, 0x05, 0xEE, 0x2E, 0x4E, 0x15, 0xD0, 0x4B, 0x24, 0x54, 0xBF,
+        0x6F, 0x4F, 0xAD, 0xF0, 0x34, 0xB1, 0x04, 0x03, 0x11, 0x9C, 0xD8, 0xE3, 0xB9, 0x2F, 0xCC, 0x5B))
+
+    if good_prime == prime_bytes:
+        if g in (3, 4, 5, 7):
+            return  # It's good
+
+    check_prime_and_good_check(int.from_bytes(prime_bytes, 'big'), g)
+
+
+def is_good_large(number: int, p: int) -> bool:
+    return number > 0 and p - number > 0
+
+
+SIZE_FOR_HASH = 256
+
+
+def num_bytes_for_hash(number: bytes) -> bytes:
+    return bytes(SIZE_FOR_HASH - len(number)) + number
+
+
+def big_num_for_hash(g: int) -> bytes:
+    return g.to_bytes(SIZE_FOR_HASH, 'big')
+
+
+def sha256(*p: bytes) -> bytes:
+    hash = hashlib.sha256()
+    for q in p:
+        hash.update(q)
+    return hash.digest()
+
+
+def is_good_mod_exp_first(modexp, prime) -> bool:
+    diff = prime - modexp
+    min_diff_bits_count = 2048 - 64
+    max_mod_exp_size = 256
+    if diff < 0 or \
+            diff.bit_length() < min_diff_bits_count or \
+            modexp.bit_length() < min_diff_bits_count or \
+            (modexp.bit_length() + 7) // 8 > max_mod_exp_size:
+        return False
+    return True
+
+
+def xor(a: bytes, b: bytes) -> bytes:
+    return bytes(x ^ y for x, y in zip(a, b))
+
+
+def pbkdf2sha512(password: bytes, salt: bytes, iterations: int):
+    return hashlib.pbkdf2_hmac('sha512', password, salt, iterations)
+
+
+def compute_hash(algo: types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow,
+                 password: str):
+    hash1 = sha256(algo.salt1, password.encode('utf-8'), algo.salt1)
+    hash2 = sha256(algo.salt2, hash1, algo.salt2)
+    hash3 = pbkdf2sha512(hash2, algo.salt1, 100000)
+    return sha256(algo.salt2, hash3, algo.salt2)
+
+
+def compute_digest(algo: types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow,
+                   password: str):
+    try:
+        check_prime_and_good(algo.p, algo.g)
+    except ValueError:
+        raise ValueError('bad p/g in password')
+
+    value = pow(algo.g,
+                int.from_bytes(compute_hash(algo, password), 'big'),
+                int.from_bytes(algo.p, 'big'))
+
+    return big_num_for_hash(value)
+
+
+# https://github.com/telegramdesktop/tdesktop/blob/18b74b90451a7db2379a9d753c9cbaf8734b4d5d/Telegram/SourceFiles/core/core_cloud_password.cpp
+def compute_check(request: types.account.Password, password: str):
+    algo = request.current_algo
+    if not isinstance(algo, types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow):
+        raise ValueError('unsupported password algorithm {}'
+                         .format(algo.__class__.__name__))
+
+    pw_hash = compute_hash(algo, password)
+
+    p = int.from_bytes(algo.p, 'big')
+    g = algo.g
+    B = int.from_bytes(request.srp_B, 'big')
+    try:
+        check_prime_and_good(algo.p, g)
+    except ValueError:
+        raise ValueError('bad p/g in password')
+
+    if not is_good_large(B, p):
+        raise ValueError('bad b in check')
+
+    x = int.from_bytes(pw_hash, 'big')
+    p_for_hash = num_bytes_for_hash(algo.p)
+    g_for_hash = big_num_for_hash(g)
+    b_for_hash = num_bytes_for_hash(request.srp_B)
+    g_x = pow(g, x, p)
+    k = int.from_bytes(sha256(p_for_hash, g_for_hash), 'big')
+    kg_x = (k * g_x) % p
+
+    def generate_and_check_random():
+        random_size = 256
+        while True:
+            random = os.urandom(random_size)
+            a = int.from_bytes(random, 'big')
+            A = pow(g, a, p)
+            if is_good_mod_exp_first(A, p):
+                a_for_hash = big_num_for_hash(A)
+                u = int.from_bytes(sha256(a_for_hash, b_for_hash), 'big')
+                if u > 0:
+                    return (a, a_for_hash, u)
+
+    a, a_for_hash, u = generate_and_check_random()
+    g_b = (B - kg_x) % p
+    if not is_good_mod_exp_first(g_b, p):
+        raise ValueError('bad g_b')
+
+    ux = u * x
+    a_ux = a + ux
+    S = pow(g_b, a_ux, p)
+    K = sha256(big_num_for_hash(S))
+    M1 = sha256(
+        xor(sha256(p_for_hash), sha256(g_for_hash)),
+        sha256(algo.salt1),
+        sha256(algo.salt2),
+        a_for_hash,
+        b_for_hash,
+        K
+    )
+
+    return types.InputCheckPasswordSRP(
+        request.srp_id, bytes(a_for_hash), bytes(M1))

.venv2/Lib/site-packages/telethon/requestiter.py

@@ -0,0 +1,134 @@
+import abc
+import asyncio
+import time
+
+from . import helpers
+
+
+class RequestIter(abc.ABC):
+    """
+    Helper class to deal with requests that need offsets to iterate.
+
+    It has some facilities, such as automatically sleeping a desired
+    amount of time between requests if needed (but not more).
+
+    Can be used synchronously if the event loop is not running and
+    as an asynchronous iterator otherwise.
+
+    `limit` is the total amount of items that the iterator should return.
+    This is handled on this base class, and will be always ``>= 0``.
+
+    `left` will be reset every time the iterator is used and will indicate
+    the amount of items that should be emitted left, so that subclasses can
+    be more efficient and fetch only as many items as they need.
+
+    Iterators may be used with ``reversed``, and their `reverse` flag will
+    be set to `True` if that's the case. Note that if this flag is set,
+    `buffer` should be filled in reverse too.
+    """
+    def __init__(self, client, limit, *, reverse=False, wait_time=None, **kwargs):
+        self.client = client
+        self.reverse = reverse
+        self.wait_time = wait_time
+        self.kwargs = kwargs
+        self.limit = max(float('inf') if limit is None else limit, 0)
+        self.left = self.limit
+        self.buffer = None
+        self.index = 0
+        self.total = None
+        self.last_load = 0
+
+    async def _init(self, **kwargs):
+        """
+        Called when asynchronous initialization is necessary. All keyword
+        arguments passed to `__init__` will be forwarded here, and it's
+        preferable to use named arguments in the subclasses without defaults
+        to avoid forgetting or misspelling any of them.
+
+        This method may ``raise StopAsyncIteration`` if it cannot continue.
+
+        This method may actually fill the initial buffer if it needs to,
+        and similarly to `_load_next_chunk`, ``return True`` to indicate
+        that this is the last iteration (just the initial load).
+        """
+
+    async def __anext__(self):
+        if self.buffer is None:
+            self.buffer = []
+            if await self._init(**self.kwargs):
+                self.left = len(self.buffer)
+
+        if self.left <= 0:  # <= 0 because subclasses may change it
+            raise StopAsyncIteration
+
+        if self.index == len(self.buffer):
+            # asyncio will handle times <= 0 to sleep 0 seconds
+            if self.wait_time:
+                await asyncio.sleep(
+                    self.wait_time - (time.time() - self.last_load)
+                )
+                self.last_load = time.time()
+
+            self.index = 0
+            self.buffer = []
+            if await self._load_next_chunk():
+                self.left = len(self.buffer)
+
+        if not self.buffer:
+            raise StopAsyncIteration
+
+        result = self.buffer[self.index]
+        self.left -= 1
+        self.index += 1
+        return result
+
+    def __next__(self):
+        try:
+            return self.client.loop.run_until_complete(self.__anext__())
+        except StopAsyncIteration:
+            raise StopIteration
+
+    def __aiter__(self):
+        self.buffer = None
+        self.index = 0
+        self.last_load = 0
+        self.left = self.limit
+        return self
+
+    def __iter__(self):
+        if self.client.loop.is_running():
+            raise RuntimeError(
+                'You must use "async for" if the event loop '
+                'is running (i.e. you are inside an "async def")'
+            )
+
+        return self.__aiter__()
+
+    async def collect(self):
+        """
+        Create a `self` iterator and collect it into a `TotalList`
+        (a normal list with a `.total` attribute).
+        """
+        result = helpers.TotalList()
+        async for message in self:
+            result.append(message)
+
+        result.total = self.total
+        return result
+
+    @abc.abstractmethod
+    async def _load_next_chunk(self):
+        """
+        Called when the next chunk is necessary.
+
+        It should extend the `buffer` with new items.
+
+        It should return `True` if it's the last chunk,
+        after which moment the method won't be called again
+        during the same iteration.
+        """
+        raise NotImplementedError
+
+    def __reversed__(self):
+        self.reverse = not self.reverse
+        return self  # __aiter__ will be called after, too

.venv2/Lib/site-packages/telethon/sessions/__init__.py

@@ -0,0 +1,4 @@
+from .abstract import Session
+from .memory import MemorySession
+from .sqlite import SQLiteSession
+from .string import StringSession

.venv2/Lib/site-packages/telethon/sessions/abstract.py

@@ -0,0 +1,172 @@
+from abc import ABC, abstractmethod
+
+
+class Session(ABC):
+    def __init__(self):
+        pass
+
+    def clone(self, to_instance=None):
+        """
+        Creates a clone of this session file.
+        """
+        return to_instance or self.__class__()
+
+    @abstractmethod
+    def set_dc(self, dc_id, server_address, port):
+        """
+        Sets the information of the data center address and port that
+        the library should connect to, as well as the data center ID,
+        which is currently unused.
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def dc_id(self):
+        """
+        Returns the currently-used data center ID.
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def server_address(self):
+        """
+        Returns the server address where the library should connect to.
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def port(self):
+        """
+        Returns the port to which the library should connect to.
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def auth_key(self):
+        """
+        Returns an ``AuthKey`` instance associated with the saved
+        data center, or `None` if a new one should be generated.
+        """
+        raise NotImplementedError
+
+    @auth_key.setter
+    @abstractmethod
+    def auth_key(self, value):
+        """
+        Sets the ``AuthKey`` to be used for the saved data center.
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def takeout_id(self):
+        """
+        Returns an ID of the takeout process initialized for this session,
+        or `None` if there's no were any unfinished takeout requests.
+        """
+        raise NotImplementedError
+
+    @takeout_id.setter
+    @abstractmethod
+    def takeout_id(self, value):
+        """
+        Sets the ID of the unfinished takeout process for this session.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_update_state(self, entity_id):
+        """
+        Returns the ``UpdateState`` associated with the given `entity_id`.
+        If the `entity_id` is 0, it should return the ``UpdateState`` for
+        no specific channel (the "general" state). If no state is known
+        it should ``return None``.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_update_state(self, entity_id, state):
+        """
+        Sets the given ``UpdateState`` for the specified `entity_id`, which
+        should be 0 if the ``UpdateState`` is the "general" state (and not
+        for any specific channel).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_update_states(self):
+        """
+        Returns an iterable over all known pairs of ``(entity ID, update state)``.
+        """
+
+    def close(self):
+        """
+        Called on client disconnection. Should be used to
+        free any used resources. Can be left empty if none.
+        """
+
+    @abstractmethod
+    def save(self):
+        """
+        Called whenever important properties change. It should
+        make persist the relevant session information to disk.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self):
+        """
+        Called upon client.log_out(). Should delete the stored
+        information from disk since it's not valid anymore.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def list_sessions(cls):
+        """
+        Lists available sessions. Not used by the library itself.
+        """
+        return []
+
+    @abstractmethod
+    def process_entities(self, tlo):
+        """
+        Processes the input ``TLObject`` or ``list`` and saves
+        whatever information is relevant (e.g., ID or access hash).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_input_entity(self, key):
+        """
+        Turns the given key into an ``InputPeer`` (e.g. ``InputPeerUser``).
+        The library uses this method whenever an ``InputPeer`` is needed
+        to suit several purposes (e.g. user only provided its ID or wishes
+        to use a cached username to avoid extra RPC).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def cache_file(self, md5_digest, file_size, instance):
+        """
+        Caches the given file information persistently, so that it
+        doesn't need to be re-uploaded in case the file is used again.
+
+        The ``instance`` will be either an ``InputPhoto`` or ``InputDocument``,
+        both with an ``.id`` and ``.access_hash`` attributes.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_file(self, md5_digest, file_size, cls):
+        """
+        Returns an instance of ``cls`` if the ``md5_digest`` and ``file_size``
+        match an existing saved record. The class will either be an
+        ``InputPhoto`` or ``InputDocument``, both with two parameters
+        ``id`` and ``access_hash`` in that order.
+        """
+        raise NotImplementedError

.venv2/Lib/site-packages/telethon/sessions/memory.py

@@ -0,0 +1,251 @@
+from enum import Enum
+
+from .abstract import Session
+from .. import utils
+from ..tl import TLObject
+from ..tl.types import (
+    PeerUser, PeerChat, PeerChannel,
+    InputPeerUser, InputPeerChat, InputPeerChannel,
+    InputPhoto, InputDocument
+)
+
+
+class _SentFileType(Enum):
+    DOCUMENT = 0
+    PHOTO = 1
+
+    @staticmethod
+    def from_type(cls):
+        if cls == InputDocument:
+            return _SentFileType.DOCUMENT
+        elif cls == InputPhoto:
+            return _SentFileType.PHOTO
+        else:
+            raise ValueError('The cls must be either InputDocument/InputPhoto')
+
+
+class MemorySession(Session):
+    def __init__(self):
+        super().__init__()
+
+        self._dc_id = 0
+        self._server_address = None
+        self._port = None
+        self._auth_key = None
+        self._takeout_id = None
+
+        self._files = {}
+        self._entities = set()
+        self._update_states = {}
+
+    def set_dc(self, dc_id, server_address, port):
+        self._dc_id = dc_id or 0
+        self._server_address = server_address
+        self._port = port
+
+    @property
+    def dc_id(self):
+        return self._dc_id
+
+    @property
+    def server_address(self):
+        return self._server_address
+
+    @property
+    def port(self):
+        return self._port
+
+    @property
+    def auth_key(self):
+        return self._auth_key
+
+    @auth_key.setter
+    def auth_key(self, value):
+        self._auth_key = value
+
+    @property
+    def takeout_id(self):
+        return self._takeout_id
+
+    @takeout_id.setter
+    def takeout_id(self, value):
+        self._takeout_id = value
+
+    def get_update_state(self, entity_id):
+        return self._update_states.get(entity_id, None)
+
+    def set_update_state(self, entity_id, state):
+        self._update_states[entity_id] = state
+
+    def get_update_states(self):
+        return self._update_states.items()
+
+    def close(self):
+        pass
+
+    def save(self):
+        pass
+
+    def delete(self):
+        pass
+
+    @staticmethod
+    def _entity_values_to_row(id, hash, username, phone, name):
+        # While this is a simple implementation it might be overrode by,
+        # other classes so they don't need to implement the plural form
+        # of the method. Don't remove.
+        return id, hash, username, phone, name
+
+    def _entity_to_row(self, e):
+        if not isinstance(e, TLObject):
+            return
+        try:
+            p = utils.get_input_peer(e, allow_self=False)
+            marked_id = utils.get_peer_id(p)
+        except TypeError:
+            # Note: `get_input_peer` already checks for non-zero `access_hash`.
+            #        See issues #354 and #392. It also checks that the entity
+            #        is not `min`, because its `access_hash` cannot be used
+            #        anywhere (since layer 102, there are two access hashes).
+            return
+
+        if isinstance(p, (InputPeerUser, InputPeerChannel)):
+            p_hash = p.access_hash
+        elif isinstance(p, InputPeerChat):
+            p_hash = 0
+        else:
+            return
+
+        username = getattr(e, 'username', None) or None
+        if username is not None:
+            username = username.lower()
+        phone = getattr(e, 'phone', None)
+        name = utils.get_display_name(e) or None
+        return self._entity_values_to_row(
+            marked_id, p_hash, username, phone, name
+        )
+
+    def _entities_to_rows(self, tlo):
+        if not isinstance(tlo, TLObject) and utils.is_list_like(tlo):
+            # This may be a list of users already for instance
+            entities = tlo
+        else:
+            entities = []
+            if hasattr(tlo, 'user'):
+                entities.append(tlo.user)
+            if hasattr(tlo, 'chat'):
+                entities.append(tlo.chat)
+            if hasattr(tlo, 'chats') and utils.is_list_like(tlo.chats):
+                entities.extend(tlo.chats)
+            if hasattr(tlo, 'users') and utils.is_list_like(tlo.users):
+                entities.extend(tlo.users)
+
+        rows = []  # Rows to add (id, hash, username, phone, name)
+        for e in entities:
+            row = self._entity_to_row(e)
+            if row:
+                rows.append(row)
+        return rows
+
+    def process_entities(self, tlo):
+        self._entities |= set(self._entities_to_rows(tlo))
+
+    def get_entity_rows_by_phone(self, phone):
+        try:
+            return next((id, hash) for id, hash, _, found_phone, _
+                        in self._entities if found_phone == phone)
+        except StopIteration:
+            pass
+
+    def get_entity_rows_by_username(self, username):
+        try:
+            return next((id, hash) for id, hash, found_username, _, _
+                        in self._entities if found_username == username)
+        except StopIteration:
+            pass
+
+    def get_entity_rows_by_name(self, name):
+        try:
+            return next((id, hash) for id, hash, _, _, found_name
+                        in self._entities if found_name == name)
+        except StopIteration:
+            pass
+
+    def get_entity_rows_by_id(self, id, exact=True):
+        try:
+            if exact:
+                return next((found_id, hash) for found_id, hash, _, _, _
+                            in self._entities if found_id == id)
+            else:
+                ids = (
+                    utils.get_peer_id(PeerUser(id)),
+                    utils.get_peer_id(PeerChat(id)),
+                    utils.get_peer_id(PeerChannel(id))
+                )
+                return next((found_id, hash) for found_id, hash, _, _, _
+                            in self._entities if found_id in ids)
+        except StopIteration:
+            pass
+
+    def get_input_entity(self, key):
+        try:
+            if key.SUBCLASS_OF_ID in (0xc91c90b6, 0xe669bf46, 0x40f202fd):
+                # hex(crc32(b'InputPeer', b'InputUser' and b'InputChannel'))
+                # We already have an Input version, so nothing else required
+                return key
+            # Try to early return if this key can be casted as input peer
+            return utils.get_input_peer(key)
+        except (AttributeError, TypeError):
+            # Not a TLObject or can't be cast into InputPeer
+            if isinstance(key, TLObject):
+                key = utils.get_peer_id(key)
+                exact = True
+            else:
+                exact = not isinstance(key, int) or key < 0
+
+        result = None
+        if isinstance(key, str):
+            phone = utils.parse_phone(key)
+            if phone:
+                result = self.get_entity_rows_by_phone(phone)
+            else:
+                username, invite = utils.parse_username(key)
+                if username and not invite:
+                    result = self.get_entity_rows_by_username(username)
+                else:
+                    tup = utils.resolve_invite_link(key)[1]
+                    if tup:
+                        result = self.get_entity_rows_by_id(tup, exact=False)
+
+        elif isinstance(key, int):
+            result = self.get_entity_rows_by_id(key, exact)
+
+        if not result and isinstance(key, str):
+            result = self.get_entity_rows_by_name(key)
+
+        if result:
+            entity_id, entity_hash = result  # unpack resulting tuple
+            entity_id, kind = utils.resolve_id(entity_id)
+            # removes the mark and returns type of entity
+            if kind == PeerUser:
+                return InputPeerUser(entity_id, entity_hash)
+            elif kind == PeerChat:
+                return InputPeerChat(entity_id)
+            elif kind == PeerChannel:
+                return InputPeerChannel(entity_id, entity_hash)
+        else:
+            raise ValueError('Could not find input entity with key ', key)
+
+    def cache_file(self, md5_digest, file_size, instance):
+        if not isinstance(instance, (InputDocument, InputPhoto)):
+            raise TypeError('Cannot cache %s instance' % type(instance))
+        key = (md5_digest, file_size, _SentFileType.from_type(type(instance)))
+        value = (instance.id, instance.access_hash)
+        self._files[key] = value
+
+    def get_file(self, md5_digest, file_size, cls):
+        key = (md5_digest, file_size, _SentFileType.from_type(cls))
+        try:
+            return cls(*self._files[key])
+        except KeyError:
+            return None

.venv2/Lib/site-packages/telethon/sessions/sqlite.py

@@ -0,0 +1,368 @@
+import datetime
+import os
+import time
+
+from ..tl import types
+from .memory import MemorySession, _SentFileType
+from .. import utils
+from ..crypto import AuthKey
+from ..tl.types import (
+    InputPhoto, InputDocument, PeerUser, PeerChat, PeerChannel
+)
+
+try:
+    import sqlite3
+    sqlite3_err = None
+except ImportError as e:
+    sqlite3 = None
+    sqlite3_err = type(e)
+
+EXTENSION = '.session'
+CURRENT_VERSION = 7  # database version
+
+
+class SQLiteSession(MemorySession):
+    """This session contains the required information to login into your
+       Telegram account. NEVER give the saved session file to anyone, since
+       they would gain instant access to all your messages and contacts.
+
+       If you think the session has been compromised, close all the sessions
+       through an official Telegram client to revoke the authorization.
+    """
+
+    def __init__(self, session_id=None):
+        if sqlite3 is None:
+            raise sqlite3_err
+
+        super().__init__()
+        self.filename = ':memory:'
+        self.save_entities = True
+
+        if session_id:
+            self.filename = session_id
+            if not self.filename.endswith(EXTENSION):
+                self.filename += EXTENSION
+
+        self._conn = None
+        c = self._cursor()
+        c.execute("select name from sqlite_master "
+                  "where type='table' and name='version'")
+        if c.fetchone():
+            # Tables already exist, check for the version
+            c.execute("select version from version")
+            version = c.fetchone()[0]
+            if version < CURRENT_VERSION:
+                self._upgrade_database(old=version)
+                c.execute("delete from version")
+                c.execute("insert into version values (?)", (CURRENT_VERSION,))
+                self.save()
+
+            # These values will be saved
+            c.execute('select * from sessions')
+            tuple_ = c.fetchone()
+            if tuple_:
+                self._dc_id, self._server_address, self._port, key, \
+                    self._takeout_id = tuple_
+                self._auth_key = AuthKey(data=key)
+
+            c.close()
+        else:
+            # Tables don't exist, create new ones
+            self._create_table(
+                c,
+                "version (version integer primary key)"
+                ,
+                """sessions (
+                    dc_id integer primary key,
+                    server_address text,
+                    port integer,
+                    auth_key blob,
+                    takeout_id integer
+                )"""
+                ,
+                """entities (
+                    id integer primary key,
+                    hash integer not null,
+                    username text,
+                    phone integer,
+                    name text,
+                    date integer
+                )"""
+                ,
+                """sent_files (
+                    md5_digest blob,
+                    file_size integer,
+                    type integer,
+                    id integer,
+                    hash integer,
+                    primary key(md5_digest, file_size, type)
+                )"""
+                ,
+                """update_state (
+                    id integer primary key,
+                    pts integer,
+                    qts integer,
+                    date integer,
+                    seq integer
+                )"""
+            )
+            c.execute("insert into version values (?)", (CURRENT_VERSION,))
+            self._update_session_table()
+            c.close()
+            self.save()
+
+    def clone(self, to_instance=None):
+        cloned = super().clone(to_instance)
+        cloned.save_entities = self.save_entities
+        return cloned
+
+    def _upgrade_database(self, old):
+        c = self._cursor()
+        if old == 1:
+            old += 1
+            # old == 1 doesn't have the old sent_files so no need to drop
+        if old == 2:
+            old += 1
+            # Old cache from old sent_files lasts then a day anyway, drop
+            c.execute('drop table sent_files')
+            self._create_table(c, """sent_files (
+                md5_digest blob,
+                file_size integer,
+                type integer,
+                id integer,
+                hash integer,
+                primary key(md5_digest, file_size, type)
+            )""")
+        if old == 3:
+            old += 1
+            self._create_table(c, """update_state (
+                id integer primary key,
+                pts integer,
+                qts integer,
+                date integer,
+                seq integer
+            )""")
+        if old == 4:
+            old += 1
+            c.execute("alter table sessions add column takeout_id integer")
+        if old == 5:
+            # Not really any schema upgrade, but potentially all access
+            # hashes for User and Channel are wrong, so drop them off.
+            old += 1
+            c.execute('delete from entities')
+        if old == 6:
+            old += 1
+            c.execute("alter table entities add column date integer")
+
+        c.close()
+
+    @staticmethod
+    def _create_table(c, *definitions):
+        for definition in definitions:
+            c.execute('create table {}'.format(definition))
+
+    # Data from sessions should be kept as properties
+    # not to fetch the database every time we need it
+    def set_dc(self, dc_id, server_address, port):
+        super().set_dc(dc_id, server_address, port)
+        self._update_session_table()
+
+        # Fetch the auth_key corresponding to this data center
+        row = self._execute('select auth_key from sessions')
+        if row and row[0]:
+            self._auth_key = AuthKey(data=row[0])
+        else:
+            self._auth_key = None
+
+    @MemorySession.auth_key.setter
+    def auth_key(self, value):
+        self._auth_key = value
+        self._update_session_table()
+
+    @MemorySession.takeout_id.setter
+    def takeout_id(self, value):
+        self._takeout_id = value
+        self._update_session_table()
+
+    def _update_session_table(self):
+        c = self._cursor()
+        # While we can save multiple rows into the sessions table
+        # currently we only want to keep ONE as the tables don't
+        # tell us which auth_key's are usable and will work. Needs
+        # some more work before being able to save auth_key's for
+        # multiple DCs. Probably done differently.
+        c.execute('delete from sessions')
+        c.execute('insert or replace into sessions values (?,?,?,?,?)', (
+            self._dc_id,
+            self._server_address,
+            self._port,
+            self._auth_key.key if self._auth_key else b'',
+            self._takeout_id
+        ))
+        c.close()
+
+    def get_update_state(self, entity_id):
+        row = self._execute('select pts, qts, date, seq from update_state '
+                            'where id = ?', entity_id)
+        if row:
+            pts, qts, date, seq = row
+            date = datetime.datetime.fromtimestamp(
+                date, tz=datetime.timezone.utc)
+            return types.updates.State(pts, qts, date, seq, unread_count=0)
+
+    def set_update_state(self, entity_id, state):
+        self._execute('insert or replace into update_state values (?,?,?,?,?)',
+                      entity_id, state.pts, state.qts,
+                      state.date.timestamp(), state.seq)
+
+    def get_update_states(self):
+        c = self._cursor()
+        try:
+            rows = c.execute('select id, pts, qts, date, seq from update_state').fetchall()
+            return ((row[0], types.updates.State(
+                pts=row[1],
+                qts=row[2],
+                date=datetime.datetime.fromtimestamp(row[3], tz=datetime.timezone.utc),
+                seq=row[4],
+                unread_count=0)
+            ) for row in rows)
+        finally:
+            c.close()
+
+    def save(self):
+        """Saves the current session object as session_user_id.session"""
+        # This is a no-op if there are no changes to commit, so there's
+        # no need for us to keep track of an "unsaved changes" variable.
+        if self._conn is not None:
+            self._conn.commit()
+
+    def _cursor(self):
+        """Asserts that the connection is open and returns a cursor"""
+        if self._conn is None:
+            self._conn = sqlite3.connect(self.filename,
+                                         check_same_thread=False)
+        return self._conn.cursor()
+
+    def _execute(self, stmt, *values):
+        """
+        Gets a cursor, executes `stmt` and closes the cursor,
+        fetching one row afterwards and returning its result.
+        """
+        c = self._cursor()
+        try:
+            return c.execute(stmt, values).fetchone()
+        finally:
+            c.close()
+
+    def close(self):
+        """Closes the connection unless we're working in-memory"""
+        if self.filename != ':memory:':
+            if self._conn is not None:
+                self._conn.commit()
+                self._conn.close()
+                self._conn = None
+
+    def delete(self):
+        """Deletes the current session file"""
+        if self.filename == ':memory:':
+            return True
+        try:
+            os.remove(self.filename)
+            return True
+        except OSError:
+            return False
+
+    @classmethod
+    def list_sessions(cls):
+        """Lists all the sessions of the users who have ever connected
+           using this client and never logged out
+        """
+        return [os.path.splitext(os.path.basename(f))[0]
+                for f in os.listdir('.') if f.endswith(EXTENSION)]
+
+    # Entity processing
+
+    def process_entities(self, tlo):
+        """
+        Processes all the found entities on the given TLObject,
+        unless .save_entities is False.
+        """
+        if not self.save_entities:
+            return
+
+        rows = self._entities_to_rows(tlo)
+        if not rows:
+            return
+
+        c = self._cursor()
+        try:
+            now_tup = (int(time.time()),)
+            rows = [row + now_tup for row in rows]
+            c.executemany(
+                'insert or replace into entities values (?,?,?,?,?,?)', rows)
+        finally:
+            c.close()
+
+    def get_entity_rows_by_phone(self, phone):
+        return self._execute(
+            'select id, hash from entities where phone = ?', phone)
+
+    def get_entity_rows_by_username(self, username):
+        c = self._cursor()
+        try:
+            results = c.execute(
+                'select id, hash, date from entities where username = ?',
+                (username,)
+            ).fetchall()
+
+            if not results:
+                return None
+
+            # If there is more than one result for the same username, evict the oldest one
+            if len(results) > 1:
+                results.sort(key=lambda t: t[2] or 0)
+                c.executemany('update entities set username = null where id = ?',
+                              [(t[0],) for t in results[:-1]])
+
+            return results[-1][0], results[-1][1]
+        finally:
+            c.close()
+
+    def get_entity_rows_by_name(self, name):
+        return self._execute(
+            'select id, hash from entities where name = ?', name)
+
+    def get_entity_rows_by_id(self, id, exact=True):
+        if exact:
+            return self._execute(
+                'select id, hash from entities where id = ?', id)
+        else:
+            return self._execute(
+                'select id, hash from entities where id in (?,?,?)',
+                utils.get_peer_id(PeerUser(id)),
+                utils.get_peer_id(PeerChat(id)),
+                utils.get_peer_id(PeerChannel(id))
+            )
+
+    # File processing
+
+    def get_file(self, md5_digest, file_size, cls):
+        row = self._execute(
+            'select id, hash from sent_files '
+            'where md5_digest = ? and file_size = ? and type = ?',
+            md5_digest, file_size, _SentFileType.from_type(cls).value
+        )
+        if row:
+            # Both allowed classes have (id, access_hash) as parameters
+            return cls(row[0], row[1])
+
+    def cache_file(self, md5_digest, file_size, instance):
+        if not isinstance(instance, (InputDocument, InputPhoto)):
+            raise TypeError('Cannot cache %s instance' % type(instance))
+
+        self._execute(
+            'insert or replace into sent_files values (?,?,?,?,?)',
+            md5_digest, file_size,
+            _SentFileType.from_type(type(instance)).value,
+            instance.id, instance.access_hash
+        )

.venv2/Lib/site-packages/telethon/sessions/string.py

@@ -0,0 +1,63 @@
+import base64
+import ipaddress
+import struct
+
+from .abstract import Session
+from .memory import MemorySession
+from ..crypto import AuthKey
+
+_STRUCT_PREFORMAT = '>B{}sH256s'
+
+CURRENT_VERSION = '1'
+
+
+class StringSession(MemorySession):
+    """
+    This session file can be easily saved and loaded as a string. According
+    to the initial design, it contains only the data that is necessary for
+    successful connection and authentication, so takeout ID is not stored.
+
+    It is thought to be used where you don't want to create any on-disk
+    files but would still like to be able to save and load existing sessions
+    by other means.
+
+    You can use custom `encode` and `decode` functions, if present:
+
+    * `encode` definition must be ``def encode(value: bytes) -> str:``.
+    * `decode` definition must be ``def decode(value: str) -> bytes:``.
+    """
+    def __init__(self, string: str = None):
+        super().__init__()
+        if string:
+            if string[0] != CURRENT_VERSION:
+                raise ValueError('Not a valid string')
+
+            string = string[1:]
+            ip_len = 4 if len(string) == 352 else 16
+            self._dc_id, ip, self._port, key = struct.unpack(
+                _STRUCT_PREFORMAT.format(ip_len), StringSession.decode(string))
+
+            self._server_address = ipaddress.ip_address(ip).compressed
+            if any(key):
+                self._auth_key = AuthKey(key)
+
+    @staticmethod
+    def encode(x: bytes) -> str:
+        return base64.urlsafe_b64encode(x).decode('ascii')
+
+    @staticmethod
+    def decode(x: str) -> bytes:
+        return base64.urlsafe_b64decode(x)
+
+    def save(self: Session):
+        if not self.auth_key:
+            return ''
+
+        ip = ipaddress.ip_address(self.server_address).packed
+        return CURRENT_VERSION + StringSession.encode(struct.pack(
+            _STRUCT_PREFORMAT.format(len(ip)),
+            self.dc_id,
+            ip,
+            self.port,
+            self.auth_key.key
+        ))

.venv2/Lib/site-packages/telethon/sync.py

@@ -0,0 +1,74 @@
+"""
+This magical module will rewrite all public methods in the public interface
+of the library so they can run the loop on their own if it's not already
+running. This rewrite may not be desirable if the end user always uses the
+methods they way they should be ran, but it's incredibly useful for quick
+scripts and the runtime overhead is relatively low.
+
+Some really common methods which are hardly used offer this ability by
+default, such as ``.start()`` and ``.run_until_disconnected()`` (since
+you may want to start, and then run until disconnected while using async
+event handlers).
+"""
+import asyncio
+import functools
+import inspect
+
+from . import events, errors, utils, connection, helpers
+from .client.account import _TakeoutClient
+from .client.telegramclient import TelegramClient
+from .tl import types, functions, custom
+from .tl.custom import (
+    Draft, Dialog, MessageButton, Forward, Button,
+    Message, InlineResult, Conversation
+)
+from .tl.custom.chatgetter import ChatGetter
+from .tl.custom.sendergetter import SenderGetter
+
+
+def _syncify_wrap(t, method_name):
+    method = getattr(t, method_name)
+
+    @functools.wraps(method)
+    def syncified(*args, **kwargs):
+        coro = method(*args, **kwargs)
+        loop = helpers.get_running_loop()
+        if loop.is_running():
+            return coro
+        else:
+            return loop.run_until_complete(coro)
+
+    # Save an accessible reference to the original method
+    setattr(syncified, '__tl.sync', method)
+    setattr(t, method_name, syncified)
+
+
+def syncify(*types):
+    """
+    Converts all the methods in the given types (class definitions)
+    into synchronous, which return either the coroutine or the result
+    based on whether ``asyncio's`` event loop is running.
+    """
+    # Our asynchronous generators all are `RequestIter`, which already
+    # provide a synchronous iterator variant, so we don't need to worry
+    # about asyncgenfunction's here.
+    for t in types:
+        for name in dir(t):
+            if not name.startswith('_') or name == '__call__':
+                if inspect.iscoroutinefunction(getattr(t, name)):
+                    _syncify_wrap(t, name)
+
+
+syncify(TelegramClient, _TakeoutClient, Draft, Dialog, MessageButton,
+        ChatGetter, SenderGetter, Forward, Message, InlineResult, Conversation)
+
+
+# Private special case, since a conversation's methods return
+# futures (but the public function themselves are synchronous).
+_syncify_wrap(Conversation, '_get_result')
+
+__all__ = [
+    'TelegramClient', 'Button',
+    'types', 'functions', 'custom', 'errors',
+    'events', 'utils', 'connection'
+]

.venv2/Lib/site-packages/telethon/tl/__init__.py

@@ -0,0 +1 @@
+from .tlobject import TLObject, TLRequest

.venv2/Lib/site-packages/telethon/tl/core/__init__.py

@@ -0,0 +1,26 @@
+"""
+This module holds core "special" types, which are more convenient ways
+to do stuff in a `telethon.network.mtprotosender.MTProtoSender` instance.
+
+Only special cases are gzip-packed data, the response message (not a
+client message), the message container which references these messages
+and would otherwise conflict with the rest, and finally the RpcResult:
+
+    rpc_result#f35c6d01 req_msg_id:long result:bytes = RpcResult;
+
+Three things to note with this definition:
+1. The constructor ID is actually ``42d36c2c``.
+2. Those bytes are not read like the rest of bytes (length + payload).
+   They are actually the raw bytes of another object, which can't be
+   read directly because it depends on per-request information (since
+   some can return ``Vector<int>`` and ``Vector<long>``).
+3. Those bytes may be gzipped data, which needs to be treated early.
+"""
+from .tlmessage import TLMessage
+from .gzippacked import GzipPacked
+from .messagecontainer import MessageContainer
+from .rpcresult import RpcResult
+
+core_objects = {x.CONSTRUCTOR_ID: x for x in (
+    GzipPacked, MessageContainer, RpcResult
+)}

.venv2/Lib/site-packages/telethon/tl/core/gzippacked.py

@@ -0,0 +1,45 @@
+import gzip
+import struct
+
+from .. import TLObject
+
+
+class GzipPacked(TLObject):
+    CONSTRUCTOR_ID = 0x3072cfa1
+
+    def __init__(self, data):
+        self.data = data
+
+    @staticmethod
+    def gzip_if_smaller(content_related, data):
+        """Calls bytes(request), and based on a certain threshold,
+           optionally gzips the resulting data. If the gzipped data is
+           smaller than the original byte array, this is returned instead.
+
+           Note that this only applies to content related requests.
+        """
+        if content_related and len(data) > 512:
+            gzipped = bytes(GzipPacked(data))
+            return gzipped if len(gzipped) < len(data) else data
+        else:
+            return data
+
+    def __bytes__(self):
+        return struct.pack('<I', GzipPacked.CONSTRUCTOR_ID) + \
+               TLObject.serialize_bytes(gzip.compress(self.data))
+
+    @staticmethod
+    def read(reader):
+        constructor = reader.read_int(signed=False)
+        assert constructor == GzipPacked.CONSTRUCTOR_ID
+        return gzip.decompress(reader.tgread_bytes())
+
+    @classmethod
+    def from_reader(cls, reader):
+        return GzipPacked(gzip.decompress(reader.tgread_bytes()))
+
+    def to_dict(self):
+        return {
+            '_': 'GzipPacked',
+            'data': self.data
+        }

.venv2/Lib/site-packages/telethon/tl/core/messagecontainer.py

@@ -0,0 +1,47 @@
+from .tlmessage import TLMessage
+from ..tlobject import TLObject
+
+
+class MessageContainer(TLObject):
+    CONSTRUCTOR_ID = 0x73f1f8dc
+
+    # Maximum size in bytes for the inner payload of the container.
+    # Telegram will close the connection if the payload is bigger.
+    # The overhead of the container itself is subtracted.
+    MAXIMUM_SIZE = 1044456 - 8
+
+    # Maximum amount of messages that can't be sent inside a single
+    # container, inclusive. Beyond this limit Telegram will respond
+    # with BAD_MESSAGE 64 (invalid container).
+    #
+    # This limit is not 100% accurate and may in some cases be higher.
+    # However, sending up to 100 requests at once in a single container
+    # is a reasonable conservative value, since it could also depend on
+    # other factors like size per request, but we cannot know this.
+    MAXIMUM_LENGTH = 100
+
+    def __init__(self, messages):
+        self.messages = messages
+
+    def to_dict(self):
+        return {
+            '_': 'MessageContainer',
+            'messages':
+                [] if self.messages is None else [
+                    None if x is None else x.to_dict() for x in self.messages
+                ],
+        }
+
+    @classmethod
+    def from_reader(cls, reader):
+        # This assumes that .read_* calls are done in the order they appear
+        messages = []
+        for _ in range(reader.read_int()):
+            msg_id = reader.read_long()
+            seq_no = reader.read_int()
+            length = reader.read_int()
+            before = reader.tell_position()
+            obj = reader.tgread_object()  # May over-read e.g. RpcResult
+            reader.set_position(before + length)
+            messages.append(TLMessage(msg_id, seq_no, obj))
+        return MessageContainer(messages)

.venv2/Lib/site-packages/telethon/tl/core/rpcresult.py

@@ -0,0 +1,35 @@
+from .gzippacked import GzipPacked
+from .. import TLObject
+from ..types import RpcError
+
+
+class RpcResult(TLObject):
+    CONSTRUCTOR_ID = 0xf35c6d01
+
+    def __init__(self, req_msg_id, body, error):
+        self.req_msg_id = req_msg_id
+        self.body = body
+        self.error = error
+
+    @classmethod
+    def from_reader(cls, reader):
+        msg_id = reader.read_long()
+        inner_code = reader.read_int(signed=False)
+        if inner_code == RpcError.CONSTRUCTOR_ID:
+            return RpcResult(msg_id, None, RpcError.from_reader(reader))
+        if inner_code == GzipPacked.CONSTRUCTOR_ID:
+            return RpcResult(msg_id, GzipPacked.from_reader(reader).data, None)
+
+        reader.seek(-4)
+        # This reader.read() will read more than necessary, but it's okay.
+        # We could make use of MessageContainer's length here, but since
+        # it's not necessary we don't need to care about it.
+        return RpcResult(msg_id, reader.read(), None)
+
+    def to_dict(self):
+        return {
+            '_': 'RpcResult',
+            'req_msg_id': self.req_msg_id,
+            'body': self.body,
+            'error': self.error
+        }

.venv2/Lib/site-packages/telethon/tl/core/tlmessage.py

@@ -0,0 +1,34 @@
+from .. import TLObject
+
+
+class TLMessage(TLObject):
+    """
+    https://core.telegram.org/mtproto/service_messages#simple-container.
+
+    Messages are what's ultimately sent to Telegram:
+        message msg_id:long seqno:int bytes:int body:bytes = Message;
+
+    Each message has its own unique identifier, and the body is simply
+    the serialized request that should be executed on the server, or
+    the response object from Telegram. Since the body is always a valid
+    object, it makes sense to store the object and not the bytes to
+    ease working with them.
+
+    There is no need to add serializing logic here since that can be
+    inlined and is unlikely to change. Thus these are only needed to
+    encapsulate responses.
+    """
+    SIZE_OVERHEAD = 12
+
+    def __init__(self, msg_id, seq_no, obj):
+        self.msg_id = msg_id
+        self.seq_no = seq_no
+        self.obj = obj
+
+    def to_dict(self):
+        return {
+            '_': 'TLMessage',
+            'msg_id': self.msg_id,
+            'seq_no': self.seq_no,
+            'obj': self.obj
+        }

.venv2/Lib/site-packages/telethon/tl/custom/__init__.py

@@ -0,0 +1,14 @@
+from .adminlogevent import AdminLogEvent
+from .draft import Draft
+from .dialog import Dialog
+from .inputsizedfile import InputSizedFile
+from .messagebutton import MessageButton
+from .forward import Forward
+from .message import Message
+from .button import Button
+from .inlinebuilder import InlineBuilder
+from .inlineresult import InlineResult
+from .inlineresults import InlineResults
+from .conversation import Conversation
+from .qrlogin import QRLogin
+from .participantpermissions import ParticipantPermissions

.venv2/Lib/site-packages/telethon/tl/custom/adminlogevent.py

@@ -0,0 +1,475 @@
+from ...tl import types
+from ...utils import get_input_peer
+
+
+class AdminLogEvent:
+    """
+    Represents a more friendly interface for admin log events.
+
+    Members:
+        original (:tl:`ChannelAdminLogEvent`):
+            The original :tl:`ChannelAdminLogEvent`.
+
+        entities (`dict`):
+            A dictionary mapping user IDs to :tl:`User`.
+
+            When `old` and `new` are :tl:`ChannelParticipant`, you can
+            use this dictionary to map the ``user_id``, ``kicked_by``,
+            ``inviter_id`` and ``promoted_by`` IDs to their :tl:`User`.
+
+        user (:tl:`User`):
+            The user that caused this action (``entities[original.user_id]``).
+
+        input_user (:tl:`InputPeerUser`):
+            Input variant of `user`.
+    """
+    def __init__(self, original, entities):
+        self.original = original
+        self.entities = entities
+        self.user = entities[original.user_id]
+        self.input_user = get_input_peer(self.user)
+
+    @property
+    def id(self):
+        """
+        The ID of this event.
+        """
+        return self.original.id
+
+    @property
+    def date(self):
+        """
+        The date when this event occurred.
+        """
+        return self.original.date
+
+    @property
+    def user_id(self):
+        """
+        The ID of the user that triggered this event.
+        """
+        return self.original.user_id
+
+    @property
+    def action(self):
+        """
+        The original :tl:`ChannelAdminLogEventAction`.
+        """
+        return self.original.action
+
+    @property
+    def old(self):
+        """
+        The old value from the event.
+        """
+        ori = self.original.action
+        if isinstance(ori, (
+                types.ChannelAdminLogEventActionChangeAbout,
+                types.ChannelAdminLogEventActionChangeTitle,
+                types.ChannelAdminLogEventActionChangeUsername,
+                types.ChannelAdminLogEventActionChangeLocation,
+                types.ChannelAdminLogEventActionChangeHistoryTTL,
+        )):
+            return ori.prev_value
+        elif isinstance(ori, types.ChannelAdminLogEventActionChangePhoto):
+            return ori.prev_photo
+        elif isinstance(ori, types.ChannelAdminLogEventActionChangeStickerSet):
+            return ori.prev_stickerset
+        elif isinstance(ori, types.ChannelAdminLogEventActionEditMessage):
+            return ori.prev_message
+        elif isinstance(ori, (
+                types.ChannelAdminLogEventActionParticipantToggleAdmin,
+                types.ChannelAdminLogEventActionParticipantToggleBan
+        )):
+            return ori.prev_participant
+        elif isinstance(ori, (
+                types.ChannelAdminLogEventActionToggleInvites,
+                types.ChannelAdminLogEventActionTogglePreHistoryHidden,
+                types.ChannelAdminLogEventActionToggleSignatures
+        )):
+            return not ori.new_value
+        elif isinstance(ori, types.ChannelAdminLogEventActionDeleteMessage):
+            return ori.message
+        elif isinstance(ori, types.ChannelAdminLogEventActionDefaultBannedRights):
+            return ori.prev_banned_rights
+        elif isinstance(ori, types.ChannelAdminLogEventActionDiscardGroupCall):
+            return ori.call
+        elif isinstance(ori, (
+            types.ChannelAdminLogEventActionExportedInviteDelete,
+            types.ChannelAdminLogEventActionExportedInviteRevoke,
+            types.ChannelAdminLogEventActionParticipantJoinByInvite,
+        )):
+            return ori.invite
+        elif isinstance(ori, types.ChannelAdminLogEventActionExportedInviteEdit):
+            return ori.prev_invite
+
+    @property
+    def new(self):
+        """
+        The new value present in the event.
+        """
+        ori = self.original.action
+        if isinstance(ori, (
+                types.ChannelAdminLogEventActionChangeAbout,
+                types.ChannelAdminLogEventActionChangeTitle,
+                types.ChannelAdminLogEventActionChangeUsername,
+                types.ChannelAdminLogEventActionToggleInvites,
+                types.ChannelAdminLogEventActionTogglePreHistoryHidden,
+                types.ChannelAdminLogEventActionToggleSignatures,
+                types.ChannelAdminLogEventActionChangeLocation,
+                types.ChannelAdminLogEventActionChangeHistoryTTL,
+        )):
+            return ori.new_value
+        elif isinstance(ori, types.ChannelAdminLogEventActionChangePhoto):
+            return ori.new_photo
+        elif isinstance(ori, types.ChannelAdminLogEventActionChangeStickerSet):
+            return ori.new_stickerset
+        elif isinstance(ori, types.ChannelAdminLogEventActionEditMessage):
+            return ori.new_message
+        elif isinstance(ori, (
+                types.ChannelAdminLogEventActionParticipantToggleAdmin,
+                types.ChannelAdminLogEventActionParticipantToggleBan
+        )):
+            return ori.new_participant
+        elif isinstance(ori, (
+            types.ChannelAdminLogEventActionParticipantInvite,
+            types.ChannelAdminLogEventActionParticipantVolume,
+        )):
+            return ori.participant
+        elif isinstance(ori, types.ChannelAdminLogEventActionDefaultBannedRights):
+            return ori.new_banned_rights
+        elif isinstance(ori, types.ChannelAdminLogEventActionStopPoll):
+            return ori.message
+        elif isinstance(ori, types.ChannelAdminLogEventActionStartGroupCall):
+            return ori.call
+        elif isinstance(ori, (
+                types.ChannelAdminLogEventActionParticipantMute,
+                types.ChannelAdminLogEventActionParticipantUnmute,
+        )):
+            return ori.participant
+        elif isinstance(ori, types.ChannelAdminLogEventActionToggleGroupCallSetting):
+            return ori.join_muted
+        elif isinstance(ori, types.ChannelAdminLogEventActionExportedInviteEdit):
+            return ori.new_invite
+
+    @property
+    def changed_about(self):
+        """
+        Whether the channel's about was changed or not.
+
+        If `True`, `old` and `new` will be present as `str`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionChangeAbout)
+
+    @property
+    def changed_title(self):
+        """
+        Whether the channel's title was changed or not.
+
+        If `True`, `old` and `new` will be present as `str`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionChangeTitle)
+
+    @property
+    def changed_username(self):
+        """
+        Whether the channel's username was changed or not.
+
+        If `True`, `old` and `new` will be present as `str`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionChangeUsername)
+
+    @property
+    def changed_photo(self):
+        """
+        Whether the channel's photo was changed or not.
+
+        If `True`, `old` and `new` will be present as :tl:`Photo`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionChangePhoto)
+
+    @property
+    def changed_sticker_set(self):
+        """
+        Whether the channel's sticker set was changed or not.
+
+        If `True`, `old` and `new` will be present as :tl:`InputStickerSet`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionChangeStickerSet)
+
+    @property
+    def changed_message(self):
+        """
+        Whether a message in this channel was edited or not.
+
+        If `True`, `old` and `new` will be present as
+        `Message <telethon.tl.custom.message.Message>`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionEditMessage)
+
+    @property
+    def deleted_message(self):
+        """
+        Whether a message in this channel was deleted or not.
+
+        If `True`, `old` will be present as
+        `Message <telethon.tl.custom.message.Message>`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionDeleteMessage)
+
+    @property
+    def changed_admin(self):
+        """
+        Whether the permissions for an admin in this channel
+        changed or not.
+
+        If `True`, `old` and `new` will be present as
+        :tl:`ChannelParticipant`.
+        """
+        return isinstance(
+            self.original.action,
+            types.ChannelAdminLogEventActionParticipantToggleAdmin)
+
+    @property
+    def changed_restrictions(self):
+        """
+        Whether a message in this channel was edited or not.
+
+        If `True`, `old` and `new` will be present as
+        :tl:`ChannelParticipant`.
+        """
+        return isinstance(
+            self.original.action,
+            types.ChannelAdminLogEventActionParticipantToggleBan)
+
+    @property
+    def changed_invites(self):
+        """
+        Whether the invites in the channel were toggled or not.
+
+        If `True`, `old` and `new` will be present as `bool`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionToggleInvites)
+
+    @property
+    def changed_location(self):
+        """
+        Whether the location setting of the channel has changed or not.
+
+        If `True`, `old` and `new` will be present as :tl:`ChannelLocation`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionChangeLocation)
+
+    @property
+    def joined(self):
+        """
+        Whether `user` joined through the channel's
+        public username or not.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionParticipantJoin)
+
+    @property
+    def joined_invite(self):
+        """
+        Whether a new user joined through an invite
+        link to the channel or not.
+
+        If `True`, `new` will be present as
+        :tl:`ChannelParticipant`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionParticipantInvite)
+
+    @property
+    def left(self):
+        """
+        Whether `user` left the channel or not.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionParticipantLeave)
+
+    @property
+    def changed_hide_history(self):
+        """
+        Whether hiding the previous message history for new members
+        in the channel was toggled or not.
+
+        If `True`, `old` and `new` will be present as `bool`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionTogglePreHistoryHidden)
+
+    @property
+    def changed_signatures(self):
+        """
+        Whether the message signatures in the channel were toggled
+        or not.
+
+        If `True`, `old` and `new` will be present as `bool`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionToggleSignatures)
+
+    @property
+    def changed_pin(self):
+        """
+        Whether a new message in this channel was pinned or not.
+
+        If `True`, `new` will be present as
+        `Message <telethon.tl.custom.message.Message>`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionUpdatePinned)
+
+    @property
+    def changed_default_banned_rights(self):
+        """
+        Whether the default banned rights were changed or not.
+
+        If `True`, `old` and `new` will
+        be present as :tl:`ChatBannedRights`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionDefaultBannedRights)
+
+    @property
+    def stopped_poll(self):
+        """
+        Whether a poll was stopped or not.
+
+        If `True`, `new` will be present as
+        `Message <telethon.tl.custom.message.Message>`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionStopPoll)
+
+    @property
+    def started_group_call(self):
+        """
+        Whether a group call was started or not.
+
+        If `True`, `new` will be present as :tl:`InputGroupCall`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionStartGroupCall)
+
+    @property
+    def discarded_group_call(self):
+        """
+        Whether a group call was started or not.
+
+        If `True`, `old` will be present as :tl:`InputGroupCall`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionDiscardGroupCall)
+
+    @property
+    def user_muted(self):
+        """
+        Whether a participant was muted in the ongoing group call or not.
+
+        If `True`, `new` will be present as :tl:`GroupCallParticipant`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionParticipantMute)
+
+    @property
+    def user_unmutted(self):
+        """
+        Whether a participant was unmuted from the ongoing group call or not.
+
+        If `True`, `new` will be present as :tl:`GroupCallParticipant`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionParticipantUnmute)
+
+    @property
+    def changed_call_settings(self):
+        """
+        Whether the group call settings were changed or not.
+
+        If `True`, `new` will be `True` if new users are muted on join.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionToggleGroupCallSetting)
+
+    @property
+    def changed_history_ttl(self):
+        """
+        Whether the Time To Live of the message history has changed.
+
+        Messages sent after this change will have a ``ttl_period`` in seconds
+        indicating how long they should live for before being auto-deleted.
+
+        If `True`, `old` will be the old TTL, and `new` the new TTL, in seconds.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionChangeHistoryTTL)
+
+    @property
+    def deleted_exported_invite(self):
+        """
+        Whether the exported chat invite has been deleted.
+
+        If `True`, `old` will be the deleted :tl:`ExportedChatInvite`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionExportedInviteDelete)
+
+    @property
+    def edited_exported_invite(self):
+        """
+        Whether the exported chat invite has been edited.
+
+        If `True`, `old` and `new` will be the old and new
+        :tl:`ExportedChatInvite`, respectively.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionExportedInviteEdit)
+
+    @property
+    def revoked_exported_invite(self):
+        """
+        Whether the exported chat invite has been revoked.
+
+        If `True`, `old` will be the revoked :tl:`ExportedChatInvite`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionExportedInviteRevoke)
+
+    @property
+    def joined_by_invite(self):
+        """
+        Whether a new participant has joined with the use of an invite link.
+
+        If `True`, `old` will be pre-existing (old) :tl:`ExportedChatInvite`
+        used to join.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionParticipantJoinByInvite)
+
+    @property
+    def changed_user_volume(self):
+        """
+        Whether a participant's volume in a call has been changed.
+
+        If `True`, `new` will be the updated :tl:`GroupCallParticipant`.
+        """
+        return isinstance(self.original.action,
+                          types.ChannelAdminLogEventActionParticipantVolume)
+
+    def __str__(self):
+        return str(self.original)
+
+    def stringify(self):
+        return self.original.stringify()

.venv2/Lib/site-packages/telethon/tl/custom/button.py

@@ -0,0 +1,309 @@
+from .. import types
+from ... import utils
+
+
+class Button:
+    """
+    .. note::
+
+        This class is used to **define** reply markups, e.g. when
+        sending a message or replying to events. When you access
+        `Message.buttons <telethon.tl.custom.message.Message.buttons>`
+        they are actually `MessageButton
+        <telethon.tl.custom.messagebutton.MessageButton>`,
+        so you might want to refer to that class instead.
+
+    Helper class to allow defining ``reply_markup`` when
+    sending a message with inline or keyboard buttons.
+
+    You should make use of the defined class methods to create button
+    instances instead making them yourself (i.e. don't do ``Button(...)``
+    but instead use methods line `Button.inline(...) <inline>` etc.
+
+    You can use `inline`, `switch_inline`, `url`, `auth`, `buy` and `game`
+    together to create inline buttons (under the message).
+
+    You can use `text`, `request_location`, `request_phone` and `request_poll`
+    together to create a reply markup (replaces the user keyboard).
+    You can also configure the aspect of the reply with these.
+    The latest message with a reply markup will be the one shown to the user
+    (messages contain the buttons, not the chat itself).
+
+    You **cannot** mix the two type of buttons together,
+    and it will error if you try to do so.
+
+    The text for all buttons may be at most 142 characters.
+    If more characters are given, Telegram will cut the text
+    to 128 characters and add the ellipsis (…) character as
+    the 129.
+    """
+    def __init__(self, button, *, resize, single_use, selective):
+        self.button = button
+        self.resize = resize
+        self.single_use = single_use
+        self.selective = selective
+
+    @staticmethod
+    def _is_inline(button):
+        """
+        Returns `True` if the button belongs to an inline keyboard.
+        """
+        return isinstance(button, (
+            types.KeyboardButtonBuy,
+            types.KeyboardButtonCallback,
+            types.KeyboardButtonGame,
+            types.KeyboardButtonSwitchInline,
+            types.KeyboardButtonUrl,
+            types.InputKeyboardButtonUrlAuth,
+            types.KeyboardButtonWebView,
+        ))
+
+    @staticmethod
+    def inline(text, data=None):
+        """
+        Creates a new inline button with some payload data in it.
+
+        If `data` is omitted, the given `text` will be used as `data`.
+        In any case `data` should be either `bytes` or `str`.
+
+        Note that the given `data` must be less or equal to 64 bytes.
+        If more than 64 bytes are passed as data, ``ValueError`` is raised.
+        If you need to store more than 64 bytes, consider saving the real
+        data in a database and a reference to that data inside the button.
+
+        When the user clicks this button, `events.CallbackQuery
+        <telethon.events.callbackquery.CallbackQuery>` will trigger with the
+        same data that the button contained, so that you can determine which
+        button was pressed.
+        """
+        if not data:
+            data = text.encode('utf-8')
+        elif not isinstance(data, (bytes, bytearray, memoryview)):
+            data = str(data).encode('utf-8')
+
+        if len(data) > 64:
+            raise ValueError('Too many bytes for the data')
+
+        return types.KeyboardButtonCallback(text, data)
+
+    @staticmethod
+    def switch_inline(text, query='', same_peer=False):
+        """
+        Creates a new inline button to switch to inline query.
+
+        If `query` is given, it will be the default text to be used
+        when making the inline query.
+
+        If ``same_peer is True`` the inline query will directly be
+        set under the currently opened chat. Otherwise, the user will
+        have to select a different dialog to make the query.
+
+        When the user clicks this button, after a chat is selected, their
+        input field will be filled with the username of your bot followed
+        by the query text, ready to make inline queries.
+        """
+        return types.KeyboardButtonSwitchInline(text, query, same_peer)
+
+    @staticmethod
+    def url(text, url=None):
+        """
+        Creates a new inline button to open the desired URL on click.
+
+        If no `url` is given, the `text` will be used as said URL instead.
+
+        You cannot detect that the user clicked this button directly.
+
+        When the user clicks this button, a confirmation box will be shown
+        to the user asking whether they want to open the displayed URL unless
+        the domain is trusted, and once confirmed the URL will open in their
+        device.
+        """
+        return types.KeyboardButtonUrl(text, url or text)
+
+    @staticmethod
+    def auth(text, url=None, *, bot=None, write_access=False, fwd_text=None):
+        """
+        Creates a new inline button to authorize the user at the given URL.
+
+        You should set the `url` to be on the same domain as the one configured
+        for the desired `bot` via `@BotFather <https://t.me/BotFather>`_ using
+        the ``/setdomain`` command.
+
+        For more information about letting the user login via Telegram to
+        a certain domain, see https://core.telegram.org/widgets/login.
+
+        If no `url` is specified, it will default to `text`.
+
+        Args:
+            bot (`hints.EntityLike`):
+                The bot that requires this authorization. By default, this
+                is the bot that is currently logged in (itself), although
+                you may pass a different input peer.
+
+                .. note::
+
+                    For now, you cannot use ID or username for this argument.
+                    If you want to use a different bot than the one currently
+                    logged in, you must manually use `client.get_input_entity()
+                    <telethon.client.users.UserMethods.get_input_entity>`.
+
+            write_access (`bool`):
+                Whether write access is required or not.
+                This is `False` by default (read-only access).
+
+            fwd_text (`str`):
+                The new text to show in the button if the message is
+                forwarded. By default, the button text will be the same.
+
+        When the user clicks this button, a confirmation box will be shown
+        to the user asking whether they want to login to the specified domain.
+        """
+        return types.InputKeyboardButtonUrlAuth(
+            text=text,
+            url=url or text,
+            bot=utils.get_input_user(bot or types.InputUserSelf()),
+            request_write_access=write_access,
+            fwd_text=fwd_text
+        )
+
+    @classmethod
+    def text(cls, text, *, resize=None, single_use=None, selective=None):
+        """
+        Creates a new keyboard button with the given text.
+
+        Args:
+            resize (`bool`):
+                If present, the entire keyboard will be reconfigured to
+                be resized and be smaller if there are not many buttons.
+
+            single_use (`bool`):
+                If present, the entire keyboard will be reconfigured to
+                be usable only once before it hides itself.
+
+            selective (`bool`):
+                If present, the entire keyboard will be reconfigured to
+                be "selective". The keyboard will be shown only to specific
+                users. It will target users that are @mentioned in the text
+                of the message or to the sender of the message you reply to.
+
+        When the user clicks this button, a text message with the same text
+        as the button will be sent, and can be handled with `events.NewMessage
+        <telethon.events.newmessage.NewMessage>`. You cannot distinguish
+        between a button press and the user typing and sending exactly the
+        same text on their own.
+        """
+        return cls(types.KeyboardButton(text),
+                   resize=resize, single_use=single_use, selective=selective)
+
+    @classmethod
+    def request_location(cls, text, *,
+                         resize=None, single_use=None, selective=None):
+        """
+        Creates a new keyboard button to request the user's location on click.
+
+        ``resize``, ``single_use`` and ``selective`` are documented in `text`.
+
+        When the user clicks this button, a confirmation box will be shown
+        to the user asking whether they want to share their location with the
+        bot, and if confirmed a message with geo media will be sent.
+        """
+        return cls(types.KeyboardButtonRequestGeoLocation(text),
+                   resize=resize, single_use=single_use, selective=selective)
+
+    @classmethod
+    def request_phone(cls, text, *,
+                      resize=None, single_use=None, selective=None):
+        """
+        Creates a new keyboard button to request the user's phone on click.
+
+        ``resize``, ``single_use`` and ``selective`` are documented in `text`.
+
+        When the user clicks this button, a confirmation box will be shown
+        to the user asking whether they want to share their phone with the
+        bot, and if confirmed a message with contact media will be sent.
+        """
+        return cls(types.KeyboardButtonRequestPhone(text),
+                   resize=resize, single_use=single_use, selective=selective)
+
+    @classmethod
+    def request_poll(cls, text, *, force_quiz=False,
+                     resize=None, single_use=None, selective=None):
+        """
+        Creates a new keyboard button to request the user to create a poll.
+
+        If `force_quiz` is `False`, the user will be allowed to choose whether
+        they want their poll to be a quiz or not. Otherwise, the user will be
+        forced to create a quiz when creating the poll.
+
+        If a poll is a quiz, there will be only one answer that is valid, and
+        the votes cannot be retracted. Otherwise, users can vote and retract
+        the vote, and the pol might be multiple choice.
+
+        ``resize``, ``single_use`` and ``selective`` are documented in `text`.
+
+        When the user clicks this button, a screen letting the user create a
+        poll will be shown, and if they do create one, the poll will be sent.
+        """
+        return cls(types.KeyboardButtonRequestPoll(text, quiz=force_quiz),
+                   resize=resize, single_use=single_use, selective=selective)
+
+    @staticmethod
+    def clear(selective=None):
+        """
+        Clears all keyboard buttons after sending a message with this markup.
+        When used, no other button should be present or it will be ignored.
+
+       ``selective`` is as documented in `text`.
+
+        """
+        return types.ReplyKeyboardHide(selective=selective)
+
+    @staticmethod
+    def force_reply(single_use=None, selective=None, placeholder=None):
+        """
+        Forces a reply to the message with this markup. If used,
+        no other button should be present or it will be ignored.
+
+        ``single_use`` and ``selective`` are as documented in `text`.
+
+        Args:
+            placeholder (str):
+                text to show the user at typing place of message.
+
+                If the placeholder is too long, Telegram applications will
+                crop the text (for example, to 64 characters and adding an
+                ellipsis (…) character as the 65th).
+        """
+        return types.ReplyKeyboardForceReply(
+            single_use=single_use,
+            selective=selective,
+            placeholder=placeholder)
+
+    @staticmethod
+    def buy(text):
+        """
+        Creates a new inline button to buy a product.
+
+        This can only be used when sending files of type
+        :tl:`InputMediaInvoice`, and must be the first button.
+
+        If the button is not specified, Telegram will automatically
+        add the button to the message. See the
+        `Payments API <https://core.telegram.org/api/payments>`__
+        documentation for more information.
+        """
+        return types.KeyboardButtonBuy(text)
+
+    @staticmethod
+    def game(text):
+        """
+        Creates a new inline button to start playing a game.
+
+        This should be used when sending files of type
+        :tl:`InputMediaGame`, and must be the first button.
+
+        See the
+        `Games <https://core.telegram.org/api/bots/games>`__
+        documentation for more information on using games.
+        """
+        return types.KeyboardButtonGame(text)

.venv2/Lib/site-packages/telethon/tl/custom/chatgetter.py

@@ -0,0 +1,150 @@
+import abc
+
+from ... import errors, utils
+from ...tl import types
+
+
+class ChatGetter(abc.ABC):
+    """
+    Helper base class that introduces the `chat`, `input_chat`
+    and `chat_id` properties and `get_chat` and `get_input_chat`
+    methods.
+    """
+    def __init__(self, chat_peer=None, *, input_chat=None, chat=None, broadcast=None):
+        self._chat_peer = chat_peer
+        self._input_chat = input_chat
+        self._chat = chat
+        self._broadcast = broadcast
+        self._client = None
+
+    @property
+    def chat(self):
+        """
+        Returns the :tl:`User`, :tl:`Chat` or :tl:`Channel` where this object
+        belongs to. It may be `None` if Telegram didn't send the chat.
+
+        If you only need the ID, use `chat_id` instead.
+
+        If you need to call a method which needs
+        this chat, use `input_chat` instead.
+
+        If you're using `telethon.events`, use `get_chat()` instead.
+        """
+        return self._chat
+
+    async def get_chat(self):
+        """
+        Returns `chat`, but will make an API call to find the
+        chat unless it's already cached.
+
+        If you only need the ID, use `chat_id` instead.
+
+        If you need to call a method which needs
+        this chat, use `get_input_chat()` instead.
+        """
+        # See `get_sender` for information about 'min'.
+        if (self._chat is None or getattr(self._chat, 'min', None))\
+                and await self.get_input_chat():
+            try:
+                self._chat =\
+                    await self._client.get_entity(self._input_chat)
+            except ValueError:
+                await self._refetch_chat()
+        return self._chat
+
+    @property
+    def input_chat(self):
+        """
+        This :tl:`InputPeer` is the input version of the chat where the
+        message was sent. Similarly to `input_sender
+        <telethon.tl.custom.sendergetter.SenderGetter.input_sender>`, this
+        doesn't have things like username or similar, but still useful in
+        some cases.
+
+        Note that this might not be available if the library doesn't
+        have enough information available.
+        """
+        if self._input_chat is None and self._chat_peer and self._client:
+            try:
+                self._input_chat = self._client._mb_entity_cache.get(
+                        utils.get_peer_id(self._chat_peer, add_mark=False))._as_input_peer()
+            except AttributeError:
+                pass
+
+        return self._input_chat
+
+    async def get_input_chat(self):
+        """
+        Returns `input_chat`, but will make an API call to find the
+        input chat unless it's already cached.
+        """
+        if self.input_chat is None and self.chat_id and self._client:
+            try:
+                # The chat may be recent, look in dialogs
+                target = self.chat_id
+                async for d in self._client.iter_dialogs(100):
+                    if d.id == target:
+                        self._chat = d.entity
+                        self._input_chat = d.input_entity
+                        break
+            except errors.RPCError:
+                pass
+
+        return self._input_chat
+
+    @property
+    def chat_id(self):
+        """
+        Returns the marked chat integer ID. Note that this value **will
+        be different** from ``peer_id`` for incoming private messages, since
+        the chat *to* which the messages go is to your own person, but
+        the *chat* itself is with the one who sent the message.
+
+        TL;DR; this gets the ID that you expect.
+
+        If there is a chat in the object, `chat_id` will *always* be set,
+        which is why you should use it instead of `chat.id <chat>`.
+        """
+        return utils.get_peer_id(self._chat_peer) if self._chat_peer else None
+
+    @property
+    def is_private(self):
+        """
+        `True` if the message was sent as a private message.
+
+        Returns `None` if there isn't enough information
+        (e.g. on `events.MessageDeleted <telethon.events.messagedeleted.MessageDeleted>`).
+        """
+        return isinstance(self._chat_peer, types.PeerUser) if self._chat_peer else None
+
+    @property
+    def is_group(self):
+        """
+        True if the message was sent on a group or megagroup.
+
+        Returns `None` if there isn't enough information
+        (e.g. on `events.MessageDeleted <telethon.events.messagedeleted.MessageDeleted>`).
+        """
+        # TODO Cache could tell us more in the future
+        if self._broadcast is None and hasattr(self.chat, 'broadcast'):
+            self._broadcast = bool(self.chat.broadcast)
+
+        if isinstance(self._chat_peer, types.PeerChannel):
+            if self._broadcast is None:
+                return None
+            else:
+                return not self._broadcast
+
+        return isinstance(self._chat_peer, types.PeerChat)
+
+    @property
+    def is_channel(self):
+        """`True` if the message was sent on a megagroup or channel."""
+        # The only case where chat peer could be none is in MessageDeleted,
+        # however those always have the peer in channels.
+        return isinstance(self._chat_peer, types.PeerChannel)
+
+    async def _refetch_chat(self):
+        """
+        Re-fetches chat information through other means.
+        """

.venv2/Lib/site-packages/telethon/tl/custom/conversation.py

@@ -0,0 +1,529 @@
+import asyncio
+import functools
+import inspect
+import itertools
+import time
+
+from .chatgetter import ChatGetter
+from ... import helpers, utils, errors
+
+# Sometimes the edits arrive very fast (within the same second).
+# In that case we add a small delta so that the age is older, for
+# comparision purposes. This value is enough for up to 1000 messages.
+_EDIT_COLLISION_DELTA = 0.001
+
+
+def _checks_cancelled(f):
+    @functools.wraps(f)
+    def wrapper(self, *args, **kwargs):
+        if self._cancelled:
+            raise asyncio.CancelledError('The conversation was cancelled before')
+
+        return f(self, *args, **kwargs)
+    return wrapper
+
+
+class Conversation(ChatGetter):
+    """
+    Represents a conversation inside an specific chat.
+
+    A conversation keeps track of new messages since it was
+    created until its exit and easily lets you query the
+    current state.
+
+    If you need a conversation across two or more chats,
+    you should use two conversations and synchronize them
+    as you better see fit.
+    """
+    _id_counter = 0
+    _custom_counter = 0
+
+    def __init__(self, client, input_chat,
+                 *, timeout, total_timeout, max_messages,
+                 exclusive, replies_are_responses):
+        # This call resets the client
+        ChatGetter.__init__(self, input_chat=input_chat)
+
+        self._id = Conversation._id_counter
+        Conversation._id_counter += 1
+
+        self._client = client
+        self._timeout = timeout
+        self._total_timeout = total_timeout
+        self._total_due = None
+
+        self._outgoing = set()
+        self._last_outgoing = 0
+        self._incoming = []
+        self._last_incoming = 0
+        self._max_incoming = max_messages
+        self._last_read = None
+        self._custom = {}
+
+        self._pending_responses = {}
+        self._pending_replies = {}
+        self._pending_edits = {}
+        self._pending_reads = {}
+
+        self._exclusive = exclusive
+        self._cancelled = False
+
+        # The user is able to expect two responses for the same message.
+        # {desired message ID: next incoming index}
+        self._response_indices = {}
+        if replies_are_responses:
+            self._reply_indices = self._response_indices
+        else:
+            self._reply_indices = {}
+
+        self._edit_dates = {}
+
+    @_checks_cancelled
+    async def send_message(self, *args, **kwargs):
+        """
+        Sends a message in the context of this conversation. Shorthand
+        for `telethon.client.messages.MessageMethods.send_message` with
+        ``entity`` already set.
+        """
+        sent = await self._client.send_message(
+            self._input_chat, *args, **kwargs)
+
+        # Albums will be lists, so handle that
+        ms = sent if isinstance(sent, list) else (sent,)
+        self._outgoing.update(m.id for m in ms)
+        self._last_outgoing = ms[-1].id
+        return sent
+
+    @_checks_cancelled
+    async def send_file(self, *args, **kwargs):
+        """
+        Sends a file in the context of this conversation. Shorthand
+        for `telethon.client.uploads.UploadMethods.send_file` with
+        ``entity`` already set.
+        """
+        sent = await self._client.send_file(
+            self._input_chat, *args, **kwargs)
+
+        # Albums will be lists, so handle that
+        ms = sent if isinstance(sent, list) else (sent,)
+        self._outgoing.update(m.id for m in ms)
+        self._last_outgoing = ms[-1].id
+        return sent
+
+    @_checks_cancelled
+    def mark_read(self, message=None):
+        """
+        Marks as read the latest received message if ``message is None``.
+        Otherwise, marks as read until the given message (or message ID).
+
+        This is equivalent to calling `client.send_read_acknowledge
+        <telethon.client.messages.MessageMethods.send_read_acknowledge>`.
+        """
+        if message is None:
+            if self._incoming:
+                message = self._incoming[-1].id
+            else:
+                message = 0
+        elif not isinstance(message, int):
+            message = message.id
+
+        return self._client.send_read_acknowledge(
+            self._input_chat, max_id=message)
+
+    def get_response(self, message=None, *, timeout=None):
+        """
+        Gets the next message that responds to a previous one. This is
+        the method you need most of the time, along with `get_edit`.
+
+        Args:
+            message (`Message <telethon.tl.custom.message.Message>` | `int`, optional):
+                The message (or the message ID) for which a response
+                is expected. By default this is the last sent message.
+
+            timeout (`int` | `float`, optional):
+                If present, this `timeout` (in seconds) will override the
+                per-action timeout defined for the conversation.
+
+        .. code-block:: python
+
+            async with client.conversation(...) as conv:
+                await conv.send_message('Hey, what is your name?')
+
+                response = await conv.get_response()
+                name = response.text
+
+                await conv.send_message('Nice to meet you, {}!'.format(name))
+        """
+        return self._get_message(
+            message, self._response_indices, self._pending_responses, timeout,
+            lambda x, y: True
+        )
+
+    def get_reply(self, message=None, *, timeout=None):
+        """
+        Gets the next message that explicitly replies to a previous one.
+        """
+        return self._get_message(
+            message, self._reply_indices, self._pending_replies, timeout,
+            lambda x, y: x.reply_to and x.reply_to.reply_to_msg_id == y
+        )
+
+    def _get_message(
+            self, target_message, indices, pending, timeout, condition):
+        """
+        Gets the next desired message under the desired condition.
+
+        Args:
+            target_message (`object`):
+                The target message for which we want to find another
+                response that applies based on `condition`.
+
+            indices (`dict`):
+                This dictionary remembers the last ID chosen for the
+                input `target_message`.
+
+            pending (`dict`):
+                This dictionary remembers {msg_id: Future} to be set
+                once `condition` is met.
+
+            timeout (`int`):
+                The timeout (in seconds) override to use for this operation.
+
+            condition (`callable`):
+                The condition callable that checks if an incoming
+                message is a valid response.
+        """
+        start_time = time.time()
+        target_id = self._get_message_id(target_message)
+
+        # If there is no last-chosen ID, make sure to pick one *after*
+        # the input message, since we don't want responses back in time
+        if target_id not in indices:
+            for i, incoming in enumerate(self._incoming):
+                if incoming.id > target_id:
+                    indices[target_id] = i
+                    break
+            else:
+                indices[target_id] = len(self._incoming)
+
+        # We will always return a future from here, even if the result
+        # can be set immediately. Otherwise, needing to await only
+        # sometimes is an annoying edge case (i.e. we would return
+        # a `Message` but `get_response()` always `await`'s).
+        future = self._client.loop.create_future()
+
+        # If there are enough responses saved return the next one
+        last_idx = indices[target_id]
+        if last_idx < len(self._incoming):
+            incoming = self._incoming[last_idx]
+            if condition(incoming, target_id):
+                indices[target_id] += 1
+                future.set_result(incoming)
+                return future
+
+        # Otherwise the next incoming response will be the one to use
+        #
+        # Note how we fill "pending" before giving control back to the
+        # event loop through "await". We want to register it as soon as
+        # possible, since any other task switch may arrive with the result.
+        pending[target_id] = future
+        return self._get_result(future, start_time, timeout, pending, target_id)
+
+    def get_edit(self, message=None, *, timeout=None):
+        """
+        Awaits for an edit after the last message to arrive.
+        The arguments are the same as those for `get_response`.
+        """
+        start_time = time.time()
+        target_id = self._get_message_id(message)
+
+        target_date = self._edit_dates.get(target_id, 0)
+        earliest_edit = min(
+            (x for x in self._incoming
+             if x.edit_date
+             and x.id > target_id
+             and x.edit_date.timestamp() > target_date
+             ),
+            key=lambda x: x.edit_date.timestamp(),
+            default=None
+        )
+
+        future = self._client.loop.create_future()
+        if earliest_edit and earliest_edit.edit_date.timestamp() > target_date:
+            self._edit_dates[target_id] = earliest_edit.edit_date.timestamp()
+            future.set_result(earliest_edit)
+            return future  # we should always return something we can await
+
+        # Otherwise the next incoming response will be the one to use
+        self._pending_edits[target_id] = future
+        return self._get_result(future, start_time, timeout, self._pending_edits, target_id)
+
+    def wait_read(self, message=None, *, timeout=None):
+        """
+        Awaits for the sent message to be marked as read. Note that
+        receiving a response doesn't imply the message was read, and
+        this action will also trigger even without a response.
+        """
+        start_time = time.time()
+        future = self._client.loop.create_future()
+        target_id = self._get_message_id(message)
+
+        if self._last_read is None:
+            self._last_read = target_id - 1
+
+        if self._last_read >= target_id:
+            return
+
+        self._pending_reads[target_id] = future
+        return self._get_result(future, start_time, timeout, self._pending_reads, target_id)
+
+    async def wait_event(self, event, *, timeout=None):
+        """
+        Waits for a custom event to occur. Timeouts still apply.
+
+        .. note::
+
+            **Only use this if there isn't another method available!**
+            For example, don't use `wait_event` for new messages,
+            since `get_response` already exists, etc.
+
+        Unless you're certain that your code will run fast enough,
+        generally you should get a "handle" of this special coroutine
+        before acting. In this example you will see how to wait for a user
+        to join a group with proper use of `wait_event`:
+
+        .. code-block:: python
+
+            from telethon import TelegramClient, events
+
+            client = TelegramClient(...)
+            group_id = ...
+
+            async def main():
+                # Could also get the user id from an event; this is just an example
+                user_id = ...
+
+                async with client.conversation(user_id) as conv:
+                    # Get a handle to the future event we'll wait for
+                    handle = conv.wait_event(events.ChatAction(
+                        group_id,
+                        func=lambda e: e.user_joined and e.user_id == user_id
+                    ))
+
+                    # Perform whatever action in between
+                    await conv.send_message('Please join this group before speaking to me!')
+
+                    # Wait for the event we registered above to fire
+                    event = await handle
+
+                    # Continue with the conversation
+                    await conv.send_message('Thanks!')
+
+        This way your event can be registered before acting,
+        since the response may arrive before your event was
+        registered. It depends on your use case since this
+        also means the event can arrive before you send
+        a previous action.
+        """
+        start_time = time.time()
+        if isinstance(event, type):
+            event = event()
+
+        await event.resolve(self._client)
+
+        counter = Conversation._custom_counter
+        Conversation._custom_counter += 1
+
+        future = self._client.loop.create_future()
+        self._custom[counter] = (event, future)
+        try:
+            return await self._get_result(future, start_time, timeout, self._custom, counter)
+        finally:
+            # Need to remove it from the dict if it times out, else we may
+            # try and fail to set the result later (#1618).
+            self._custom.pop(counter, None)
+
+    async def _check_custom(self, built):
+        for key, (ev, fut) in list(self._custom.items()):
+            ev_type = type(ev)
+            inst = built[ev_type]
+
+            if inst:
+                filter = ev.filter(inst)
+                if inspect.isawaitable(filter):
+                    filter = await filter
+
+                if filter:
+                    fut.set_result(inst)
+                    del self._custom[key]
+
+    def _on_new_message(self, response):
+        response = response.message
+        if response.chat_id != self.chat_id or response.out:
+            return
+
+        if len(self._incoming) == self._max_incoming:
+            self._cancel_all(ValueError('Too many incoming messages'))
+            return
+
+        self._incoming.append(response)
+
+        # Most of the time, these dictionaries will contain just one item
+        # TODO In fact, why not make it be that way? Force one item only.
+        #      How often will people want to wait for two responses at
+        #      the same time? It's impossible, first one will arrive
+        #      and then another, so they can do that.
+        for msg_id, future in list(self._pending_responses.items()):
+            self._response_indices[msg_id] = len(self._incoming)
+            future.set_result(response)
+            del self._pending_responses[msg_id]
+
+        for msg_id, future in list(self._pending_replies.items()):
+            if response.reply_to and msg_id == response.reply_to.reply_to_msg_id:
+                self._reply_indices[msg_id] = len(self._incoming)
+                future.set_result(response)
+                del self._pending_replies[msg_id]
+
+    def _on_edit(self, message):
+        message = message.message
+        if message.chat_id != self.chat_id or message.out:
+            return
+
+        # We have to update our incoming messages with the new edit date
+        for i, m in enumerate(self._incoming):
+            if m.id == message.id:
+                self._incoming[i] = message
+                break
+
+        for msg_id, future in list(self._pending_edits.items()):
+            if msg_id < message.id:
+                edit_ts = message.edit_date.timestamp()
+
+                # We compare <= because edit_ts resolution is always to
+                # seconds, but we may have increased _edit_dates before.
+                # Since the dates are ever growing this is not a problem.
+                if edit_ts <= self._edit_dates.get(msg_id, 0):
+                    self._edit_dates[msg_id] += _EDIT_COLLISION_DELTA
+                else:
+                    self._edit_dates[msg_id] = message.edit_date.timestamp()
+
+                future.set_result(message)
+                del self._pending_edits[msg_id]
+
+    def _on_read(self, event):
+        if event.chat_id != self.chat_id or event.inbox:
+            return
+
+        self._last_read = event.max_id
+
+        for msg_id, pending in list(self._pending_reads.items()):
+            if msg_id >= self._last_read:
+                pending.set_result(True)
+                del self._pending_reads[msg_id]
+
+    def _get_message_id(self, message):
+        if message is not None:  # 0 is valid but false-y, check for None
+            return message if isinstance(message, int) else message.id
+        elif self._last_outgoing:
+            return self._last_outgoing
+        else:
+            raise ValueError('No message was sent previously')
+
+    @_checks_cancelled
+    def _get_result(self, future, start_time, timeout, pending, target_id):
+        due = self._total_due
+        if timeout is None:
+            timeout = self._timeout
+
+        if timeout is not None:
+            due = min(due, start_time + timeout)
+
+        # NOTE: We can't try/finally to pop from pending here because
+        #       the event loop needs to get back to us, but it might
+        #       dispatch another update before, and in that case a
+        #       response could be set twice. So responses must be
+        #       cleared when their futures are set to a result.
+        return asyncio.wait_for(
+            future,
+            timeout=None if due == float('inf') else due - time.time()
+        )
+
+    def _cancel_all(self, exception=None):
+        self._cancelled = True
+        for pending in itertools.chain(
+                self._pending_responses.values(),
+                self._pending_replies.values(),
+                self._pending_edits.values()):
+            if exception:
+                pending.set_exception(exception)
+            else:
+                pending.cancel()
+
+        for _, fut in self._custom.values():
+            if exception:
+                fut.set_exception(exception)
+            else:
+                fut.cancel()
+
+    async def __aenter__(self):
+        self._input_chat = \
+            await self._client.get_input_entity(self._input_chat)
+
+        self._chat_peer = utils.get_peer(self._input_chat)
+
+        # Make sure we're the only conversation in this chat if it's exclusive
+        chat_id = utils.get_peer_id(self._chat_peer)
+        conv_set = self._client._conversations[chat_id]
+        if self._exclusive and conv_set:
+            raise errors.AlreadyInConversationError()
+
+        conv_set.add(self)
+        self._cancelled = False
+
+        self._last_outgoing = 0
+        self._last_incoming = 0
+        for d in (
+                self._outgoing, self._incoming,
+                self._pending_responses, self._pending_replies,
+                self._pending_edits, self._response_indices,
+                self._reply_indices, self._edit_dates, self._custom):
+            d.clear()
+
+        if self._total_timeout:
+            self._total_due = time.time() + self._total_timeout
+        else:
+            self._total_due = float('inf')
+
+        return self
+
+    def cancel(self):
+        """
+        Cancels the current conversation. Pending responses and subsequent
+        calls to get a response will raise ``asyncio.CancelledError``.
+
+        This method is synchronous and should not be awaited.
+        """
+        self._cancel_all()
+
+    async def cancel_all(self):
+        """
+        Calls `cancel` on *all* conversations in this chat.
+
+        Note that you should ``await`` this method, since it's meant to be
+        used outside of a context manager, and it needs to resolve the chat.
+        """
+        chat_id = await self._client.get_peer_id(self._input_chat)
+        for conv in self._client._conversations[chat_id]:
+            conv.cancel()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        chat_id = utils.get_peer_id(self._chat_peer)
+        conv_set = self._client._conversations[chat_id]
+        conv_set.discard(self)
+        if not conv_set:
+            del self._client._conversations[chat_id]
+
+        self._cancel_all()
+
+    __enter__ = helpers._sync_enter
+    __exit__ = helpers._sync_exit

.venv2/Lib/site-packages/telethon/tl/custom/dialog.py

@@ -0,0 +1,161 @@
+from . import Draft
+from .. import TLObject, types, functions
+from ... import utils
+
+
+class Dialog:
+    """
+    Custom class that encapsulates a dialog (an open "conversation" with
+    someone, a group or a channel) providing an abstraction to easily
+    access the input version/normal entity/message etc. The library will
+    return instances of this class when calling :meth:`.get_dialogs()`.
+
+    Args:
+        dialog (:tl:`Dialog`):
+            The original ``Dialog`` instance.
+
+        pinned (`bool`):
+            Whether this dialog is pinned to the top or not.
+
+        folder_id (`folder_id`):
+            The folder ID that this dialog belongs to.
+
+        archived (`bool`):
+            Whether this dialog is archived or not (``folder_id is None``).
+
+        message (`Message <telethon.tl.custom.message.Message>`):
+            The last message sent on this dialog. Note that this member
+            will not be updated when new messages arrive, it's only set
+            on creation of the instance.
+
+        date (`datetime`):
+            The date of the last message sent on this dialog.
+
+        entity (`entity`):
+            The entity that belongs to this dialog (user, chat or channel).
+
+        input_entity (:tl:`InputPeer`):
+            Input version of the entity.
+
+        id (`int`):
+            The marked ID of the entity, which is guaranteed to be unique.
+
+        name (`str`):
+            Display name for this dialog. For chats and channels this is
+            their title, and for users it's "First-Name Last-Name".
+
+        title (`str`):
+            Alias for `name`.
+
+        unread_count (`int`):
+            How many messages are currently unread in this dialog. Note that
+            this value won't update when new messages arrive.
+
+        unread_mentions_count (`int`):
+            How many mentions are currently unread in this dialog. Note that
+            this value won't update when new messages arrive.
+
+        draft (`Draft <telethon.tl.custom.draft.Draft>`):
+            The draft object in this dialog. It will not be `None`,
+            so you can call ``draft.set_message(...)``.
+
+        is_user (`bool`):
+            `True` if the `entity` is a :tl:`User`.
+
+        is_group (`bool`):
+            `True` if the `entity` is a :tl:`Chat`
+            or a :tl:`Channel` megagroup.
+
+        is_channel (`bool`):
+            `True` if the `entity` is a :tl:`Channel`.
+    """
+    def __init__(self, client, dialog, entities, message):
+        # Both entities and messages being dicts {ID: item}
+        self._client = client
+        self.dialog = dialog
+        self.pinned = bool(dialog.pinned)
+        self.folder_id = dialog.folder_id
+        self.archived = dialog.folder_id is not None
+        self.message = message
+        self.date = getattr(self.message, 'date', None)
+
+        self.entity = entities[utils.get_peer_id(dialog.peer)]
+        self.input_entity = utils.get_input_peer(self.entity)
+        self.id = utils.get_peer_id(self.entity)  # ^ May be InputPeerSelf()
+        self.name = self.title = utils.get_display_name(self.entity)
+
+        self.unread_count = dialog.unread_count
+        self.unread_mentions_count = dialog.unread_mentions_count
+
+        self.draft = Draft(client, self.entity, self.dialog.draft)
+
+        self.is_user = isinstance(self.entity, types.User)
+        self.is_group = (
+            isinstance(self.entity, (types.Chat, types.ChatForbidden)) or
+            (isinstance(self.entity, types.Channel) and self.entity.megagroup)
+        )
+        self.is_channel = isinstance(self.entity, types.Channel)
+
+    async def send_message(self, *args, **kwargs):
+        """
+        Sends a message to this dialog. This is just a wrapper around
+        ``client.send_message(dialog.input_entity, *args, **kwargs)``.
+        """
+        return await self._client.send_message(
+            self.input_entity, *args, **kwargs)
+
+    async def delete(self, revoke=False):
+        """
+        Deletes the dialog from your dialog list. If you own the
+        channel this won't destroy it, only delete it from the list.
+
+        Shorthand for `telethon.client.dialogs.DialogMethods.delete_dialog`
+        with ``entity`` already set.
+        """
+        # Pass the entire entity so the method can determine whether
+        # the `Chat` is deactivated (in which case we don't kick ourselves,
+        # or it would raise `PEER_ID_INVALID`).
+        await self._client.delete_dialog(self.entity, revoke=revoke)
+
+    async def archive(self, folder=1):
+        """
+        Archives (or un-archives) this dialog.
+
+        Args:
+            folder (`int`, optional):
+                The folder to which the dialog should be archived to.
+
+                If you want to "un-archive" it, use ``folder=0``.
+
+        Returns:
+            The :tl:`Updates` object that the request produces.
+
+        Example:
+
+            .. code-block:: python
+
+                # Archiving
+                dialog.archive()
+
+                # Un-archiving
+                dialog.archive(0)
+        """
+        return await self._client(functions.folders.EditPeerFoldersRequest([
+            types.InputFolderPeer(self.input_entity, folder_id=folder)
+        ]))
+
+    def to_dict(self):
+        return {
+            '_': 'Dialog',
+            'name': self.name,
+            'date': self.date,
+            'draft': self.draft,
+            'message': self.message,
+            'entity': self.entity,
+        }
+
+    def __str__(self):
+        return TLObject.pretty_format(self.to_dict())
+
+    def stringify(self):
+        return TLObject.pretty_format(self.to_dict(), indent=0)

.venv2/Lib/site-packages/telethon/tl/custom/draft.py

@@ -0,0 +1,191 @@
+import datetime
+
+from .. import TLObject, types
+from ..functions.messages import SaveDraftRequest
+from ..types import DraftMessage
+from ...errors import RPCError
+from ...extensions import markdown
+from ...utils import get_input_peer, get_peer, get_peer_id
+
+
+class Draft:
+    """
+    Custom class that encapsulates a draft on the Telegram servers, providing
+    an abstraction to change the message conveniently. The library will return
+    instances of this class when calling :meth:`get_drafts()`.
+
+    Args:
+        date (`datetime`):
+            The date of the draft.
+
+        link_preview (`bool`):
+            Whether the link preview is enabled or not.
+
+        reply_to_msg_id (`int`):
+            The message ID that the draft will reply to.
+    """
+    def __init__(self, client, entity, draft):
+        self._client = client
+        self._peer = get_peer(entity)
+        self._entity = entity
+        self._input_entity = get_input_peer(entity) if entity else None
+
+        if not draft or not isinstance(draft, DraftMessage):
+            draft = DraftMessage('', None, None, None, None)
+
+        self._text = markdown.unparse(draft.message, draft.entities)
+        self._raw_text = draft.message
+        self.date = draft.date
+        self.link_preview = not draft.no_webpage
+        self.reply_to_msg_id = draft.reply_to.reply_to_msg_id if isinstance(draft.reply_to, types.InputReplyToMessage) else None
+
+    @property
+    def entity(self):
+        """
+        The entity that belongs to this dialog (user, chat or channel).
+        """
+        return self._entity
+
+    @property
+    def input_entity(self):
+        """
+        Input version of the entity.
+        """
+        if not self._input_entity:
+            try:
+                self._input_entity = self._client._mb_entity_cache.get(
+                        get_peer_id(self._peer, add_mark=False))._as_input_peer()
+            except AttributeError:
+                pass
+
+        return self._input_entity
+
+    async def get_entity(self):
+        """
+        Returns `entity` but will make an API call if necessary.
+        """
+        if not self.entity and await self.get_input_entity():
+            try:
+                self._entity =\
+                    await self._client.get_entity(self._input_entity)
+            except ValueError:
+                pass
+
+        return self._entity
+
+    async def get_input_entity(self):
+        """
+        Returns `input_entity` but will make an API call if necessary.
+        """
+        # We don't actually have an API call we can make yet
+        # to get more info, but keep this method for consistency.
+        return self.input_entity
+
+    @property
+    def text(self):
+        """
+        The markdown text contained in the draft. It will be
+        empty if there is no text (and hence no draft is set).
+        """
+        return self._text
+
+    @property
+    def raw_text(self):
+        """
+        The raw (text without formatting) contained in the draft.
+        It will be empty if there is no text (thus draft not set).
+        """
+        return self._raw_text
+
+    @property
+    def is_empty(self):
+        """
+        Convenience bool to determine if the draft is empty or not.
+        """
+        return not self._text
+
+    async def set_message(
+            self, text=None, reply_to=0, parse_mode=(),
+            link_preview=None):
+        """
+        Changes the draft message on the Telegram servers. The changes are
+        reflected in this object.
+
+        :param str text: New text of the draft.
+                         Preserved if left as None.
+
+        :param int reply_to: Message ID to reply to.
+                             Preserved if left as 0, erased if set to None.
+
+        :param bool link_preview: Whether to attach a web page preview.
+                                  Preserved if left as None.
+
+        :param str parse_mode: The parse mode to be used for the text.
+        :return bool: `True` on success.
+        """
+        if text is None:
+            text = self._text
+
+        if reply_to == 0:
+            reply_to = self.reply_to_msg_id
+
+        if link_preview is None:
+            link_preview = self.link_preview
+
+        raw_text, entities =\
+            await self._client._parse_message_text(text, parse_mode)
+
+        result = await self._client(SaveDraftRequest(
+            peer=self._peer,
+            message=raw_text,
+            no_webpage=not link_preview,
+            reply_to=None if reply_to is None else types.InputReplyToMessage(reply_to),
+            entities=entities
+        ))
+
+        if result:
+            self._text = text
+            self._raw_text = raw_text
+            self.link_preview = link_preview
+            self.reply_to_msg_id = reply_to
+            self.date = datetime.datetime.now(tz=datetime.timezone.utc)
+
+        return result
+
+    async def send(self, clear=True, parse_mode=()):
+        """
+        Sends the contents of this draft to the dialog. This is just a
+        wrapper around ``send_message(dialog.input_entity, *args, **kwargs)``.
+        """
+        await self._client.send_message(
+            self._peer, self.text, reply_to=self.reply_to_msg_id,
+            link_preview=self.link_preview, parse_mode=parse_mode,
+            clear_draft=clear
+        )
+
+    async def delete(self):
+        """
+        Deletes this draft, and returns `True` on success.
+        """
+        return await self.set_message(text='')
+
+    def to_dict(self):
+        try:
+            entity = self.entity
+        except RPCError as e:
+            entity = e
+
+        return {
+            '_': 'Draft',
+            'text': self.text,
+            'entity': entity,
+            'date': self.date,
+            'link_preview': self.link_preview,
+            'reply_to_msg_id': self.reply_to_msg_id
+        }
+
+    def __str__(self):
+        return TLObject.pretty_format(self.to_dict())
+
+    def stringify(self):
+        return TLObject.pretty_format(self.to_dict(), indent=0)

.venv2/Lib/site-packages/telethon/tl/custom/file.py

@@ -0,0 +1,146 @@
+import mimetypes
+import os
+
+from ... import utils
+from ...tl import types
+
+
+class File:
+    """
+    Convenience class over media like photos or documents, which
+    supports accessing the attributes in a more convenient way.
+
+    If any of the attributes are not present in the current media,
+    the properties will be `None`.
+
+    The original media is available through the ``media`` attribute.
+    """
+    def __init__(self, media):
+        self.media = media
+
+    @property
+    def id(self):
+        """
+        The old bot-API style ``file_id`` representing this file.
+
+        .. warning::
+
+            This feature has not been maintained for a long time and
+            may not work. It will be removed in future versions.
+
+        .. note::
+
+            This file ID may not work under user accounts,
+            but should still be usable by bot accounts.
+
+            You can, however, still use it to identify
+            a file in for example a database.
+        """
+        return utils.pack_bot_file_id(self.media)
+
+    @property
+    def name(self):
+        """
+        The file name of this document.
+        """
+        return self._from_attr(types.DocumentAttributeFilename, 'file_name')
+
+    @property
+    def ext(self):
+        """
+        The extension from the mime type of this file.
+
+        If the mime type is unknown, the extension
+        from the file name (if any) will be used.
+        """
+        return (
+            mimetypes.guess_extension(self.mime_type)
+            or os.path.splitext(self.name or '')[-1]
+            or None
+        )
+
+    @property
+    def mime_type(self):
+        """
+        The mime-type of this file.
+        """
+        if isinstance(self.media, types.Photo):
+            return 'image/jpeg'
+        elif isinstance(self.media, types.Document):
+            return self.media.mime_type
+
+    @property
+    def width(self):
+        """
+        The width in pixels of this media if it's a photo or a video.
+        """
+        if isinstance(self.media, types.Photo):
+            return max(getattr(s, 'w', 0) for s in self.media.sizes)
+
+        return self._from_attr((
+            types.DocumentAttributeImageSize, types.DocumentAttributeVideo), 'w')
+
+    @property
+    def height(self):
+        """
+        The height in pixels of this media if it's a photo or a video.
+        """
+        if isinstance(self.media, types.Photo):
+            return max(getattr(s, 'h', 0) for s in self.media.sizes)
+
+        return self._from_attr((
+           types.DocumentAttributeImageSize, types.DocumentAttributeVideo), 'h')
+
+    @property
+    def duration(self):
+        """
+        The duration in seconds of the audio or video.
+        """
+        return self._from_attr((
+            types.DocumentAttributeAudio, types.DocumentAttributeVideo), 'duration')
+
+    @property
+    def title(self):
+        """
+        The title of the song.
+        """
+        return self._from_attr(types.DocumentAttributeAudio, 'title')
+
+    @property
+    def performer(self):
+        """
+        The performer of the song.
+        """
+        return self._from_attr(types.DocumentAttributeAudio, 'performer')
+
+    @property
+    def emoji(self):
+        """
+        A string with all emoji that represent the current sticker.
+        """
+        return self._from_attr(types.DocumentAttributeSticker, 'alt')
+
+    @property
+    def sticker_set(self):
+        """
+        The :tl:`InputStickerSet` to which the sticker file belongs.
+        """
+        return self._from_attr(types.DocumentAttributeSticker, 'stickerset')
+
+    @property
+    def size(self):
+        """
+        The size in bytes of this file.
+
+        For photos, this is the heaviest thumbnail, as it often repressents the largest dimensions.
+        """
+        if isinstance(self.media, types.Photo):
+            return max(filter(None, map(utils._photo_size_byte_count, self.media.sizes)), default=None)
+        elif isinstance(self.media, types.Document):
+            return self.media.size
+
+    def _from_attr(self, cls, field):
+        if isinstance(self.media, types.Document):
+            for attr in self.media.attributes:
+                if isinstance(attr, cls):
+                    return getattr(attr, field, None)

.venv2/Lib/site-packages/telethon/tl/custom/forward.py

@@ -0,0 +1,51 @@
+from .chatgetter import ChatGetter
+from .sendergetter import SenderGetter
+from ... import utils, helpers
+from ...tl import types
+
+
+class Forward(ChatGetter, SenderGetter):
+    """
+    Custom class that encapsulates a :tl:`MessageFwdHeader` providing an
+    abstraction to easily access information like the original sender.
+
+    Remember that this class implements `ChatGetter
+    <telethon.tl.custom.chatgetter.ChatGetter>` and `SenderGetter
+    <telethon.tl.custom.sendergetter.SenderGetter>` which means you
+    have access to all their sender and chat properties and methods.
+
+    Attributes:
+
+        original_fwd (:tl:`MessageFwdHeader`):
+            The original :tl:`MessageFwdHeader` instance.
+
+        Any other attribute:
+            Attributes not described here are the same as those available
+            in the original :tl:`MessageFwdHeader`.
+    """
+    def __init__(self, client, original, entities):
+        # Copy all the fields, not reference! It would cause memory cycles:
+        #   self.original_fwd.original_fwd.original_fwd.original_fwd
+        # ...would be valid if we referenced.
+        self.__dict__.update(original.__dict__)
+        self.original_fwd = original
+
+        sender_id = sender = input_sender = peer = chat = input_chat = None
+        if original.from_id:
+            ty = helpers._entity_type(original.from_id)
+            if ty == helpers._EntityType.USER:
+                sender_id = utils.get_peer_id(original.from_id)
+                sender, input_sender = utils._get_entity_pair(
+                    sender_id, entities, client._mb_entity_cache)
+
+            elif ty in (helpers._EntityType.CHAT, helpers._EntityType.CHANNEL):
+                peer = original.from_id
+                chat, input_chat = utils._get_entity_pair(
+                    utils.get_peer_id(peer), entities, client._mb_entity_cache)
+
+        # This call resets the client
+        ChatGetter.__init__(self, peer, chat=chat, input_chat=input_chat)
+        SenderGetter.__init__(self, sender_id, sender=sender, input_sender=input_sender)
+        self._client = client
+
+    # TODO We could reload the message

.venv2/Lib/site-packages/telethon/tl/custom/inlinebuilder.py

@@ -0,0 +1,450 @@
+import hashlib
+
+from .. import functions, types
+from ... import utils
+
+_TYPE_TO_MIMES = {
+    'gif': ['image/gif'],  # 'video/mp4' too, but that's used for video
+    'article': ['text/html'],
+    'audio': ['audio/mpeg'],
+    'contact': [],
+    'file': ['application/pdf', 'application/zip'],  # actually any
+    'geo': [],
+    'photo': ['image/jpeg'],
+    'sticker': ['image/webp', 'application/x-tgsticker'],
+    'venue': [],
+    'video': ['video/mp4'],  # tdlib includes text/html for some reason
+    'voice': ['audio/ogg'],
+}
+
+
+class InlineBuilder:
+    """
+    Helper class to allow defining `InlineQuery
+    <telethon.events.inlinequery.InlineQuery>` ``results``.
+
+    Common arguments to all methods are
+    explained here to avoid repetition:
+
+        text (`str`, optional):
+            If present, the user will send a text
+            message with this text upon being clicked.
+
+        link_preview (`bool`, optional):
+            Whether to show a link preview in the sent
+            text message or not.
+
+        geo (:tl:`InputGeoPoint`, :tl:`GeoPoint`, :tl:`InputMediaVenue`, :tl:`MessageMediaVenue`, optional):
+            If present, it may either be a geo point or a venue.
+
+        period (int, optional):
+            The period in seconds to be used for geo points.
+
+        contact (:tl:`InputMediaContact`, :tl:`MessageMediaContact`, optional):
+            If present, it must be the contact information to send.
+
+        game (`bool`, optional):
+            May be `True` to indicate that the game will be sent.
+
+        buttons (`list`, `custom.Button <telethon.tl.custom.button.Button>`, :tl:`KeyboardButton`, optional):
+            Same as ``buttons`` for `client.send_message()
+            <telethon.client.messages.MessageMethods.send_message>`.
+
+        parse_mode (`str`, optional):
+            Same as ``parse_mode`` for `client.send_message()
+            <telethon.client.messageparse.MessageParseMethods.parse_mode>`.
+
+        id (`str`, optional):
+            The string ID to use for this result. If not present, it
+            will be the SHA256 hexadecimal digest of converting the
+            created :tl:`InputBotInlineResult` with empty ID to ``bytes()``,
+            so that the ID will be deterministic for the same input.
+
+            .. note::
+
+                If two inputs are exactly the same, their IDs will be the same
+                too. If you send two articles with the same ID, it will raise
+                ``ResultIdDuplicateError``. Consider giving them an explicit
+                ID if you need to send two results that are the same.
+    """
+    def __init__(self, client):
+        self._client = client
+
+    # noinspection PyIncorrectDocstring
+    async def article(
+            self, title, description=None,
+            *, url=None, thumb=None, content=None,
+            id=None, text=None, parse_mode=(), link_preview=True,
+            geo=None, period=60, contact=None, game=False, buttons=None
+    ):
+        """
+        Creates new inline result of article type.
+
+        Args:
+            title (`str`):
+                The title to be shown for this result.
+
+            description (`str`, optional):
+                Further explanation of what this result means.
+
+            url (`str`, optional):
+                The URL to be shown for this result.
+
+            thumb (:tl:`InputWebDocument`, optional):
+                The thumbnail to be shown for this result.
+                For now it has to be a :tl:`InputWebDocument` if present.
+
+            content (:tl:`InputWebDocument`, optional):
+                The content to be shown for this result.
+                For now it has to be a :tl:`InputWebDocument` if present.
+
+        Example:
+            .. code-block:: python
+
+                results = [
+                    # Option with title and description sending a message.
+                    builder.article(
+                        title='First option',
+                        description='This is the first option',
+                        text='Text sent after clicking this option',
+                    ),
+                    # Option with title URL to be opened when clicked.
+                    builder.article(
+                        title='Second option',
+                        url='https://example.com',
+                        text='Text sent if the user clicks the option and not the URL',
+                    ),
+                    # Sending a message with buttons.
+                    # You can use a list or a list of lists to include more buttons.
+                    builder.article(
+                        title='Third option',
+                        text='Text sent with buttons below',
+                        buttons=Button.url('https://example.com'),
+                    ),
+                ]
+        """
+        # TODO Does 'article' work always?
+        # article, photo, gif, mpeg4_gif, video, audio,
+        # voice, document, location, venue, contact, game
+        result = types.InputBotInlineResult(
+            id=id or '',
+            type='article',
+            send_message=await self._message(
+                text=text, parse_mode=parse_mode, link_preview=link_preview,
+                geo=geo, period=period,
+                contact=contact,
+                game=game,
+                buttons=buttons
+            ),
+            title=title,
+            description=description,
+            url=url,
+            thumb=thumb,
+            content=content
+        )
+        if id is None:
+            result.id = hashlib.sha256(bytes(result)).hexdigest()
+
+        return result
+
+    # noinspection PyIncorrectDocstring
+    async def photo(
+            self, file, *, id=None, include_media=True,
+            text=None, parse_mode=(), link_preview=True,
+            geo=None, period=60, contact=None, game=False, buttons=None
+    ):
+        """
+        Creates a new inline result of photo type.
+
+        Args:
+            include_media (`bool`, optional):
+                Whether the photo file used to display the result should be
+                included in the message itself or not. By default, the photo
+                is included, and the text parameter alters the caption.
+
+            file (`obj`, optional):
+                Same as ``file`` for `client.send_file()
+                <telethon.client.uploads.UploadMethods.send_file>`.
+
+        Example:
+            .. code-block:: python
+
+                results = [
+                    # Sending just the photo when the user selects it.
+                    builder.photo('/path/to/photo.jpg'),
+
+                    # Including a caption with some in-memory photo.
+                    photo_bytesio = ...
+                    builder.photo(
+                        photo_bytesio,
+                        text='This will be the caption of the sent photo',
+                    ),
+
+                    # Sending just the message without including the photo.
+                    builder.photo(
+                        photo,
+                        text='This will be a normal text message',
+                        include_media=False,
+                    ),
+                ]
+        """
+        try:
+            fh = utils.get_input_photo(file)
+        except TypeError:
+            _, media, _ = await self._client._file_to_media(
+                file, allow_cache=True, as_image=True
+            )
+            if isinstance(media, types.InputPhoto):
+                fh = media
+            else:
+                r = await self._client(functions.messages.UploadMediaRequest(
+                    types.InputPeerSelf(), media=media
+                ))
+                fh = utils.get_input_photo(r.photo)
+
+        result = types.InputBotInlineResultPhoto(
+            id=id or '',
+            type='photo',
+            photo=fh,
+            send_message=await self._message(
+                text=text or '',
+                parse_mode=parse_mode,
+                link_preview=link_preview,
+                media=include_media,
+                geo=geo,
+                period=period,
+                contact=contact,
+                game=game,
+                buttons=buttons
+            )
+        )
+        if id is None:
+            result.id = hashlib.sha256(bytes(result)).hexdigest()
+
+        return result
+
+    # noinspection PyIncorrectDocstring
+    async def document(
+            self, file, title=None, *, description=None, type=None,
+            mime_type=None, attributes=None, force_document=False,
+            voice_note=False, video_note=False, use_cache=True, id=None,
+            text=None, parse_mode=(), link_preview=True,
+            geo=None, period=60, contact=None, game=False, buttons=None,
+            include_media=True
+    ):
+        """
+        Creates a new inline result of document type.
+
+        `use_cache`, `mime_type`, `attributes`, `force_document`,
+        `voice_note` and `video_note` are described in `client.send_file
+        <telethon.client.uploads.UploadMethods.send_file>`.
+
+        Args:
+            file (`obj`):
+                Same as ``file`` for `client.send_file()
+                <telethon.client.uploads.UploadMethods.send_file>`.
+
+            title (`str`, optional):
+                The title to be shown for this result.
+
+            description (`str`, optional):
+                Further explanation of what this result means.
+
+            type (`str`, optional):
+                The type of the document. May be one of: article, audio,
+                contact, file, geo, gif, photo, sticker, venue, video, voice.
+                It will be automatically set if ``mime_type`` is specified,
+                and default to ``'file'`` if no matching mime type is found.
+                you may need to pass ``attributes`` in order to use ``type``
+                effectively.
+
+            attributes (`list`, optional):
+                Optional attributes that override the inferred ones, like
+                :tl:`DocumentAttributeFilename` and so on.
+
+            include_media (`bool`, optional):
+                Whether the document file used to display the result should be
+                included in the message itself or not. By default, the document
+                is included, and the text parameter alters the caption.
+
+        Example:
+            .. code-block:: python
+
+                results = [
+                    # Sending just the file when the user selects it.
+                    builder.document('/path/to/file.pdf'),
+
+                    # Including a caption with some in-memory file.
+                    file_bytesio = ...
+                    builder.document(
+                        file_bytesio,
+                        text='This will be the caption of the sent file',
+                    ),
+
+                    # Sending just the message without including the file.
+                    builder.document(
+                        photo,
+                        text='This will be a normal text message',
+                        include_media=False,
+                    ),
+                ]
+        """
+        if type is None:
+            if voice_note:
+                type = 'voice'
+            elif mime_type:
+                for ty, mimes in _TYPE_TO_MIMES.items():
+                    for mime in mimes:
+                        if mime_type == mime:
+                            type = ty
+                            break
+
+            if type is None:
+                type = 'file'
+
+        try:
+            fh = utils.get_input_document(file)
+        except TypeError:
+            _, media, _ = await self._client._file_to_media(
+                file,
+                mime_type=mime_type,
+                attributes=attributes,
+                force_document=force_document,
+                voice_note=voice_note,
+                video_note=video_note,
+                allow_cache=use_cache
+            )
+            if isinstance(media, types.InputDocument):
+                fh = media
+            else:
+                r = await self._client(functions.messages.UploadMediaRequest(
+                    types.InputPeerSelf(), media=media
+                ))
+                fh = utils.get_input_document(r.document)
+
+        result = types.InputBotInlineResultDocument(
+            id=id or '',
+            type=type,
+            document=fh,
+            send_message=await self._message(
+                # Empty string for text if there's media but text is None.
+                # We may want to display a document but send text; however
+                # default to sending the media (without text, i.e. stickers).
+                text=text or '',
+                parse_mode=parse_mode,
+                link_preview=link_preview,
+                media=include_media,
+                geo=geo,
+                period=period,
+                contact=contact,
+                game=game,
+                buttons=buttons
+            ),
+            title=title,
+            description=description
+        )
+        if id is None:
+            result.id = hashlib.sha256(bytes(result)).hexdigest()
+
+        return result
+
+    # noinspection PyIncorrectDocstring
+    async def game(
+            self, short_name, *, id=None,
+            text=None, parse_mode=(), link_preview=True,
+            geo=None, period=60, contact=None, game=False, buttons=None
+    ):
+        """
+        Creates a new inline result of game type.
+
+        Args:
+            short_name (`str`):
+                The short name of the game to use.
+        """
+        result = types.InputBotInlineResultGame(
+            id=id or '',
+            short_name=short_name,
+            send_message=await self._message(
+                text=text, parse_mode=parse_mode, link_preview=link_preview,
+                geo=geo, period=period,
+                contact=contact,
+                game=game,
+                buttons=buttons
+            )
+        )
+        if id is None:
+            result.id = hashlib.sha256(bytes(result)).hexdigest()
+
+        return result
+
+    async def _message(
+            self, *,
+            text=None, parse_mode=(), link_preview=True, media=False,
+            geo=None, period=60, contact=None, game=False, buttons=None
+    ):
+        # Empty strings are valid but false-y; if they're empty use dummy '\0'
+        args = ('\0' if text == '' else text, geo, contact, game)
+        if sum(1 for x in args if x is not None and x is not False) != 1:
+            raise ValueError(
+                'Must set exactly one of text, geo, contact or game (set {})'
+                .format(', '.join(x[0] for x in zip(
+                    'text geo contact game'.split(), args) if x[1]) or 'none')
+            )
+
+        markup = self._client.build_reply_markup(buttons, inline_only=True)
+        if text is not None:
+            text, msg_entities = await self._client._parse_message_text(
+                text, parse_mode
+            )
+            if media:
+                # "MediaAuto" means it will use whatever media the inline
+                # result itself has (stickers, photos, or documents), while
+                # respecting the user's text (caption) and formatting.
+                return types.InputBotInlineMessageMediaAuto(
+                    message=text,
+                    entities=msg_entities,
+                    reply_markup=markup
+                )
+            else:
+                return types.InputBotInlineMessageText(
+                    message=text,
+                    no_webpage=not link_preview,
+                    entities=msg_entities,
+                    reply_markup=markup
+                )
+        elif isinstance(geo, (types.InputGeoPoint, types.GeoPoint)):
+            return types.InputBotInlineMessageMediaGeo(
+                geo_point=utils.get_input_geo(geo),
+                period=period,
+                reply_markup=markup
+            )
+        elif isinstance(geo, (types.InputMediaVenue, types.MessageMediaVenue)):
+            if isinstance(geo, types.InputMediaVenue):
+                geo_point = geo.geo_point
+            else:
+                geo_point = geo.geo
+
+            return types.InputBotInlineMessageMediaVenue(
+                geo_point=geo_point,
+                title=geo.title,
+                address=geo.address,
+                provider=geo.provider,
+                venue_id=geo.venue_id,
+                venue_type=geo.venue_type,
+                reply_markup=markup
+            )
+        elif isinstance(contact, (
+                types.InputMediaContact, types.MessageMediaContact)):
+            return types.InputBotInlineMessageMediaContact(
+                phone_number=contact.phone_number,
+                first_name=contact.first_name,
+                last_name=contact.last_name,
+                vcard=contact.vcard,
+                reply_markup=markup
+            )
+        elif game:
+            return types.InputBotInlineMessageGame(
+                reply_markup=markup
+            )
+        else:
+            raise ValueError('No text, game or valid geo or contact given')

.venv2/Lib/site-packages/telethon/tl/custom/inlineresult.py

@@ -0,0 +1,176 @@
+from .. import types, functions
+from ... import utils
+
+
+class InlineResult:
+    """
+    Custom class that encapsulates a bot inline result providing
+    an abstraction to easily access some commonly needed features
+    (such as clicking a result to select it).
+
+    Attributes:
+
+        result (:tl:`BotInlineResult`):
+            The original :tl:`BotInlineResult` object.
+    """
+    # tdlib types are the following (InlineQueriesManager::answer_inline_query @ 1a4a834):
+    # gif, article, audio, contact, file, geo, photo, sticker, venue, video, voice
+    #
+    # However, those documented in https://core.telegram.org/bots/api#inline-mode are different.
+    ARTICLE = 'article'
+    PHOTO = 'photo'
+    GIF = 'gif'
+    VIDEO = 'video'
+    VIDEO_GIF = 'mpeg4_gif'
+    AUDIO = 'audio'
+    DOCUMENT = 'document'
+    LOCATION = 'location'
+    VENUE = 'venue'
+    CONTACT = 'contact'
+    GAME = 'game'
+
+    def __init__(self, client, original, query_id=None, *, entity=None):
+        self._client = client
+        self.result = original
+        self._query_id = query_id
+        self._entity = entity
+
+    @property
+    def type(self):
+        """
+        The always-present type of this result. It will be one of:
+        ``'article'``, ``'photo'``, ``'gif'``, ``'mpeg4_gif'``, ``'video'``,
+        ``'audio'``, ``'voice'``, ``'document'``, ``'location'``, ``'venue'``,
+        ``'contact'``, ``'game'``.
+
+        You can access all of these constants through `InlineResult`,
+        such as `InlineResult.ARTICLE`, `InlineResult.VIDEO_GIF`, etc.
+        """
+        return self.result.type
+
+    @property
+    def message(self):
+        """
+        The always-present :tl:`BotInlineMessage` that
+        will be sent if `click` is called on this result.
+        """
+        return self.result.send_message
+
+    @property
+    def title(self):
+        """
+        The title for this inline result. It may be `None`.
+        """
+        return self.result.title
+
+    @property
+    def description(self):
+        """
+        The description for this inline result. It may be `None`.
+        """
+        return self.result.description
+
+    @property
+    def url(self):
+        """
+        The URL present in this inline results. If you want to "click"
+        this URL to open it in your browser, you should use Python's
+        `webbrowser.open(url)` for such task.
+        """
+        if isinstance(self.result, types.BotInlineResult):
+            return self.result.url
+
+    @property
+    def photo(self):
+        """
+        Returns either the :tl:`WebDocument` thumbnail for
+        normal results or the :tl:`Photo` for media results.
+        """
+        if isinstance(self.result, types.BotInlineResult):
+            return self.result.thumb
+        elif isinstance(self.result, types.BotInlineMediaResult):
+            return self.result.photo
+
+    @property
+    def document(self):
+        """
+        Returns either the :tl:`WebDocument` content for
+        normal results or the :tl:`Document` for media results.
+        """
+        if isinstance(self.result, types.BotInlineResult):
+            return self.result.content
+        elif isinstance(self.result, types.BotInlineMediaResult):
+            return self.result.document
+
+    async def click(self, entity=None, reply_to=None, comment_to=None,
+                    silent=False, clear_draft=False, hide_via=False,
+                    background=None):
+        """
+        Clicks this result and sends the associated `message`.
+
+        Args:
+            entity (`entity`):
+                The entity to which the message of this result should be sent.
+
+            reply_to (`int` | `Message <telethon.tl.custom.message.Message>`, optional):
+                If present, the sent message will reply to this ID or message.
+
+            comment_to (`int` | `Message <telethon.tl.custom.message.Message>`, optional):
+                Similar to ``reply_to``, but replies in the linked group of a
+                broadcast channel instead (effectively leaving a "comment to"
+                the specified message).
+
+            silent (`bool`, optional):
+                Whether the message should notify people with sound or not.
+                Defaults to `False` (send with a notification sound unless
+                the person has the chat muted). Set it to `True` to alter
+                this behaviour.
+
+            clear_draft (`bool`, optional):
+                Whether the draft should be removed after sending the
+                message from this result or not. Defaults to `False`.
+
+            hide_via (`bool`, optional):
+                Whether the "via @bot" should be hidden or not.
+                Only works with certain bots (like @bing or @gif).
+
+            background (`bool`, optional):
+                Whether the message should be send in background.
+
+        """
+        if entity:
+            entity = await self._client.get_input_entity(entity)
+        elif self._entity:
+            entity = self._entity
+        else:
+            raise ValueError('You must provide the entity where the result should be sent to')
+
+        if comment_to:
+            entity, reply_id = await self._client._get_comment_data(entity, comment_to)
+        else:
+            reply_id = None if reply_to is None else utils.get_message_id(reply_to)
+
+        req = functions.messages.SendInlineBotResultRequest(
+            peer=entity,
+            query_id=self._query_id,
+            id=self.result.id,
+            silent=silent,
+            background=background,
+            clear_draft=clear_draft,
+            hide_via=hide_via,
+            reply_to=None if reply_id is None else types.InputReplyToMessage(reply_id)
+        )
+        return self._client._get_response_message(
+            req, await self._client(req), entity)
+
+    async def download_media(self, *args, **kwargs):
+        """
+        Downloads the media in this result (if there is a document, the
+        document will be downloaded; otherwise, the photo will if present).
+
+        This is a wrapper around `client.download_media
+        <telethon.client.downloads.DownloadMethods.download_media>`.
+        """
+        if self.document or self.photo:
+            return await self._client.download_media(
+                self.document or self.photo, *args, **kwargs)

.venv2/Lib/site-packages/telethon/tl/custom/inlineresults.py

@@ -0,0 +1,83 @@
+import time
+
+from .inlineresult import InlineResult
+
+
+class InlineResults(list):
+    """
+    Custom class that encapsulates :tl:`BotResults` providing
+    an abstraction to easily access some commonly needed features
+    (such as clicking one of the results to select it)
+
+    Note that this is a list of `InlineResult
+    <telethon.tl.custom.inlineresult.InlineResult>`
+    so you can iterate over it or use indices to
+    access its elements. In addition, it has some
+    attributes.
+
+    Attributes:
+        result (:tl:`BotResults`):
+            The original :tl:`BotResults` object.
+
+        query_id (`int`):
+            The random ID that identifies this query.
+
+        cache_time (`int`):
+            For how long the results should be considered
+            valid. You can call `results_valid` at any
+            moment to determine if the results are still
+            valid or not.
+
+        users (:tl:`User`):
+            The users present in this inline query.
+
+        gallery (`bool`):
+            Whether these results should be presented
+            in a grid (as a gallery of images) or not.
+
+        next_offset (`str`, optional):
+            The string to be used as an offset to get
+            the next chunk of results, if any.
+
+        switch_pm (:tl:`InlineBotSwitchPM`, optional):
+            If presents, the results should show a button to
+            switch to a private conversation with the bot using
+            the text in this object.
+    """
+    def __init__(self, client, original, *, entity=None):
+        super().__init__(InlineResult(client, x, original.query_id, entity=entity)
+                         for x in original.results)
+
+        self.result = original
+        self.query_id = original.query_id
+        self.cache_time = original.cache_time
+        self._valid_until = time.time() + self.cache_time
+        self.users = original.users
+        self.gallery = bool(original.gallery)
+        self.next_offset = original.next_offset
+        self.switch_pm = original.switch_pm
+
+    def results_valid(self):
+        """
+        Returns `True` if the cache time has not expired
+        yet and the results can still be considered valid.
+        """
+        return time.time() < self._valid_until
+
+    def _to_str(self, item_function):
+        return ('[{}, query_id={}, cache_time={}, users={}, gallery={}, '
+                'next_offset={}, switch_pm={}]'.format(
+            ', '.join(item_function(x) for x in self),
+            self.query_id,
+            self.cache_time,
+            self.users,
+            self.gallery,
+            self.next_offset,
+            self.switch_pm
+        ))
+
+    def __str__(self):
+        return self._to_str(str)
+
+    def __repr__(self):
+        return self._to_str(repr)

.venv2/Lib/site-packages/telethon/tl/custom/inputsizedfile.py

@@ -0,0 +1,9 @@
+from ..types import InputFile
+
+
+class InputSizedFile(InputFile):
+    """InputFile class with two extra parameters: md5 (digest) and size"""
+    def __init__(self, id_, parts, name, md5, size):
+        super().__init__(id_, parts, name, md5.hexdigest())
+        self.md5 = md5.digest()
+        self.size = size

.venv2/Lib/site-packages/telethon/tl/custom/messagebutton.py

@@ -0,0 +1,151 @@
+from .. import types, functions
+from ... import password as pwd_mod
+from ...errors import BotResponseTimeoutError
+try:
+    import webbrowser
+except ModuleNotFoundError:
+    pass
+import sys
+import os
+
+
+class MessageButton:
+    """
+    .. note::
+
+        `Message.buttons <telethon.tl.custom.message.Message.buttons>`
+        are instances of this type. If you want to **define** a reply
+        markup for e.g. sending messages, refer to `Button
+        <telethon.tl.custom.button.Button>` instead.
+
+    Custom class that encapsulates a message button providing
+    an abstraction to easily access some commonly needed features
+    (such as clicking the button itself).
+
+    Attributes:
+
+        button (:tl:`KeyboardButton`):
+            The original :tl:`KeyboardButton` object.
+    """
+    def __init__(self, client, original, chat, bot, msg_id):
+        self.button = original
+        self._bot = bot
+        self._chat = chat
+        self._msg_id = msg_id
+        self._client = client
+
+    @property
+    def client(self):
+        """
+        Returns the `telethon.client.telegramclient.TelegramClient`
+        instance that created this instance.
+        """
+        return self._client
+
+    @property
+    def text(self):
+        """The text string of the button."""
+        return self.button.text
+
+    @property
+    def data(self):
+        """The `bytes` data for :tl:`KeyboardButtonCallback` objects."""
+        if isinstance(self.button, types.KeyboardButtonCallback):
+            return self.button.data
+
+    @property
+    def inline_query(self):
+        """The query `str` for :tl:`KeyboardButtonSwitchInline` objects."""
+        if isinstance(self.button, types.KeyboardButtonSwitchInline):
+            return self.button.query
+
+    @property
+    def url(self):
+        """The url `str` for :tl:`KeyboardButtonUrl` objects."""
+        if isinstance(self.button, types.KeyboardButtonUrl):
+            return self.button.url
+
+    async def click(self, share_phone=None, share_geo=None, *, password=None):
+        """
+        Emulates the behaviour of clicking this button.
+
+        If it's a normal :tl:`KeyboardButton` with text, a message will be
+        sent, and the sent `Message <telethon.tl.custom.message.Message>` returned.
+
+        If it's an inline :tl:`KeyboardButtonCallback` with text and data,
+        it will be "clicked" and the :tl:`BotCallbackAnswer` returned.
+
+        If it's an inline :tl:`KeyboardButtonSwitchInline` button, the
+        :tl:`StartBotRequest` will be invoked and the resulting updates
+        returned.
+
+        If it's a :tl:`KeyboardButtonUrl`, the URL of the button will
+        be passed to ``webbrowser.open`` and return `True` on success.
+
+        If it's a :tl:`KeyboardButtonRequestPhone`, you must indicate that you
+        want to ``share_phone=True`` in order to share it. Sharing it is not a
+        default because it is a privacy concern and could happen accidentally.
+
+        You may also use ``share_phone=phone`` to share a specific number, in
+        which case either `str` or :tl:`InputMediaContact` should be used.
+
+        If it's a :tl:`KeyboardButtonRequestGeoLocation`, you must pass a
+        tuple in ``share_geo=(longitude, latitude)``. Note that Telegram seems
+        to have some heuristics to determine impossible locations, so changing
+        this value a lot quickly may not work as expected. You may also pass a
+        :tl:`InputGeoPoint` if you find the order confusing.
+        """
+        if isinstance(self.button, types.KeyboardButton):
+            return await self._client.send_message(
+                self._chat, self.button.text, parse_mode=None)
+        elif isinstance(self.button, types.KeyboardButtonCallback):
+            if password is not None:
+                pwd = await self._client(functions.account.GetPasswordRequest())
+                password = pwd_mod.compute_check(pwd, password)
+
+            req = functions.messages.GetBotCallbackAnswerRequest(
+                peer=self._chat, msg_id=self._msg_id, data=self.button.data,
+                password=password
+            )
+            try:
+                return await self._client(req)
+            except BotResponseTimeoutError:
+                return None
+        elif isinstance(self.button, types.KeyboardButtonSwitchInline):
+            return await self._client(functions.messages.StartBotRequest(
+                bot=self._bot, peer=self._chat, start_param=self.button.query
+            ))
+        elif isinstance(self.button, types.KeyboardButtonUrl):
+            if "webbrowser" in sys.modules:
+                return webbrowser.open(self.button.url)
+        elif isinstance(self.button, types.KeyboardButtonGame):
+            req = functions.messages.GetBotCallbackAnswerRequest(
+                peer=self._chat, msg_id=self._msg_id, game=True
+            )
+            try:
+                return await self._client(req)
+            except BotResponseTimeoutError:
+                return None
+        elif isinstance(self.button, types.KeyboardButtonRequestPhone):
+            if not share_phone:
+                raise ValueError('cannot click on phone buttons unless share_phone=True')
+
+            if share_phone == True or isinstance(share_phone, str):
+                me = await self._client.get_me()
+                share_phone = types.InputMediaContact(
+                    phone_number=me.phone if share_phone == True else share_phone,
+                    first_name=me.first_name or '',
+                    last_name=me.last_name or '',
+                    vcard=''
+                )
+
+            return await self._client.send_file(self._chat, share_phone)
+        elif isinstance(self.button, types.KeyboardButtonRequestGeoLocation):
+            if not share_geo:
+                raise ValueError('cannot click on geo buttons unless share_geo=(longitude, latitude)')
+
+            if isinstance(share_geo, (tuple, list)):
+                long, lat = share_geo
+                share_geo = types.InputMediaGeoPoint(types.InputGeoPoint(lat=lat, long=long))
+
+            return await self._client.send_file(self._chat, share_geo)

.venv2/Lib/site-packages/telethon/tl/custom/participantpermissions.py

@@ -0,0 +1,138 @@
+from .. import types
+
+
+def _admin_prop(field_name, doc):
+    """
+    Helper method to build properties that return `True` if the user is an
+    administrator of a normal chat, or otherwise return `True` if the user
+    has a specific permission being an admin of a channel.
+    """
+    def fget(self):
+        if not self.is_admin:
+            return False
+        if self.is_chat:
+            return True
+
+        return getattr(self.participant.admin_rights, field_name)
+
+    return {'fget': fget, 'doc': doc}
+
+
+class ParticipantPermissions:
+    """
+    Participant permissions information.
+
+    The properties in this objects are boolean values indicating whether the
+    user has the permission or not.
+
+    Example
+        .. code-block:: python
+
+            permissions = ...
+
+            if permissions.is_banned:
+                "this user is banned"
+            elif permissions.is_admin:
+                "this user is an administrator"
+    """
+    def __init__(self, participant, chat: bool):
+        self.participant = participant
+        self.is_chat = chat
+
+    @property
+    def is_admin(self):
+        """
+        Whether the user is an administrator of the chat or not. The creator
+        also counts as begin an administrator, since they have all permissions.
+        """
+        return self.is_creator or isinstance(self.participant, (
+            types.ChannelParticipantAdmin,
+            types.ChatParticipantAdmin
+        ))
+
+    @property
+    def is_creator(self):
+        """
+        Whether the user is the creator of the chat or not.
+        """
+        return isinstance(self.participant, (
+            types.ChannelParticipantCreator,
+            types.ChatParticipantCreator
+        ))
+
+    @property
+    def has_default_permissions(self):
+        """
+        Whether the user is a normal user of the chat (not administrator, but
+        not banned either, and has no restrictions applied).
+        """
+        return isinstance(self.participant, (
+            types.ChannelParticipant,
+            types.ChatParticipant,
+            types.ChannelParticipantSelf
+        ))
+
+    @property
+    def is_banned(self):
+        """
+        Whether the user is banned in the chat.
+        """
+        return isinstance(self.participant, types.ChannelParticipantBanned)
+
+    @property
+    def has_left(self):
+        """
+        Whether the user left the chat.
+        """
+        return isinstance(self.participant, types.ChannelParticipantLeft)
+    
+    @property
+    def add_admins(self):
+        """
+        Whether the administrator can add new administrators with the same or
+        less permissions than them.
+        """
+        if not self.is_admin:
+            return False
+
+        if self.is_chat:
+            return self.is_creator
+
+        return self.participant.admin_rights.add_admins
+
+    ban_users = property(**_admin_prop('ban_users', """
+        Whether the administrator can ban other users or not.
+    """))
+
+    pin_messages = property(**_admin_prop('pin_messages', """
+        Whether the administrator can pin messages or not.
+    """))
+
+    invite_users = property(**_admin_prop('invite_users', """
+        Whether the administrator can add new users to the chat.
+    """))
+
+    delete_messages = property(**_admin_prop('delete_messages', """
+        Whether the administrator can delete messages from other participants.
+    """))
+
+    edit_messages = property(**_admin_prop('edit_messages', """
+        Whether the administrator can edit messages.
+    """))
+
+    post_messages = property(**_admin_prop('post_messages', """
+        Whether the administrator can post messages in the broadcast channel.
+    """))
+
+    change_info = property(**_admin_prop('change_info', """
+        Whether the administrator can change the information about the chat,
+        such as title or description.
+    """))
+
+    anonymous = property(**_admin_prop('anonymous', """
+        Whether the administrator will remain anonymous when sending messages.
+    """))
+    
+    manage_call = property(**_admin_prop('manage_call', """
+        Whether the user will be able to manage group calls.
+    """))

.venv2/Lib/site-packages/telethon/tl/custom/qrlogin.py

@@ -0,0 +1,119 @@
+import asyncio
+import base64
+import datetime
+
+from .. import types, functions
+from ... import events
+
+
+class QRLogin:
+    """
+    QR login information.
+
+    Most of the time, you will present the `url` as a QR code to the user,
+    and while it's being shown, call `wait`.
+    """
+    def __init__(self, client, ignored_ids):
+        self._client = client
+        self._request = functions.auth.ExportLoginTokenRequest(
+            self._client.api_id, self._client.api_hash, ignored_ids)
+        self._resp = None
+
+    async def recreate(self):
+        """
+        Generates a new token and URL for a new QR code, useful if the code
+        has expired before it was imported.
+        """
+        self._resp = await self._client(self._request)
+
+    @property
+    def token(self) -> bytes:
+        """
+        The binary data representing the token.
+
+        It can be used by a previously-authorized client in a call to
+        :tl:`auth.importLoginToken` to log the client that originally
+        requested the QR login.
+        """
+        return self._resp.token
+
+    @property
+    def url(self) -> str:
+        """
+        The ``tg://login`` URI with the token. When opened by a Telegram
+        application where the user is logged in, it will import the login
+        token.
+
+        If you want to display a QR code to the user, this is the URL that
+        should be launched when the QR code is scanned (the URL that should
+        be contained in the QR code image you generate).
+
+        Whether you generate the QR code image or not is up to you, and the
+        library can't do this for you due to the vast ways of generating and
+        displaying the QR code that exist.
+
+        The URL simply consists of `token` base64-encoded.
+        """
+        return 'tg://login?token={}'.format(base64.urlsafe_b64encode(self._resp.token).decode('utf-8').rstrip('='))
+
+    @property
+    def expires(self) -> datetime.datetime:
+        """
+        The `datetime` at which the QR code will expire.
+
+        If you want to try again, you will need to call `recreate`.
+        """
+        return self._resp.expires
+
+    async def wait(self, timeout: float = None):
+        """
+        Waits for the token to be imported by a previously-authorized client,
+        either by scanning the QR, launching the URL directly, or calling the
+        import method.
+
+        This method **must** be called before the QR code is scanned, and
+        must be executing while the QR code is being scanned. Otherwise, the
+        login will not complete.
+
+        Will raise `asyncio.TimeoutError` if the login doesn't complete on
+        time.
+
+        Arguments
+            timeout (float):
+                The timeout, in seconds, to wait before giving up. By default
+                the library will wait until the token expires, which is often
+                what you want.
+
+        Returns
+            On success, an instance of :tl:`User`. On failure it will raise.
+        """
+        if timeout is None:
+            timeout = (self._resp.expires - datetime.datetime.now(tz=datetime.timezone.utc)).total_seconds()
+
+        event = asyncio.Event()
+
+        async def handler(_update):
+            event.set()
+
+        self._client.add_event_handler(handler, events.Raw(types.UpdateLoginToken))
+
+        try:
+            # Will raise timeout error if it doesn't complete quick enough,
+            # which we want to let propagate
+            await asyncio.wait_for(event.wait(), timeout=timeout)
+        finally:
+            self._client.remove_event_handler(handler)
+
+        # We got here without it raising timeout error, so we can proceed
+        resp = await self._client(self._request)
+        if isinstance(resp, types.auth.LoginTokenMigrateTo):
+            await self._client._switch_dc(resp.dc_id)
+            resp = await self._client(functions.auth.ImportLoginTokenRequest(resp.token))
+            # resp should now be auth.loginTokenSuccess
+
+        if isinstance(resp, types.auth.LoginTokenSuccess):
+            user = resp.authorization.user
+            await self._client._on_login(user)
+            return user
+
+        raise TypeError('Login token response was unexpected: {}'.format(resp))

.venv2/Lib/site-packages/telethon/tl/custom/sendergetter.py

@@ -0,0 +1,102 @@
+import abc
+
+from ... import utils
+
+
+class SenderGetter(abc.ABC):
+    """
+    Helper base class that introduces the `sender`, `input_sender`
+    and `sender_id` properties and `get_sender` and `get_input_sender`
+    methods.
+    """
+    def __init__(self, sender_id=None, *, sender=None, input_sender=None):
+        self._sender_id = sender_id
+        self._sender = sender
+        self._input_sender = input_sender
+        self._client = None
+
+    @property
+    def sender(self):
+        """
+        Returns the :tl:`User` or :tl:`Channel` that sent this object.
+        It may be `None` if Telegram didn't send the sender.
+
+        If you only need the ID, use `sender_id` instead.
+
+        If you need to call a method which needs
+        this chat, use `input_sender` instead.
+
+        If you're using `telethon.events`, use `get_sender()` instead.
+        """
+        return self._sender
+
+    async def get_sender(self):
+        """
+        Returns `sender`, but will make an API call to find the
+        sender unless it's already cached.
+
+        If you only need the ID, use `sender_id` instead.
+
+        If you need to call a method which needs
+        this sender, use `get_input_sender()` instead.
+        """
+        # ``sender.min`` is present both in :tl:`User` and :tl:`Channel`.
+        # It's a flag that will be set if only minimal information is
+        # available (such as display name, but username may be missing),
+        # in which case we want to force fetch the entire thing because
+        # the user explicitly called a method. If the user is okay with
+        # cached information, they may use the property instead.
+        if (self._sender is None or getattr(self._sender, 'min', None)) \
+                and await self.get_input_sender():
+            # self.get_input_sender may refresh in which case the sender may no longer be min
+            # However it could still incur a cost so the cheap check is done twice instead.
+            if self._sender is None or getattr(self._sender, 'min', None):
+                try:
+                    self._sender =\
+                        await self._client.get_entity(self._input_sender)
+                except ValueError:
+                    await self._refetch_sender()
+        return self._sender
+
+    @property
+    def input_sender(self):
+        """
+        This :tl:`InputPeer` is the input version of the user/channel who
+        sent the message. Similarly to `input_chat
+        <telethon.tl.custom.chatgetter.ChatGetter.input_chat>`, this doesn't
+        have things like username or similar, but still useful in some cases.
+
+        Note that this might not be available if the library can't
+        find the input chat, or if the message a broadcast on a channel.
+        """
+        if self._input_sender is None and self._sender_id and self._client:
+            try:
+                self._input_sender = self._client._mb_entity_cache.get(
+                        utils.resolve_id(self._sender_id)[0])._as_input_peer()
+            except AttributeError:
+                pass
+        return self._input_sender
+
+    async def get_input_sender(self):
+        """
+        Returns `input_sender`, but will make an API call to find the
+        input sender unless it's already cached.
+        """
+        if self.input_sender is None and self._sender_id and self._client:
+            await self._refetch_sender()
+        return self._input_sender
+
+    @property
+    def sender_id(self):
+        """
+        Returns the marked sender integer ID, if present.
+
+        If there is a sender in the object, `sender_id` will *always* be set,
+        which is why you should use it instead of `sender.id <sender>`.
+        """
+        return self._sender_id
+
+    async def _refetch_sender(self):
+        """
+        Re-fetches sender information through other means.
+        """