Вот мой код:
import os
import logging
import re
import asyncio
from telegram import (
    Update, InlineKeyboardButton, InlineKeyboardMarkup, InputMediaPhoto,
    InputMediaVideo, InputMediaDocument, InputMediaAnimation
)
from telegram.ext import (
    ApplicationBuilder, ContextTypes, MessageHandler,
    CallbackQueryHandler, filters
)
from dotenv import load_dotenv

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

# Получение настроек из .env файла
BOT_TOKEN = os.getenv("BOT_TOKEN")
CHANNEL_ID = int(os.getenv("CHANNEL_ID"))  # Целевой канал
PREP_CHANNEL_ID = int(os.getenv("PREP_CHANNEL_ID"))  # Приватный канал для редактирования
ALLOWED_USER_ID = int(os.getenv("ALLOWED_USER_ID"))
MAX_CAPTION_LENGTH = 1024
GROUP_DELAY = 2  # Задержка для группировки медиа
MAX_RETRIES = 3
RETRY_DELAY = 2

# Настройка логирования
logging.basicConfig(
    filename="bot.log",
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

# Словари для хранения данных
grouped_messages = {}
scheduled_tasks = {}

# Глобальный словарь для хранения групп сообщений
# prep_group_map[button_message_id] = {
#     "media_data": [InputMedia...],
#     "message_ids": [int, int, ...]
# }
prep_group_map = {}

def clean_text(text):
    """Удаляет упоминания и хэштеги из текста."""
    if not text:
        return ""
    return re.sub(r'@\w+|#\w+', '', text, flags=re.IGNORECASE)

def get_action_buttons(button_id: int, is_album: bool = False):
    """Создает кнопки действий."""
    keyboard = [[
        InlineKeyboardButton("✅ Отправить", callback_data=f"send:{button_id}"),
        InlineKeyboardButton("❌ Отменить", callback_data=f"cancel:{button_id}")
    ]]
    return InlineKeyboardMarkup(keyboard)

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработчик всех входящих сообщений."""
    if update.effective_user.id != ALLOWED_USER_ID:
        await update.message.reply_text("У вас нет доступа к использованию этого бота.")
        return

    message = update.message

    try:
        if message.media_group_id:
            group_id = message.media_group_id
            if group_id not in grouped_messages:
                grouped_messages[group_id] = []
                scheduled_tasks[group_id] = asyncio.create_task(
                    process_media_group(group_id, context)
                )
            grouped_messages[group_id].append(message)
        else:
            await process_single_message(message, context)

        # Удаляем исходное сообщение
        await context.bot.delete_message(
            chat_id=message.chat_id,
            message_id=message.message_id
        )
    except Exception as e:
        logger.error(f"Ошибка в handle_message: {e}")

async def process_media_group(group_id: str, context: ContextTypes.DEFAULT_TYPE):
    """Обработка медиа-группы."""
    await asyncio.sleep(GROUP_DELAY)  # Ожидаем, чтобы собрать все сообщения группы

    try:
        messages = grouped_messages.pop(group_id, [])
        if not messages:
            return

        # Сортируем сообщения по message_id для сохранения порядка
        messages.sort(key=lambda x: x.message_id)
        media = []
        caption_set = False

        for msg in messages:
            media_item = None
            # Используем только первую подпись
            caption = clean_text(msg.caption_html) if not caption_set and (msg.caption or msg.caption_html) else None

            if msg.photo:
                media_item = InputMediaPhoto(
                    media=msg.photo[-1].file_id,
                    caption=caption if not caption_set else None,
                    parse_mode='HTML'
                )
            elif msg.video:
                media_item = InputMediaVideo(
                    media=msg.video.file_id,
                    caption=caption if not caption_set else None,
                    parse_mode='HTML'
                )
            elif msg.document:
                media_item = InputMediaDocument(
                    media=msg.document.file_id,
                    caption=caption if not caption_set else None,
                    parse_mode='HTML'
                )
            elif msg.animation:
                media_item = InputMediaAnimation(
                    media=msg.animation.file_id,
                    caption=caption if not caption_set else None,
                    parse_mode='HTML'
                )
            else:
                logger.info(f"Unsupported media type in group: {msg}")
                continue  # Пропускаем неподдерживаемые типы медиа

            if media_item:
                media.append(media_item)
                if caption:
                    caption_set = True  # Устанавливаем, что подпись уже использована

        if media:
            sent_messages = await context.bot.send_media_group(
                chat_id=PREP_CHANNEL_ID,
                media=media
            )

            # Собираем данные для дальнейшей пересылки
            media_data = []
            message_ids = []

            for sent_msg in sent_messages:
                if sent_msg.photo:
                    media_data.append(InputMediaPhoto(
                        media=sent_msg.photo[-1].file_id,
                        caption=sent_msg.caption or '',
                        parse_mode='HTML'
                    ))
                elif sent_msg.video:
                    media_data.append(InputMediaVideo(
                        media=sent_msg.video.file_id,
                        caption=sent_msg.caption or '',
                        parse_mode='HTML'
                    ))
                elif sent_msg.document:
                    media_data.append(InputMediaDocument(
                        media=sent_msg.document.file_id,
                        caption=sent_msg.caption or '',
                        parse_mode='HTML'
                    ))
                elif sent_msg.animation:
                    media_data.append(InputMediaAnimation(
                        media=sent_msg.animation.file_id,
                        caption=sent_msg.caption or '',
                        parse_mode='HTML'
                    ))
                # Можно добавить другие типы медиа при необходимости

                message_ids.append(sent_msg.message_id)

            # Сохраняем данные группы, используя message_id первого сообщения как ключ
            prep_group_map[sent_messages[0].message_id] = {
                "media_data": media_data,
                "message_ids": message_ids
            }

            # Добавляем кнопки действий к первому сообщению группы
            await context.bot.send_message(
                chat_id=PREP_CHANNEL_ID,
                text="Действия с альбомом:",
                reply_to_message_id=sent_messages[0].message_id,
                reply_markup=get_action_buttons(sent_messages[0].message_id, True)
            )

    except Exception as e:
        logger.error(f"Ошибка в process_media_group: {e}")
    finally:
        scheduled_tasks.pop(group_id, None)

async def process_single_message(message, context):
    """Обработка одиночного сообщения."""
    try:
        caption = clean_text(message.caption_html if message.caption else '')
        sent_message = None

        if message.photo:
            sent_message = await context.bot.send_photo(
                chat_id=PREP_CHANNEL_ID,
                photo=message.photo[-1].file_id,
                caption=caption,
                parse_mode='HTML'
            )
        elif message.video:
            sent_message = await context.bot.send_video(
                chat_id=PREP_CHANNEL_ID,
                video=message.video.file_id,
                caption=caption,
                parse_mode='HTML'
            )
        elif message.document:
            sent_message = await context.bot.send_document(
                chat_id=PREP_CHANNEL_ID,
                document=message.document.file_id,
                caption=caption,
                parse_mode='HTML'
            )
        elif message.animation:
            sent_message = await context.bot.send_animation(
                chat_id=PREP_CHANNEL_ID,
                animation=message.animation.file_id,
                caption=caption,
                parse_mode='HTML'
            )
        elif message.audio:
            sent_message = await context.bot.send_audio(
                chat_id=PREP_CHANNEL_ID,
                audio=message.audio.file_id,
                caption=caption,
                parse_mode='HTML'
            )
        elif message.voice:
            sent_message = await context.bot.send_voice(
                chat_id=PREP_CHANNEL_ID,
                voice=message.voice.file_id,
                caption=caption,
                parse_mode='HTML'
            )
        elif message.video_note:
            sent_message = await context.bot.send_video_note(
                chat_id=PREP_CHANNEL_ID,
                video_note=message.video_note.file_id
            )
        elif message.text:
            sent_message = await context.bot.send_message(
                chat_id=PREP_CHANNEL_ID,
                text=message.text,
                parse_mode='HTML'
            )

        if sent_message:
            # Подготавливаем данные для пересылки
            media_data = []
            message_ids = [sent_message.message_id]

            if sent_message.photo:
                media_data.append(InputMediaPhoto(
                    media=sent_message.photo[-1].file_id,
                    caption=sent_message.caption or '',
                    parse_mode='HTML'
                ))
            elif sent_message.video:
                media_data.append(InputMediaVideo(
                    media=sent_message.video.file_id,
                    caption=sent_message.caption or '',
                    parse_mode='HTML'
                ))
            elif sent_message.document:
                media_data.append(InputMediaDocument(
                    media=sent_message.document.file_id,
                    caption=sent_message.caption or '',
                    parse_mode='HTML'
                ))
            elif sent_message.animation:
                media_data.append(InputMediaAnimation(
                    media=sent_message.animation.file_id,
                    caption=sent_message.caption or '',
                    parse_mode='HTML'
                ))
            # Для аудио, голосовых сообщений и видеозаметок они не входят в медиагруппу
            else:
                media_data = []

            # Сохраняем данные сообщения
            prep_group_map[sent_message.message_id] = {
                "media_data": media_data,
                "message_ids": message_ids
            }

            # Добавляем кнопки действий
            await context.bot.edit_message_reply_markup(
                chat_id=PREP_CHANNEL_ID,
                message_id=sent_message.message_id,
                reply_markup=get_action_buttons(sent_message.message_id)
            )

    except Exception as e:
        logger.error(f"Ошибка в process_single_message: {e}")

async def button_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработчик нажатий на кнопки."""
    query = update.callback_query
    await query.answer()

    try:
        action, button_id = query.data.split(':')
        button_id = int(button_id)

        group_info = prep_group_map.get(button_id)

        if not group_info:
            await query.message.reply_text("Нет данных для обработки.")
            return

        if action == "send":
            media_data = group_info["media_data"]
            message_ids = group_info["message_ids"]

            if media_data:
                try:
                    # Если группа, отправляем её
                    if len(media_data) > 1:
                        await context.bot.send_media_group(
                            chat_id=CHANNEL_ID,
                            media=media_data
                        )
                    elif len(media_data) == 1:
                        media_item = media_data[0]
                        if isinstance(media_item, InputMediaPhoto):
                            await context.bot.send_photo(
                                chat_id=CHANNEL_ID,
                                photo=media_item.media,
                                caption=media_item.caption,
                                parse_mode='HTML'
                            )
                        elif isinstance(media_item, InputMediaVideo):
                            await context.bot.send_video(
                                chat_id=CHANNEL_ID,
                                video=media_item.media,
                                caption=media_item.caption,
                                parse_mode='HTML'
                            )
                        elif isinstance(media_item, InputMediaDocument):
                            await context.bot.send_document(
                                chat_id=CHANNEL_ID,
                                document=media_item.media,
                                caption=media_item.caption,
                                parse_mode='HTML'
                            )
                        elif isinstance(media_item, InputMediaAnimation):
                            await context.bot.send_animation(
                                chat_id=CHANNEL_ID,
                                animation=media_item.media,
                                caption=media_item.caption,
                                parse_mode='HTML'
                            )
                    # Если media_data пусто, предположим, что сообщение текстовое или другой тип без медиа
                    else:
                        # Отправка текстовых сообщений отдельно
                        for msg_id in message_ids:
                            original_message = await context.bot.get_message(
                                chat_id=PREP_CHANNEL_ID,
                                message_id=msg_id
                            )
                            if original_message.text:
                                await context.bot.send_message(
                                    chat_id=CHANNEL_ID,
                                    text=original_message.text,
                                    parse_mode='HTML'
                                )
                except Exception as send_e:
                    logger.error(f"Ошибка при отправке группы: {send_e}")

                # После отправки, удаляем кнопки
                for msg_id in message_ids:
                    try:
                        await context.bot.edit_message_reply_markup(
                            chat_id=PREP_CHANNEL_ID,
                            message_id=msg_id,
                            reply_markup=None
                        )
                    except Exception as e:
                        logger.error(f"Ошибка при удалении кнопок: {e}")

            else:
                # Для сообщений без медиа (текстовых), отправляем текст отдельно
                for msg_id in message_ids:
                    try:
                        original_message = await context.bot.get_message(
                            chat_id=PREP_CHANNEL_ID,
                            message_id=msg_id
                        )
                        if original_message.text:
                            await context.bot.send_message(
                                chat_id=CHANNEL_ID,
                                text=original_message.text,
                                parse_mode='HTML'
                            )
                    except Exception as e:
                        logger.error(f"Ошибка при отправке текстового сообщения: {e}")

            # Удаляем запись из prep_group_map
            prep_group_map.pop(button_id, None)

        elif action == "cancel":
            message_ids = group_info["message_ids"]

            for msg_id in message_ids:
                try:
                    await context.bot.delete_message(
                        chat_id=PREP_CHANNEL_ID,
                        message_id=msg_id
                    )
                except Exception as e:
                    logger.error(f"Ошибка при удалении сообщения: {e}")

            # Также удаляем сообщение с кнопками, если оно отдельное
            if query.message.message_id != button_id:
                try:
                    await context.bot.delete_message(
                        chat_id=PREP_CHANNEL_ID,
                        message_id=query.message.message_id
                    )
                except Exception as e:
                    logger.error(f"Ошибка при удалении сообщения с кнопками: {e}")

            # Удаляем запись из prep_group_map
            prep_group_map.pop(button_id, None)

    except Exception as e:
        logger.error(f"Ошибка в button_callback: {e}")

async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE):
    """Обработчик ошибок."""
    logger.error(msg="Exception while handling an update:", exc_info=context.error)

def main():
    """Основная функция для запуска бота."""
    try:
        application = ApplicationBuilder().token(BOT_TOKEN).build()

        # Обработчики
        application.add_handler(MessageHandler(filters.ALL, handle_message))
        application.add_handler(CallbackQueryHandler(button_callback))
        application.add_error_handler(error_handler)

        # Запуск бота
        logger.info("Бот запущен")
        application.run_polling()

    except Exception as e:
        logger.error(f"Ошибка при запуске бота: {e}")

if __name__ == '__main__':
    main()
➡️При отправки в основной канал, в основном канале абсолютно все до единого форматирования пропали, просто пустой текст.