Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Исправь данную ошибку: No error handlers are registered, logging exception. Traceback…

  1. User

    Исправь данную ошибку: No error handlers are registered, logging exception. Traceback (most recent call last): File "d:\Visual Studio\project\GPTTgBOT.venv\Lib\site-packages elegram\ext_application.py", line 1124, in process_update await coroutine File "d:\Visual Studio\project\GPTTgBOT.venv\Lib\site-packages elegram\ext_handler.py", line 141, in handle_update return await self.callback(update, context) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "d:\Visual Studio\project\GPTTgBOT\main.py", line 62, in message_collector context.chat_data['jobs'][user_id].schedule_removal() File "d:\Visual Studio\project\GPTTgBOT.venv\Lib\site-packages elegram\ext_jobqueue.py", line 789, in schedule_removal self.job.remove() File "d:\Visual Studio\project\GPTTgBOT.venv\Lib\site-packagespscheduler\job.py", line 108, in remove self._scheduler.remove_job(self.id, self._jobstore_alias) File "d:\Visual Studio\project\GPTTgBOT.venv\Lib\site-packagespscheduler\schedulersase.py", line 635, in remove_job raise JobLookupError(job_id) apscheduler.jobstores.base.JobLookupError: 'No job by the id of eeade670cf984aa3a3d50d9bf719155f was found'

    Код: from collections import defaultdict import re import logging from telegram import Update, ForceReply from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes, MessageHandler, filters from gradio_client import Client import time import copy

    TOKEN = "7626716371:AAFTR6OHq2JJXwmo7BPUaN3Ef3Av4eNBOKY"

    Включение логирования

    logger = logging.getLogger(name)

    Инициализация клиента Gradio

    try: logger.info("Initializing Gradio client...") client = Client("yuntian-deng/o1") logger.info("Gradio client initialized successfully") except Exception as e: logger.error(f"Failed to initialize Gradio client: {e}", exc_info=True)

    Словарь для хранения истории чатов для каждого пользователя

    chat_histories = {}

    разрешённые ID даша стёпа дениз

    ALLOWED_USER_IDS = [5197267693, 1956293525, 424323538]

    Словарь для хранения частичных сообщений

    partial_messages = defaultdict(dict)

    Максимальный интервал между сообщениями в секундах

    MAX_INTERVAL = 2 # Вы можете настроить это значение

    async def process_accumulated_message(context: ContextTypes.DEFAULT_TYPE): user_id = context.job.data['user_id'] if user_id in partial_messages: full_message = partial_messages[user_id]['text'] # Удаляем накопленное сообщение из словаря del partial_messages[user_id]

        # Вызываем функцию handle_message с полным сообщением
        await handle_message(context.job.data['update'], context, user_message=full_message)
    

    async def message_collector(update: Update, context: ContextTypes.DEFAULT_TYPE): user_id = update.effective_user.id message_text = update.message.text current_time = time.time()

    # Добавляем или обновляем частичное сообщение пользователя
    if user_id in partial_messages:
        partial_messages[user_id]['text'] += message_text
        partial_messages[user_id]['last_time'] = current_time
    else:
        partial_messages[user_id] = {'text': message_text, 'last_time': current_time}
    
    # Отменяем предыдущую задачу обработки сообщений для этого пользователя, если она есть
    if 'jobs' not in context.chat_data:
        context.chat_data['jobs'] = {}
    if user_id in context.chat_data['jobs']:
        context.chat_data['jobs'][user_id].schedule_removal()
    
    # Планируем новую задачу обработки через MAX_INTERVAL секунд
    job = context.job_queue.run_once(
        process_accumulated_message,
        when=MAX_INTERVAL,
        data={'user_id': user_id, 'update': update}
    )
    context.chat_data['jobs'][user_id] = job
    

    def markdown_to_telegram_html(text): # Заголовки text = re.sub(r'^# (.+)', r'<b></b>', text, flags=re.MULTILINE) text = re.sub(r'^## (.+)', r'', text, flags=re.MULTILINE) text = re.sub(r'^### (.+)$', r'', text, flags=re.MULTILINE)

    # Жирный курсивный текст
    text = re.sub(r'\*\*\*(.*?)\*\*\*', r'<b><i></i></b>', text)
    
    # Жирный текст
    text = re.sub(r'\*\*(.*?)\*\*', r'<b></b>', text)
    
    # Курсивный текст
    text = re.sub(r'\*(.*?)\*', r'<i></i>', text)
    
    # Зачёркнутый текст
    text = re.sub(r'~~(.*?)~~', r'<s></s>', text)
    
    # Горизонтальная линия (заменяем на символы, поддерживаемые Telegram)
    text = re.sub(r'^---$', r'――――――――――', text, flags=re.MULTILINE)
    
    # Ссылки
    text = re.sub(r'\[(.*?)\]\((.*?)\)', r'<a href=""></a>', text)
    
    # Блоки кода (многострочные)
    text = re.sub(r'```(?:\w+
    

    )?([\s\S]+?)```', r'', text)

    # Однострочный код
    text = re.sub(r'`(.*?)`', r'<code></code>', text)
    
    # Списки (упрощенно)
    text = re.sub(r'^-\s(.+)$', r'• ', text, flags=re.MULTILINE)
    text = re.sub(r'^\d+\.\s(.+)$', r'  ', text, flags=re.MULTILINE)
    
    # Удаление неподдерживаемых элементов
    #text = re.sub(r'!\[.*?\]\(.*?\)', '', text)  # Изображения
    #text = re.sub(r'^\|.*\|.*$', '', text, flags=re.MULTILINE)  # Таблицы
    #text = re.sub(r':[a-z_+-]+:', '', text)  # Эмодзи
    #text = re.sub(r'[\^~](.+?)[\^~]', r'', text)  # Подстрочный и надстрочный текст
    #text = re.sub(r'\$\$.*?\$\$', '', text, flags=re.DOTALL)  # Формулы TeX
    #text = re.sub(r'\[\d+\]:\s*http.*$', '', text, flags=re.MULTILINE)  # Сноски
    #text = re.sub(r'^> (.+)$', r'', text, flags=re.MULTILINE)  # Цитаты
    
    # Удаление неподдерживаемых HTML-тегов
    def remove_unsupported_html_tags(text):
        allowed_tags = ['a', 'b', 'strong', 'i', 'em', 'u', 'ins', 's', 'strike', 'del', 'code', 'pre']
        # Исправленное регулярное выражение
        pattern = r'</?(?!(?:' + '|'.join(allowed_tags) + r'))([a-zA-Z]+)(?:\s[^>]*)?>'
        text = re.sub(pattern, '', text)
        return text
    
    text = remove_unsupported_html_tags(text)
    
    return text.strip()
    

    Команда /start

    async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: user = update.effective_user

    # Проверка, разрешен ли доступ пользователю
    if user.id not in ALLOWED_USER_IDS:
        await update.message.reply_text("Извините, у вас нет доступа к этому боту.")
        return
    
    await update.message.reply_html(
        rf"Привет, {user.mention_html()}! Как я могу вам помочь?",
        reply_markup=ForceReply(selective=True),
    )
    

    Обработка текстовых сообщений

    async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE, user_message=None) -> None: user_id = update.effective_user.id

    # Проверка, разрешен ли доступ пользователю
    if user_id not in ALLOWED_USER_IDS:
        await update.message.reply_text("Извините, у вас нет доступа к этому боту.")
        return
    
    if user_message is None:
        user_message = update.message.text
    
    # Получение истории чата пользователя или инициализация новой
    history = chat_histories.get(user_id, [])
    
    try:
        # Вызов API /predict
        result = client.predict(
            inputs=user_message,
            top_p=1,
            temperature=1,
            chat_counter=len(history),
            chatbot=history,
            api_name="/predict"
        )
    
        # Разбор результата
        chatbot_output, chat_counter, status_code, reset_text = result
    
        # Извлечение последнего ответа бота
        if chatbot_output and len(chatbot_output) > 0:
            last_message = chatbot_output[-1]
            if isinstance(last_message, list) and len(last_message) == 2:
                bot_reply = last_message[1]
            else:
                bot_reply = "Произошла непредвиденная ошибка."
        else:
            bot_reply = "Произошла непредвиденная ошибка."
    
        # Обновление истории чата
        history.append((user_message, bot_reply))
        chat_histories[user_id] = history
    
        # Отправка ответа пользователю
        def tokenize(message):
            tokens = []
            pos = 0
            length = len(message)
            while pos < length:
                if message[pos] == '<':
                    # Это тег
                    end_tag_pos = message.find('>', pos)
                    if end_tag_pos == -1:
                        # Неполный тег, считаем остальное текстом
                        tokens.append(('text', message[pos:]))
                        break
                    else:
                        token_content = message[pos+1:end_tag_pos]
                        # Проверяем, является ли это закрывающим тегом
                        if token_content.startswith('/'):
                            tag_name = token_content[1:].split()[0]
                            tokens.append(('end_tag', tag_name, '<'+token_content+'>'))
                        else:
                            # Тег может содержать атрибуты
                            tag_name = token_content.split()[0]
                            tokens.append(('start_tag', tag_name, '<'+token_content+'>'))
                        pos = end_tag_pos + 1
                else:
                    # Это текст
                    next_tag_pos = message.find('<', pos)
                    if next_tag_pos == -1:
                        # Больше нет тегов
                        tokens.append(('text', message[pos:]))
                        break
                    else:
                        tokens.append(('text', message[pos:next_tag_pos]))
                        pos = next_tag_pos
            return tokens
    
        def generate_closing_tags(open_tags):
            closing_tags = ''
            for start_tag in reversed(open_tags):
                # Получаем имя тега из стартового тега
                tag_content = start_tag[1:-1].strip()
                if ' ' in tag_content:
                    tag_name = tag_content.split(' ',1)[0]
                else:
                    tag_name = tag_content
                closing_tags += '</{}>'.format(tag_name)
            return closing_tags
    
        async def send_large_message(message, update):
            MAX_MESSAGE_LENGTH = 4000
    
            tokens = tokenize(message)
            open_tags = []
            current_part = ''
            current_length = 0
            parts = []
    
            for token in tokens:
                if token[0] == 'start_tag':
                    tag_name = token[1]
                    tag_string = token[2]
                    token_length = len(tag_string)
                    if current_length + token_length > MAX_MESSAGE_LENGTH:
                        # Закрываем теги и начинаем новую часть
                        closing_tags = generate_closing_tags(open_tags)
                        current_part += closing_tags
                        parts.append(current_part)
                        current_part = ''
                        current_length = 0
                        # Открываем теги снова
                        opening_tags = ''.join(open_tags)
                        current_part += opening_tags
                        current_length += len(opening_tags)
                    current_part += tag_string
                    current_length += token_length
                    open_tags.append(tag_string)
                elif token[0] == 'end_tag':
                    tag_name = token[1]
                    tag_string = token[2]
                    token_length = len(tag_string)
                    if current_length + token_length > MAX_MESSAGE_LENGTH:
                        # Закрываем теги и начинаем новую часть
                        closing_tags = generate_closing_tags(open_tags)
                        current_part += closing_tags
                        parts.append(current_part)
                        current_part = ''
                        current_length = 0
                        # Открываем теги снова
                        opening_tags = ''.join(open_tags)
                        current_part += opening_tags
                        current_length += len(opening_tags)
                    current_part += tag_string
                    current_length += token_length
                    if open_tags:
                        open_tags.pop()
                elif token[0] == 'text':
                    text_content = token[1]
                    text_length = len(text_content)
                    pos = 0
                    while pos < text_length:
                        remaining_space = MAX_MESSAGE_LENGTH - current_length
                        if remaining_space <= 0:
                            # Закрываем теги и начинаем новую часть
                            closing_tags = generate_closing_tags(open_tags)
                            current_part += closing_tags
                            parts.append(current_part)
                            current_part = ''
                            current_length = 0
                            # Открываем теги снова
                            opening_tags = ''.join(open_tags)
                            current_part += opening_tags
                            current_length += len(opening_tags)
                            remaining_space = MAX_MESSAGE_LENGTH - current_length
                        take_length = min(remaining_space, text_length - pos)
                        current_part += text_content[pos:pos+take_length]
                        current_length += take_length
                        pos += take_length
                else:
                    pass
    
            # Закрываем оставшиеся открытые теги и добавляем последнюю часть
            if open_tags:
                closing_tags = generate_closing_tags(open_tags)
                current_part += closing_tags
            if current_part:
                parts.append(current_part)
    
            # Отправляем части сообщения
            for part in parts:
                await update.message.reply_text(part, parse_mode='HTML')
                
        send_bot_reply = markdown_to_telegram_html(bot_reply)
        print(send_bot_reply)
        await send_large_message(send_bot_reply, update)
    
    except Exception as e:
        logger.error(f"Ошибка при обработке сообщения: {e}", exc_info=True)
        await update.message.reply_text("Извините, произошла ошибка при обработке вашего запроса.", parse_mode='HTML')
    

    Команда /reset для сброса истории чата

    async def reset_chat(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: user_id = update.effective_user.id chat_histories[user_id] = [] await update.message.reply_text("Чат сброшен. Начнем с чистого листа!", parse_mode='HTML')

    async def get_my_id(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: user_id = update.effective_user.id await update.message.reply_text(f"Ваш Telegram ID: {user_id}")

    def main(): # Замените 'YOUR_TELEGRAM_BOT_TOKEN' на токен вашего бота application = ApplicationBuilder().token(TOKEN).build()

    # Регистрируем обработчики команд и сообщений
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("clear", reset_chat))
    application.add_handler(CommandHandler("myid", get_my_id))
    message_handler = MessageHandler(filters.TEXT & ~filters.COMMAND, message_collector)
    application.add_handler(message_handler)
    
    # Запуск бота
    application.run_polling()
    

    if name == 'main': main()

  2. Assistant

    Проблема заключается в том, что вы пытаетесь отменить (удалить) задачу, которая уже была выполнена или удалена из планировщика. Когда задача выполняется, она автоматически удаляется из планировщика apscheduler, поэтому при попытке снова вызвать schedule_removal() для этой задачи возникает ошибка JobLookupError.

    Чтобы решить эту проблему, необходимо удалить ссылку на задачу из context.chat_data['jobs'][user_id] после ее выполнения. Таким образом, при следующей проверке в message_collector вы не будете пытаться отменить задачу, которая уже не существует.

    Вот как можно исправить ваш код:

    Добавьте удаление задачи из context.chat_data['jobs'] в конце функции process_accumulated_message:

    async def process_accumulated_message(context: ContextTypes.DEFAULT_TYPE):
        user_id = context.job.data['user_id']
        if user_id in partial_messages:
            full_message = partial_messages[user_id]['text']
            # Удаляем накопленное сообщение из словаря
            del partial_messages[user_id]
    
            # Вызываем функцию handle_message с полным сообщением
            await handle_message(context.job.data['update'], context, user_message=full_message)
    
        # Удаляем задачу из context.chat_data['jobs'], чтобы избежать попыток отменить ее снова
        if 'jobs' in context.chat_data and user_id in context.chat_data['jobs']:
            del context.chat_data['jobs'][user_id]
    

    Также рекомендуется добавить обработку исключения при попытке отменить задачу в message_collector, чтобы убедиться, что ошибка не возникнет, даже если по какой-то причине задача уже была удалена:

    async def message_collector(update: Update, context: ContextTypes.DEFAULT_TYPE):
        user_id = update.effective_user.id
        message_text = update.message.text
        current_time = time.time()
    
        # Добавляем или обновляем частичное сообщение пользователя
        if user_id in partial_messages:
            partial_messages[user_id]['text'] += message_text
            partial_messages[user_id]['last_time'] = current_time
        else:
            partial_messages[user_id] = {'text': message_text, 'last_time': current_time}
    
        # Отменяем предыдущую задачу обработки сообщений для этого пользователя, если она есть
        if 'jobs' not in context.chat_data:
            context.chat_data['jobs'] = {}
        if user_id in context.chat_data['jobs']:
            try:
                context.chat_data['jobs'][user_id].schedule_removal()
            except JobLookupError:
                pass  # Задача уже была удалена
    
        # Планируем новую задачу обработки через MAX_INTERVAL секунд
        job = context.job_queue.run_once(
            process_accumulated_message,
            when=MAX_INTERVAL,
            data={'user_id': user_id, 'update': update}
        )
        context.chat_data['jobs'][user_id] = job
    

    Итого, весь исправленный код будет выглядеть следующим образом:

    from collections import defaultdict
    import re
    import logging
    from telegram import Update, ForceReply
    from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes, MessageHandler, filters
    from gradio_client import Client
    import time
    import copy
    from apscheduler.jobstores.base import JobLookupError  # Добавлено для обработки исключения
    
    TOKEN = "7626716371:AAFTR6OHq2JJXwmo7BPUaN3Ef3Av4eNBOKY"
    
    
    # Включение логирования
    logger = logging.getLogger(__name__)
    
    # Инициализация клиента Gradio
    try:
        logger.info("Initializing Gradio client...")
        client = Client("yuntian-deng/o1")
        logger.info("Gradio client initialized successfully")
    except Exception as e:
        logger.error(f"Failed to initialize Gradio client: {e}", exc_info=True)
    
    # Словарь для хранения истории чатов для каждого пользователя
    chat_histories = {}
    
    # разрешённые ID      даша        стёпа       дениз
    ALLOWED_USER_IDS = [5197267693, 1956293525, 424323538] 
    
    # Словарь для хранения частичных сообщений
    partial_messages = defaultdict(dict)
    
    # Максимальный интервал между сообщениями в секундах
    MAX_INTERVAL = 2  # Вы можете настроить это значение
    
    async def process_accumulated_message(context: ContextTypes.DEFAULT_TYPE):
        user_id = context.job.data['user_id']
        if user_id in partial_messages:
            full_message = partial_messages[user_id]['text']
            # Удаляем накопленное сообщение из словаря
            del partial_messages[user_id]
    
            # Вызываем функцию handle_message с полным сообщением
            await handle_message(context.job.data['update'], context, user_message=full_message)
    
        # Удаляем задачу из context.chat_data['jobs'], чтобы избежать попыток отменить ее снова
        if 'jobs' in context.chat_data and user_id in context.chat_data['jobs']:
            del context.chat_data['jobs'][user_id]
    
    async def message_collector(update: Update, context: ContextTypes.DEFAULT_TYPE):
        user_id = update.effective_user.id
        message_text = update.message.text
        current_time = time.time()
    
        # Добавляем или обновляем частичное сообщение пользователя
        if user_id in partial_messages:
            partial_messages[user_id]['text'] += message_text
            partial_messages[user_id]['last_time'] = current_time
        else:
            partial_messages[user_id] = {'text': message_text, 'last_time': current_time}
    
        # Отменяем предыдущую задачу обработки сообщений для этого пользователя, если она есть
        if 'jobs' not in context.chat_data:
            context.chat_data['jobs'] = {}
        if user_id in context.chat_data['jobs']:
            try:
                context.chat_data['jobs'][user_id].schedule_removal()
            except JobLookupError:
                pass  # Задача уже была удалена
    
        # Планируем новую задачу обработки через MAX_INTERVAL секунд
        job = context.job_queue.run_once(
            process_accumulated_message,
            when=MAX_INTERVAL,
            data={'user_id': user_id, 'update': update}
        )
        context.chat_data['jobs'][user_id] = job
    
    def markdown_to_telegram_html(text):
        # Ваш код функции markdown_to_telegram_html без изменений
        pass  # Оставлено для краткости
    
    # Команда /start
    async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
        # Ваш код функции start без изменений
        pass  # Оставлено для краткости
    
    # Обработка текстовых сообщений
    async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE, user_message=None) -> None:
        # Ваш код функции handle_message без изменений
        pass  # Оставлено для краткости
    
    # Команда /reset для сброса истории чата
    async def reset_chat(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
        # Ваш код функции reset_chat без изменений
        pass  # Оставлено для краткости
    
    async def get_my_id(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
        # Ваш код функции get_my_id без изменений
        pass  # Оставлено для краткости
    
    def main():
        # Ваш код функции main без изменений
        pass  # Оставлено для краткости
    
    if __name__ == '__main__':
        main()
    

    Объяснение:

    • Удаление задачи из context.chat_data['jobs'] после ее выполнения: Это гарантирует, что вы не будете пытаться отменить задачу, которая уже была выполнена или удалена.
    • Обработка исключения JobLookupError при попытке отменить задачу: Это дополнительно защищает ваш код от возникновения ошибки, если задача по какой-то причине уже была удалена до вызова schedule_removal().

    После внесения этих изменений ошибка должна исчезнуть, и ваш код будет работать корректно.