Хочу написать телеграм бота который будет считать ...

Ниже описан один из вариантов архитектуры и реализации такого Telegram-бота, который решает поставленные задачи. Основная идея состоит в следующем:

---

1. Основной функционал бота

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

• Обновляемое сообщение:
  После добавления бота с полными правами в канал администратор передаёт ссылку на сообщение (или создаёт новое), которое бот будет редактировать каждые 5 минут. В этом сообщении используется шаблон, содержащий переменные:

  • {{count}} — общее количество файлов.
  • {{size}} — общий размер файлов (можно форматировать, например, в КБ, МБ, ГБ).

• Редактирование шаблона:
  Команда /edit позволит изменить формат сообщения, подставляя нужные переменные. Можно реализовать сохранение настроек (например, в базе данных или JSON-файле), чтобы бот знал, какой формат использовать для каждого канала.

---

2. Дополнительные возможности для администрирования и автоматизации

• Инлайн кнопки и поиск:
  Помимо основного сообщения, можно добавить инлайн кнопку «Поиск». При нажатии пользователь переходит к боту, который предлагает расширенный поиск по файлам канала. Для улучшения поиска можно реализовать замену символов (английские ↔ русские) и другие манипуляции со строкой запроса, чтобы находить файлы даже при орфографических ошибках или различиях в раскладке.

• Кастомизация кнопок:
  Администратор может задавать свои кастомные инлайн кнопки, которые будут отображаться в обновляемом сообщении. Каждая кнопка может быть как с URL-ссылкой, так и с callback-данными для вызова определённого запроса (например, чтобы бот запускал поиск с предопределённым запросом).

• Мультиканальность:
  Бот должен работать сразу с несколькими каналами. Для этого можно реализовать систему настроек, где каждому каналу соответствует свой конфигурационный набор (ID канала, ID редактируемого сообщения, формат шаблона, набор кнопок, настройки поиска и т.п.).

• Команда /start:
  При старте бот отправляет справку по доступным командам и объясняет, как настроить обновляемое сообщение, как добавить/удалить кнопки, как воспользоваться поиском и прочими функциями.

---

3. Пример архитектуры и ключевых компонентов

A. Хранение настроек

Можно использовать простую базу данных (например, SQLite) или JSON-файл для хранения:

• ID канала.
• ID сообщения для обновления.
• Шаблон сообщения (например, "Всего файлов: {{count}}\nОбщий размер: {{size}}").
• Список кастомных инлайн кнопок (их тип — URL или callback, текст кнопки, дополнительные параметры).
• Флаг включения/выключения кнопки поиска.

B. Расписание обновлений

Используйте библиотеку, например, встроенный job queue (если используете python-telegram-bot) или APScheduler. Задача должна:

• Периодически (каждые 5 минут) получать настройки для каждого канала.
• Перебирать сообщения канала (при необходимости можно кешировать результаты, если канал большой, или использовать Telegram API для поиска документов).
• Подставлять актуальные значения в шаблон и вызывать метод editMessageText для обновления указанного сообщения.

C. Обработка команд

• /start:
  Отправляет справочное сообщение с описанием основных возможностей бота, инструкциями по настройке и кратким описанием доступных инлайн кнопок.

• /edit:
  Позволяет администратору изменить формат сообщения, настройки кнопок или параметры поиска. Здесь можно реализовать диалог (например, через последовательность сообщений или inline-опрос) для редактирования.

• Дополнительные админ-команды:
  Команды для включения/отключения кнопки «Поиск», добавления/удаления кастомных кнопок, изменения интервала обновления (если потребуется) и т.п.

D. Поиск по файлам

При нажатии на кнопку «Поиск» бот должен:

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

---

4. Пример кода (псевдокод на Python)

Ниже приведён упрощённый пример, демонстрирующий базовую идею (используйте библиотеку python-telegram-bot или [aiogram]):

python
import logging
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Updater, CommandHandler, CallbackContext, CallbackQueryHandler, JobQueue

# Словарь для хранения настроек канала (в реальности лучше использовать базу данных)
channel_settings = {
    # пример:
    # channel_id: {
    #     'message_id': <id сообщения для обновления>,
    #     'template': "Всего файлов: {{count}}\nОбщий размер: {{size}}",
    #     'custom_buttons': [ {'text': 'Поиск', 'callback_data': 'search'} ],
    #     'search_enabled': True,
    # }
}

def start(update: Update, context: CallbackContext):
    help_text = (
        "Привет! Я бот для автоматизации канала.\n\n"
        "Доступные команды:\n"
        "/start - справка\n"
        "/edit - изменить формат сообщения или настройки\n"
        "\n"
        "Добавьте меня в канал с правами администратора и укажите сообщение, которое нужно обновлять."
    )
    update.message.reply_text(help_text)

def edit(update: Update, context: CallbackContext):
    # Здесь реализуйте диалог для изменения шаблона и кнопок
    update.message.reply_text("Введите новый шаблон сообщения с переменными {{count}} и {{size}}:")

def update_channel_message(context: CallbackContext):
    # Функция, вызываемая каждые 5 минут для каждого канала
    for channel_id, settings in channel_settings.items():
        # Здесь можно добавить логику для получения всех сообщений канала,
        # перебора файлов и подсчёта их общего количества и размера.
        count = 123  # пример
        size = "456 MB"  # пример
        # Подстановка значений в шаблон:
        text = settings['template'].replace("{{count}}", str(count)).replace("{{size}}", str(size))
        
        # Создаем инлайн-кнопки
        buttons = []
        if settings.get('search_enabled'):
            buttons.append(InlineKeyboardButton("Поиск", callback_data="search"))
        # Добавляем кастомные кнопки
        for btn in settings.get('custom_buttons', []):
            buttons.append(InlineKeyboardButton(btn['text'], callback_data=btn.get('callback_data', '')))
        
        reply_markup = InlineKeyboardMarkup([buttons]) if buttons else None
        
        try:
            context.bot.edit_message_text(
                chat_id=channel_id,
                message_id=settings['message_id'],
                text=text,
                reply_markup=reply_markup
            )
        except Exception as e:
            logging.error(f"Ошибка обновления сообщения в канале {channel_id}: {e}")

def button_callback(update: Update, context: CallbackContext):
    query = update.callback_query
    query.answer()
    
    if query.data == "search":
        # Обработка запроса поиска: перенаправляем пользователя к боту для ввода запроса
        query.message.reply_text("Введите запрос для поиска файлов:")
    else:
        query.message.reply_text("Неизвестное действие.")

def main():
    # Инициализация бота (укажите токен)
    updater = Updater("YOUR_TELEGRAM_BOT_TOKEN", use_context=True)
    dp = updater.dispatcher
    
    dp.add_handler(CommandHandler("start", start))
    dp.add_handler(CommandHandler("edit", edit))
    dp.add_handler(CallbackQueryHandler(button_callback))
    
    # Запускаем обновление сообщений каждые 5 минут
    job_queue: JobQueue = updater.job_queue
    job_queue.run_repeating(update_channel_message, interval=300, first=10)
    
    updater.start_polling()
    updater.idle()

