У меня есть 2 кода, один для бота, второй для админ панели:
```python
# main.py
import os
import string
import random
import sqlite3
import asyncio
import logging
from telegram import (
    Update,
    ReplyKeyboardMarkup,
    InlineKeyboardButton,
    InlineKeyboardMarkup,
)
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    ContextTypes,
    CallbackQueryHandler,
)
from dotenv import load_dotenv
from gradio_client import Client

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

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

BOT_TOKEN = os.getenv('BOT_TOKEN')
ADMIN_USER_ID = os.getenv('ADMIN_USER_ID')  # ID администратора для уведомлений
SBERBANK_NUMBER = os.getenv('SBERBANK_NUMBER')
SBERBANK_AMOUNT = os.getenv('SBERBANK_AMOUNT')
O1MINI_CLIENT_URL = os.getenv('O1MINI_CLIENT_URL')  # URL вашего нейросетевого API

# Проверка наличия всех необходимых переменных окружения
if not all([BOT_TOKEN, ADMIN_USER_ID, SBERBANK_NUMBER, SBERBANK_AMOUNT, O1MINI_CLIENT_URL]):
    raise ValueError("Пожалуйста, убедитесь, что все переменные окружения корректно настроены.")

# Инициализация базы данных
def init_db():
    conn = sqlite3.connect('payments.db')
    conn.row_factory = sqlite3.Row
    cursor = conn.cursor()
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS payments (
        user_id INTEGER PRIMARY KEY,
        unique_id TEXT,
        payment_status TEXT,
        requests_left INTEGER DEFAULT 0
    )
    ''')
    conn.commit()
    return conn, cursor

conn, cursor = init_db()

# Генерация уникального ID
def generate_unique_id(length=8):
    characters = string.ascii_letters + string.digits
    return ''.join(random.choice(characters) for _ in range(length))

# Инициализация клиента для нейросети
client = Client(O1MINI_CLIENT_URL)

# Команда /start
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user = update.effective_user
    user_id = user.id

    # Проверка, если пользователь уже оплатил
    cursor.execute("SELECT payment_status FROM payments WHERE user_id=?", (user_id,))
    result = cursor.fetchone()

    if result and result['payment_status'] == 'paid':
        welcome_text = (
            f"👋 Привет, @{user.username if user.username else 'Неведомый пользователь'}!\n\n"
            "Вы уже оплатили доступ. Вы можете задать вопрос нейросети с помощью команды /ask."
        )
        await update.message.reply_text(welcome_text)
    else:
        unique_id = generate_unique_id()
        cursor.execute("""
            INSERT OR REPLACE INTO payments (user_id, unique_id, payment_status, requests_left) 
            VALUES (?, ?, ?, ?)
        """, (user_id, unique_id, 'pending', 0))
        conn.commit()

        payment_instructions = (
            "👋 Привет! Добро пожаловать в нашего Telegram-бота с нейросетью.\n\n"
            "📄 **Доступные Команды:**\n"
            "/start - Запустить бота и получить инструкции.\n"
            "/ask - Задать вопрос нейросети.\n"
            "/me - Просмотреть ваш профиль.\n"
            "/help - Показать список доступных команд.\n\n"
            "🛒 **Оплата:**\n"
            "Чтобы получить доступ к функциям бота и общению с нейросетью, пожалуйста, совершите перевод на следующую карту Сбербанк:\n\n"
            f"📱 **Номер для перевода:** `{SBERBANK_NUMBER}`\n"
            f"💰 **Сумма:** `{SBERBANK_AMOUNT}` рублей\n"
            f"🆔 **Уникальный ID:** `{unique_id}`\n\n"
            "❗ **Важно:** Введите ваш Уникальный ID в комментарии к переводу.\n\n"
            "После совершения перевода, нажмите кнопку с вашим уникальным ID для подтверждения оплаты."
        )

        # Кнопка для подтверждения оплаты
        keyboard = [
            [InlineKeyboardButton(unique_id, callback_data=f"confirm_{unique_id}")]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)

        await update.message.reply_text(
            payment_instructions,
            reply_markup=reply_markup,
            parse_mode='Markdown'
        )

# Обработка нажатий кнопок
async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    await query.answer()

    data = query.data

    if data.startswith("confirm_"):
        unique_id = data.split("_")[1]
        user_id = query.from_user.id
        username = query.from_user.username or "Н/A"

        # Уведомление администратора о подтверждении оплаты
        admin_message = (
            f"🔔 **Запрос на Подтверждение Оплаты**\n"
            f"Пользователь @{username} (ID: {user_id}) запросил подтверждение оплаты.\n\n"
            f"🆔 **Уникальный ID:** `{unique_id}`\n\n"
            f"Пожалуйста, используйте вашу административную панель для подтверждения оплаты."
        )

        try:
            await context.bot.send_message(chat_id=ADMIN_USER_ID, text=admin_message, parse_mode='Markdown')
            await query.edit_message_text("✅ Ваш запрос на подтверждение оплаты отправлен администратору. Ожидайте подтверждения.")
        except Exception as e:
            logger.error(f"Ошибка при отправке сообщения администратору: {e}")
            await query.edit_message_text("❌ Произошла ошибка при отправке запроса администратору. Пожалуйста, попробуйте позже.")

# Команда /me для просмотра профиля
async def me(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    user = update.effective_user
    cursor.execute("SELECT unique_id, payment_status, requests_left FROM payments WHERE user_id=?", (user_id,))
    result = cursor.fetchone()

    if not result:
        await update.message.reply_text("❌ Вы ещё не зарегистрированы. Введите /start для начала.")
        return

    unique_id = result['unique_id']
    payment_status = result['payment_status']
    requests_left = result['requests_left']

    profile_info = (
        f"📝 **Ваш Профиль:**\n\n"
        f"**Никнейм:** @{user.username if user.username else 'Н/A'}\n"
        f"**ID Пользователя:** {user_id}\n"
        f"**Уникальный ID:** `{unique_id}`\n"
        f"**Статус Оплаты:** {'✅ Оплачено' if payment_status == 'paid' else '❌ Неоплачено'}\n"
        f"**Доступные Запросы:** {requests_left}"
    )

    await update.message.reply_text(profile_info, parse_mode='Markdown')

# Команда /help
async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    help_text = (
        "📖 **Доступные Команды:**\n\n"
        "/start - Запустить бота и получить инструкции.\n"
        "/ask - Задать вопрос нейросети.\n"
        "/me - Просмотреть ваш профиль.\n"
        "/help - Показать список доступных команд."
    )
    await update.message.reply_text(help_text, parse_mode='Markdown')

# Команда /ask для взаимодействия с нейросетью
async def ask_neural_network(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    user_input_text = update.message.text.strip()

    # Исключить команду /ask из запроса
    if user_input_text.startswith('/ask'):
        user_query = user_input_text[4:].strip()
    else:
        user_query = user_input_text

    if not user_query:
        await update.message.reply_text("❗ Пожалуйста, задайте свой вопрос после команды /ask.")
        return

    # Проверка количества оставшихся запросов
    cursor.execute("SELECT payment_status, requests_left FROM payments WHERE user_id=?", (user_id,))
    result = cursor.fetchone()

    if not result or result['payment_status'] != 'paid':
        await update.message.reply_text(
            "🚫 Для доступа, пожалуйста, оплатите.",
            reply_markup=ReplyKeyboardMarkup([["Отправить ID"]], one_time_keyboard=True),
        )
        return

    requests_left = result['requests_left']
    if requests_left <= 0:
        await update.message.reply_text("⚠️ У вас закончились запросы. Пожалуйста, продлите подписку.")
        return

    # Отправка запроса к нейросети
    await update.message.reply_text("🔄 Обрабатываю ваш запрос...")

    try:
        # Поскольку gradio_client синхронный, выполняем его в отдельном потоке
        loop = asyncio.get_event_loop()
        response = await loop.run_in_executor(None, lambda: client.predict(
            inputs=user_query,
            top_p=1,
            temperature=1,
            chat_counter=0,
            chatbot=[],
            api_name="/predict"
        ))

        # Логирование полного ответа для отладки
        logger.info(f"Полный ответ от нейросети: {response}")

        # Проверка и обработка формата ответа
        neural_response = ""
        if isinstance(response, tuple):
            try:
                # Предполагаем, что первый элемент кортежа — это список с вопросом и ответом
                first_elem = response[0]
                if isinstance(first_elem, list) and len(first_elem) > 0:
                    inner_list = first_elem[0]
                    if isinstance(inner_list, list) and len(inner_list) > 1:
                        # Извлекаем второй элемент — ответ
                        neural_response = inner_list[1]
                    else:
                        neural_response = "❌ Не удалось извлечь ответ из структуры ответа нейросети."
                else:
                    neural_response = "❌ Не удалось извлечь ответ из структуры ответа нейросети."
            except Exception as e:
                logger.error(f"Ошибка при разборе кортежа ответа: {e}")
                neural_response = "❌ Произошла внутренняя ошибка при обработке ответа нейросети."
        elif isinstance(response, list):
            if len(response) >= 2:
                # Ожидаем, что второй элемент списка содержит ответ
                neural_response = response[1]
            elif len(response) == 1:
                # В случае, если есть только один элемент, предполагаем, что это ответ
                neural_response = response[0]
            else:
                neural_response = "❌ Получен пустой ответ от нейросети."
        elif isinstance(response, dict):
            # Если ответ в виде словаря, попытаться извлечь значение по ключу
            neural_response = response.get('answer', "❌ Не удалось извлечь ответ из полученных данных.")
        else:
            neural_response = "❌ Получен неизвестный формат ответа от нейросети."

        # Проверка содержимого нейросетевого ответа
        if neural_response and not neural_response.startswith("❌"):
            await update.message.reply_text(neural_response)
            # Уменьшаем количество запросов
            cursor.execute("UPDATE payments SET requests_left = requests_left - 1 WHERE user_id=?", (user_id,))
            conn.commit()
        else:
            await update.message.reply_text(neural_response if neural_response else "❌ Не удалось получить содержательный ответ от нейросети.")

    except Exception as e:
        logger.error(f"Ошибка при взаимодействии с нейросетью: {e}")
        await update.message.reply_text("❌ Произошла ошибка при обработке вашего запроса. Пожалуйста, попробуйте позже.")

# Основная функция для запуска бота
def main():
    application = ApplicationBuilder().token(BOT_TOKEN).build()

    # Регистрация обработчиков команд
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("ask", ask_neural_network))
    application.add_handler(CommandHandler("me", me))
    application.add_handler(CommandHandler("help", help_command))
    
    # Регистрация обработчика нажатий кнопок
    application.add_handler(CallbackQueryHandler(button_handler))

    logger.info("Бот запущен...")
    application.run_polling()

if __name__ == '__main__':
    main()
```
```python
#admin.py
import os
import sqlite3
from dotenv import load_dotenv
from telegram import Bot
import asyncio

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

BOT_TOKEN = os.getenv('BOT_TOKEN')
ADMIN_USER_ID = os.getenv('ADMIN_USER_ID')  # Не обязательно, но может быть использовано для уведомлений администратора

if not BOT_TOKEN:
    raise ValueError("Пожалуйста, убедитесь, что переменная окружения BOT_TOKEN настроена.")

# Подключение к базе данных
def init_db():
    conn = sqlite3.connect('payments.db')
    conn.row_factory = sqlite3.Row  # Для доступа к столбцам по имени
    cursor = conn.cursor()
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS payments (
        user_id INTEGER PRIMARY KEY,
        unique_id TEXT,
        payment_status TEXT,
        requests_left INTEGER DEFAULT 0
    )
    ''')
    conn.commit()
    return conn, cursor

conn, cursor = init_db()

async def send_notification(user_id):
    bot = Bot(token=BOT_TOKEN)
    message = "Ваш платеж был подтвержден! Спасибо за оплату. Вам выдано 210 запросов."
    try:
        await bot.send_message(chat_id=user_id, text=message)
    except Exception as e:
        print(f"Ошибка при отправке сообщения пользователю {user_id}: {e}")
    finally:
        await bot.close()

async def confirm_payment(unique_id):
    # Поиск пользователя по unique_id
    cursor.execute("SELECT user_id, payment_status FROM payments WHERE unique_id=?", (unique_id,))
    result = cursor.fetchone()
    
    if not result:
        print(f"Уникальный ID {unique_id} не найден.")
        return
    
    user_id = result['user_id']
    payment_status = result['payment_status']
    
    if payment_status == 'paid':
        print(f"Платеж для пользователя с ID {user_id} уже подтвержден.")
        return
    
    # Обновление статуса оплаты и установка количества запросов
    cursor.execute("UPDATE payments SET payment_status=?, requests_left=? WHERE user_id=?", ('paid', 210, user_id))
    conn.commit()
    print(f"Платеж для пользователя с ID {user_id} успешно подтвержден. Выдано 210 запросов.")
    
    # Отправка уведомления пользователю
    await send_notification(user_id)

def main():
    print("=== Административная программа для подтверждения оплат ===")
    loop = asyncio.get_event_loop()
    while True:
        user_input = input("Введите уникальный ID для подтверждения оплаты (или 'exit' для выхода): ").strip()
        if user_input.lower() == 'exit':
            break
        loop.run_until_complete(confirm_payment(user_input))
    conn.close()
    print("Программа завершена.")

if __name__ == '__main__':
    main()
```
Найди несоответствия между админ панелью и ботом, исправь это и улучши интерфейс админ панели