Telegram error telegramerror

Edit this page

Toggle table of contents sidebar

: пытаемся отправить сообщение, но пользователь заблокировал бота. Будет вызвано исключение Unauthorized, подкласса TelegramError, которое будет доставлено обработчику ошибок. В обработчике ошибок можно удалить этот контакт из списка контактов бота.

. Можно обрабатывать исключения по мере их возникновения. Обработчику ошибок python-telegram-bot перенаправляются только неперехваченные исключения.

import html
import json
import logging
import traceback

from telegram import Update, ParseMode
from telegram.ext import Updater, CommandHandler

logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO
)

logger = logging.getLogger(__name__)

# Токен, который получен от @botfather при создании бота
BOT_TOKEN = "TOKEN"

# Это может быть ваш собственный идентификатор 
# или идентификатор группы/канала.
# Можно использовать команду `/start` этого бота, 
# чтобы увидеть свой идентификатор чата.
CHAT_ID = 123456789

# Функция-обработчик ошибок
def error_handler(update, context):
    """
        Регистрирует ошибку и уведомляет   
        разработчика сообщением telegram.
    """
    # Пишем ошибку, прежде чем что-то делать. Вдруг что-то сломается.
    logger.error(msg="Исключение при обработке сообщения:", exc_info=context.error)

    # `traceback.format_exception` возвращает обычное сообщение python 
    # об исключении в виде списка строк, поэтому объединяем их вместе.
    tb_list = traceback.format_exception(None, context.error, context.error.__traceback__)
    tb_string = ''.join(tb_list)

    # Создаем сообщение с некоторой разметкой и дополнительной 
    # информацией о том, что произошло. Возможно, придется добавить некоторую 
    # логику для работы с сообщениями длиной более 4096 символов.
    update_str = update.to_dict() if isinstance(update, Update) else str(update)
    message = (
        f'Возникло исключение при обработке сообщения.n'
        f'<pre>update = {html.escape(json.dumps(update_str, indent=2, ensure_ascii=False))}'
        '</pre>nn'
        f'<pre>context.chat_data = {html.escape(str(context.chat_data))}</pre>nn'
        f'<pre>context.user_data = {html.escape(str(context.user_data))}</pre>nn'
        f'<pre>{html.escape(tb_string)}</pre>'
    )

    # Отправляем сообщение разработчику
    context.bot.send_message(chat_id=CHAT_ID, text=message, parse_mode=ParseMode.HTML)

# объект `update` в функции не используется, заменяем его на `_`
def bad_command(_, context):
    """Вызывает ошибку, чтобы вызвать обработчик ошибок."""
    context.bot.wrong_method_name()

# объект `context` в функции не используется, заменяем его на `_`
def start(update, _):
    update.effective_message.reply_html(
        'Принудительный вызов ошибки `/bad_command`n'
        f'Ваш идентификатор чата <code>{update.effective_chat.id}</code>.'
    )


if __name__ == '__main__':

    updater = Updater(BOT_TOKEN)
    dispatcher = updater.dispatcher

    # Зарегистрируем команды...
    dispatcher.add_handler(CommandHandler('start', start))
    dispatcher.add_handler(CommandHandler('bad_command', bad_command))

    # ...и обработчик ошибок
    dispatcher.add_error_handler(error_handler)

    # Запускаем бота
    updater.start_polling()
    updater.idle()

from telegram import ParseMode
from telegram.utils.helpers import mention_html
import sys
import traceback