if __name__ == '__main__':
    main()

Примечание: Этот пример носит ознакомительный характер. Для полноценной реализации нужно:

• Реализовать корректный сбор файлов из канала (учитывая ограничения API Telegram).
• Обеспечить сохранение настроек для мультиканальной работы (например, использовать базу данных).
• Расширить логику обработки инлайн кнопок, добавить кастомизацию и улучшенную обработку поиска с заменой символов.
• Добавить обработку ошибок и логирование.

---

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

• Многоканальность:
  При привязке настроек к каждому каналу обязательно сохраняйте уникальный идентификатор канала (например, chat_id) и свяжите с ним все параметры. Это позволит одновременно обслуживать несколько каналов.

• Безопасность и права:
  Убедитесь, что бот имеет все необходимые права администратора в канале для редактирования сообщений. Также следует проверить, что команды выполняют только администраторы канала.

• Расширение функционала поиска:
  Для улучшенного поиска можно использовать алгоритмы нормализации текста (например, транслитерацию) и регулярные выражения для сопоставления строк. Возможно, стоит добавить кэширование списка файлов, чтобы не опрашивать канал каждый раз.

• Инлайн кнопки и кастомизация:
  Предусмотрите возможность администратору настраивать набор кнопок через команды (например, /addbutton, /removebutton). Каждая кнопка может иметь два типа: переход по ссылке или выполнение callback-запроса.

• Документация и помощь:
  Команда /start должна подробно описывать все команды и возможности, а также предоставлять ссылки на справочные материалы, если они нужны.

---

Таким образом, основная идея заключается в регулярном сборе статистики по файлам в канале, динамической подстановке данных в заранее заданный шаблон и обновлении сообщения с дополнительными элементами управления (инлайн кнопками). Такой подход позволяет создавать гибкий и масштабируемый инструмент для автоматизации работы с каналами в Telegram.

Ниже приведён полный пример исправленного скрипта, написанного без сокращений и с подробными комментариями. В этом варианте предполагается, что каналов не будет много (2–4), поэтому настройки хранятся в простом словаре, а обновление сообщения происходит каждые 5 минут. Учтите, что для полноценной работы необходимо доработать функции для получения списка файлов из канала, а также реализовать дополнительные проверки прав администратора и обработку ошибок. Вы можете расширять функционал (например, добавлять свои кастомные инлайн-кнопки) по мере необходимости.

python
#!/usr/bin/env python3
import logging
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import (Updater, CommandHandler, CallbackContext,
                          CallbackQueryHandler, ConversationHandler,
                          MessageHandler, Filters)
import time

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

# Глобальный словарь для хранения настроек каналов.
# Ключ словаря — идентификатор канала, значение — словарь с настройками.
# Настройки включают:
#   'channel_id'       — идентификатор канала (число, например, -1001234567890);
#   'message_id'       — идентификатор сообщения, которое бот будет обновлять;
#   'template'         — шаблон текста сообщения, в котором используются переменные:
#                        {{count}} для количества файлов и {{size}} для общего размера файлов;
#   'custom_buttons'   — список пользовательских кнопок, каждая кнопка представлена словарём с ключами:
#                        'text' (текст кнопки), и либо 'callback_data' для обратного вызова,
#                        либо 'url' для перехода по ссылке;
#   'search_enabled'   — булево значение, определяющее, будет ли добавляться кнопка «Поиск».
channel_settings = {
    # Пример настроек для канала:
    # -1001234567890: {
    #     'channel_id': -1001234567890,
    #     'message_id': 123,
    #     'template': "Всего файлов: {{count}}\nОбщий размер: {{size}}",
    #     'custom_buttons': [
    #         {'text': 'Поиск', 'callback_data': 'search'},
    #         {'text': 'Сайт', 'url': 'https://example.com'}
    #     ],
    #     'search_enabled': True,
    # }
}

# Определяем состояния для диалога команды /edit
STATE_WAIT_CHANNEL_ID = 1
STATE_WAIT_MESSAGE_ID = 2
STATE_WAIT_TEMPLATE_TEXT = 3

def start_command_handler(update: Update, context: CallbackContext) -> None:
    """
    Обработчик команды /start.
    Отправляет справочное сообщение с инструкциями по использованию бота.
    """
    help_message = (
        "Здравствуйте! Я бот для автоматизации канала.\n\n"
        "Доступные команды:\n"
        "/start - показать справку по командам\n"
        "/edit - изменить формат сообщения и настройки инлайн кнопок\n\n"
        "Инструкция по настройке:\n"
        "1. Добавьте меня в канал с правами администратора.\n"
        "2. Укажите идентификатор канала и идентификатор сообщения, которое я буду обновлять каждые 5 минут.\n"
        "3. Задайте шаблон сообщения с переменными {{count}} для количества файлов и {{size}} для общего размера файлов.\n"
        "4. При необходимости настройте дополнительные инлайн кнопки (например, для поиска файлов).\n\n"
        "Пример шаблона:\n"
        "Всего файлов: {{count}}\n"
        "Общий размер: {{size}}"
    )
    update.message.reply_text(help_message)

def edit_command_handler(update: Update, context: CallbackContext) -> int:
    """
    Обработчик команды /edit.
    Запускает диалог для поэтапного ввода настроек канала.
    """
    update.message.reply_text("Пожалуйста, введите идентификатор канала, для которого необходимо изменить настройки:")
    return STATE_WAIT_CHANNEL_ID

def receive_channel_id(update: Update, context: CallbackContext) -> int:
    """
    Принимает идентификатор канала от администратора и сохраняет его во временных данных.
    """
    channel_id_text = update.message.text.strip()
    try:
        channel_id = int(channel_id_text)
    except ValueError:
        update.message.reply_text("Идентификатор канала должен быть числом. Пожалуйста, введите идентификатор канала еще раз:")
        return STATE_WAIT_CHANNEL_ID

    context.user_data['channel_id'] = channel_id
    update.message.reply_text("Пожалуйста, введите идентификатор сообщения, которое необходимо обновлять:")
    return STATE_WAIT_MESSAGE_ID

def receive_message_id(update: Update, context: CallbackContext) -> int:
    """
    Принимает идентификатор сообщения для обновления и сохраняет его во временных данных.
    """
    message_id_text = update.message.text.strip()
    try:
        message_id = int(message_id_text)
    except ValueError:
        update.message.reply_text("Идентификатор сообщения должен быть числом. Пожалуйста, введите идентификатор сообщения еще раз:")
        return STATE_WAIT_MESSAGE_ID

    context.user_data['message_id'] = message_id
    update.message.reply_text(
        "Пожалуйста, введите шаблон сообщения, используя переменные {{count}} для количества файлов и {{size}} для общего размера файлов.\n"
        "Например:\n"
        "Всего файлов: {{count}}\nОбщий размер: {{size}}"
    )
    return STATE_WAIT_TEMPLATE_TEXT

