➡️Братан, вот мой код:
👉
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(
    filename="bot.log",
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

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

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
            )

            # Добавляем кнопки к первому сообщению группы
            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":
            # Копируем сообщение в целевой канал
            await context.bot.copy_message(
                chat_id=CHANNEL_ID,
                from_chat_id=PREP_CHANNEL_ID,
                message_id=message_id
            )

            # Если это альбом, получаем все сообщения альбома
            original_message = await context.bot.get_message(
                chat_id=PREP_CHANNEL_ID,
                message_id=message_id
            )

            if hasattr(original_message, 'media_group_id'):
                messages = await context.bot.get_media_group(
                    chat_id=PREP_CHANNEL_ID,
                    message_id=message_id
                )
                for msg in messages:
                    await context.bot.copy_message(
                        chat_id=CHANNEL_ID,
                        from_chat_id=PREP_CHANNEL_ID,
                        message_id=msg.message_id
                    )

            # Удаляем кнопки после отправки
            await context.bot.edit_message_reply_markup(
                chat_id=PREP_CHANNEL_ID,
                message_id=message_id,
                reply_markup=None
            )

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

            # Если это сообщение с кнопками, удаляем и его
            if query.message.reply_to_message:
                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}")

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)

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

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

if __name__ == '__main__':
    main()
👈
🔓Твои предложения и рекомендации по улучшению кода🙏