Все подряд

.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
+)}