I’m writing a bot that parses channels with a ban on copying through the Teleton client. It works with single messages + text, but does not see the media group. I tried different options.
In one, it downloads the media group from the next message.

Handler for aiogram

    if isinstance(result, dict):
        text = result['text']
        
        media_files = result.get('media_files', [])
    # Проверяем, есть ли медиафайлы для отправки
        if media_files:
            media_group = []
            for media_file_path in media_files:
                if os.path.exists(media_file_path):
                    logger.info(f'Подготовка медиафайла для отправки: {media_file_path}')
                    try:
                        # Определяем тип медиафайла по расширению
                        if media_file_path.endswith('.jpg') or media_file_path.endswith('.jpeg'):
                            media_group.append(types.InputMediaPhoto(media=FSInputFile(media_file_path), caption=""))
                        elif media_file_path.endswith('.mp4'):
                            media_group.append(types.InputMediaVideo(media=FSInputFile(media_file_path), caption=""))
                        elif media_file_path.endswith('.gif'):
                            media_group.append(type.InputMediaAnimation(media=FSInputFile(media_file_path), caption=""))
                        else:
                            logger.warning(f'Неизвестный тип медиафайла: {media_file_path}')
                    except Exception as e:
                        logger.error(f'Ошибка при создании InputMedia для {media_file_path}: {e}')

        # Отправляем медиагруппу, если она не пуста
        if media_group:
            try:
                # Отправляем медиагруппу
                sent_messages = await message.answer_media_group(media_group)
                logger.info(f'Медиагруппа отправлена успешно.')
                
                # Отправляем текст после медиагруппы
                if text:
                    try:
                        # Получаем ID последнего сообщения из медиагруппы
                        last_media_message_id = sent_messages[-1].message_id
                        # Отправляем текст
                        await message.answer(text, parse_mode='Markdown')
                        logger.info(f'Текст отправлен успешно.')
                    except Exception as e:
                        logger.error(f'Ошибка при отправке текста: {e}')
            except Exception as e:
                logger.error(f'Ошибка при отправке медиагруппы: {e}')

        if os.path.exists(media_file_path):
            logger.info(f'Удаление временного файла: {media_file_path}')
            os.remove(media_file_path)
        else:
            logger.warning(f'Не удалось удалить {media_file_path}, так как это не файл.')
    else:
        await message.answer("Медиа файл(ы) не найдены.")

Paths from this code are passed to the handler. And code for telethon Client

async def get_and_forward_message(phone, api_id, api_hash, post_link, chat_id):
    client = TelegramClient(f"sessions/{phone}", api_id, api_hash)

    try:
        await client.start()

        # Извлечение ID чата и ID сообщения из ссылки
        match = re.search(r'/c/(d+)/(d+)', post_link)
        if not match:
            logger.error("Ошибка: ссылка не соответствует ожидаемому формату.")
            return "Ошибка: ссылка не соответствует ожидаемому формату."

        channel_id = int(match.group(1))
        message_id = int(match.group(2))

        # Получение сущности канала
        entity = await client.get_entity(PeerChannel(channel_id))
        if not entity:
            logger.error("Ошибка: не удалось получить сущность канала.")
            return "Ошибка: не удалось получить сущность канала."

        # Получение сообщения из канала по ID
        message = await client.get_messages(entity, ids=message_id)
        if message:
            logger.info(f"Сообщение получено: {message.id}")

            # Сохранение текста сообщения в файл
            if message.text:
                text_file_name = 'message.txt'
                with open(text_file_name, 'w', encoding='utf-8') as f:
                    f.write(message.text)
                logger.info(f"Текстовое сообщение сохранено: {text_file_name}")

            # Сохранение медиа сообщений
            media_file_paths = []
            if message.media:
                if hasattr(message.media, 'document'):
                    file_name = message.media.document.attributes[0].file_name
                    logger.info(f"Найден медиафайл: {file_name}")
                    suffix = os.path.splitext(file_name)[1] or '.bin'
                    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp_file:
                        media_file_path = tmp_file.name
                    await client.download_media(message.media, media_file_path)
                    media_file_paths.append(media_file_path)
                    logger.info(f"Медиа файл сохранен: {media_file_path}")

                # Проверка наличия медиагруппы
                media_group_id = getattr(message, 'grouped_id', None)
                if media_group_id:
                    logger.info(f"Обработка медиагруппы с grouped_id: {media_group_id}")
                    messages_in_group = await client.get_messages(entity, ids=range(message_id - 9, message_id + 1))
                    for msg in messages_in_group:
                        if msg.grouped_id == media_group_id and msg.media:
                            if hasattr(msg.media, 'document'):
                                file_name = msg.media.document.attributes[0].file_name
                                suffix = os.path.splitext(file_name)[1] or '.bin'
                                with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp_file:
                                    media_file_path = tmp_file.name
                                await client.download_media(msg.media, media_file_path)
                                media_file_paths.append(media_file_path)
                                logger.info(f"Медиа файл из медиагруппы сохранен: {media_file_path}")

            if not media_file_paths:
                logger.warning("Медиа файлы не найдены.")

            return {
                "text": message.text,
                "media_files": media_file_paths
            }

        else:
            logger.error("Сообщение не найдено.")
            return "Сообщение не найдено."

    except Exception as e:
        logger.error(f"Ошибка при выполнении операции: {e}")
        return f"Ошибка при выполнении операции: {e}"

    finally:
        # Отключаем клиента
        await client.disconnect()

Returns Media files not found