def receive_template_text(update: Update, context: CallbackContext) -> int:
    """
    Принимает текст шаблона, сохраняет настройки канала в глобальном словаре и завершает диалог.
    """
    template_text = update.message.text
    channel_identifier = context.user_data.get('channel_id')
    message_identifier = context.user_data.get('message_id')

    if channel_identifier is None or message_identifier is None:
        update.message.reply_text("Ошибка при получении данных канала или сообщения. Попробуйте выполнить команду /edit заново.")
        return ConversationHandler.END

    # Сохранение настроек в глобальном словаре для данного канала
    channel_settings[channel_identifier] = {
        'channel_id': channel_identifier,
        'message_id': message_identifier,
        'template': template_text,
        'custom_buttons': [],  # Здесь можно добавить логику для добавления пользовательских кнопок
        'search_enabled': True  # По умолчанию кнопка поиска включена
    }
    update.message.reply_text(
        f"Настройки для канала с идентификатором {channel_identifier} успешно сохранены.\n"
        f"Шаблон сообщения: {template_text}"
    )
    return ConversationHandler.END

def cancel_edit(update: Update, context: CallbackContext) -> int:
    """
    Обработчик отмены диалога команды /edit.
    """
    update.message.reply_text("Редактирование настроек отменено.")
    return ConversationHandler.END

def update_messages_in_channels(context: CallbackContext) -> None:
    """
    Функция обновления сообщений для каждого настроенного канала.
    Вызывается по расписанию (каждые 5 минут).
    Здесь реализована базовая логика с тестовыми данными для количества файлов и общего размера.
    """
    for channel_identifier, settings in channel_settings.items():
        # Здесь необходимо реализовать получение списка файлов из канала и подсчёт их количества и общего размера.
        # В данном примере используются тестовые данные.
        total_file_count = 123  # Пример: замените на реальную логику подсчёта файлов
        total_file_size = "456 МБ"  # Пример: замените на реальную логику вычисления размера файлов

        # Формирование текста сообщения на основе шаблона с подстановкой переменных
        template_text = settings.get('template', "Всего файлов: {{count}}\nОбщий размер: {{size}}")
        updated_text = template_text.replace("{{count}}", str(total_file_count)).replace("{{size}}", str(total_file_size))

        # Формирование списка инлайн кнопок для обновляемого сообщения
        inline_buttons = []

        if settings.get('search_enabled', False):
            inline_buttons.append(InlineKeyboardButton(text="Поиск", callback_data="search"))

        # Добавление пользовательских кнопок, если они заданы в настройках
        for button_configuration in settings.get('custom_buttons', []):
            if 'url' in button_configuration:
                inline_buttons.append(InlineKeyboardButton(text=button_configuration.get('text', 'Кнопка'), url=button_configuration.get('url')))
            else:
                inline_buttons.append(InlineKeyboardButton(text=button_configuration.get('text', 'Кнопка'), callback_data=button_configuration.get('callback_data', '')))

        if inline_buttons:
            keyboard_markup = InlineKeyboardMarkup([inline_buttons])
        else:
            keyboard_markup = None

        try:
            context.bot.edit_message_text(
                chat_id=settings['channel_id'],
                message_id=settings['message_id'],
                text=updated_text,
                reply_markup=keyboard_markup
            )
            logger.info(f"Сообщение в канале {settings['channel_id']} успешно обновлено.")
        except Exception as error:
            logger.error(f"Ошибка при обновлении сообщения в канале {settings['channel_id']}: {error}")

def inline_button_callback_handler(update: Update, context: CallbackContext) -> None:
    """
    Обработчик callback запросов от инлайн кнопок.
    При нажатии на кнопку «Поиск» бот просит ввести запрос для поиска файлов.
    """
    callback_query = update.callback_query
    callback_query.answer()

    if callback_query.data == "search":
        callback_query.message.reply_text("Пожалуйста, введите запрос для поиска файлов:")
    else:
        callback_query.message.reply_text("Неизвестное действие.")

def main() -> None:
    """
    Основная функция, инициализирующая бота, обработчики команд и планировщик обновлений.
    """
    # Замените 'YOUR_TELEGRAM_BOT_TOKEN' на реальный токен вашего бота
    telegram_bot_token = "YOUR_TELEGRAM_BOT_TOKEN"
    updater = Updater(telegram_bot_token, use_context=True)
    dispatcher = updater.dispatcher

    # Добавление обработчика команды /start
    start_handler = CommandHandler("start", start_command_handler)
    dispatcher.add_handler(start_handler)

    # Создание ConversationHandler для команды /edit с поэтапным вводом настроек
    edit_conversation_handler = ConversationHandler(
        entry_points=[CommandHandler("edit", edit_command_handler)],
        states={
            STATE_WAIT_CHANNEL_ID: [MessageHandler(Filters.text & ~Filters.command, receive_channel_id)],
            STATE_WAIT_MESSAGE_ID: [MessageHandler(Filters.text & ~Filters.command, receive_message_id)],
            STATE_WAIT_TEMPLATE_TEXT: [MessageHandler(Filters.text & ~Filters.command, receive_template_text)]
        },
        fallbacks=[CommandHandler("cancel", cancel_edit)]
    )
    dispatcher.add_handler(edit_conversation_handler)

    # Добавление обработчика для инлайн кнопок
    callback_query_handler = CallbackQueryHandler(inline_button_callback_handler)
    dispatcher.add_handler(callback_query_handler)

    # Планирование обновления сообщений во всех каналах каждые 5 минут (300 секунд)
    job_queue = updater.job_queue
    job_queue.run_repeating(update_messages_in_channels, interval=300, first=10)

    # Запуск бота (поллинг)
    updater.start_polling()
    updater.idle()

if __name__ == '__main__':
    main()

Основные моменты реализации

• Хранение настроек:
  Все настройки по каналам хранятся в словаре channel_settings. Это позволяет работать сразу с несколькими (2–4) каналами.

• Диалог редактирования:
  Команда /edit реализована через ConversationHandler, что позволяет последовательно получить от администратора идентификатор канала, идентификатор сообщения для обновления и сам шаблон сообщения.

• Обновление сообщения:
  Функция update_messages_in_channels вызывается каждые 5 минут и обновляет указанное сообщение в каждом канале, подставляя актуальные данные (в примере используются тестовые данные).

• Инлайн кнопки:
  При наличии включённой кнопки поиска или пользовательских кнопок, формируется инлайн-разметка, которая передаётся в сообщение.

• Расширяемость:
  Вы можете дорабатывать функции для получения реального списка файлов, улучшенного поиска (с заменой символов и т.д.) и добавления кастомных инлайн кнопок по аналогичной схеме.

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

Ниже приведён полный пример скрипта, реализованный с использованием библиотеки pyTelegramBotAPI (telebot). Скрипт включает обработку команд /start и /edit, диалог для ввода настроек (идентификатор канала, идентификатор сообщения и шаблон) с сохранением настроек в глобальном словаре, а также периодическое обновление указанного сообщения (каждые 5 минут) с подстановкой тестовых данных. Обратите внимание, что для полноценной работы потребуется реализовать функции для реального получения списка файлов и их характеристик, а также расширить обработку ошибок и проверку прав администратора.

