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

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

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(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Словари для хранения данных
grouped_messages = {}
scheduled_tasks = {}
media_groups = {}  # Словарь для хранения медиагрупп

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

def get_action_buttons(message_id: int, is_album: bool = False):
    """Создает кнопки действий."""
    keyboard = [[
        InlineKeyboardButton("✅ Отправить", callback_data=f"send:{message_id}"),
        InlineKeyboardButton("❌ Отменить", callback_data=f"cancel:{message_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

        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) else None

            if msg.photo:
                media_item = InputMediaPhoto(
                    media=msg.photo[-1].file_id,
                    caption=caption,
                    parse_mode='HTML'
                )
            elif msg.video:
                media_item = InputMediaVideo(
                    media=msg.video.file_id,
                    caption=caption,
                    parse_mode='HTML'
                )
            elif msg.document:
                media_item = InputMediaDocument(
                    media=msg.document.file_id,
                    caption=caption,
                    parse_mode='HTML'
                )

            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_groups[sent_messages[0].message_id] = sent_messages

            # Добавляем кнопки к первому сообщению группы
            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.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.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.text:
            sent_message = await context.bot.send_message(
                chat_id=PREP_CHANNEL_ID,
                text=message.text,
                parse_mode='HTML'
            )

        if sent_message:
            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, message_id = query.data.split(':')
        message_id = int(message_id)

        if action == "send":
            if message_id in media_groups:
                # Это медиагруппа
                messages = media_groups[message_id]

                # Создаём список объектов InputMedia с обновлённой информацией
                media = []
                for msg in messages:
                    media_item = None
                    caption = clean_text(msg.caption_html) if msg.caption else None

                    if msg.photo:
                        media_item = InputMediaPhoto(
                            media=msg.photo[-1].file_id,
                            caption=caption,
                            parse_mode='HTML'
                        )
                    elif msg.video:
                        media_item = InputMediaVideo(
                            media=msg.video.file_id,
                            caption=caption,
                            parse_mode='HTML'
                        )
                    elif msg.document:
                        media_item = InputMediaDocument(
                            media=msg.document.file_id,
                            caption=caption,
                            parse_mode='HTML'
                        )

                    if media_item:
                        media.append(media_item)

                if media:
                    # Отправляем медиагруппу в целевой канал
                    await context.bot.send_media_group(
                        chat_id=CHANNEL_ID,
                        media=media
                    )

                # Удаляем информацию о медиагруппе из словаря
                del media_groups[message_id]

                # Удаляем сообщение с кнопками
                await context.bot.delete_message(
                    chat_id=PREP_CHANNEL_ID,
                    message_id=query.message.message_id
                )

                # Удаляем все сообщения медиагруппы из канала подготовки
                for msg in messages:
                    await context.bot.delete_message(
                        chat_id=PREP_CHANNEL_ID,
                        message_id=msg.message_id
                    )

            else:
                # Это одиночное сообщение
                # Копируем сообщение в целевой канал
                await context.bot.copy_message(
                    chat_id=CHANNEL_ID,
                    from_chat_id=PREP_CHANNEL_ID,
                    message_id=message_id
                )

                # Удаляем сообщение с кнопками
                await context.bot.delete_message(
                    chat_id=PREP_CHANNEL_ID,
                    message_id=query.message.message_id
                )

                # Удаляем оригинальное сообщение из канала подготовки
                await context.bot.delete_message(
                    chat_id=PREP_CHANNEL_ID,
                    message_id=message_id
                )

        elif action == "cancel":
            if message_id in media_groups:
                # Удаляем все сообщения медиагруппы из канала подготовки
                messages = media_groups[message_id]
                for msg in messages:
                    await context.bot.delete_message(
                        chat_id=PREP_CHANNEL_ID,
                        message_id=msg.message_id
                    )

                # Удаляем информацию о медиагруппе из словаря
                del media_groups[message_id]
            else:
                # Удаляем одиночное сообщение из канала подготовки
                await context.bot.delete_message(
                    chat_id=PREP_CHANNEL_ID,
                    message_id=message_id
                )

            # Удаляем сообщение с кнопками
            await context.bot.delete_message(
                chat_id=PREP_CHANNEL_ID,
                message_id=query.message.message_id
            )

    except Exception as e:
        logger.error(f"Ошибка в button_callback: {e}")
        # Сообщение пользователю об ошибке
        await query.message.reply_text(f"Произошла ошибка: {e}")

async def handle_edited_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработчик редактирования сообщений в канале подготовки."""
    message = update.edited_message
    chat_id = message.chat_id
    message_id = message.message_id

    # Проверяем, что сообщение из канала подготовки
    if chat_id != PREP_CHANNEL_ID:
        return

    # Обновляем информацию в media_groups
    for group_key, group_messages in media_groups.items():
        for idx, msg in enumerate(group_messages):
            if msg.message_id == message_id:
                # Обновляем сообщение в медиагруппе
                media_groups[group_key][idx] = message
                return

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_handler(MessageHandler(filters.UpdateType.EDITED_MESSAGE, handle_edited_message))
        application.add_error_handler(error_handler)

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

    except KeyboardInterrupt:
        logger.info("Бот остановлен пользователем (Ctrl+C)")
    except Exception as e:
        logger.error(f"Ошибка при запуске бота: {e}")

if __name__ == '__main__':
    main()
➡️Я не понимаю в чем дело, но при изменении(редактировании) в промежуточном канале и отправки в основной канал, в основном канале пост без изменений.