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

import re import time import logging from gradioclient import Client from collections…

  1. User

    import re import time import logging from gradio_client import Client from collections import defaultdict from telegram import Update, ForceReply from apscheduler.jobstores.base import JobLookupError from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes, MessageHandler, filters

    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): # Заголовки text = re.sub(r'^# (.+)', r'<b>\1</b>', text, flags=re.MULTILINE) text = re.sub(r'^## (.+)', r'\1', text, flags=re.MULTILINE) text = re.sub(r'^### (.+)$', r'\1', text, flags=re.MULTILINE)

    # Жирный курсивный текст
    text = re.sub(r'\*\*\*(.*?)\*\*\*', r'<b><i>\1</i></b>', text)
    
    # Жирный текст
    text = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', text)
    
    # Курсивный текст
    text = re.sub(r'\*(.*?)\*', r'<i>\1</i>', text)
    
    # Зачёркнутый текст
    text = re.sub(r'(.*?)', r'<s>\1</s>', text)
    
    # Горизонтальная линия (заменяем на символы, поддерживаемые Telegram)
    text = re.sub(r'^---$', r'――――――――――', text, flags=re.MULTILINE)
    
    # Ссылки
    text = re.sub(r'\[(.*?)\]\((.*?)\)', r'<a href="\2">\1</a>', text)
    
    # Блоки кода (многострочные)
    text = re.sub(r'(?:\w+\n)?([\s\S]+?)', r'<pre>\1</pre>', text)
    
    # Однострочный код
    text = re.sub(r'(.*?)', r'<code>\1</code>', text)
    
    # Списки (упрощенно)
    text = re.sub(r'^-\s(.+)$', r'• \1', text, flags=re.MULTILINE)
    text = re.sub(r'^\d+\.\s(.+)$', r'  \1', 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'\1', 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'\1', 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')\b)([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

    Кажется, в вашем коде есть несколько ошибок, которые могут вызывать проблемы при запуске.

    1. Проблема с переменной name:

      Вы используете переменную name в следующих местах:

      logger = logging.getLogger(name)
      
      if name == 'main':
          main()
      

      Однако переменная name в данном контексте не определена. В Python для получения имени модуля используется встроенная переменная __name__. Вам следует заменить name на __name__:

      logger = logging.getLogger(__name__)
      
      if __name__ == '__main__':
          main()
      

      Это исправление позволит вашему коду работать корректно, так как __name__ автоматически содержит имя текущего модуля.

    2. Утечка токена Telegram-бота:

      В вашем коде вы напрямую указываете токен бота:

      TOKEN = "Ваш_токен_здесь"
      

      Это небезопасно, поскольку при публикации кода токен может быть скомпрометирован. Рекомендуется хранить токен в переменной окружения или в отдельном конфигурационном файле, который не отслеживается системой контроля версий. Например:

      import os
      
      TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
      

      И перед запуском скрипта установить переменную окружения TELEGRAM_BOT_TOKEN.

    3. Некорректные регулярные выражения в функции markdown_to_telegram_html:

      В данной функции некоторые регулярные выражения могут работать некорректно. Например:

      # Зачёркнутый текст
      text = re.sub(r'(.*?)', r'<s>\1</s>', text)
      
      # Однострочный код
      text = re.sub(r'(.*?)', r'<code>\1</code>', text)
      

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

      Вам следует исправить эти регулярные выражения, указав правильные шаблоны Markdown для зачёркнутого текста (обычно используется ~~текст~~) и для однострочного кода (обычно используется `код`). Например:

      # Зачёркнутый текст
      text = re.sub(r'~~(.*?)~~', r'<s>\1</s>', text)
      
      # Однострочный код
      text = re.sub(r'`([^`]+)`', r'<code>\1</code>', text)
      
    4. Проверка функций по работе с сообщениями:

      Функция send_large_message довольно сложна и работает с разбиением сообщения на части с учётом HTML-тегов. Рекомендуется протестировать её отдельно с разными сообщениями, чтобы убедиться в корректности её работы. Возможно, стоит упростить или оптимизировать логику разбиения.

    5. Задержка обработки сообщений:

      В функции message_collector вы устанавливаете задержку перед обработкой сообщений:

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

      Это может приводить к тому, что бот не отвечает сразу на сообщения пользователя. Если необходимость в сборе частичных сообщений отсутствует, возможно, стоит убрать задержку и обрабатывать сообщения сразу по мере поступления.

    6. Использование context.chat_data без инициализации:

      Убедитесь, что вы правильно используете context.chat_data. В некоторых версиях библиотеки python-telegram-bot может понадобиться инициализировать context.chat_data перед использованием.

    7. Проверка корректности импортов и зависимостей:

      Убедитесь, что все необходимые пакеты установлены и импорты корректны. Например, проверьте, что пакет gradio_client установлен и доступен.


    Если после внесения этих изменений ошибки все ещё возникают, пожалуйста, предоставьте текст ошибок или исключений, которые вы получаете при запуске кода. Это поможет более точно определить причину проблемы и предложить конкретное решение.