Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

Помоги решить ошибку: ERROR:asyncio:Task exception was never retrieved future: <Task…

  1. User

    Помоги решить ошибку: ERROR:asyncio:Task exception was never retrieved future: <Task finished name='Task-99' coro=<Dispatcher._process_polling_updates() done, defined at C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\dispatcher\dispatcher.py:407> exception=BadRequest('Invalid file_id')> Traceback (most recent call last): File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\dispatcher\dispatcher.py", line 415, in _process_polling_updates for responses in itertools.chain.from_iterable(await self.process_updates(updates, fast)): ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\dispatcher\dispatcher.py", line 235, in process_updates return await asyncio.gather(*tasks) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\dispatcher\handler.py", line 117, in notify response = await handler_obj.handler(*args, **partial_data) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\dispatcher\dispatcher.py", line 256, in process_update return await self.message_handlers.notify(update.message) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\dispatcher\handler.py", line 117, in notify response = await handler_obj.handler(*args, **partial_data) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt\main.py", line 860, in on_change_background_button processed_image_io = await apply_background(user_photo[0], background[0]) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt\main.py", line 782, in apply_background background_photo_file = await bot.get_file(background_photo_id) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\bot\bot.py", line 1791, in get_file result = await self.request(api.Methods.GET_FILE, payload) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\bot\base.py", line 236, in request return await api.make_request(await self.get_session(), self.server, self.__token, method, data, files, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\bot\api.py", line 140, in make_request return check_result(method, response.content_type, response.status, await response.text()) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\bot\api.py", line 115, in check_result exceptions.BadRequest.detect(description) File "C:\Users\Аскар\PycharmProjects\smena tt.venv\Lib\site-packages\aiogram\utils\exceptions.py", line 141, in detect raise cls(description) aiogram.utils.exceptions.BadRequest: Invalid file_id

    Вот код моего бота: import asyncio from io import BytesIO from PIL import Image, ImageFilter import aiohttp import time import random from aiogram import Bot, Dispatcher, types, executor from aiogram.contrib.fsm_storage.memory import MemoryStorage from aiogram.dispatcher import FSMContext from aiogram.dispatcher.filters.state import State, StatesGroup from aiosqlite import connect import logging from aiogram.utils.exceptions import MessageNotModified from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton, ParseMode from aiogram import types from aiogram.dispatcher.middlewares import BaseMiddleware from aiogram.dispatcher.handler import CancelHandler from aiogram.dispatcher.middlewares import LifetimeControllerMiddleware from collections import defaultdict import ssl

    logging.basicConfig(level=logging.INFO) ADMINS=[989037374,6663889022] TOKEN = "6937803168:AAE-eV82HlqV3M0w7a8U89aJBpkGfywCz7A"

    bot = Bot(token=TOKEN) storage = MemoryStorage() dp = Dispatcher(bot, storage=storage)

    Создание таблиц если они не существуют

    async def init_db(): logging.info("инициализация БД") async with connect('bot.db') as db: await db.execute(""" CREATE TABLE IF NOT EXISTS backgrounds ( id INTEGER PRIMARY KEY, user_id INTEGER NOT NULL, photo_id TEXT NOT NULL ) """) await db.execute(""" CREATE TABLE IF NOT EXISTS userphotos ( id INTEGER PRIMARY KEY, user_id INTEGER NOT NULL, photo_id TEXT NOT NULL ) """) await db.execute(""" CREATE TABLE IF NOT EXISTS users ( user_id INTEGER PRIMARY KEY, is_banned INTEGER DEFAULT 0, first_name TEXT, username TEXT ) """) await db.execute(""" CREATE TABLE IF NOT EXISTS common_backgrounds ( id INTEGER PRIMARY KEY, photo_id TEXT NOT NULL ) """) await db.commit()

    from aiogram.utils.markdown import escape_md

    class MailingState(StatesGroup): waiting_for_message = State() waiting_for_buttons = State()

    from aiogram.utils.markdown import quote_html

    @dp.message_handler(commands=['profile'], user_id=ADMINS, state='*') async def cmd_profile(message: types.Message): # Разбор аргумента команды arg = message.get_args()

    # Проверка, является ли аргумент числом (user_id) или строкой (username)
    user_id = None
    username = None
    if arg.isdigit():
        user_id = int(arg)
    elif arg.startswith('@'):
        username = arg[1:]  # Удаляем @ в начале
    
    # Если аргумент отсутствует
    if not user_id and not username:
        await message.reply("Необходимо указать user_id или username пользователя.")
        return
    
    # Поиск пользователя
    async with connect('bot.db') as db:
        if user_id:
            cursor = await db.execute("""
                SELECT user_id, username, use_common_backgrounds,
                common_backgrounds_count, personal_backgrounds_count, is_banned
                FROM users WHERE user_id = ?""", (user_id,))
        else:
            cursor = await db.execute("""
                SELECT user_id, username, use_common_backgrounds,
                common_backgrounds_count, personal_backgrounds_count, is_banned
                FROM users WHERE username = ?""", (username,))
    
        user_data = await cursor.fetchone()
    
    # Если пользователь не найден
    if not user_data:
        await message.reply("Пользователь не найден.")
        return
    
    # Формирование сообщения для отправки администратору
    profile_text = (
        f"👨 *Профиль пользователя*\n\n"
        f"User ID: {user_data[0]}\n"
        f"Username: @{quote_html(user_data[1])}\n\n"
        f"Использование общих фонов: *{'вкл' if user_data[2] else 'выкл'}*\n"
        f"Количество использований общих фонов: {user_data[3]}\n"
        f"Количество использований личных фонов: {user_data[4]}\n"
        f"Статус: *{'забанен' if user_data[5] else 'активен'}*"
    )
    
    # Создание инлайн-кнопок
    buttons = [
        InlineKeyboardButton("Забанить", callback_data=f'ban_{user_data[0]}'),
        InlineKeyboardButton("Разбанить", callback_data=f'unban_{user_data[0]}')
    ]
    keyboard = InlineKeyboardMarkup().add(*buttons)
    
    # Отправка сообщения
    await message.reply(profile_text, parse_mode="MarkdownV2", reply_markup = keyboard)
    
    @dp.callback_query_handler(lambda c: c.data.startswith('ban_'))
    async def process_ban_button(callback_query: types.CallbackQuery):
        admin_id = callback_query.from_user.id
        if admin_id not in ADMINS:  # Проверяем, что вызывающий команду является администратором
            await callback_query.answer("Вы не являетесь администратором.")
            return
        user_id_to_ban = int(callback_query.data.split('_')[1])
        async with connect('bot.db') as db:
            await db.execute("INSERT OR IGNORE INTO banned_users (user_id) VALUES (?)", (user_id_to_ban,))
            await db.commit()
        await callback_query.answer(f"Пользователь {user_id_to_ban} заблокирован.")
    
    @dp.callback_query_handler(lambda c: c.data.startswith('unban_'))
    async def process_unban_button(callback_query: types.CallbackQuery):
        admin_id = callback_query.from_user.id
        if admin_id not in ADMINS:
            await callback_query.answer("Вы не являетесь администратором.")
            return
        user_id_to_unban = int(callback_query.data.split('_')[1])
        async with connect('bot.db') as db:
            await db.execute("DELETE FROM banned_users WHERE user_id = ?", (user_id_to_unban,))
            await db.commit()
        await callback_query.answer(f"Пользователь {user_id_to_unban} разблокирован.")
    
    # Обработчик команды /post, передаем состояние ожидания сообщения для рассылки
    

    @dp.message_handler(commands=['post'], user_id=ADMINS, state='*') async def cmd_post(message: types.Message): await MailingState.waiting_for_message.set() await message.reply("Отправьте текст рассылки")

    Обработчик текста рассылки, переводим в состояние ожидания кнопок

    @dp.message_handler(state=MailingState.waiting_for_message, content_types=types.ContentTypes.TEXT) async def post_message(message: types.Message, state: FSMContext): await MailingState.waiting_for_buttons.set() await state.update_data(mailing_text=message.text) await message.reply( "Теперь отправьте данные для inline-кнопок в формате: Текст кнопки;URL на каждую кнопку или /skip, если кнопки не нужны.")

    Обработчик кнопок для рассылки или пропуска их добавления

    @dp.message_handler(state=MailingState.waiting_for_buttons) async def post_buttons(message: types.Message, state: FSMContext): if message.text != "/skip": # Разбиваем сообщение по строкам и создаем кнопки lines = message.text.split("\n") buttons = [InlineKeyboardButton(text=line.split(';')[0], url=line.split(';')[1]) for line in lines if len(line.split(';')) == 2]

        markup = InlineKeyboardMarkup()
        markup.add(*buttons)
    else:
        markup = None
    
    # Получаем данные из состояния и текст рассылки
    data = await state.get_data()
    text = data.get('mailing_text')
    mode = data.get('mailing_mode')
    
    # Запускаем рассылку
    success_count, failure_count = await send_mailing(text, mode, markup)
    await state.finish()  # Сброс состояния после рассылки
    await message.answer(f"Рассылка выполнена. Успешно: {success_count}. Неудачно: {failure_count}.")
    

    async def send_mailing(text, parse_mode, keyboard=None): async with connect('bot.db') as db: cursor = await db.execute("SELECT user_id FROM users") user_ids = [row[0] for row in await cursor.fetchall()]

    success_count = 0
    failure_count = 0
    for user_id in user_ids:
        try:
            await bot.send_message(
                chat_id=user_id,
                text=text,
                reply_markup=keyboard,
                parse_mode=types.ParseMode.HTML
            )
            success_count += 1
        except Exception as e:
            # Обрабатываем возможные исключения, например, если пользователь заблокировал бота
            logging.error(f"Failed to send message to {user_id}: {e}")
            failure_count += 1
    return success_count, failure_count
    

    Обработчик команды /skip для пропуска добавления кнопок

    @dp.message_handler(state=MailingState.waiting_for_buttons, commands=['skip']) async def post_skip(message: types.Message, state: FSMContext): await post_buttons(message, state)

    Хэндлер команды /sql для выполнения произвольных SQL-запросов (ТОЛЬКО для администраторов)

    @dp.message_handler(commands=['sql'], user_id=ADMINS) async def execute_sql_command(message: types.Message): # Получаем аргументы команды (SQL-запрос) sql_query = message.get_args()

    # Проверяем, что запрос не пустой
    if not sql_query:
        await message.reply("Введите SQL-запрос.")
        return
    
    # Подключаемся к базе данных и выполняем запрос
    async with connect('bot.db') as db:
        try:
            await db.execute(sql_query)
            await db.commit()
            await message.reply("SQL-запрос успешно выполнен.")
        except Exception as e:
            await message.reply(f"Ошибка при выполнении SQL-запроса: {e}")
    

    class UploadBackgroundState(StatesGroup): waiting_for_backgrounds = State()

    class UploadUserPhotoState(StatesGroup): waiting_for_user_photo = State()

    Админ-команда для очистки таблицы с общими фонами

    @dp.message_handler(commands=['clear_common'], user_id=ADMINS) async def clear_common_backgrounds(message: types.Message): async with connect('bot.db') as db: await db.execute("DELETE FROM common_backgrounds") await db.commit() await message.reply("Все общие фоны были успешно удалены из базы данных.")

    Админ-команда для просмотра количества общих фонов

    @dp.message_handler(commands=['count_common'], user_id=ADMINS) async def count_common_backgrounds(message: types.Message): async with connect('bot.db') as db: cursor = await db.execute("SELECT COUNT(*) FROM common_backgrounds") count = await cursor.fetchone() await message.reply(f"Количество общих фонов в базе данных: {count[0]}") async def generate_invite_link(chat_id): try: chat_invite_link = await bot.create_chat_invite_link(chat_id, expire_date=int(time.time()) + 900) # на 15 минут return chat_invite_link.invite_link except Exception as e: logging.error(e) return None

    async def is_user_subscribed(chat_id, user_id): try: member = await bot.get_chat_member(chat_id, user_id) return member.status not in ["left", "kicked"] except Exception as e: logging.error(e) return False # По умолчанию считаем, что пользователь не подписан, если возникла ошибка

    CHANNEL_ID = "-1002046113496" # ID вашего канала

    class SubscriptionCheckMiddleware(BaseMiddleware): def init(self, channel_id): super().init() self.channel_id = channel_id

    async def on_process_message(self, message: types.Message, data: dict):
        member = await bot.get_chat_member(self.channel_id, message.from_user.id)
        if member.status not in ["member", "administrator", "creator"]:
            invite_link = await generate_invite_link(self.channel_id)
            if invite_link:
                keyboard = InlineKeyboardMarkup().add(
                    InlineKeyboardButton("🔗 Подписаться на канал", url=invite_link)
                )
                await message.answer(
                    f"🔒 Для продолжения работы с ботом *необходимо подписаться на наш новостной канал\.*\n\n👌 Если вы уже подписались на канал, нажмите /start",parse_mode="MarkdownV2",
                    reply_markup=keyboard
                )
                # прерываем обработку следующих хэндлеров
                raise CancelHandler()
    
    async def post_process(self, obj, data, *args):
        pass
    

    dp.middleware.setup(SubscriptionCheckMiddleware(CHANNEL_ID)) @dp.message_handler(commands=['count']) async def count_backgrounds(message: types.Message): user_id = message.from_user.id async with connect('bot.db') as db: cursor = await db.execute("SELECT COUNT(*) FROM backgrounds WHERE user_id = ?", (user_id,)) count = await cursor.fetchone() await message.answer(f"У вас в базе данных {count[0]} фоновых изображений.",parse_mode="MarkdownV2")

    @dp.message_handler(commands=['ex']) async def export_backgrounds(message: types.Message): user_id = message.from_user.id try: # Получаем количество изображений для выгрузки из команды command_args = message.get_args().split() # если ничего не введено, выгрузить все num_images = int(command_args[0]) if command_args else -1 except (IndexError, ValueError): await message.answer("Укажите количество фонов для выгрузки. Например: /ex 10") return

    async with connect('bot.db') as db:
        # Если num_images равен -1, значит выгрузить все изображения
        query = "SELECT id, photo_id FROM backgrounds LIMIT ?"
        cursor = await db.execute(query, (10 if num_images == -1 else num_images,))
    
        backgrounds_chunk = await cursor.fetchall()
        while backgrounds_chunk:
            media_group = [types.InputMediaPhoto(photo[1]) for photo in backgrounds_chunk]
            await bot.send_media_group(message.chat.id, media_group)
    
            # Удаляем отправленные фоны из БД
            await db.executemany("DELETE FROM backgrounds WHERE id = ?", [(photo[0],) for photo in backgrounds_chunk])
            await db.commit()
    
            if num_images != -1:
                num_images -= len(backgrounds_chunk)
                if num_images <= 0:
                    break
    
            # Получаем следующую пачку изображений
            cursor = await db.execute(query, (10 if num_images == -1 else min(num_images, 10),))
            backgrounds_chunk = await cursor.fetchall()
    
        await message.answer("*Все запрошенные фоновые изображения были выгружены и удалены из базы данных\.*",parse_mode="MarkdownV2")
    

    LOG_CHANNEL_ID = "@smenalogs"

    async def log_to_channel(user: types.User, action: str): message_to_send = f"Пользователь @{user.username} ({user.id}) выполнил действие: {action}" await bot.send_message(LOG_CHANNEL_ID, message_to_send)

    stop_keyboard = ReplyKeyboardMarkup(resize_keyboard=True).add(KeyboardButton("Стоп"))

    async def start_keyboard(): # Создаем начальную клавиатуру с кнопками "Замена фона" и "Личный кабинет" return ReplyKeyboardMarkup(resize_keyboard=True).add( KeyboardButton("🖼 Замена фона") ).add( KeyboardButton("📊 Личный кабинет") )

    @dp.message_handler(commands=['stop'], state='*') async def stop_processing(message: types.Message, state: FSMContext): # … await message.reply("Обработка фотографий прекращена.", reply_markup=await start_keyboard()) await state.finish()

    @dp.message_handler(commands=['start', 'help']) async def send_welcome(message: types.Message): user_id = message.from_user.id first_name = message.from_user.first_name username = message.from_user.username

    # Подключаемся к БД и проверяем, существует ли пользователь
    async with connect('bot.db') as db:
        cursor = await db.execute("SELECT user_id FROM users WHERE user_id = ?", (user_id,))
        user_exists = await cursor.fetchone()
    
        # Если пользователя нет в БД, сохраняем его
        if not user_exists:
            await db.execute("INSERT INTO users (user_id, first_name, username) VALUES (?, ?, ?)",
                             (user_id, first_name, username))
            await db.commit()
    # Создаем кнопки
    button_photos = KeyboardButton("🖼 Замена фона")
    button_cabinet = KeyboardButton("📊 Личный кабинет")
    # Отправляем сообщение вместе с клавиатурой
    await message.answer(
        "Привет! Пользуйся кнопками",
        reply_markup=await start_keyboard()
    )
    await log_to_channel(message.from_user, "прописал /start")
    

    @dp.callback_query_handler( lambda c: c.data == 'toggle_common_backgrounds_on' or c.data == 'toggle_common_backgrounds_off') async def toggle_common_backgrounds(callback_query: types.CallbackQuery): user_id = callback_query.from_user.id # Переключаем состояние использования общих фонов new_setting = not (callback_query.data == 'toggle_common_backgrounds_on')

    # Сохраняем новое состояние в базу данных
    async with connect('bot.db') as db:
        await db.execute("UPDATE users SET use_common_backgrounds = ? WHERE user_id = ?", (int(new_setting), user_id))
        await db.commit()
    
    # Ответное сообщение пользователю
    reply_text = "Общие фоны включены." if new_setting else "Общие фоны выключены."
    await bot.answer_callback_query(callback_query.id, reply_text)
    
    # Обновить сообщение в "личном кабинете", чтобы отразить изменения с "включено/выключено"
    await personal_cabinet(callback_query)
    

    @dp.callback_query_handler(lambda c: c.data == 'support') async def support_callback(callback_query: types.CallbackQuery): support_text = ( "❓ Если у вас есть вопросы, предложения, проблемы - обращайтесь к администратору бота.\n\n" "Нажмите на кнопку ниже, чтобы связаться." ) admin_button = InlineKeyboardMarkup().add( InlineKeyboardButton("👨‍💻 Администратор бота", url="t.me/ih82seeucry") ) await bot.edit_message_text( chat_id=callback_query.message.chat.id, message_id=callback_query.message.message_id, text=support_text, parse_mode="MarkdownV2", reply_markup=admin_button ) @dp.message_handler(lambda message: message.text == "📊 Личный кабинет") async def personal_cabinet(message_or_query): # Определяем, является ли объект сообщением или коллбэк-запросом if isinstance(message_or_query, types.Message): user_id = message_or_query.from_user.id message = message_or_query elif isinstance(message_or_query, types.CallbackQuery): user_id = message_or_query.from_user.id message = message_or_query.message else: return # Если полученный объект не поддерживается, не предпринимать никаких действий

    async with connect('bot.db') as db:
        cursor = await db.execute("SELECT COUNT(*) FROM backgrounds WHERE user_id = ?", (user_id,))
        count = (await cursor.fetchone())[0]
    
        cursor = await db.execute("SELECT use_common_backgrounds FROM users WHERE user_id = ?", (user_id,))
        use_common_backgrounds = (await cursor.fetchone())[0]
        common_bg_status = "включено" if use_common_backgrounds else "выключено"
        cursor = await db.execute(
            "SELECT common_backgrounds_count, personal_backgrounds_count FROM users WHERE user_id = ?", (user_id,))
        counts = await cursor.fetchone()
        common_bg_count = counts[0]
        personal_bg_count = counts[1]
    toggle_text = "Общие фоны: вкл" if use_common_backgrounds else "Общие фоны: выкл"
    callback_data = 'toggle_common_backgrounds_on' if use_common_backgrounds else 'toggle_common_backgrounds_off'
    
    keyboard = InlineKeyboardMarkup(row_width=1).add(
        InlineKeyboardButton("Загрузить фоны", callback_data='upload_backgrounds'),
        InlineKeyboardButton("Загрузить креатив", callback_data='upload_user_photos'),
        InlineKeyboardButton("Очистить фоны", callback_data='clear_backgrounds'),
        InlineKeyboardButton(toggle_text, callback_data=callback_data),
        InlineKeyboardButton("Поддержка", callback_data='support')
    )
    
    text_message = f"*📊 Личный кабинет*\n\nКоличество фонов: {count}\nИспользование общих фонов *{common_bg_status}*\n\nКоличество использований общих фонов: {common_bg_count}\nКоличество использований личных фонов: {personal_bg_count}"
    if isinstance(message_or_query, types.CallbackQuery):
        try:
            # Метод для изменения текста сообщения и клавиатуры
            await bot.edit_message_text(text=text_message, chat_id=message.chat.id, message_id=message.message_id,
                                        parse_mode="MarkdownV2", reply_markup=keyboard)
        except MessageNotModified:
            # Ничего не делаем, если содержимое сообщения не изменилось
            pass
    else:
        await message.answer(text_message, parse_mode="MarkdownV2", reply_markup=keyboard)
    

    @dp.callback_query_handler(lambda c: c.data == 'upload_backgrounds') async def upload_backgrounds(callback_query: types.CallbackQuery): await upload_background_start(callback_query.message) await bot.send_message(callback_query.from_user.id, "Отправьте фоны для загрузки или нажмите Стоп, чтобы завершить.", reply_markup=stop_keyboard)

    @dp.callback_query_handler(lambda c: c.data == 'upload_user_photos') async def upload_user_photos(callback_query: types.CallbackQuery): await clear_user_photos_action(callback_query.from_user.id) await upload_user_photo_start(callback_query.message) await bot.send_message(callback_query.from_user.id, "Отправьте креатив для загрузки или нажмите Стоп, чтобы завершить.", reply_markup=stop_keyboard)

    @dp.callback_query_handler(lambda c: c.data == 'clear_backgrounds') async def clear_backgrounds(callback_query: types.CallbackQuery): confirmation_keyboard = InlineKeyboardMarkup().add( InlineKeyboardButton("Да", callback_data='confirm_clear_backgrounds'), InlineKeyboardButton("Нет", callback_data='cancel_clear_backgrounds') ) await callback_query.message.edit_text( "Вы уверены, что хотите удалить все свои фоны из базы? Это действие необратимо.", reply_markup=confirmation_keyboard ) @dp.callback_query_handler(lambda c: c.data == 'confirm_clear_backgrounds') async def confirm_clear_backgrounds(callback_query: types.CallbackQuery): user_id = callback_query.from_user.id async with connect('bot.db') as db: await db.execute("DELETE FROM backgrounds WHERE user_id = ?", (user_id,)) await db.commit() await bot.answer_callback_query(callback_query.id, "Ваши фоновые изображения были удалены из базы данных.") await callback_query.message.delete() await log_to_channel(callback_query.from_user, "очистил свои фоновые изображения") await send_welcome(callback_query.message) @dp.callback_query_handler(lambda c: c.data == 'cancel_clear_backgrounds') async def cancel_clear_backgrounds(callback_query: types.CallbackQuery): await callback_query.message.delete() await send_welcome(callback_query.message)

    общие фоны

    class UploadCommonBackgroundState(StatesGroup): waiting_for_common_backgrounds = State()

    @dp.message_handler(commands=['common'], user_id=ADMINS, state='*') async def upload_common_background_start(message: types.Message): await UploadCommonBackgroundState.waiting_for_common_backgrounds.set() await message.reply("Отправьте общие фоны для загрузки или нажмите Стоп, чтобы сохранить их в базу данных.", reply_markup=stop_keyboard)

    @dp.message_handler(content_types=['photo'], state=UploadCommonBackgroundState.waiting_for_common_backgrounds) async def upload_common_background(message: types.Message, state: FSMContext): photo_id = message.photo[-1].file_id state_data = await state.get_data() buffer = state_data.get('buffer', []) buffer.append(photo_id) await state.update_data(buffer=buffer) await message.reply( "Фон добавлен в очередь. Продолжайте добавлять фоны или нажмите Стоп, чтобы сохранить их в базу данных.")

    @dp.message_handler(lambda message: message.text.lower() == "стоп", state=UploadCommonBackgroundState.waiting_for_common_backgrounds) async def stop_uploading_common_backgrounds(message: types.Message, state: FSMContext): state_data = await state.get_data() buffer = state_data.get('buffer', []) if buffer: async with connect('bot.db') as db: await db.executemany("INSERT INTO common_backgrounds (photo_id) VALUES (?)", [(photo_id,) for photo_id in buffer]) await db.commit() await state.finish() await message.reply("Все общие фоны сохранены в базу данных.", reply_markup=await start_keyboard())

    @dp.callback_query_handler(lambda c: c.data == 'back_to_start') async def back_to_start(callback_query: types.CallbackQuery): await send_welcome(callback_query.message)

    @dp.message_handler(commands=['clear_upload']) async def clear_backgrounds(message: types.Message): user_id = message.from_user.id # Получаем ID пользователя async with connect('bot.db') as db: # Удаляем только фоны конкретного пользователя await db.execute("DELETE FROM backgrounds WHERE user_id = ?", (user_id,)) await db.commit() await message.answer("Ваши фоновые изображения были удалены из базы данных.") await log_to_channel(message.from_user, "очистил свои фоновые изображения")

    async def clear_user_photos_action(user_id: int): async with connect('bot.db') as db: await db.execute("DELETE FROM userphotos WHERE user_id = ?", (user_id,)) await db.commit() @dp.message_handler(commands=['clear_user']) async def clear_user_photos(message: types.Message): user_id = message.from_user.id await clear_user_photos_action(user_id) await message.answer("Ваш креатив был удален из базы данных.") await log_to_channel(message.from_user, "очистил userphoto")

    Инициируем FSM для загрузки фонов

    @dp.message_handler(commands=['upload'], state='*') async def upload_background_start(message: types.Message): logging.info("прием аплоад") await UploadBackgroundState.waiting_for_backgrounds.set() await log_to_channel(message.from_user, "прописал /upload")

    Инициируем FSM для загрузки пользовательского фото

    @dp.message_handler(commands=['user'], state='*') async def upload_user_photo_start(message: types.Message): logging.info("прием юзер фото") await UploadUserPhotoState.waiting_for_user_photo.set() await log_to_channel(message.from_user, "загружает userphoto")

    Обработка загрузки фоновых фотографий

    @dp.message_handler(content_types=['photo'], state=UploadBackgroundState.waiting_for_backgrounds) async def upload_background(message: types.Message, state: FSMContext): user_id = message.from_user.id photo_id = message.photo[-1].file_id state_data = await state.get_data() buffer = state_data.get("buffer", []) buffer.append((user_id, photo_id)) await state.update_data(buffer=buffer) await message.answer("Фон добавлен. Не забудьте нажать Стоп, чтобы сохранить все ваши фото в базу",parse_mode="MarkdownV2")

    Обработка загрузки пользовательских фотографий

    @dp.message_handler(content_types=['photo'], state=UploadUserPhotoState.waiting_for_user_photo) async def upload_user_photo(message: types.Message, state: FSMContext): user_id = message.from_user.id photo_id = message.photo[-1].file_id state_data = await state.get_data() buffer = state_data.get("buffer", []) buffer.append((user_id, photo_id)) await state.update_data(buffer=buffer) await message.answer("Фото креатива добавлено в очередь. Не забудьте нажать Стоп, чтобы сохранить все ваши фото в базу",parse_mode="MarkdownV2")

    Переход обратно в обычное состояние после команды /stop

    @dp.message_handler(commands=['stop'], state='*') async def stop_processing(message: types.Message, state: FSMContext): logging.info("Процесс остановлен пользователем") await state.finish() await message.reply("Обработка фотографий прекращена.", reply_markup=await start_keyboard()) @dp.message_handler(lambda message: message.text.lower() == "стоп", state=UploadBackgroundState.waiting_for_backgrounds) async def stop_processing_background(message: types.Message, state: FSMContext): state_data = await state.get_data() buffer = state_data.get("buffer", []) if buffer: async with connect('bot.db') as db: await db.executemany("INSERT INTO backgrounds (user_id, photo_id) VALUES (?, ?)", buffer) await db.commit() await state.update_data(buffer=[]) # Очистка буфера после сохранения await state.finish() await message.answer("Все фоны сохранены в базу данных.",parse_mode="MarkdownV2", reply_markup=await start_keyboard())

    Обработка команды "Стоп" для загрузки фотографий пользователя

    @dp.message_handler(lambda message: message.text.lower() == "стоп", state=UploadUserPhotoState.waiting_for_user_photo) async def stop_processing_user_photo(message: types.Message, state: FSMContext): state_data = await state.get_data() buffer = state_data.get("buffer", []) if buffer: async with connect('bot.db') as db: await db.executemany("INSERT INTO userphotos (user_id, photo_id) VALUES (?, ?)", buffer) await db.commit() await state.update_data(buffer=[]) # Очистка буфера после сохранения await state.finish() await message.answer("Все ваши фотографии сохранены в базу данных.",parse_mode="MarkdownV2", reply_markup=await start_keyboard())

    async def fetch_photo(file_url): async with aiohttp.ClientSession() as session: async with session.get(file_url, ssl=False) as resp: return await resp.read()

    async def create_banned_users_table(): async with connect('bot.db') as db: await db.execute(""" CREATE TABLE IF NOT EXISTS banned_users ( user_id INTEGER PRIMARY KEY ) """) await db.commit()

    class BanUserState(StatesGroup): waiting_for_user_id = State()

    Добавьте обработку команды /ban только для администраторов

    @dp.message_handler(commands=['ban'], user_id=ADMINS) # Замените ADMINS на список ID администраторов async def ban_user_command(message: types.Message): args = message.get_args().split() if not args or not args[0].isdigit(): await message.reply("Необходимо указать ID пользователя для блокировки: /ban 123456789") return user_id_to_ban = int(args[0])

    async with connect('bot.db') as db:
        await db.execute("INSERT OR IGNORE INTO banned_users (user_id) VALUES (?)", (user_id_to_ban,))
        await db.commit()
    
    await message.reply(f"Пользователь {user_id_to_ban} заблокирован.")
    

    Добавьте проверку на наличие пользователя в списке заблокированных перед любым действием с ботом

    class CheckBanMiddleware(BaseMiddleware): async def on_process_message(self, message: types.Message, data: dict): user_id = message.from_user.id async with connect('bot.db') as db: cursor = await db.execute("SELECT user_id FROM banned_users WHERE user_id = ?", (user_id,)) is_banned = await cursor.fetchone() is not None if is_banned: admin_button = InlineKeyboardMarkup().add( InlineKeyboardButton("👨‍💻 Администратор бота", url="t.me/ih82seeucry") ) await message.answer( "Вы заблокированы администратором бота. Если у вас есть вопросы - обратитесь к администратору по кнопке ниже.", parse_mode="MarkdownV2", reply_markup=admin_button) raise CancelHandler()

    Регистрируйте middleware

    dp.middleware.setup(CheckBanMiddleware())

    @dp.message_handler(commands=['unban'], user_id=ADMINS) # Замените ADMINS на список ID администраторов async def unban_user_command(message: types.Message): args = message.get_args().split() if not args or not args[0].isdigit(): await message.reply("Необходимо указать ID пользователя для разблокировки: /unban 123456789") return user_id_to_unban = int(args[0])

    async with connect('bot.db') as db:
        await db.execute("DELETE FROM banned_users WHERE user_id = ?", (user_id_to_unban,))
        await db.commit()
    
    await message.reply(f"Пользователь {user_id_to_unban} разблокирован.")
    

    Use this handler to get photos from the database, apply changes, and send to the user

    @dp.message_handler(commands=['photos']) async def send_processed_photos(message: types.Message): user_id = message.from_user.id async with connect('bot.db') as db: cursor = await db.execute("SELECT COUNT(*) FROM userphotos WHERE user_id = ?", (user_id,)) user_photo_count = (await cursor.fetchone())[0]

        cursor = await db.execute("SELECT id, photo_id FROM backgrounds WHERE user_id = ?", (user_id,))
        backgrounds = await cursor.fetchall()
    
        cursor = await db.execute("SELECT id, photo_id FROM userphotos WHERE user_id = ?", (user_id,))
        user_photos = await cursor.fetchall()
    
        if not backgrounds or not user_photos:
            await message.reply("Необходимо загрузить фоновые изображения и/или креатив.")
            return
    
        used_background_ids = []  # Сюда будут собираться ID использованных фонов для последующего удаления
        media_groups = []  # Здесь будут храниться пачки изображений для отправки
    
        for user_photo in user_photos:
            if not backgrounds:
                await message.reply("Количество фонов меньше количества фотографий в креативе.")
                break  # Если фоновых изображений недостаточно, прекращаем обработку
    
            background = backgrounds.pop(0)  # Получаем первый фон из списка
            used_background_ids.append(background[0])  # Добавляем ID фона в список использованных
    
            processed_image_io = await apply_background(user_photo[1], background[1], padding_horizontal=100, padding_vertical=70)
            media_groups.append(types.InputMediaPhoto(processed_image_io))
    
            # Если в текущей пачке 4 изображения или это последняя итерация, отправляем пачку
            if len(media_groups) == user_photo_count or not backgrounds:
                await bot.send_media_group(message.chat.id, media=media_groups)
                media_groups = []  # Очищаем текущую пачку для следующей
    
        # Удаляем использованные фоны из базы данных
        if used_background_ids:
            await db.executemany("DELETE FROM backgrounds WHERE id = ?", [(id,) for id in used_background_ids])
            await db.commit()
    

    Function to apply background to user photo

    async def apply_background(user_photo_id, background_photo_id, padding_horizontal=100, padding_vertical=70, blur_radius=5): logging.info("обработка фото") user_photo_file = await bot.get_file(user_photo_id) background_photo_file = await bot.get_file(background_photo_id)

    user_photo_url = bot.get_file_url(user_photo_file.file_path)
    background_photo_url = bot.get_file_url(background_photo_file.file_path)
    
    user_photo_data = await fetch_photo(user_photo_url)
    background_photo_data = await fetch_photo(background_photo_url)
    
    with Image.open(BytesIO(user_photo_data)) as user_image, Image.open(BytesIO(background_photo_data)) as background_image:
        user_image = user_image.convert('RGBA')
        background_image = background_image.convert('RGBA')
        background_image = background_image.filter(ImageFilter.GaussianBlur(blur_radius))
    
        # Задаем размер фона, увеличенный на указанные отступы
        new_background_width = user_image.width + padding_horizontal * 2  # Слева и справа
        new_background_height = user_image.height + padding_vertical * 2  # Сверху и снизу
        background_image = background_image.resize((new_background_width, new_background_height), Image.Resampling.LANCZOS)
    
        # Готовим позицию для наложения фото пользователя на фон
        user_image_position = (padding_horizontal, padding_vertical)  # Отступы слева и сверху
    
        # Накладываем пользовательское изображение на фон
        background_image.paste(user_image, user_image_position, user_image.split()[3])  # Используем альфа-канал для маски
    
        # Сохраняем во временный файл
        result_image_io = BytesIO()
        background_image.save(result_image_io, format='PNG')
        result_image_io.seek(0)
    
        return result_image_io
    

    async def delete_used_backgrounds(used_background_ids): if used_background_ids: async with connect('bot.db') as db: await db.executemany("DELETE FROM backgrounds WHERE id = ?", [(bg_id,) for bg_id in used_background_ids]) await db.commit() async def get_use_common_backgrounds(db, user_id): cursor = await db.execute("SELECT use_common_backgrounds FROM users WHERE user_id = ?", (user_id,)) result = await cursor.fetchone() return result[0] if result else False

    async def get_backgrounds(db, user_id, use_common_backgrounds): if use_common_backgrounds: cursor = await db.execute("SELECT id, photo_id FROM common_backgrounds") else: cursor = await db.execute("SELECT id, photo_id FROM backgrounds WHERE user_id = ?", (user_id,)) return await cursor.fetchall()

    async def get_user_photos(db, user_id): cursor = await db.execute("SELECT photo_id FROM userphotos WHERE user_id = ?", (user_id,)) return await cursor.fetchall() @dp.message_handler(lambda message: message.text == "🖼 Замена фона") async def on_change_background_button(message: types.Message): user_id = message.from_user.id used_background_ids = []

    async with connect('bot.db') as db:
        use_common_backgrounds = await get_use_common_backgrounds(db, user_id)
        backgrounds = await get_backgrounds(db, user_id, use_common_backgrounds)
        user_photos = await get_user_photos(db, user_id)
    
    if not backgrounds or not user_photos:
        await message.answer("Необходимо загрузить фоновые изображения и/или креатив.")
        return
    
    media_groups = []
    background_index = 0
    
    for user_photo in user_photos:
        if not use_common_backgrounds:
            background = backgrounds[background_index]
            used_background_ids.append(background[0])
            background_index += 1
            if background_index >= len(backgrounds):
                background_index = 0
        else:
            background = random.choice(backgrounds)  # случайный фон для общего использования
    
        processed_image_io = await apply_background(user_photo[0], background[0])
        media_groups.append(types.InputMediaPhoto(processed_image_io))
    
    if media_groups:
        await bot.send_media_group(message.chat.id, media=media_groups)
        await delete_used_backgrounds(used_background_ids)
    

    Init DB on startup

    async def on_startup(_): print("Starting bot…") await init_db() await create_banned_users_table()

    Starting the bot

    if name == 'main': executor.start_polling(dp, skip_updates=True, on_startup=on_startup)

  2. Assistant

    Ошибка, о которой вы сообщаете, указывает на проблему с неправильным идентификатором файла (file_id) при попытке получить файл с помощью метода get_file. Ошибка BadRequest('Invalid file_id') говорит о том, что Telegram API не может найти файл с данным file_id.

    Ваш обработчик событий on_change_background_button, который запускается при нажатии на кнопку "🖼 Замена фона", пытается получить доступ к файлу (фото) для изменения фона на изображении пользователя. Проблема вызывается когда метод apply_background пытается вызвать bot.get_file, передавая невалидный file_id.

    Чтобы решить эту проблему:

    1. Убедитесь, что file_id, который вы передаете в метод apply_background, действительно указывает на существующий файл в Telegram, и что этот файл доступен для бота.
    2. Проверьте логику, по которой вы выбираете file_id для фонов и пользовательских фото, чтобы удостовериться что они верные. Возможно, file_id устарел или был удален.
    3. Если file_id указывает на фотографию, которая должна быть доступна, убедитесь, что ваш бот не превышает ограничения по времени на использование file_id. В Telegram есть ограничение по времени на использование file_id после загрузки фотографии. Оно может быть около 1 часа для ссылок на файлы.

    Также обратите внимание на обработку исключений вокруг вызова bot.get_file. Вы должны корректно обработать исключение BadRequest, чтобы ваш бот мог продолжать работу в случае, если какой-либо file_id не найден.

    Предположительно, ошибка может возникать в этой части кода:

    for user_photo in user_photos:
        if not use_common_backgrounds:
            ...
        else:
            background = random.choice(backgrounds)  # случайный фон для общего использования
    
        processed_image_io = await apply_background(user_photo[0], background[0])  # Здесь может быть неправильный file_id
        ...
    

    Вы можете добавить try-except блок вокруг вызова bot.get_file, чтобы обработать BadRequest исключение и определить, какой именно file_id неверен.

    Пример:

    try:
        background_photo_file = await bot.get_file(background_photo_id)
    except BadRequest as e:
        logging.error(f"Invalid file_id: {background_photo_id}")
        continue  # Пропустить текущий file_id и продолжить с следующим
    

    Обратите внимание на методы send_processed_photos и apply_background, убедитесь, что они используют правильные file_id.

    Помимо этого, следует рассмотреть возможность добавления проверок на существование файлов с данной file_id перед их использованием в функции apply_background.

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