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

Вот мой код: import datetime import os from dotenv import loaddotenv import asyncio…

  1. User

    Вот мой код: import datetime import os from dotenv import load_dotenv import asyncio import logging import re from contextlib import suppress from telethon import TelegramClient, events, Button from telethon.errors import (MediaCaptionTooLongError, FloodWaitError, SlowModeWaitError, MediaEmptyError, MediaInvalidError) from telethon.tl.types import MessageMediaPhoto, MessageMediaDocument

    Load environment variables from .env file

    load_dotenv()

    API_ID = os.getenv("API_ID") API_HASH = os.getenv("API_HASH") BOT_TOKEN = os.getenv("BOT_TOKEN") CHANNEL_ID = int(os.getenv("CHANNEL_ID")) ALLOWED_USER_ID = int(os.getenv("ALLOWED_USER_ID")) MAX_CAPTION_LENGTH = 1024

    with TelegramClient('bot', API_ID, API_HASH) as client: client.start(bot_token=BOT_TOKEN)

    logging.basicConfig(filename="bot.log", level=logging.INFO)

    def clean_text(text): return re.sub(r'@\w+|#\w+', '', text, flags=re.IGNORECASE)

    async def send_media_with_caption(event, media_list, caption): try: # Проверка типа медиафайла for media in media_list: if not isinstance(media, (MessageMediaPhoto, MessageMediaDocument)): raise ValueError("Invalid media type")

        # Проверка длины подписи
        if caption and len(caption) > MAX_CAPTION_LENGTH:
            await client.send_message(CHANNEL_ID, caption)
            caption = None
    
        # Отправка медиафайлов как альбом
        if len(media_list) > 1:
            await client.send_file(CHANNEL_ID, media_list, caption=caption)
        else:
            await client.send_file(CHANNEL_ID, media_list[0], caption=caption)
    
    except (MediaCaptionTooLongError, FloodWaitError, SlowModeWaitError,
            MediaEmptyError, MediaInvalidError, ValueError) as e:
        # Обработка исключений
        await client.send_message(event.chat_id, f"Ошибка: {str(e)}")
    
    else:
        logging.info("Media files sent successfully.")
    
    finally:
        # Подавление исключений при отправке сообщения об ошибке
        with suppress(Exception):
            await event.delete()
    

    grouped_messages = {} grouped_messages_timeout = 5 # 30 seconds timeout for grouped messages grouped_messages_timeouts = {} # Словарь для хранения таймаутов групп

    @client.on(events.NewMessage) async def handle_message(event): if event.sender_id != ALLOWED_USER_ID: await event.reply("Извините, вы не имеете доступа к использованию этого бота.") return

    # Check if the message is part of a group
    if event.grouped_id:
        # Add the message to the cache
        if event.grouped_id not in grouped_messages:
            grouped_messages[event.grouped_id] = []
        grouped_messages[event.grouped_id].append(event.id)  # Store message ID
    
        # Сброс таймаута для группы
        if event.grouped_id in grouped_messages_timeouts:
            grouped_messages_timeouts[event.grouped_id].cancel()
        grouped_messages_timeouts[event.grouped_id] = asyncio.create_task(process_grouped_messages(event, event.grouped_id, grouped_messages_timeout))
    else:
        # Copy and send individual messages
        message = await client.get_messages(event.chat_id, ids=event.id)
        await client.send_message(CHANNEL_ID, message)
        await event.delete()
    

    async def process_grouped_messages(event, group_id, timeout): await asyncio.sleep(timeout) if group_id in grouped_messages: message_ids = grouped_messages.pop(group_id) messages = await client.get_messages(event.chat_id, ids=message_ids)

        # Collect media files and caption
        media_list = []
        caption = ""
        for message in messages:
            if message.media:
                media_list.append(message.media)
            if message.text:
                caption += message.text + "\n"  # Combine captions if multiple messages have text
    
        # Send media files as an album
        await client.send_file(CHANNEL_ID, media_list, caption=caption)
    else:
        print(f"Group {group_id} timed out or was cancelled")
    

    Additional logic to handle cache cleanup

    async def cleanup_cache(): while True: await asyncio.sleep(60) # run every 1 minute for group_id, messages in list(grouped_messages.items()): if len(messages) == 0 or messages[-1][0].date < datetime.datetime.now() - datetime.timedelta(minutes=30): print(f"Cleaning up group {group_id}") grouped_messages.pop(group_id)

    Create an event loop and run the cleanup task

    loop = asyncio.get_event_loop() loop.create_task(cleanup_cache()) # run the cleanup task in the background

    with client: client.run_until_disconnected() ➡️Можно ли абсолютно идентично переделать этот код под официальный Telegram Bot API ❤️

  2. Assistant

    Да, вы можете адаптировать ваш существующий код, написанный на библиотеке Telethon, для использования официального Telegram Bot API с помощью библиотеки python-telegram-bot. Ниже приведен пример того, как можно переписать ваш код, сохраняя его функциональность.

    Основные отличия

    1. Библиотека: Telethon — это клиентская библиотека, которая взаимодействует напрямую с Telegram API, тогда как python-telegram-bot использует официальный Bot API.
    2. Архитектура приложения: python-telegram-bot использует обработчики событий (handlers) для различных типов сообщений и команд.
    3. Группировка сообщений: В Bot API группировка медиафайлов осуществляется с помощью media_group_id, что упрощает обработку альбомов.

    Установка необходимых библиотек

    Убедитесь, что у вас установлены необходимые библиотеки:

    pip install python-telegram-bot python-dotenv
    

    Переписанный код с использованием python-telegram-bot

    import os
    import re
    import logging
    import asyncio
    import datetime
    from dotenv import load_dotenv
    from contextlib import suppress
    
    from telegram import Update, InputMediaPhoto, InputMediaDocument
    from telegram.ext import (
        ApplicationBuilder,
        ContextTypes,
        MessageHandler,
        filters,
    )
    
    # Загрузка переменных окружения из .env файла
    load_dotenv()
    
    API_TOKEN = os.getenv("BOT_TOKEN")
    CHANNEL_ID = os.getenv("CHANNEL_ID")
    ALLOWED_USER_ID = int(os.getenv("ALLOWED_USER_ID"))
    MAX_CAPTION_LENGTH = 1024
    GROUPED_MESSAGES_TIMEOUT = 5  # секунд
    CLEANUP_INTERVAL = 60  # секунд
    GROUP_TIMEOUT = 30  # минут
    
    # Настройка логирования
    logging.basicConfig(
        filename="bot.log",
        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
        level=logging.INFO
    )
    logger = logging.getLogger(__name__)
    
    # Словари для хранения группированных сообщений и таймаутов
    grouped_messages = {}
    grouped_messages_tasks = {}
    
    def clean_text(text):
        return re.sub(r'@\w+|#\w+', '', text, flags=re.IGNORECASE)
    
    async def send_media_with_caption(context: ContextTypes.DEFAULT_TYPE, media_list, caption):
        try:
            # Проверка длины подписи
            if caption and len(caption) > MAX_CAPTION_LENGTH:
                await context.bot.send_message(chat_id=CHANNEL_ID, text=caption[:MAX_CAPTION_LENGTH])
                caption = None
    
            # Отправка медиафайлов как альбом
            if media_list:
                input_media = []
                for media in media_list:
                    if media['type'] == 'photo':
                        input_media.append(InputMediaPhoto(media=media['media'], caption=caption if len(input_media) == 0 else None))
                    elif media['type'] == 'document':
                        input_media.append(InputMediaDocument(media=media['media'], caption=caption if len(input_media) == 0 else None))
                
                if len(input_media) > 1:
                    await context.bot.send_media_group(chat_id=CHANNEL_ID, media=input_media)
                elif len(input_media) == 1:
                    await context.bot.send_media_group(chat_id=CHANNEL_ID, media=input_media)
            
        except Exception as e:
            logger.error(f"Ошибка при отправке медиа: {e}")
            await context.bot.send_message(chat_id=CHANNEL_ID, text=f"Ошибка: {str(e)}")
        else:
            logger.info("Медиафайлы успешно отправлены.")
        finally:
            # Дополнительные действия при необходимости
            pass
    
    async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
        message = update.effective_message
    
        # Проверка пользователя
        if message.from_user.id != ALLOWED_USER_ID:
            await message.reply_text("Извините, вы не имеете доступа к использованию этого бота.")
            return
    
        # Очистка текста от @ и #
        if message.text:
            message.text = clean_text(message.text)
    
        # Обработка групповых сообщений (альбомов)
        if message.media_group_id:
            group_id = message.media_group_id
    
            if group_id not in grouped_messages:
                grouped_messages[group_id] = {
                    'messages': [],
                    'caption': ""
                }
    
            if message.media:
                media_type = None
                if message.photo:
                    media_type = 'photo'
                elif message.document:
                    media_type = 'document'
                else:
                    media_type = 'unknown'
    
                if media_type in ['photo', 'document']:
                    grouped_messages[group_id]['messages'].append({
                        'type': media_type,
                        'media': message.photo.file_id if media_type == 'photo' else message.document.file_id
                    })
    
            if message.caption:
                grouped_messages[group_id]['caption'] += message.caption + "\n"
    
            # Сброс таймаута для группы
            if group_id in grouped_messages_tasks:
                grouped_messages_tasks[group_id].cancel()
    
            # Установка таймаута для обработки группы
            grouped_messages_tasks[group_id] = asyncio.create_task(
                process_grouped_messages(context, group_id, GROUPED_MESSAGES_TIMEOUT)
            )
        else:
            # Обработка одиночных сообщений
            media_list = []
            caption = message.text or ""
    
            if message.photo:
                media_list.append({
                    'type': 'photo',
                    'media': message.photo.file_id
                })
            elif message.document:
                media_list.append({
                    'type': 'document',
                    'media': message.document.file_id
                })
    
            await send_media_with_caption(context, media_list, caption)
    
            # Удаление оригинального сообщения (если необходимо)
            with suppress(Exception):
                await message.delete()
    
    async def process_grouped_messages(context: ContextTypes.DEFAULT_TYPE, group_id, timeout):
        await asyncio.sleep(timeout)
        if group_id in grouped_messages:
            group = grouped_messages.pop(group_id)
            media_list = group['messages']
            caption = group['caption'].strip()
    
            await send_media_with_caption(context, media_list, caption)
    
            # Удаление оригинных сообщений (если необходимо)
            # Примечание: Удаление отдельных сообщений по ID может быть нетривиальным через Bot API
        else:
            logger.info(f"Группа {group_id} уже обработана или отсутствует.")
    
    async def cleanup_cache():
        while True:
            await asyncio.sleep(CLEANUP_INTERVAL)
            now = datetime.datetime.now()
            to_remove = []
            for group_id, group in grouped_messages.items():
                # Предполагаем, что у вас есть способ отслеживать время последнего обновления группы
                # Здесь можно расширить словарь группы, чтобы включить временную метку
                pass  # Реализуйте логику очистки при необходимости
    
            # Пример очистки всех групп, которые не были обработаны
            for group_id in to_remove:
                grouped_messages.pop(group_id, None)
    
    async def main():
        application = ApplicationBuilder().token(API_TOKEN).concurrent_updates(True).build()
    
        # Обработчик всех сообщений
        message_handler = MessageHandler(filters.ALL, handle_message)
        application.add_handler(message_handler)
    
        # Запуск задачи очистки кеша
        application.job_queue.run_repeating(lambda context: asyncio.create_task(cleanup_cache()), interval=CLEANUP_INTERVAL, first= CLEANUP_INTERVAL)
    
        await application.run_polling()
    
    if __name__ == "__main__":
        asyncio.run(main())
    

    Пояснения и изменения

    1. Библиотека python-telegram-bot:

      • Используется версия с поддержкой асинхронности (v20).
      • Обработчики сообщений добавляются через MessageHandler.
    2. Обработка сообщений:

      • Проверяется from_user.id, чтобы ограничить доступ.
      • Для группированных сообщений (media_group_id) создается временное хранилище grouped_messages, куда добавляются все медиафайлы и подписи.
      • После таймаута GROUPED_MESSAGES_TIMEOUT вызывается функция process_grouped_messages, которая отправляет собранные медиа в целевой канал.
    3. Отправка медиафайлов:

      • Используется send_media_group для отправки альбомов.
      • Если подпись превышает максимальную длину, она обрезается и отправляется отдельно.
    4. Исключения и логирование:

      • Все ошибки логируются, и пользователю отправляется сообщение об ошибке в канал.
      • Применяется подавление исключений при удалении сообщений.
    5. Очистка кэша:

      • Реализован цикл cleanup_cache, который периодически очищает старые группы сообщений. В данном примере логика очистки не реализована полностью и должна быть доработана в зависимости от требований.
    6. Удаление исходных сообщений:

      • В Bot API удаление сообщений возможно только при наличии соответствующих прав. Убедитесь, что у бота есть права администратора в канале для удаления сообщений.
    7. Асинхронность:

      • Вся обработка осуществляется асинхронно с использованием asyncio, что обеспечивает эффективную работу бота.

    Дополнительные рекомендации

    1. Права бота:

      • Убедитесь, что бот обладает необходимыми правами для отправки сообщений и удаления их в целевом канале.
    2. Управление группами:

      • В python-telegram-bot обработка групповых сообщений упрощена благодаря media_group_id.
      • Можно дополнительно отслеживать время последнего сообщения в группе для более точной очистки.
    3. Обработка других типов медиа:

      • Если ваш бот должен обрабатывать другие типы медиа (видео, аудио и т.д.), добавьте соответствующие проверки и обработку.
    4. Улучшение логики очистки:

      • В текущем примере функция cleanup_cache не реализует полноценную очистку. Вы можете расширить структуру grouped_messages, добавив временные метки, и использовать их для определения устаревших групп.
    5. Тестирование:

      • Рекомендуется протестировать бота в различных сценариях (отправка одиночных сообщений, альбомов, превышение длины подписи и т.д.), чтобы убедиться в корректности работы.

    Заключение

    Использование официального Telegram Bot API через библиотеку python-telegram-bot предоставляет удобный и мощный интерфейс для создания ботов. Переписав ваш код согласно приведенному примеру, вы сможете воспользоваться всеми преимуществами официального API, включая надежность, поддержку и регулярные обновления.

    Если у вас возникнут дополнительные вопросы или потребуется помощь в доработке функциональности, пожалуйста, сообщите!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.