python
#!/usr/bin/env python3
import telebot
from telebot import types
import threading
import time
import logging

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

# Инициализация бота. Замените YOUR_TELEGRAM_BOT_TOKEN на реальный токен.
bot = telebot.TeleBot("YOUR_TELEGRAM_BOT_TOKEN")

# Глобальный словарь для хранения настроек каналов.
# Ключ — идентификатор канала, значение — словарь с настройками:
#   'channel_id'     — идентификатор канала (например, -1001234567890);
#   'message_id'     — идентификатор сообщения, которое бот будет обновлять;
#   'template'       — шаблон сообщения с переменными {{count}} и {{size}};
#   'custom_buttons' — список пользовательских кнопок (каждая кнопка: словарь с 'text', 'callback_data' или 'url');
#   'search_enabled' — булево значение, включена ли кнопка «Поиск».
channel_settings = {
    # Пример:
    # -1001234567890: {
    #     'channel_id': -1001234567890,
    #     'message_id': 123,
    #     'template': "Всего файлов: {{count}}\nОбщий размер: {{size}}",
    #     'custom_buttons': [
    #         {'text': 'Поиск', 'callback_data': 'search'},
    #         {'text': 'Сайт', 'url': 'https://example.com'}
    #     ],
    #     'search_enabled': True,
    # }
}

# Словарь для хранения состояний диалога при выполнении команды /edit.
# Ключ — идентификатор пользователя, значение — словарь с данными диалога.
user_conversation_state = {}

# Определяем состояния диалога
STATE_WAIT_CHANNEL_ID = 1
STATE_WAIT_MESSAGE_ID = 2
STATE_WAIT_TEMPLATE_TEXT = 3

# Обработчик команды /start: отправляет справочное сообщение.
@bot.message_handler(commands=["start"])
def handle_start(message):
    help_text = (
        "Здравствуйте! Я бот для автоматизации канала.\n\n"
        "Доступные команды:\n"
        "/start - показать справку по командам\n"
        "/edit - изменить настройки обновляемого сообщения\n\n"
        "Инструкция по настройке:\n"
        "1. Добавьте меня в канал с правами администратора.\n"
        "2. Укажите идентификатор канала и идентификатор сообщения, которое я буду обновлять каждые 5 минут.\n"
        "3. Задайте шаблон сообщения с переменными {{count}} для количества файлов и {{size}} для общего размера файлов.\n"
        "Пример шаблона:\n"
        "Всего файлов: {{count}}\nОбщий размер: {{size}}"
    )
    bot.reply_to(message, help_text)

# Обработчик команды /edit: запускает диалог ввода настроек.
@bot.message_handler(commands=["edit"])
def handle_edit(message):
    user_id = message.from_user.id
    user_conversation_state[user_id] = {"state": STATE_WAIT_CHANNEL_ID}
    bot.send_message(message.chat.id, "Пожалуйста, введите идентификатор канала, для которого необходимо изменить настройки:")

# Обработчик текстовых сообщений в рамках диалога /edit.
@bot.message_handler(func=lambda m: m.from_user.id in user_conversation_state)
def handle_conversation(message):
    user_id = message.from_user.id
    state_data = user_conversation_state[user_id]
    current_state = state_data.get("state")

    if current_state == STATE_WAIT_CHANNEL_ID:
        # Обработка ввода идентификатора канала
        try:
            channel_id = int(message.text.strip())
        except ValueError:
            bot.send_message(message.chat.id, "Идентификатор канала должен быть числом. Пожалуйста, введите идентификатор канала еще раз:")
            return
        state_data["channel_id"] = channel_id
        state_data["state"] = STATE_WAIT_MESSAGE_ID
        bot.send_message(message.chat.id, "Пожалуйста, введите идентификатор сообщения, которое необходимо обновлять:")

    elif current_state == STATE_WAIT_MESSAGE_ID:
        # Обработка ввода идентификатора сообщения
        try:
            message_id = int(message.text.strip())
        except ValueError:
            bot.send_message(message.chat.id, "Идентификатор сообщения должен быть числом. Пожалуйста, введите идентификатор сообщения еще раз:")
            return
        state_data["message_id"] = message_id
        state_data["state"] = STATE_WAIT_TEMPLATE_TEXT
        bot.send_message(message.chat.id,
            "Пожалуйста, введите шаблон сообщения, используя переменные {{count}} для количества файлов и {{size}} для общего размера файлов.\n"
            "Например:\nВсего файлов: {{count}}\nОбщий размер: {{size}}"
        )

    elif current_state == STATE_WAIT_TEMPLATE_TEXT:
        # Обработка ввода шаблона сообщения
        template_text = message.text
        channel_id = state_data.get("channel_id")
        message_id = state_data.get("message_id")
        if channel_id is None or message_id is None:
            bot.send_message(message.chat.id, "Ошибка при получении данных канала или сообщения. Попробуйте выполнить команду /edit заново.")
        else:
            # Сохранение настроек для канала
            channel_settings[channel_id] = {
                "channel_id": channel_id,
                "message_id": message_id,
                "template": template_text,
                "custom_buttons": [],  # Можно расширить для добавления кастомных кнопок
                "search_enabled": True  # По умолчанию кнопка поиска включена
            }
            bot.send_message(message.chat.id,
                f"Настройки для канала с идентификатором {channel_id} успешно сохранены.\nШаблон сообщения: {template_text}"
            )
        # Завершение диалога
        user_conversation_state.pop(user_id, None)

# Обработчик callback-запросов от инлайн кнопок.
@bot.callback_query_handler(func=lambda call: True)
def handle_callback_query(call):
    if call.data == "search":
        bot.answer_callback_query(call.id)
        bot.send_message(call.message.chat.id, "Пожалуйста, введите запрос для поиска файлов:")
    else:
        bot.answer_callback_query(call.id, text="Неизвестное действие.")

# Функция обновления сообщений для каждого настроенного канала.
# Здесь используется тестовая логика: подставляются фиксированные значения количества файлов и их общего размера.
def update_messages_in_channels():
    while True:
        for channel_id, settings in channel_settings.items():
            # Здесь необходимо реализовать логику получения списка файлов из канала
            total_file_count = 123     # Пример: заменить на реальное значение
            total_file_size = "456 МБ"  # Пример: заменить на реальное значение

            # Формирование текста сообщения на основе шаблона
            template = settings.get("template", "Всего файлов: {{count}}\nОбщий размер: {{size}}")
            updated_text = template.replace("{{count}}", str(total_file_count)).replace("{{size}}", str(total_file_size))

            # Формирование инлайн-кнопок
            inline_buttons = []
            if settings.get("search_enabled", False):
                inline_buttons.append(types.InlineKeyboardButton(text="Поиск", callback_data="search"))
            for btn in settings.get("custom_buttons", []):
                if "url" in btn:
                    inline_buttons.append(types.InlineKeyboardButton(text=btn.get("text", "Кнопка"), url=btn.get("url")))
                else:
                    inline_buttons.append(types.InlineKeyboardButton(text=btn.get("text", "Кнопка"), callback_data=btn.get("callback_data", "")))
            keyboard = types.InlineKeyboardMarkup()
            if inline_buttons:
                keyboard.add(*inline_buttons)

            try:
                bot.edit_message_text(
                    chat_id=settings["channel_id"],
                    message_id=settings["message_id"],
                    text=updated_text,
                    reply_markup=keyboard
                )
                logger.info(f"Сообщение в канале {settings['channel_id']} успешно обновлено.")
            except Exception as e:
                logger.error(f"Ошибка при обновлении сообщения в канале {settings['channel_id']}: {e}")
        # Ждем 5 минут (300 секунд) перед следующим обновлением
        time.sleep(300)

