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

Вот мой код: import os import asyncio import logging from collections import defaultdict…

  1. User

    Вот мой код: import os import asyncio import logging from collections import defaultdict from dotenv import load_dotenv from telethon import TelegramClient, events, Button

    Загрузка переменных окружения

    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")) INTERIM_CHAT_ID = int(os.getenv("INTERIM_CHAT_ID")) ALLOWED_USER_ID = int(os.getenv("ALLOWED_USER_ID"))

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

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

    Настройка логирования

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

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

    pending_albums = {} pending_messages = {} grouped_messages = defaultdict(list)

    ALBUM_TIMEOUT = 1.0

    @client.on(events.NewMessage(func=lambda e: e.is_private and e.sender_id == ALLOWED_USER_ID)) async def handle_message(event): message = event.message

    if message.text and message.text.startswith('/'):
        return
    
    if message.grouped_id:
        group_id = str(message.grouped_id)
        grouped_messages[group_id].append(message)
        if len(grouped_messages[group_id]) == 1:
            asyncio.create_task(schedule_group_send(group_id))
    else:
        # Отправляем само сообщение в промежуточный канал
        sent_message = await client.send_message(
            INTERIM_CHAT_ID,
            message
        )
    
        # Создаём инлайн-кнопки
        buttons = [
            [
                Button.inline("✅ Отправить", data=f"send_message:{message.id}"),
                Button.inline("❌ Отменить", data=f"cancel_message:{message.id}")
            ]
        ]
    
        # Отправляем сообщение с кнопками
        buttons_message = await client.send_message(
            INTERIM_CHAT_ID,
            "Выберите действие для сообщения:",
            buttons=buttons
        )
    
        pending_messages[message.id] = {
            'interim_message': sent_message,
            'buttons_message_id': buttons_message.id,
            'sender_id': message.sender_id,
            'message': message
        }
    await event.delete()
    

    async def schedule_group_send(group_id): await asyncio.sleep(ALBUM_TIMEOUT) if group_id in grouped_messages: messages = grouped_messages.pop(group_id)

        # Создаём списки для медиа и подписей
        media_list = [msg.media for msg in messages]
        caption = "\n".join([msg.text for msg in messages if msg.text])
    
        # Отправляем альбом в промежуточный канал как единое целое
        sent_messages = await client.send_file(
            INTERIM_CHAT_ID,
            media_list,
            caption=caption,
            silent=True
        )
    
        # Создаём инлайн-кнопки для альбома
        buttons = [
            [
                Button.inline("✅ Отправить", data=f"send_album:{group_id}"),
                Button.inline("❌ Отменить", data=f"cancel_album:{group_id}")
            ]
        ]
    
        # Отправляем сообщение с кнопками после альбома
        buttons_message = await client.send_message(
            INTERIM_CHAT_ID,
            "Выберите действие для альбома:",
            buttons=buttons
        )
    
        pending_albums[group_id] = {
            'message_ids': [msg.id for msg in sent_messages],
            'buttons_message_id': buttons_message.id,
            'sender_id': messages[0].sender_id,
            'messages': messages
        }
    
        # Удаляем исходные сообщения
        for msg in messages:
            await msg.delete()
    

    @client.on(events.CallbackQuery) async def callback_handler(event): data = event.data.decode('utf-8') if ':' not in data: return

    command, identifier = data.split(':', 1)
    
    if command in ['send_album', 'cancel_album']:
        pending = pending_albums.get(identifier)
        if not pending or pending['sender_id'] != event.sender_id:
            await event.answer("У вас нет доступа к этой функции.", alert=True)
            return
    
        if command == 'send_album':
            # Получаем изменённые сообщения из промежуточного канала
            interim_messages = await client.get_messages(
                INTERIM_CHAT_ID,
                ids=pending['message_ids']
            )
    
            media_list = [msg.media for msg in interim_messages]
            caption = "\n".join([msg.text for msg in interim_messages if msg.text])
    
            # Отправляем обновлённый альбом
            await client.send_file(
                CHANNEL_ID,
                media_list,
                caption=caption
            )
    
            # Удаляем сообщения альбома и кнопки
            await client.delete_messages(INTERIM_CHAT_ID, pending['message_ids'])
            await client.delete_messages(INTERIM_CHAT_ID, [pending['buttons_message_id']])
            del pending_albums[identifier]
            await event.answer("Альбом успешно отправлен в канал.", alert=True)
    
        elif command == 'cancel_album':
            # Удаляем сообщения альбома и кнопки
            await client.delete_messages(INTERIM_CHAT_ID, pending['message_ids'])
            await client.delete_messages(INTERIM_CHAT_ID, [pending['buttons_message_id']])
            del pending_albums[identifier]
            await event.answer("Отправка альбома отменена.", alert=True)
    
    elif command in ['send_message', 'cancel_message']:
        message_id = int(identifier)
        pending = pending_messages.get(message_id)
        if not pending or pending['sender_id'] != event.sender_id:
            await event.answer("У вас нет доступа к этой функции.", alert=True)
            return
    
        if command == 'send_message':
            # Получаем изменённое сообщение из промежуточного канала
            interim_message = await client.get_messages(
                INTERIM_CHAT_ID,
                ids=pending['interim_message'].id
            )
    
            # Отправляем сообщение как есть
            await client.send_message(
                CHANNEL_ID,
                interim_message
            )
    
            # Удаляем оба сообщения из промежуточного канала
            await client.delete_messages(INTERIM_CHAT_ID, [pending['interim_message'].id, pending['buttons_message_id']])
            del pending_messages[message_id]
            await event.answer("Сообщение отправлено в канал.", alert=True)
    
        elif command == 'cancel_message':
            # Удаляем оба сообщения
            await client.delete_messages(INTERIM_CHAT_ID, [pending['interim_message'].id, pending['buttons_message_id']])
            del pending_messages[message_id]
            await event.answer("Отправка отменена.", alert=True)
    

    print("Бот запущен!") client.run_until_disconnected() В промежуточном канале при изменение групповых альбомов и отправки в основной канал, некоторые форматирования пропадают. Я решил сделать так вот, всё работало, но теперь в основном канале показывает что переслано из промежуточного: import os import asyncio import logging from collections import defaultdict from dotenv import load_dotenv from telethon import TelegramClient, events, Button

    Загрузка переменных окружения

    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")) INTERIM_CHAT_ID = int(os.getenv("INTERIM_CHAT_ID")) ALLOWED_USER_ID = int(os.getenv("ALLOWED_USER_ID"))

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

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

    Настройка логирования

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

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

    pending_albums = {} pending_messages = {} grouped_messages = defaultdict(list)

    ALBUM_TIMEOUT = 1.0

    @client.on(events.NewMessage(func=lambda e: e.is_private and e.sender_id == ALLOWED_USER_ID)) async def handle_message(event): message = event.message

    if message.text and message.text.startswith('/'):
        return
    
    if message.grouped_id:
        group_id = str(message.grouped_id)
        grouped_messages[group_id].append(message)
        if len(grouped_messages[group_id]) == 1:
            asyncio.create_task(schedule_group_send(group_id))
    else:
        # Отправляем само сообщение в промежуточный канал
        sent_message = await client.send_message(
            INTERIM_CHAT_ID,
            message
        )
    
        # Создаём инлайн-кнопки
        buttons = [
            [
                Button.inline("✅ Отправить", data=f"send_message:{message.id}"),
                Button.inline("❌ Отменить", data=f"cancel_message:{message.id}")
            ]
        ]
    
        # Отправляем сообщение с кнопками
        buttons_message = await client.send_message(
            INTERIM_CHAT_ID,
            "Выберите действие для сообщения:",
            buttons=buttons
        )
    
        pending_messages[message.id] = {
            'interim_message': sent_message,
            'buttons_message_id': buttons_message.id,
            'sender_id': message.sender_id,
            'message': message
        }
    await event.delete()
    

    async def schedule_group_send(group_id): await asyncio.sleep(ALBUM_TIMEOUT) if group_id in grouped_messages: messages = grouped_messages.pop(group_id)

        # Создаём списки для медиа и подписей
        media_list = [msg.media for msg in messages]
        caption = "\n".join([msg.text for msg in messages if msg.text])
    
        # Отправляем альбом в промежуточный канал как единое целое
        sent_messages = await client.send_file(
            INTERIM_CHAT_ID,
            media_list,
            caption=caption,
            silent=True
        )
    
        # Создаём инлайн-кнопки для альбома
        buttons = [
            [
                Button.inline("✅ Отправить", data=f"send_album:{group_id}"),
                Button.inline("❌ Отменить", data=f"cancel_album:{group_id}")
            ]
        ]
    
        # Отправляем сообщение с кнопками после альбома
        buttons_message = await client.send_message(
            INTERIM_CHAT_ID,
            "Выберите действие для альбома:",
            buttons=buttons
        )
    
        pending_albums[group_id] = {
            'message_ids': [msg.id for msg in sent_messages],
            'buttons_message_id': buttons_message.id,
            'sender_id': messages[0].sender_id,
            'messages': messages
        }
    
        # Удаляем исходные сообщения
        for msg in messages:
            await msg.delete()
    

    @client.on(events.CallbackQuery) async def callback_handler(event): data = event.data.decode('utf-8') if ':' not in data: return

    command, identifier = data.split(':', 1)
    
    if command in ['send_album', 'cancel_album']:
        pending = pending_albums.get(identifier)
        if not pending or pending['sender_id'] != event.sender_id:
            await event.answer("У вас нет доступа к этой функции.", alert=True)
            return
    
        if command == 'send_album':
            # Пересылаем все сообщения альбома из промежуточного канала в основной канал
            await client.forward_messages(
                CHANNEL_ID,
                pending['message_ids'],
                from_peer=INTERIM_CHAT_ID
            )
    
            # Удаляем сообщения альбома и кнопки
            await client.delete_messages(INTERIM_CHAT_ID, pending['message_ids'])
            await client.delete_messages(INTERIM_CHAT_ID, [pending['buttons_message_id']])
            del pending_albums[identifier]
            await event.answer("Альбом успешно отправлен в канал.", alert=True)
    
        elif command == 'cancel_album':
            # Удаляем сообщения альбома и кнопки
            await client.delete_messages(INTERIM_CHAT_ID, pending['message_ids'])
            await client.delete_messages(INTERIM_CHAT_ID, [pending['buttons_message_id']])
            del pending_albums[identifier]
            await event.answer("Отправка альбома отменена.", alert=True)
    
    elif command in ['send_message', 'cancel_message']:
        message_id = int(identifier)
        pending = pending_messages.get(message_id)
        if not pending or pending['sender_id'] != event.sender_id:
            await event.answer("У вас нет доступа к этой функции.", alert=True)
            return
    
        if command == 'send_message':
            # Пересылаем сообщение из промежуточного канала в основной канал
            await client.forward_messages(
                CHANNEL_ID,
                pending['interim_message'].id,
                from_peer=INTERIM_CHAT_ID
            )
    
            # Удаляем оба сообщения из промежуточного канала
            await client.delete_messages(INTERIM_CHAT_ID, [pending['interim_message'].id, pending['buttons_message_id']])
            del pending_messages[message_id]
            await event.answer("Сообщение отправлено в канал.", alert=True)
    
        elif command == 'cancel_message':
            # Удаляем оба сообщения
            await client.delete_messages(INTERIM_CHAT_ID, [pending['interim_message'].id, pending['buttons_message_id']])
            del pending_messages[message_id]
            await event.answer("Отправка отменена.", alert=True)
    

    print("Бот запущен!") client.run_until_disconnected()

  2. Assistant

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

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

    Ниже приведены шаги и пример кода, которые помогут вам достичь этой цели:

    1. Извлечение содержимого исходного сообщения:

      • Для текстовых сообщений извлеките текст и его форматирование (сущности).
      • Для сообщений с мультимедиа извлеките медиафайлы и подписи (caption).
    2. Создание новых сообщений в основном канале:

      • Используйте методы send_message и send_file для отправки текста и мультимедиа соответственно.
      • Убедитесь, что используете правильный parse_mode (например, Markdown или HTML) для сохранения форматирования.
    3. Обработка групповых сообщений (альбомов):

      • Соберите все медиасообщения в альбом и отправьте их как единый альбом с объединенной подписью, если необходимо.
    4. Обновленный код: Ниже приведён обновленный код, который реализует вышеописанный подход. В этом коде мы избегаем использования forward_messages и вместо этого пересоздаём сообщения в основном канале, сохраняя оригинальное форматирование.

    import os
    import asyncio
    import logging
    from collections import defaultdict
    from dotenv import load_dotenv
    from telethon import TelegramClient, events, Button
    from telethon.tl.types import MessageEntityBold, MessageEntityItalic, MessageEntityCode, MessageEntityPre
    
    # Загрузка переменных окружения
    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"))
    INTERIM_CHAT_ID = int(os.getenv("INTERIM_CHAT_ID"))
    ALLOWED_USER_ID = int(os.getenv("ALLOWED_USER_ID"))
    
    # Инициализация клиента
    client = TelegramClient('bot', API_ID, API_HASH)
    client.start(bot_token=BOT_TOKEN)
    
    # Настройка логирования
    logging.basicConfig(filename="bot.log", level=logging.INFO)
    
    # Словари для хранения сообщений
    pending_albums = {}
    pending_messages = {}
    grouped_messages = defaultdict(list)
    
    ALBUM_TIMEOUT = 1.0
    
    def extract_caption(message):
        """Извлекает текст и форматирование из сообщения."""
        if not message.text:
            return "", None
        return message.text, message.entities
    
    @client.on(events.NewMessage(func=lambda e: e.is_private and e.sender_id == ALLOWED_USER_ID))
    async def handle_message(event):
        message = event.message
    
        if message.text and message.text.startswith('/'):
            return
    
        if message.grouped_id:
            group_id = str(message.grouped_id)
            grouped_messages[group_id].append(message)
            if len(grouped_messages[group_id]) == 1:
                asyncio.create_task(schedule_group_send(group_id))
        else:
            # Извлекаем текст и форматирование
            text, entities = extract_caption(message)
    
            # Отправляем само сообщение в промежуточный канал без форматирования
            sent_message = await client.send_message(
                INTERIM_CHAT_ID,
                text,
                entities=entities,
                file=message.media if message.media else None
            )
    
            # Создаём инлайн-кнопки
            buttons = [
                [
                    Button.inline("✅ Отправить", data=f"send_message:{message.id}"),
                    Button.inline("❌ Отменить", data=f"cancel_message:{message.id}")
                ]
            ]
    
            # Отправляем сообщение с кнопками
            buttons_message = await client.send_message(
                INTERIM_CHAT_ID,
                "Выберите действие для сообщения:",
                buttons=buttons
            )
    
            pending_messages[message.id] = {
                'interim_message_id': sent_message.id,
                'buttons_message_id': buttons_message.id,
                'sender_id': message.sender_id,
                'text': text,
                'entities': entities,
                'media': message.media
            }
        await event.delete()
    
    async def schedule_group_send(group_id):
        await asyncio.sleep(ALBUM_TIMEOUT)
        if group_id in grouped_messages:
            messages = grouped_messages.pop(group_id)
    
            # Извлекаем все медиа и тексты
            media_list = [msg.media for msg in messages if msg.media]
            captions = [msg.text for msg in messages if msg.text]
            combined_caption = "\n".join(captions)
    
            # Отправляем альбом в промежуточный канал
            # Если есть подпись, она прикрепляется к первому медиа
            sent_messages = await client.send_file(
                INTERIM_CHAT_ID,
                media_list,
                caption=combined_caption if combined_caption else None,
                silent=True
            )
    
            # Создаём инлайн-кнопки для альбома
            buttons = [
                [
                    Button.inline("✅ Отправить", data=f"send_album:{group_id}"),
                    Button.inline("❌ Отменить", data=f"cancel_album:{group_id}")
                ]
            ]
    
            # Отправляем сообщение с кнопками после альбома
            buttons_message = await client.send_message(
                INTERIM_CHAT_ID,
                "Выберите действие для альбома:",
                buttons=buttons
            )
    
            pending_albums[group_id] = {
                'message_ids': [msg.id for msg in sent_messages],
                'buttons_message_id': buttons_message.id,
                'sender_id': messages[0].sender_id,
                'media': media_list,
                'caption': combined_caption
            }
    
            # Удаляем исходные сообщения
            for msg in messages:
                await msg.delete()
    
    @client.on(events.CallbackQuery)
    async def callback_handler(event):
        data = event.data.decode('utf-8')
        if ':' not in data:
            return
    
        command, identifier = data.split(':', 1)
    
        if command in ['send_album', 'cancel_album']:
            pending = pending_albums.get(identifier)
            if not pending or pending['sender_id'] != event.sender_id:
                await event.answer("У вас нет доступа к этой функции.", alert=True)
                return
    
            if command == 'send_album':
                # Отправляем альбом как новое сообщение в основной канал
                if pending['media']:
                    await client.send_file(
                        CHANNEL_ID,
                        pending['media'],
                        caption=pending['caption'],
                        silent=True
                    )
    
                # Удаляем сообщения альбома и кнопки из промежуточного канала
                await client.delete_messages(INTERIM_CHAT_ID, pending['message_ids'])
                await client.delete_messages(INTERIM_CHAT_ID, [pending['buttons_message_id']])
                del pending_albums[identifier]
                await event.answer("Альбом успешно отправлен в канал.", alert=True)
    
            elif command == 'cancel_album':
                # Удаляем сообщения альбома и кнопки
                await client.delete_messages(INTERIM_CHAT_ID, pending['message_ids'])
                await client.delete_messages(INTERIM_CHAT_ID, [pending['buttons_message_id']])
                del pending_albums[identifier]
                await event.answer("Отправка альбома отменена.", alert=True)
    
        elif command in ['send_message', 'cancel_message']:
            message_id = int(identifier)
            pending = pending_messages.get(message_id)
            if not pending or pending['sender_id'] != event.sender_id:
                await event.answer("У вас нет доступа к этой функции.", alert=True)
                return
    
            if command == 'send_message':
                # Отправляем текстовое сообщение как новое сообщение в основной канал
                if pending['media']:
                    # Если есть медиа, отправляем его с подписью
                    await client.send_file(
                        CHANNEL_ID,
                        pending['media'],
                        caption=pending['text'],
                        parse_mode='html'  # Или 'markdown', в зависимости от формата
                    )
                else:
                    # Если только текст, отправляем текст с сохранёнными сущностями
                    await client.send_message(
                        CHANNEL_ID,
                        pending['text'],
                        parse_mode='html'  # Или используйте entities, если необходимо
                    )
    
                # Удаляем оба сообщения из промежуточного канала
                await client.delete_messages(INTERIM_CHAT_ID, [pending['interim_message_id'], pending['buttons_message_id']])
                del pending_messages[message_id]
                await event.answer("Сообщение отправлено в канал.", alert=True)
    
            elif command == 'cancel_message':
                # Удаляем оба сообщения
                await client.delete_messages(INTERIM_CHAT_ID, [pending['interim_message_id'], pending['buttons_message_id']])
                del pending_messages[message_id]
                await event.answer("Отправка отменена.", alert=True)
    
    print("Бот запущен!")
    client.run_until_disconnected()
    

    Пояснения к обновленному коду:

    1. Извлечение содержимого сообщений:

      • Функция extract_caption извлекает текст и сущности (форматирование) из сообщения. Это позволяет сохранить форматирование при пересылке.
    2. Отправка новых сообщений:

      • Вместо forward_messages используем send_message и send_file для создания новых сообщений в основном канале.
      • При отправке текстовых сообщений указываем parse_mode (например, 'html' или 'markdown') для сохранения форматирования.
      • При отправке медиафайлов сохраняем подпись (caption), объединённую из всех сообщений альбома.
    3. Обработка альбомов:

      • Собираем все медиафайлы из групповых сообщений и отправляем их как единый альбом в основной канал.
      • Подписи к альбому формируются объединением текстов всех сообщений группы.
    4. Удаление промежуточных сообщений:

      • После успешной отправки или отмены удаления соответствующих сообщений из промежуточного канала для поддержания чистоты.

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

    • Сохранение формата при отправке: Убедитесь, что вы правильно указываете parse_mode при отправке сообщений. Если исходные сообщения используют Markdown, установите parse_mode='markdown', если HTML — parse_mode='html'. Это позволит сохранить все форматирования (жирный, курсив, ссылки и т.д.).

    • Обработка сущностей вручную: Если вам необходимо более тонкое управление форматированием, вы можете передавать сущности напрямую при отправке сообщения:

      await client.send_message(
          CHANNEL_ID,
          pending['text'],
          entities=pending['entities'],
          parse_mode=None  # Отключаем автоматический парсинг
      )
      

      Однако это может потребовать дополнительной обработки и тестирования.

    • Логирование и отладка: Убедитесь, что вы проверяете лог-файл bot.log на наличие возможных ошибок или предупреждений, которые могут помочь в отладке и улучшении функциональности бота.

    • Тестирование: Перед развертыванием на продакшене протестируйте бота с различными типами сообщений (текст, форматированный текст, медиафайлы, альбомы) чтобы убедиться, что все они правильно пересылаются и форматируются в основном канале.

    Заключение

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