# это общая функция обработчика ошибок. 
# Если нужна дополнительная информация о конкретном типе сообщения, 
# добавьте ее в полезную нагрузку в соответствующем предложении `if ...`
def error(update, context):
    # добавьте все идентификаторы разработчиков в этот список. 
    # Можно добавить идентификаторы каналов или групп.
    devs = [208589966]
   # Уведомление пользователя об этой проблеме. 
   # Уведомления будут работать, только если сообщение НЕ является 
   # обратным вызовом, встроенным запросом или обновлением опроса. 
   # В случае, если это необходимо, то имейте в виду, что отправка 
   # сообщения может потерпеть неудачу
    if update.effective_message:
        text = "К сожалению произошла ошибка в момент обработки сообщения. " 
               "Мы уже работаем над этой проблемой."
        update.effective_message.reply_text(text)
    # Трассировка создается из `sys.exc_info`, которая возвращается в  
    # как третье значение возвращаемого кортежа. Затем используется  
    # `traceback.format_tb`, для получения `traceback` в виде строки.
    trace = "".join(traceback.format_tb(sys.exc_info()[2]))
    # попробуем получить как можно больше информации из обновления telegram
    payload = []
    # обычно всегда есть пользователь. Если нет, то это 
    # либо канал, либо обновление опроса.
    if update.effective_user:
        bad_user = mention_html(update.effective_user.id, update.effective_user.first_name)
        payload.append(f' с пользователем {bad_user}')
    # есть ситуаций, когда что то с чатом
    if update.effective_chat:
        payload.append(f' внутри чата <i>{update.effective_chat.title}</i>')
        if update.effective_chat.username:
            payload.append(f' (@{update.effective_chat.username})')
    # полезная нагрузка - опрос
    if update.poll:
        payload.append(f' с id опроса {update.poll.id}.')
    # Поместим это в 'хорошо' отформатированный текст
    text = f"Ошибка <code>{context.error}</code> случилась{''.join(payload)}. " 
           f"Полная трассировка:nn<code>{trace}</code>"
    # и отправляем все разработчикам
    for dev_id in devs:
        context.bot.send_message(dev_id, text, parse_mode=ParseMode.HTML)
    # Необходимо снова вызывать ошибку, для того, чтобы модуль `logger` ее записал.
    # Если вы не используете этот модуль, то самое время задуматься.
    raise

def get_me(self, timeout=None, **kwargs):
        """A simple method for testing your bot's auth token. Requires no parameters.

        Args:
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).

        Returns:
            :class:`telegram.User`: A :class:`telegram.User` instance representing that bot if the
            credentials are valid, :obj:`None` otherwise.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/getMe'.format(self.base_url)

        result = self._request.get(url, timeout=timeout)

        self.bot = User.de_json(result, self)

        return self.bot 

def delete_webhook(self, timeout=None, **kwargs):
        """
        Use this method to remove webhook integration if you decide to switch back to
        getUpdates. Requires no parameters.

        Args:
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :obj:`bool` On success, ``True`` is returned.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/deleteWebhook'.format(self.base_url)

        data = kwargs

        result = self._request.post(url, data, timeout=timeout)

        return result 