# Запуск фонового потока для обновления сообщений
def start_update_thread():
    update_thread = threading.Thread(target=update_messages_in_channels, daemon=True)
    update_thread.start()

if __name__ == "__main__":
    # Запуск фонового потока обновления сообщений
    start_update_thread()
    # Запуск бота в режиме поллинга
    bot.infinity_polling()

Основные моменты реализации

1. Обработка команд:

   • /start отправляет справочное сообщение с описанием основных команд и инструкций.
   • /edit запускает диалог, в котором последовательно запрашивается идентификатор канала, идентификатор сообщения и шаблон обновляемого сообщения.

2. Диалог редактирования:
   Состояния диалога отслеживаются в словаре user_conversation_state с использованием идентификатора пользователя.

3. Периодическое обновление:
   Функция update_messages_in_channels запускается в отдельном потоке и каждые 5 минут перебирает все настройки каналов, формирует новое сообщение с подстановкой тестовых данных и вызывает метод edit_message_text для обновления сообщения.

4. Инлайн кнопки:
   При наличии включённой кнопки «Поиск» (а также дополнительных кнопок из настроек) формируется разметка для обновляемого сообщения. Обработка callback-запроса кнопки «Поиск» перенаправляет пользователя для ввода запроса.

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

Ниже предлагается один из вариантов реализации схемы получения информации о файлах в канале. Основная идея состоит в том, чтобы при первом запуске бот прошёлся по всем сообщениям канала, собрал данные о файлах (например, идентификатор сообщения, тип файла, размер файла и т.п.) и сохранил их в постоянное хранилище (например, в базе данных или JSON-файле). При последующих обновлениях бот будет получать только новые сообщения (те, чей идентификатор больше максимального обработанного) и добавлять данные о файлах к уже имеющейся информации. Это позволит не проходить заново по всем сообщениям, а лишь обновлять данные инкрементально.

---

Предлагаемая схема

1. Инициализация и первичное сканирование:

   • При первом запуске бот использует методы Telegram API для получения истории сообщений канала (например, по 100 сообщений за запрос).
   • Начинаем с самого первого сообщения (или с момента, когда канал был создан) и перебираем все сообщения.
   • Для каждого сообщения проверяем наличие файлов. В Telegram файлы могут быть представлены в разных типах (документы, фото, аудио, видео и пр.), и у большинства объектов есть параметр file_size.
   • Если сообщение содержит файл, извлекаем его размер и, возможно, другие данные (например, идентификатор сообщения, тип файла).
   • Сохраняем информацию о файле в хранилище. Дополнительно сохраняем максимальный message_id (или дату), до которого произведено сканирование.

2. Инкрементальное обновление:

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

3. Использование информации:

   • При обновлении сообщения с итоговой статистикой бот подставляет данные (например, общее количество файлов и их суммарный размер) в заранее заданный шаблон (например, используя переменные {{count}} и {{size}}).
   • Обновление сообщения происходит через метод edit_message_text (или его аналог).

4. Дополнительные соображения:

   • Хранилище: Для небольшого количества каналов (2–4) можно использовать простую базу (например, SQLite) или даже JSON-файл. Это позволит сохранить сведения о файлах и последний обработанный message_id.
   • Обработка ошибок: Стоит добавить проверки на отсутствие доступа, ошибки API и ограничение частоты запросов.
   • Периодическая синхронизация: Если канал большой или возможны случаи, когда некоторые сообщения были изменены/удалены, можно раз в неделю выполнять полное сканирование для синхронизации базы.

---

Пример логики (псевдокод)

Ниже приведён упрощённый пример того, как может выглядеть реализация на Python с использованием библиотеки telebot. Этот пример показывает основную логику по первичному сканированию и последующему инкрементальному обновлению.

python
import telebot
import time
import json
import logging

# Инициализация бота
bot = telebot.TeleBot("YOUR_TELEGRAM_BOT_TOKEN")

# Пусть для хранения данных в JSON (можно заменить на SQLite)
DATA_FILE = "channel_files_data.json"

# Загружаем данные, если они есть
try:
    with open(DATA_FILE, "r") as f:
        data_storage = json.load(f)
except Exception:
    data_storage = {}  # формат: { channel_id: { "max_message_id": <число>, "files": [ { "message_id": <число>, "file_size": <число> }, ... ] } }

def save_data():
    with open(DATA_FILE, "w") as f:
        json.dump(data_storage, f, indent=4)

def process_message(channel_id, message):
    """
    Обрабатываем отдельное сообщение.
    Если в сообщении содержится файл, сохраняем его данные.
    """
    file_info = None
    # Проверка различных типов файлов (документ, аудио, видео, фото и т.д.)
    if message.document:
        file_info = {"message_id": message.message_id, "file_size": message.document.file_size}
    elif message.video:
        file_info = {"message_id": message.message_id, "file_size": message.video.file_size}
    elif message.audio:
        file_info = {"message_id": message.message_id, "file_size": message.audio.file_size}
    elif message.voice:
        file_info = {"message_id": message.message_id, "file_size": message.voice.file_size}
    # Можно добавить обработку фото, но у фото file_size может отсутствовать, поэтому следует запросить информацию о фото через метод get_file
    # Если нашли файл, сохраняем его
    if file_info:
        if str(channel_id) not in data_storage:
            data_storage[str(channel_id)] = {"max_message_id": message.message_id, "files": []}
        data_storage[str(channel_id)]["files"].append(file_info)
        # Обновляем max_message_id, если сообщение новее
        if message.message_id > data_storage[str(channel_id)]["max_message_id"]:
            data_storage[str(channel_id)]["max_message_id"] = message.message_id

def scan_channel(channel_id, start_from=1):
    """
    Функция для первичного сканирования канала.
    Переходит по истории сообщений, начиная с start_from.
    """
    offset = start_from
    limit = 100  # размер пакета сообщений
    while True:
        messages = bot.get_chat_history(chat_id=channel_id, offset=offset, limit=limit)
        if not messages:
            break
        for message in messages:
            process_message(channel_id, message)
        offset = messages[-1].message_id + 1
        # Можно добавить sleep для соблюдения лимитов запросов
        time.sleep(0.5)
    save_data()

