Completely change errors (make one class for each)

telethon/errors/__init__.py

@@ -0,0 +1,43 @@
+import re
+
+from .common import (
+    ReadCancelledError, InvalidParameterError, TypeNotFoundError,
+    InvalidChecksumError
+)
+
+from .rpc_errors import (
+    RPCError, InvalidDCError, BadRequestError, UnauthorizedError,
+    ForbiddenError, NotFoundError, FloodError, ServerError, BadMessageError
+)
+
+from .rpc_errors_303 import *
+from .rpc_errors_400 import *
+from .rpc_errors_401 import *
+from .rpc_errors_420 import *
+
+
+def rpc_message_to_error(code, message):
+    errors = {
+        303: rpc_303_errors,
+        400: rpc_400_errors,
+        401: rpc_401_errors,
+        420: rpc_420_errors
+    }.get(code, None)
+
+    if errors is not None:
+        for msg, cls in errors.items():
+            m = re.match(msg, message)
+            if m:
+                extra = int(m.group(1)) if m.groups() else None
+                return cls(extra=extra)
+
+    elif code == 403:
+        return ForbiddenError()
+
+    elif code == 404:
+        return NotFoundError()
+
+    elif code == 500:
+        return ServerError()
+
+    return RPCError('{} (code {})'.format(message, code))

telethon/errors/common.py

@@ -0,0 +1,37 @@
+"""Errors not related to the Telegram API itself"""
+
+
+class ReadCancelledError(Exception):
+    """Occurs when a read operation was cancelled"""
+    def __init__(self):
+        super().__init__(self, 'The read operation was cancelled.')
+
+
+class InvalidParameterError(Exception):
+    """Occurs when an invalid parameter is given, for example,
+    when either A or B are required but none is given"""
+
+
+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):
+        super().__init__(
+            self, 'Could not find a matching Constructor ID for the TLObject '
+            'that was supposed to be read with ID {}. Most likely, a TLObject '
+            'was trying to be read when it should not be read.'
+            .format(hex(invalid_constructor_id)))
+
+        self.invalid_constructor_id = invalid_constructor_id
+
+
+class InvalidChecksumError(Exception):
+    def __init__(self, checksum, valid_checksum):
+        super().__init__(
+            self,
+            'Invalid checksum ({} when {} was expected). This packet should be skipped.'
+            .format(checksum, valid_checksum))
+
+        self.checksum = checksum
+        self.valid_checksum = valid_checksum

telethon/errors/rpc_errors.py

@@ -0,0 +1,111 @@
+class RPCError(Exception):
+    code = None
+    message = None
+
+
+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 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
+    message = 'INTERNAL'
+
+
+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, code):
+        super().__init__(self, self.ErrorMessages.get(
+            code,
+            'Unknown error code (this should not happen): {}.'.format(code)))
+
+        self.code = code

telethon/errors/rpc_errors_303.py

@@ -0,0 +1,51 @@
+from . import InvalidDCError
+
+
+class FileMigrateError(InvalidDCError):
+    def __init__(self, **kwargs):
+        self.new_dc = kwargs['extra']
+        super(Exception, self).__init__(
+            self,
+            'The file to be accessed is currently stored in DC {}.'
+            .format(self.new_dc)
+        )
+
+
+class PhoneMigrateError(InvalidDCError):
+    def __init__(self, **kwargs):
+        self.new_dc = kwargs['extra']
+        super(Exception, self).__init__(
+            self,
+            'The phone number a user is trying to use for authorization is '
+            'associated with DC {}.'
+            .format(self.new_dc)
+        )
+
+
+class NetworkMigrateError(InvalidDCError):
+    def __init__(self, **kwargs):
+        self.new_dc = kwargs['extra']
+        super(Exception, self).__init__(
+            self,
+            'The source IP address is associated with DC {}.'
+            .format(self.new_dc)
+        )
+
+
+class UserMigrateError(InvalidDCError):
+    def __init__(self, **kwargs):
+        self.new_dc = kwargs['extra']
+        super(Exception, self).__init__(
+            self,
+            'The user whose identity is being used to execute queries is '
+            'associated with DC {}.'
+            .format(self.new_dc)
+        )
+
+
+rpc_303_errors = {
+    'FILE_MIGRATE_(\d+)': FileMigrateError,
+    'PHONE_MIGRATE_(\d+)': PhoneMigrateError,
+    'NETWORK_MIGRATE_(\d+)': NetworkMigrateError,
+    'USER_MIGRATE_(\d+)': UserMigrateError
+}

telethon/errors/rpc_errors_400.py