def delete_sticker_from_set(self, sticker, timeout=None, **kwargs):
        """Use this method to delete a sticker from a set created by the bot.

        Args:
            sticker (:obj:`str`): File identifier of the sticker.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during
                creation of the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :obj:`bool`: On success, ``True`` is returned.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/deleteStickerFromSet'.format(self.base_url)

        data = {'sticker': sticker}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def main():
    global update_id
    bot = telegram.Bot(token=TOKEN)

    try:
        update_id = bot.get_updates()[0].update_id
    except IndexError:
        update_id = None

    interface = telegram.ReplyKeyboardMarkup(
        [["Arabic", "Audio", "English", "Tafsir"],
         ["Previous", "Random", "Next"]],
        resize_keyboard=True)

    data = {
        "english": Quran("translation"),
        "tafsir": Quran("tafsir"),
        "index": make_index(),
        "interface": interface
    }
    data["default_query_results"] = get_default_query_results(data["english"])

    while True:
        try:
            serve(bot, data)
        except NetworkError:
            sleep(1)
        except Unauthorized:  # user has removed or blocked the bot
            update_id += 1
        except TelegramError as e:
            if "Invalid server response" in str(e):
                sleep(3)
            else:
                raise e 

def file_id_query_received(update: Update, context: CallbackContext):
    # get query
    query = update.inline_query
    user_id = query.from_user.id
    results = None

    try:
        file = bot.get_file(query.query)

        _id = uuid.uuid4()
        title = get_message(user_id, "your_sticker")
        desc = get_message(user_id, "forward_desc")
        caption = "@EzStickerBot"
        results = [InlineQueryResultCachedDocument(_id, title, file.file_id, description=desc, caption=caption)]

        query.answer(results=results, cache_time=5, is_personal=True)
    # if file_id wasn't found show share option
    except TelegramError:
        share_query_received(update, context) 

def error_callback(bot, update, error):
    try:
        raise error
    except Unauthorized:
        print("no nono1")
        print(error)
        # remove update.message.chat_id from conversation list
    except BadRequest:
        print("no nono2")
        print("BadRequest caught")
        print(error)

        # handle malformed requests - read more below!
    except TimedOut:
        print("no nono3")
        # handle slow connection problems
    except NetworkError:
        print("no nono4")
        # handle other connection problems
    except ChatMigrated as err:
        print("no nono5")
        print(err)
        # the chat_id of a group has changed, use e.new_chat_id instead
    except TelegramError:
        print(error)
        # handle all other telegram related errors 

def send_to_list(bot: Bot, send_to: list, message: str, markdown=False, html=False) -> None:
    if html and markdown:
        raise Exception("Can only send with either markdown or HTML!")
    for user_id in set(send_to):
        try:
            if markdown:
                bot.send_message(user_id, message, parse_mode=ParseMode.MARKDOWN)
            elif html:
                bot.send_message(user_id, message, parse_mode=ParseMode.HTML)
            else:
                bot.send_message(user_id, message)
        except TelegramError:
            pass  # ignore users who fail 

def finish(self):
        # set last update
        self.channel.last_update = datetime.date.today()
        self._save_channel()

        new_bots = Bot.select_new_bots()
        if not self.silent and len(new_bots) > 0:
            self.notify_admin("Sending notifications to subscribers...")
            subscribers = Notifications.select().where(Notifications.enabled == True)
            notification_count = 0
            for sub in subscribers:
                try:
                    util.send_md_message(self.bot, sub.chat_id,
                                         messages.BOTLIST_UPDATE_NOTIFICATION.format(
                                             n_bots=len(new_bots),
                                             new_bots=Bot.get_new_bots_markdown()))
                    notification_count += 1
                    sub.last_notification = datetime.date.today()
                    sub.save()
                except TelegramError:
                    pass
            self.sent['notifications'] = "Notifications sent to {} users.".format(
                notification_count)

        changes_made = len(self.sent) > 1 or len(self.sent['category']) > 0
        if changes_made:
            text = util.success('{}{}'.format('BotList updated successfully:nn',
                                              mdformat.results_list(self.sent)))
        else:
            text = mdformat.none_action("No changes were necessary.")

        log.info(self.sent)
        self.bot.formatter.send_or_edit(self.chat_id, text, to_edit=self.message_id) 

def check_requirements(self):
        try:
            self.bot.get_me()
            self.bot.send_message(chat_id=self.chat_id, text="Kimsufi Crawler started")
        except TelegramError as te:
            _logger.error("Telegram validation failed: {error}".format(error=te.message))
            raise 

def notify(self, title, text, url=None):
        try:
            self.bot.send_message(chat_id=self.chat_id, text=text)
        except TelegramError as te:
            _logger.error("Something went wrong sending the message to Telegram:")
            _logger.error(te) 

def send_to_list(bot: Bot, send_to: list, message: str, markdown=False, html=False) -> None:
    if html and markdown:
        raise Exception("Can only send with either markdown or HTML!")
    for user_id in set(send_to):
        try:
            if markdown:
                bot.send_message(user_id, message, parse_mode=ParseMode.MARKDOWN)
            elif html:
                bot.send_message(user_id, message, parse_mode=ParseMode.HTML)
            else:
                bot.send_message(user_id, message)
        except TelegramError:
            pass  # ignore users who fail 

def delete_message(self, chat_id, message_id, timeout=None, **kwargs):
        """
        Use this method to delete a message. A message can only be deleted if it was sent less
        than 48 hours ago. Any such recently sent outgoing message may be deleted. Additionally,
        if the bot is an administrator in a group chat, it can delete any message. If the bot is
        an administrator in a supergroup, it can delete messages from any other user and service
        messages about people joining or leaving the group (other types of service messages may
        only be removed by the group creator). In channels, bots can only remove their own
        messages.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target channel (in the format @channelusername).
            message_id (:obj:`int`): Identifier of the message to delete.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
            the read timeout
                from the server (instead of the one specified during creation of the connection
                pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :obj:`bool`: On success, ``True`` is returned.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/deleteMessage'.format(self.base_url)

        data = {'chat_id': chat_id, 'message_id': message_id}

        result = self._request.post(url, data, timeout=timeout)

        return result 

def send_game(self,
                  chat_id,
                  game_short_name,
                  disable_notification=False,
                  reply_to_message_id=None,
                  reply_markup=None,
                  timeout=None,
                  **kwargs):
        """Use this method to send a game.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target channel (in the format @channelusername).
            game_short_name (:obj:`str`): Short name of the game, serves as the unique identifier
                for the game. Set up your games via Botfather.
            disable_notification (:obj:`bool`, optional): Sends the message silently. Users will
                receive a notification with no sound.
            reply_to_message_id (:obj:`int`, optional): If the message is a reply, ID of the
                original message.
            reply_markup (:class:`telegram.ReplyMarkup`, optional): Additional interface options. A
                JSON-serialized object for an inline keyboard, custom reply keyboard, instructions
                to remove reply keyboard or to force a reply from the user.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :class:`telegram.Message`: On success, the sent Message is returned.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/sendGame'.format(self.base_url)

        data = {'chat_id': chat_id, 'game_short_name': game_short_name}

        return url, data 

def get_user_profile_photos(self, user_id, offset=None, limit=100, timeout=None, **kwargs):
        """Use this method to get a list of profile pictures for a user.

        Args:
            user_id (:obj:`int`): Unique identifier of the target user.
            offset (:obj:`int`, optional): Sequential number of the first photo to be returned.
                By default, all photos are returned.
            limit (:obj:`int`, optional): Limits the number of photos to be retrieved. Values
                between 1-100 are accepted. Defaults to 100.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :class:`telegram.UserProfilePhotos`

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/getUserProfilePhotos'.format(self.base_url)

        data = {'user_id': user_id}

        if offset is not None:
            data['offset'] = offset
        if limit:
            data['limit'] = limit
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return UserProfilePhotos.de_json(result, self) 

def get_file(self, file_id, timeout=None, **kwargs):
        """
        Use this method to get basic info about a file and prepare it for downloading. For the
        moment, bots can download files of up to 20MB in size. The file can then be downloaded
        with :attr:`telegram.File.download`. It is guaranteed that the link will be
        valid for at least 1 hour. When the link expires, a new one can be requested by
        calling getFile again.

        Args:
            file_id (:obj:`str`): File identifier to get info about.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :class:`telegram.File`

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/getFile'.format(self.base_url)

        data = {'file_id': file_id}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        if result.get('file_path'):
            result['file_path'] = '%s/%s' % (self.base_file_url, result['file_path'])

        return File.de_json(result, self) 

def unban_chat_member(self, chat_id, user_id, timeout=None, **kwargs):
        """Use this method to unban a previously kicked user in a supergroup.

        The user will not return to the group automatically, but will be able to join via link,
        etc. The bot must be an administrator in the group for this to work.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target channel (in the format @channelusername).
            user_id (:obj:`int`): Unique identifier of the target user.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :obj:`bool` On success, ``True`` is returned.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/unbanChatMember'.format(self.base_url)

        data = {'chat_id': chat_id, 'user_id': user_id}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def leave_chat(self, chat_id, timeout=None, **kwargs):
        """Use this method for your bot to leave a group, supergroup or channel.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :obj:`bool` On success, ``True`` is returned.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/leaveChat'.format(self.base_url)

        data = {'chat_id': chat_id}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def get_chat(self, chat_id, timeout=None, **kwargs):
        """
        Use this method to get up to date information about the chat (current name of the user for
        one-on-one conversations, current username of a user, group or channel, etc.).

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :class:`telegram.Chat`

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/getChat'.format(self.base_url)

        data = {'chat_id': chat_id}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return Chat.de_json(result, self) 

def get_chat_members_count(self, chat_id, timeout=None, **kwargs):
        """Use this method to get the number of members in a chat

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            int: Number of members in the chat.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/getChatMembersCount'.format(self.base_url)

        data = {'chat_id': chat_id}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def get_chat_member(self, chat_id, user_id, timeout=None, **kwargs):
        """Use this method to get information about a member of a chat.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            user_id (:obj:`int`): Unique identifier of the target user.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :class:`telegram.ChatMember`

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/getChatMember'.format(self.base_url)

        data = {'chat_id': chat_id, 'user_id': user_id}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return ChatMember.de_json(result, self) 

def export_chat_invite_link(self, chat_id, timeout=None, **kwargs):
        """
        Use this method to export an invite link to a supergroup or a channel. The bot must be an
        administrator in the chat for this to work and must have the appropriate admin rights.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments

        Returns:
            :obj:`str`: Exported invite link on success.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/exportChatInviteLink'.format(self.base_url)

        data = {'chat_id': chat_id}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def set_chat_photo(self, chat_id, photo, timeout=None, **kwargs):
        """Use this method to set a new profile photo for the chat.

        Photos can't be changed for private chats. The bot must be an administrator in the chat
        for this to work and must have the appropriate admin rights.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            photo (`telegram.InputFile`): New chat photo.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments

        Note:
            In regular groups (non-supergroups), this method will only work if the
            'All Members Are Admins' setting is off in the target group.

        Returns:
            :obj:`bool`: Returns True on success.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/setChatPhoto'.format(self.base_url)

        data = {'chat_id': chat_id, 'photo': photo}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def delete_chat_photo(self, chat_id, timeout=None, **kwargs):
        """
        Use this method to delete a chat photo. Photos can't be changed for private chats. The bot
        must be an administrator in the chat for this to work and must have the appropriate admin
        rights.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments

        Note:
            In regular groups (non-supergroups), this method will only work if the
            'All Members Are Admins' setting is off in the target group.

        Returns:
            :obj:`bool`: Returns ``True`` on success.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/deleteChatPhoto'.format(self.base_url)

        data = {'chat_id': chat_id}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def set_chat_title(self, chat_id, title, timeout=None, **kwargs):
        """
        Use this method to change the title of a chat. Titles can't be changed for private chats.
        The bot must be an administrator in the chat for this to work and must have the appropriate
        admin rights.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            title (:obj:`str`): New chat title, 1-255 characters.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments

        Note:
            In regular groups (non-supergroups), this method will only work if the
            'All Members Are Admins' setting is off in the target group.

        Returns:
            :obj:`bool`: Returns ``True`` on success.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/setChatTitle'.format(self.base_url)

        data = {'chat_id': chat_id, 'title': title}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def pin_chat_message(self, chat_id, message_id, disable_notification=None, timeout=None,
                         **kwargs):
        """
        Use this method to pin a message in a supergroup. The bot must be an administrator in the
        chat for this to work and must have the appropriate admin rights.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            message_id (:obj:`int`): Identifier of a message to pin.
            disable_notification (:obj:`bool`, optional): Pass True, if it is not necessary to send
                a notification to all group members about the new pinned message.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments

        Returns:
            :obj:`bool`: Returns ``True`` on success.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/pinChatMessage'.format(self.base_url)

        data = {'chat_id': chat_id, 'message_id': message_id}

        if disable_notification is not None:
            data['disable_notification'] = disable_notification
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def unpin_chat_message(self, chat_id, timeout=None, **kwargs):
        """
        Use this method to unpin a message in a supergroup. The bot must be an administrator in the
        chat for this to work and must have the appropriate admin rights.

        Args:
            chat_id (:obj:`int` | :obj:`str`): Unique identifier for the target chat or username
                of the target`channel (in the format @channelusername).
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during creation of
                the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments

        Returns:
            :obj:`bool`: Returns ``True`` on success.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/unpinChatMessage'.format(self.base_url)

        data = {'chat_id': chat_id}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def get_sticker_set(self, name, timeout=None, **kwargs):
        """Use this method to get a sticker set.

        Args:
            name (:obj:`str`): Short name of the sticker set that is used in t.me/addstickers/
                URLs (e.g., animals)
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during
                creation of the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :class:`telegram.StickerSet`

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/getStickerSet'.format(self.base_url)

        data = {'name': name}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return StickerSet.de_json(result, self) 

def upload_sticker_file(self, user_id, png_sticker, timeout=None, **kwargs):
        """
        Use this method to upload a .png file with a sticker for later use in
        :attr:`create_new_sticker_set` and :attr:`add_sticker_to_set` methods (can be used multiple
        times).

        Note:
            The png_sticker argument can be either a file_id, an URL or a file from disk
            ``open(filename, 'rb')``

        Args:
            user_id (:obj:`int`): User identifier of sticker file owner.
            png_sticker (:obj:`str` | `filelike object`): Png image with the sticker,
                must be up to 512 kilobytes in size, dimensions must not exceed 512px,
                and either width or height must be exactly 512px.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during
                creation of the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :class:`telegram.File`: The uploaded File

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/uploadStickerFile'.format(self.base_url)

        data = {'user_id': user_id, 'png_sticker': png_sticker}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return File.de_json(result, self) 

def set_sticker_position_in_set(self, sticker, position, timeout=None, **kwargs):
        """Use this method to move a sticker in a set created by the bot to a specific position.

        Args:
            sticker (:obj:`str`): File identifier of the sticker.
            position (:obj:`int`): New sticker position in the set, zero-based.
            timeout (:obj:`int` | :obj:`float`, optional): If this value is specified, use it as
                the read timeout from the server (instead of the one specified during
                creation of the connection pool).
            **kwargs (:obj:`dict`): Arbitrary keyword arguments.

        Returns:
            :obj:`bool`: On success, ``True`` is returned.

        Raises:
            :class:`telegram.TelegramError`

        """
        url = '{0}/setStickerPositionInSet'.format(self.base_url)

        data = {'sticker': sticker, 'position': position}
        data.update(kwargs)

        result = self._request.post(url, data, timeout=timeout)

        return result 

def error_callback(bot, update, error):
    try:
        raise error
    except Unauthorized:
        print("no nono1")
        print(error)
        # remove update.message.chat_id from conversation list
    except BadRequest:
        print("no nono2")
        print("BadRequest caught")
        print(error)

        # handle malformed requests - read more below!
    except TimedOut:
        print("no nono3")
        # handle slow connection problems
    except NetworkError:
        print("no nono4")
        # handle other connection problems
    except ChatMigrated as err:
        print("no nono5")
        print(err)
        # the chat_id of a group has changed, use e.new_chat_id instead
    except TelegramError:
        print(error)
        # handle all other telegram related errors 

4 / 4 / 0

Регистрация: 10.10.2018

Сообщений: 3

Добрый день.
Столкнулся с проблемой отправки файлов через Telegram bot.
Пользуюсь библиотекой Python telegram bot.

Пытаюсь отправить файл через бота, сам файл весит 77 КБ

Отправку делаю следующим образом
def systemInCommand(bot, update):
bot.send_document(chat_id=update.message.chat_id, ocument=open(r’C:UsersusernameDocumentsFile.tx t’, ‘rb’))

В логах выдает следующее сообщение:

Traceback (most recent call last):
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libsite-packagestelegramutilsrequest.py», line 157, in _parse
data = json.loads(decoded_s)
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libjson__init__.py», line 354, in loads
return _default_decoder.decode(s)
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libjsondecoder.py», line 339, in decode
obj, end = self.raw_decode(s, idx=_w(s, 0).end())
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libjsondecoder.py», line 357, in raw_decode
raise JSONDecodeError(«Expecting value», s, err.value) from None
json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libsite-packagestelegramextdispatcher.py», line 279, in process_update
handler.handle_update(update, self)
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libsite-packagestelegramextcommandhandler.py», line 173, in handle_update
return self.callback(dispatcher.bot, update, **optional_args)
File «c:/Users/user/Documents/Python/MyBot/bot.py», line 71, in checkuserCommand
systemInCommand(bot, update)
File «c:/Users/user/Documents/Python/MyBot/bot.py», line 146, in systemInCommand
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libsite-packagestelegrambot.py», line 65, in decorator
result = func(self, *args, **kwargs)
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libsite-packagestelegrambot.py», line 90, in decorator
result = self._request.post(url, data, timeout=kwargs.get(‘timeout’))
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libsite-packagestelegramutilsrequest.py», line 305, in post
result = self._request_wrapper(‘POST’, url, fields=data, **urlopen_kwargs)
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libsite-packagestelegramutilsrequest.py», line 216, in _request_wrapper
message = self._parse(resp.data)
File «C:UsersuserAppDataLocalProgramsPythonPytho n36-32libsite-packagestelegramutilsrequest.py», line 163, in _parse
raise TelegramError(‘Invalid server response’)
telegram.error.TelegramError: Invalid server response

По итогу бот ничего не присылает, но если отправить файл размер которого 25 КБ, то бот его успешно отправляет.

Прошу помочь разобраться с данной проблемой.

Добавлено через 28 минут
Добрый день.
Тема уже не актуальна. Прошу администрацию удалить тему.