def incremental_scan(channel_id):
    """
    Функция для инкрементального сканирования:
    Получает новые сообщения с message_id больше, чем сохранённое.
    """
    last_message_id = data_storage.get(str(channel_id), {}).get("max_message_id", 1)
    # Получаем новые сообщения (можно также использовать offset, если API позволяет)
    messages = bot.get_chat_history(chat_id=channel_id, offset=last_message_id+1, limit=100)
    if messages:
        for message in messages:
            process_message(channel_id, message)
        save_data()

def calculate_totals(channel_id):
    """
    Подсчитывает общее количество файлов и суммарный размер.
    """
    channel_data = data_storage.get(str(channel_id), {})
    files = channel_data.get("files", [])
    total_count = len(files)
    total_size = sum(file["file_size"] for file in files)
    return total_count, total_size

# Пример функции, которая обновляет сообщение в канале с подстановкой данных
def update_channel_message(channel_id, message_id, template_text):
    total_count, total_size = calculate_totals(channel_id)
    updated_text = template_text.replace("{{count}}", str(total_count)).replace("{{size}}", str(total_size))
    try:
        bot.edit_message_text(chat_id=channel_id, message_id=message_id, text=updated_text)
    except Exception as e:
        logging.error(f"Ошибка обновления сообщения в канале {channel_id}: {e}")

# Фоновый поток для периодического инкрементального сканирования
def background_scan():
    # Предположим, что у нас настроено 2-4 канала, их идентификаторы можно хранить в отдельном списке
    channel_ids = [-1001234567890, -1009876543210]  # замените на реальные
    while True:
        for channel_id in channel_ids:
            incremental_scan(channel_id)
            # Здесь можно также вызывать update_channel_message с шаблоном, сохранённым для данного канала
        time.sleep(300)  # сканирование каждые 5 минут

# Пример запуска фонового сканирования
import threading
scan_thread = threading.Thread(target=background_scan, daemon=True)
scan_thread.start()

# Базовые обработчики для команд (например, /start и /edit) можно реализовать, как в предыдущем примере.
@bot.message_handler(commands=["start"])
def start_handler(message):
    bot.reply_to(message, "Бот запущен. Информация о файлах будет собираться в фоне.")

bot.infinity_polling()

---

Пояснения

• Первичное сканирование:
  Функция scan_channel проходит по истории сообщений, начиная с первого (или с указанного start_from). Для каждого сообщения вызывается функция process_message, которая проверяет наличие файлов и сохраняет их информацию. После завершения сканирования данные сохраняются в файл.

• Инкрементальное обновление:
  Функция incremental_scan получает сообщения, у которых message_id больше последнего обработанного. Это позволяет не повторять полный проход по истории канала, а лишь добавлять новые данные.

• Хранение данных:
  В примере используется JSON-файл для простоты, но можно использовать и SQLite или другую СУБД для надежного хранения.

• Обновление сообщения:
  Функция update_channel_message подставляет полученные данные (общее количество файлов и суммарный размер) в заданный шаблон и обновляет сообщение в канале.

• Фоновый поток:
  Функция background_scan запускается в отдельном потоке и каждые 5 минут проверяет новые сообщения для указанных каналов.

Эта схема позволяет один раз провести полный обход сообщений, а затем инкрементально обновлять статистику, что значительно снижает нагрузку и количество запросов к Telegram API. Вы можете дорабатывать её, добавляя дополнительные проверки, обработку разных типов файлов (например, для фотографий, у которых может отсутствовать file_size в базовом объекте) и улучшая логику хранения данных.

Ниже приведён полный исправленный скрипт с использованием библиотеки telebot, в котором реализована схема первичного и инкрементального сканирования канала для сбора информации о файлах. В данном примере предполагается, что бот может получать историю сообщений (через метод get_chat_history, который может потребовать доработки или замены на другой метод для вашего случая). При первом запуске бот проходит по истории сообщений, а затем каждую итерацию (каждые 5 минут) проверяет только новые сообщения и обновляет сохранённую статистику. Также реализована функция обновления сообщения в канале с подстановкой статистики в заданный шаблон.

python
#!/usr/bin/env python3
import telebot
from telebot import types
import threading
import time
import json
import logging

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

# Инициализация бота. Замените YOUR_TELEGRAM_BOT_TOKEN на реальный токен.
bot = telebot.TeleBot("YOUR_TELEGRAM_BOT_TOKEN")

# Файл для хранения данных о файлах канала (можно заменить на использование базы данных)
DATA_FILE = "channel_files_data.json"

# Загружаем данные, если файл существует. Формат:
# {
#     "channel_id": {
#         "max_message_id": <число>,
#         "files": [
#             { "message_id": <число>, "file_size": <число> },
#             ...
#         ]
#     },
#     ...
# }
try:
    with open(DATA_FILE, "r") as f:
        data_storage = json.load(f)
except Exception:
    data_storage = {}

def save_data():
    with open(DATA_FILE, "w") as f:
        json.dump(data_storage, f, indent=4)

def process_message(channel_id, message):
    """
    Обрабатываем отдельное сообщение. Если сообщение содержит файл,
    извлекаем его размер и сохраняем информацию.
    """
    file_info = None
    if hasattr(message, 'document') and message.document:
        file_info = {"message_id": message.message_id, "file_size": message.document.file_size}
    elif hasattr(message, 'video') and message.video:
        file_info = {"message_id": message.message_id, "file_size": message.video.file_size}
    elif hasattr(message, 'audio') and message.audio:
        file_info = {"message_id": message.message_id, "file_size": message.audio.file_size}
    elif hasattr(message, 'voice') and message.voice:
        file_info = {"message_id": message.message_id, "file_size": message.voice.file_size}
    
    if file_info:
        channel_key = str(channel_id)
        if channel_key not in data_storage:
            data_storage[channel_key] = {"max_message_id": message.message_id, "files": []}
        data_storage[channel_key]["files"].append(file_info)
        if message.message_id > data_storage[channel_key]["max_message_id"]:
            data_storage[channel_key]["max_message_id"] = message.message_id

def scan_channel(channel_id, start_from=1):
    """
    Первичное сканирование канала: проходит по истории сообщений,
    начиная с указанного номера сообщения.
    """
    offset = start_from
    limit = 100  # размер пакета сообщений
    while True:
        try:
            messages = bot.get_chat_history(chat_id=channel_id, offset=offset, limit=limit)
        except Exception as e:
            logger.error(f"Ошибка при получении истории канала {channel_id}: {e}")
            break

        if not messages:
            break

        for message in messages:
            process_message(channel_id, message)
        offset = messages[-1].message_id + 1
        time.sleep(0.5)  # задержка для соблюдения лимитов API
    save_data()