@@ -0,0 +1,364 @@
+from . import BadRequestError
+
+
+class ApiIdInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The api_id/api_hash combination is invalid.'
+        )
+
+
+class BotMethodInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The API access for bot users is restricted. The method you '
+            'tried to invoke cannot be executed as a bot.'
+        )
+
+
+class ChannelInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'Invalid channel object. Make sure to pass the right types.'
+        )
+
+
+class ChatAdminRequiredError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'Chat admin privileges are required to do that in the specified '
+            'chat (for example, to send a message in a channel which is not '
+            'yours).'
+        )
+
+
+class ChatIdInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'Invalid object ID for a chat. Make sure to pass the right types.'
+        )
+
+
+class ConnectionLayerInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The very first request must always be InvokeWithLayerRequest.'
+        )
+
+
+class DcIdInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'This occurs when an authorization is tried to be exported for '
+            'the same data center one is currently connected to.'
+        )
+
+
+class FieldNameEmptyError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The field with the name FIELD_NAME is missing.'
+        )
+
+
+class FieldNameInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The field with the name FIELD_NAME is invalid.'
+        )
+
+
+class FilePartsInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The number of file parts is invalid.'
+        )
+
+
+class FilePartMissingError(BadRequestError):
+    def __init__(self, **kwargs):
+        self.which = kwargs['extra']
+        super(Exception, self).__init__(
+            self,
+            'Part {} of the file is missing from storage.'.format(self.which)
+        )
+
+
+class FilePartInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The file part number is invalid.'
+        )
+
+
+class FirstNameInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The first name is invalid.'
+        )
+
+
+class InputMethodInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The invoked method does not exist anymore or has never existed.'
+        )
+
+
+class LastNameInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The last name is invalid.'
+        )
+
+
+class Md5ChecksumInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The MD5 check-sums do not match.'
+        )
+
+
+class MessageEmptyError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'Empty or invalid UTF-8 message was sent.'
+        )
+
+
+class MessageIdInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The specified message ID is invalid.'
+        )
+
+
+class MessageTooLongError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'Message was too long. Current maximum length is 4096 UTF-8 '
+            'characters.'
+        )
+
+
+class MsgWaitFailedError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'A waiting call returned an error.'
+        )
+
+
+class PasswordHashInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The password (and thus its hash value) you entered is invalid.'
+        )
+
+
+class PeerIdInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'An invalid Peer was used. Make sure to pass the right peer type.'
+        )
+
+
+class PhoneCodeEmptyError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The phone code is missing.'
+        )
+
+
+class PhoneCodeExpiredError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The confirmation code has expired.'
+        )
+
+
+class PhoneCodeHashEmptyError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The phone code hash is missing.'
+        )
+
+
+class PhoneCodeInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The phone code entered was invalid.'
+        )
+
+
+class PhoneNumberBannedError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The used phone number has been banned from Telegram and cannot '
+            'be used anymore. Maybe check https://www.telegram.org/faq_spam.'
+        )
+
+
+class PhoneNumberInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The phone number is invalid.'
+        )
+
+
+class PhoneNumberOccupiedError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The phone number is already in use.'
+        )
+
+
+class PhoneNumberUnoccupiedError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The phone number is not yet being used.'
+        )
+
+
+class PhotoInvalidDimensionsError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The photo dimensions are invalid.'
+        )
+
+
+class TypeConstructorInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The type constructor is invalid.'
+        )
+
+
+class UsernameInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'Unacceptable username. Must match r"[a-zA-Z][\w\d]{4,32}"'
+        )
+
+
+class UsernameNotModifiedError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The username is not different from the current username'
+        )
+
+
+class UsernameNotOccupiedError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'See issue #96 for Telethon - try upgrading the library.'
+        )
+
+
+class UsernameOccupiedError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The username is already taken.'
+        )
+
+
+class UsersTooFewError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'Not enough users (to create a chat, for example).'
+        )
+
+
+class UsersTooMuchError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The maximum number of users has been exceeded (to create a '
+            'chat, for example).'
+        )
+
+
+class UserIdInvalidError(BadRequestError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'Invalid object ID for an user. Make sure to pass the right types.'
+        )
+
+
+rpc_400_errors = {
+    'API_ID_INVALID': ApiIdInvalidError,
+    'BOT_METHOD_INVALID': BotMethodInvalidError,
+    'CHANNEL_INVALID': ChannelInvalidError,
+    'CHAT_ADMIN_REQUIRED': ChatAdminRequiredError,
+    'CHAT_ID_INVALID': ChatIdInvalidError,
+    'CONNECTION_LAYER_INVALID': ConnectionLayerInvalidError,
+    'DC_ID_INVALID': DcIdInvalidError,
+    'FIELD_NAME_EMPTY': FieldNameEmptyError,
+    'FIELD_NAME_INVALID': FieldNameInvalidError,
+    'FILE_PARTS_INVALID': FilePartsInvalidError,
+    'FILE_PART_(\d+)_MISSING': FilePartMissingError,
+    'FILE_PART_INVALID': FilePartInvalidError,
+    'FIRSTNAME_INVALID': FirstNameInvalidError,
+    'INPUT_METHOD_INVALID': InputMethodInvalidError,
+    'LASTNAME_INVALID': LastNameInvalidError,
+    'MD5_CHECKSUM_INVALID': Md5ChecksumInvalidError,
+    'MESSAGE_EMPTY': MessageEmptyError,
+    'MESSAGE_ID_INVALID': MessageIdInvalidError,
+    'MESSAGE_TOO_LONG': MessageTooLongError,
+    'MSG_WAIT_FAILED': MsgWaitFailedError,
+    'PASSWORD_HASH_INVALID': PasswordHashInvalidError,
+    'PEER_ID_INVALID': PeerIdInvalidError,
+    'PHONE_CODE_EMPTY': PhoneCodeEmptyError,
+    'PHONE_CODE_EXPIRED': PhoneCodeExpiredError,
+    'PHONE_CODE_HASH_EMPTY': PhoneCodeHashEmptyError,
+    'PHONE_CODE_INVALID': PhoneCodeInvalidError,
+    'PHONE_NUMBER_BANNED': PhoneNumberBannedError,
+    'PHONE_NUMBER_INVALID': PhoneNumberInvalidError,
+    'PHONE_NUMBER_OCCUPIED': PhoneNumberOccupiedError,
+    'PHONE_NUMBER_UNOCCUPIED': PhoneNumberUnoccupiedError,
+    'PHOTO_INVALID_DIMENSIONS': PhotoInvalidDimensionsError,
+    'TYPE_CONSTRUCTOR_INVALID': TypeConstructorInvalidError,
+    'USERNAME_INVALID': UsernameInvalidError,
+    'USERNAME_NOT_MODIFIED': UsernameNotModifiedError,
+    'USERNAME_NOT_OCCUPIED': UsernameNotOccupiedError,
+    'USERNAME_OCCUPIED': UsernameOccupiedError,
+    'USERS_TOO_FEW': UsersTooFewError,
+    'USERS_TOO_MUCH': UsersTooMuchError,
+    'USER_ID_INVALID': UserIdInvalidError,
+}