def incremental_scan(channel_id):
    """
    Инкрементальное сканирование: получает новые сообщения с message_id,
    большим чем последний обработанный.
    """
    channel_key = str(channel_id)
    last_message_id = data_storage.get(channel_key, {}).get("max_message_id", 1)
    try:
        messages = bot.get_chat_history(chat_id=channel_id, offset=last_message_id+1, limit=100)
    except Exception as e:
        logger.error(f"Ошибка при инкрементальном получении истории канала {channel_id}: {e}")
        return

    if messages:
        for message in messages:
            process_message(channel_id, message)
        save_data()

def calculate_totals(channel_id):
    """
    Подсчитывает общее количество файлов и суммарный размер файлов для канала.
    """
    channel_key = str(channel_id)
    channel_data = data_storage.get(channel_key, {})
    files = channel_data.get("files", [])
    total_count = len(files)
    total_size = sum(file["file_size"] for file in files)
    return total_count, total_size

def update_channel_message(channel_id, message_id, template_text):
    """
    Обновляет сообщение в канале, подставляя в шаблон статистику:
    {{count}} - количество файлов, {{size}} - суммарный размер.
    """
    total_count, total_size = calculate_totals(channel_id)
    updated_text = template_text.replace("{{count}}", str(total_count)).replace("{{size}}", str(total_size))
    try:
        bot.edit_message_text(chat_id=channel_id, message_id=message_id, text=updated_text)
    except Exception as e:
        logger.error(f"Ошибка обновления сообщения в канале {channel_id}: {e}")

# Пример настроек для обновления сообщений.
# Здесь хранятся настройки для каждого канала, где ключ — идентификатор канала,
# а значение — словарь с параметрами: message_id для обновления и шаблон.
channel_settings = {
    # Пример:
    # -1001234567890: {
    #     "message_id": 123, 
    #     "template": "Всего файлов: {{count}}\nОбщий размер: {{size}}"
    # }
}

def background_scan():
    """
    Фоновый поток для инкрементального сканирования каналов.
    Каждые 5 минут для каждого канала:
      - Инкрементально сканировать новые сообщения.
      - Обновлять сообщение с итоговой статистикой, если настроено.
    """
    # Список идентификаторов каналов, за которыми нужно следить.
    channel_ids = [-1001234567890, -1009876543210]  # замените на реальные значения
    while True:
        for channel_id in channel_ids:
            incremental_scan(channel_id)
            # Если для канала настроено обновляемое сообщение, обновляем его
            if channel_id in channel_settings:
                settings = channel_settings[channel_id]
                update_channel_message(channel_id, settings["message_id"], settings["template"])
        time.sleep(300)  # ожидание 5 минут

# Простой обработчик команды /start, информирующий о запуске бота.
@bot.message_handler(commands=["start"])
def start_handler(message):
    bot.reply_to(message, "Бот запущен. Информация о файлах собирается в фоновом режиме.")

# Запускаем фоновый поток для сканирования каналов.
scan_thread = threading.Thread(target=background_scan, daemon=True)
scan_thread.start()

# Запуск бота в режиме постоянного опроса.
bot.infinity_polling()

Пояснения

1. Сканирование сообщений:

   • Функция scan_channel выполняет первичное сканирование, проходя по истории сообщений начиная с указанного start_from.
   • Функция incremental_scan получает только новые сообщения (с message_id большим, чем сохранённое максимальное значение).

2. Сохранение и подсчёт:

   • Все данные сохраняются в JSON-файл (channel_files_data.json).
   • Функция calculate_totals подсчитывает общее количество файлов и их суммарный размер для подстановки в шаблон.

3. Обновление сообщения:

   • Функция update_channel_message редактирует сообщение в канале, подставляя статистику в заданный шаблон (с переменными {{count}} и {{size}}).

4. Фоновый поток:

   • Функция background_scan запускается в отдельном потоке и каждые 5 минут проходит по списку каналов, выполняя инкрементальное сканирование и обновляя сообщение (если настройки для канала заданы в словаре channel_settings).

Обратите внимание, что метод bot.get_chat_history используется здесь в качестве примера – для получения истории сообщений может понадобиться иная реализация или библиотека, в зависимости от возможностей Bot API и ваших условий работы.

Ниже приведён пример полного скрипта на основе библиотеки telebot, который использует обработчик событий новых сообщений из каналов (channel_post) для сбора информации о файлах. В этом варианте бот не может получить историю всех сообщений по Bot API, поэтому он будет собирать данные только для сообщений, поступающих после его запуска (а для исторических сообщений можно предложить администратору переслать их боту вручную). При каждом новом сообщении с файлом бот сохраняет его сведения, а фоновый поток раз в 5 минут обновляет указанное сообщение с итоговой статистикой. Также реализована базовая обработка команд /start и /edit для настройки обновляемого сообщения.

python
#!/usr/bin/env python3
import telebot
from telebot import types
import threading
import time
import json
import logging

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

# Инициализация бота. Замените YOUR_TELEGRAM_BOT_TOKEN на реальный токен.
bot = telebot.TeleBot("YOUR_TELEGRAM_BOT_TOKEN")

# Файл для хранения данных о файлах каналов.
DATA_FILE = "channel_files_data.json"

# Загружаем данные из файла (если он существует)
try:
    with open(DATA_FILE, "r") as f:
        data_storage = json.load(f)
except Exception:
    data_storage = {}
    # Формат data_storage:
    # {
    #   "<channel_id>": {
    #       "max_message_id": <число>,
    #       "files": [
    #           { "message_id": <число>, "file_size": <число> },
    #           ...
    #       ]
    #   },
    #   ...
    # }

def save_data():
    with open(DATA_FILE, "w") as f:
        json.dump(data_storage, f, indent=4)

def process_message(channel_id, message):
    """
    Обрабатывает отдельное сообщение из канала.
    Если сообщение содержит файл (документ, видео, аудио или голосовое),
    то сохраняет информацию о размере файла и идентификатор сообщения.
    """
    file_info = None
    if hasattr(message, 'document') and message.document:
        file_info = {"message_id": message.message_id, "file_size": message.document.file_size}
    elif hasattr(message, 'video') and message.video:
        file_info = {"message_id": message.message_id, "file_size": message.video.file_size}
    elif hasattr(message, 'audio') and message.audio:
        file_info = {"message_id": message.message_id, "file_size": message.audio.file_size}
    elif hasattr(message, 'voice') and message.voice:
        file_info = {"message_id": message.message_id, "file_size": message.voice.file_size}
    
    if file_info:
        channel_key = str(channel_id)
        # Если данных о канале ещё нет — создаём запись
        if channel_key not in data_storage:
            data_storage[channel_key] = {"max_message_id": message.message_id, "files": []}
        # Проверяем, что сообщение ещё не было обработано (по message_id)
        if not any(f["message_id"] == message.message_id for f in data_storage[channel_key]["files"]):
            data_storage[channel_key]["files"].append(file_info)
            # Обновляем max_message_id, если полученное сообщение новее
            if message.message_id > data_storage[channel_key]["max_message_id"]:
                data_storage[channel_key]["max_message_id"] = message.message_id
            logger.info(f"Обработано сообщение {message.message_id} в канале {channel_id}")
            save_data()

@bot.channel_post_handler(func=lambda m: True)
def channel_post_handler(message):
    """
    Обработчик новых сообщений из канала.
    Если в сообщении содержится файл, вызывается process_message.
    """
    channel_id = message.chat.id
    process_message(channel_id, message)

# Словарь для хранения настроек обновляемых сообщений по каналам.
# Формат:
# {
#     <channel_id>: {
#         "message_id": <id сообщения, которое нужно обновлять>,
#         "template": "<текст шаблона, где {{count}} и {{size}} будут заменены>"
#     },
#     ...
# }
channel_settings = {
    # Пример:
    # -1001234567890: {
    #     "message_id": 123,
    #     "template": "Всего файлов: {{count}}\nОбщий размер: {{size}}"
    # }
}

# Словарь для состояний диалога команды /edit
user_conversation_state = {}

# Определяем состояния диалога
STATE_WAIT_CHANNEL_ID = 1
STATE_WAIT_MESSAGE_ID = 2
STATE_WAIT_TEMPLATE_TEXT = 3

@bot.message_handler(commands=["start"])
def start_handler(message):
    """
    Обработчик команды /start.
    Отправляет справку по командам.
    """
    help_text = (
        "Здравствуйте! Я бот для сбора статистики файлов в канале.\n\n"
        "Доступные команды:\n"
        "/start - показать справку\n"
        "/edit - настроить сообщение для обновления статистики\n\n"
        "Важно: бот должен быть добавлен в канал в качестве администратора. "
        "Новые сообщения с файлами будут автоматически обрабатываться."
    )
    bot.reply_to(message, help_text)

@bot.message_handler(commands=["edit"])
def edit_handler(message):
    """
    Обработчик команды /edit.
    Запускает диалог для ввода настроек обновляемого сообщения.
    """
    user_id = message.from_user.id
    user_conversation_state[user_id] = {"state": STATE_WAIT_CHANNEL_ID}
    bot.send_message(message.chat.id, "Пожалуйста, введите идентификатор канала (например, -1001234567890):")

@bot.message_handler(func=lambda m: m.from_user.id in user_conversation_state)
def conversation_handler(message):
    """
    Обрабатывает поэтапный диалог для команды /edit.
    """
    user_id = message.from_user.id
    state_data = user_conversation_state[user_id]
    current_state = state_data.get("state")
    
    if current_state == STATE_WAIT_CHANNEL_ID:
        try:
            channel_id = int(message.text.strip())
        except ValueError:
            bot.send_message(message.chat.id, "Идентификатор канала должен быть числом. Попробуйте еще раз:")
            return
        state_data["channel_id"] = channel_id
        state_data["state"] = STATE_WAIT_MESSAGE_ID
        bot.send_message(message.chat.id, "Пожалуйста, введите идентификатор сообщения, которое нужно обновлять:")
    
    elif current_state == STATE_WAIT_MESSAGE_ID:
        try:
            message_id = int(message.text.strip())
        except ValueError:
            bot.send_message(message.chat.id, "Идентификатор сообщения должен быть числом. Попробуйте еще раз:")
            return
        state_data["message_id"] = message_id
        state_data["state"] = STATE_WAIT_TEMPLATE_TEXT
        bot.send_message(message.chat.id,
            "Пожалуйста, введите шаблон сообщения с переменными:\n"
            "{{count}} - количество файлов\n{{size}} - суммарный размер файлов\n\n"
            "Пример:\nВсего файлов: {{count}}\nОбщий размер: {{size}}"
        )
    
    elif current_state == STATE_WAIT_TEMPLATE_TEXT:
        template_text = message.text
        channel_id = state_data.get("channel_id")
        message_id = state_data.get("message_id")
        if channel_id is None or message_id is None:
            bot.send_message(message.chat.id, "Ошибка получения данных канала или сообщения. Попробуйте заново команду /edit.")
        else:
            channel_settings[channel_id] = {
                "message_id": message_id,
                "template": template_text
            }
            bot.send_message(message.chat.id,
                f"Настройки для канала {channel_id} сохранены.\nШаблон:\n{template_text}"
            )
        user_conversation_state.pop(user_id, None)

def calculate_totals(channel_id):
    """
    Подсчитывает общее количество файлов и суммарный размер файлов для указанного канала.
    """
    channel_key = str(channel_id)
    channel_data = data_storage.get(channel_key, {})
    files = channel_data.get("files", [])
    total_count = len(files)
    total_size = sum(file["file_size"] for file in files)
    return total_count, total_size

def update_channel_message(channel_id, message_id, template_text):
    """
    Обновляет сообщение в канале, подставляя в шаблон данные:
    {{count}} - количество файлов, {{size}} - суммарный размер файлов.
    """
    total_count, total_size = calculate_totals(channel_id)
    updated_text = template_text.replace("{{count}}", str(total_count)).replace("{{size}}", str(total_size))
    try:
        bot.edit_message_text(chat_id=channel_id, message_id=message_id, text=updated_text)
        logger.info(f"Обновлено сообщение в канале {channel_id} (message_id: {message_id}).")
    except Exception as e:
        logger.error(f"Ошибка обновления сообщения в канале {channel_id}: {e}")

def background_update():
    """
    Фоновый поток, который каждые 5 минут обновляет сообщение статистики для настроенных каналов.
    """
    while True:
        for channel_id, settings in channel_settings.items():
            update_channel_message(channel_id, settings["message_id"], settings["template"])
        time.sleep(300)  # 300 секунд = 5 минут

# Запуск фонового потока обновления сообщений
update_thread = threading.Thread(target=background_update, daemon=True)
update_thread.start()

# Запуск бота в режиме поллинга
bot.infinity_polling()

---

Краткое описание работы скрипта

1. Сбор данных о файлах:
   – При поступлении нового сообщения в канал (через обработчик channel_post) бот проверяет, содержит ли сообщение файл (документ, видео, аудио или голосовое).
   – Если файл найден и сообщение ещё не было обработано, информация (message_id и размер файла) сохраняется в data_storage (и в JSON-файл).

2. Настройка обновляемого сообщения:
   – Команда /edit запускает диалог, в ходе которого администратор указывает идентификатор канала, идентификатор сообщения, которое нужно обновлять, и шаблон текста.
   – Шаблон может содержать переменные {{count}} (количество файлов) и {{size}} (суммарный размер файлов).

3. Периодическое обновление:
   – Фоновый поток (функция background_update) каждые 5 минут проходит по настроенным каналам и обновляет сообщение с подставленными данными.

4. Команда /start:
   – Отправляет справочное сообщение с описанием основных команд.

Обратите внимание, что бот получает информацию только о новых сообщениях, поступающих после его запуска. Если необходимо собрать историю файлов за прошлые периоды, администратору придётся переслать исторические сообщения боту (или использовать другой клиентский инструмент, например, Telethon).

Этот скрипт является отправной точкой для реализации требуемой функциональности и может быть расширен в зависимости от конкретных требований и условий эксплуатации.