telethon/errors/rpc_errors_401.py

@@ -0,0 +1,98 @@
+from . import UnauthorizedError
+
+
+class ActiveUserRequiredError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The method is only available to already activated users.'
+        )
+
+
+class AuthKeyInvalidError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The key is invalid.'
+        )
+
+
+class AuthKeyPermEmptyError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The method is unavailable for temporary authorization key, not '
+            'bound to permanent.'
+        )
+
+
+class AuthKeyUnregisteredError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The key is not registered in the system.'
+        )
+
+
+class InviteHashExpiredError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The chat the user tried to join has expired and is not valid '
+            'anymore.'
+        )
+
+
+class SessionExpiredError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The authorization has expired.'
+        )
+
+
+class SessionPasswordNeededError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'Two-steps verification is enabled and a password is required.'
+        )
+
+
+class SessionRevokedError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The authorization has been invalidated, because of the user '
+            'terminating all sessions.'
+        )
+
+
+class UserAlreadyParticipantError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The authenticated user is already a participant of the chat.'
+        )
+
+
+class UserDeactivatedError(UnauthorizedError):
+    def __init__(self, **kwargs):
+        super(Exception, self).__init__(
+            self,
+            'The user has been deleted/deactivated.'
+        )
+
+
+rpc_401_errors = {
+    'ACTIVE_USER_REQUIRED': ActiveUserRequiredError,
+    'AUTH_KEY_INVALID': AuthKeyInvalidError,
+    'AUTH_KEY_PERM_EMPTY': AuthKeyPermEmptyError,
+    'AUTH_KEY_UNREGISTERED': AuthKeyUnregisteredError,
+    'INVITE_HASH_EXPIRED': InviteHashExpiredError,
+    'SESSION_EXPIRED': SessionExpiredError,
+    'SESSION_PASSWORD_NEEDED': SessionPasswordNeededError,
+    'SESSION_REVOKED': SessionRevokedError,
+    'USER_ALREADY_PARTICIPANT': UserAlreadyParticipantError,
+    'USER_DEACTIVATED': UserDeactivatedError,
+}

telethon/errors/rpc_errors_420.py

@@ -0,0 +1,16 @@
+from . import FloodError
+
+
+class FloodWaitError(FloodError):
+    def __init__(self, **kwargs):
+        self.seconds = kwargs['extra']
+        super(Exception, self).__init__(
+            self,
+            'A wait of {} seconds is required.'
+            .format(self.seconds)
+        )
+
+
+rpc_420_errors = {
+    'FLOOD_WAIT_(\d+)': FloodWaitError
+}