Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

import logging from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup…

  1. User

    import logging from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup from telegram.ext import ( ApplicationBuilder, CommandHandler, ContextTypes, CallbackQueryHandler, MessageHandler, filters, ConversationHandler ) import sqlite3 from datetime import datetime import random

    Настройка логирования

    logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO ) logger = logging.getLogger(name)

    Подключение к базе данных

    conn = sqlite3.connect('attendance_bot.db', check_same_thread=False) cursor = conn.cursor()

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

    cursor.execute(''' CREATE TABLE IF NOT EXISTS students ( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL UNIQUE, duty_count INTEGER DEFAULT 0 ) ''')

    cursor.execute(''' CREATE TABLE IF NOT EXISTS attendance ( id INTEGER PRIMARY KEY AUTOINCREMENT, date TEXT NOT NULL, student_id INTEGER, status TEXT, FOREIGN KEY(student_id) REFERENCES students(id) ) ''')

    conn.commit()

    Определение состояний для ConversationHandler

    ADDING_STUDENT = 1

    Ваш Telegram ID для ограничения доступа (замените на ваш фактический Telegram ID)

    ADMIN_USER_ID = 1525524847 # Замените на ваш Telegram ID

    def restricted(func): async def wrapped(update: Update, context: ContextTypes.DEFAULT_TYPE): user_id = update.effective_user.id if user_id != ADMIN_USER_ID: await update.message.reply_text("У вас нет доступа к этой команде.") return return await func(update, context) return wrapped

    Команда /start

    async def start(update: Update, context: ContextTypes.DEFAULT_TYPE): await update.message.reply_text( "Привет! Я помогу вам вести посещаемость и распределять дежурства.\n\n" + "Команды:\n" + "/add_student - Добавить студента\n" + "/mark_attendance - Отметить посещаемость\n" + "/assign_duty - Назначить дежурство\n" + "/stats - Показать статистику\n" + "/cancel - Отменить текущую операцию" )

    Команда /add_student

    @restricted async def add_student(update: Update, context: ContextTypes.DEFAULT_TYPE): await update.message.reply_text("Введите имя студента:") return ADDING_STUDENT

    Обработка имени студента

    @restricted async def add_student_name(update: Update, context: ContextTypes.DEFAULT_TYPE): name = update.message.text.strip() if not name: await update.message.reply_text("Имя не может быть пустым. Попробуйте снова:") return ADDING_STUDENT try: cursor.execute("INSERT INTO students (name) VALUES (?)", (name,)) conn.commit() await update.message.reply_text(f"Студент '{name}' добавлен.") except sqlite3.IntegrityError: await update.message.reply_text(f"Студент '{name}' уже существует.") return ConversationHandler.END

    Отмена операции добавления студента

    @restricted async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE): await update.message.reply_text("Добавление студента отменено.") return ConversationHandler.END

    Команда /mark_attendance

    @restricted async def mark_attendance(update: Update, context: ContextTypes.DEFAULT_TYPE): today = datetime.now().strftime("%Y-%m-%d")

    # Проверка, была ли уже отмечена посещаемость сегодня
    existing = cursor.execute("SELECT COUNT(*) FROM attendance WHERE date = ?", (today,)).fetchone()[0]
    if existing > 0:
        await update.message.reply_text(
            "Посещаемость на сегодня уже была отмечена. Если хотите отметить заново, выполните /reset_attendance."
        )
        return
    
    cursor.execute("SELECT id, name FROM students ORDER BY name")
    students = cursor.fetchall()
    
    if not students:
        await update.message.reply_text("Список студентов пуст. Добавьте студентов с помощью /add_student.")
        return
    
    # Отправка сообщения с кнопками "Не было (Н)" и "Опоздал (О)" для каждого студента
    for student in students:
        buttons = [
            InlineKeyboardButton("Не было (Н)", callback_data=f"mark_N_{student[0]}"),
            InlineKeyboardButton("Опоздал (О)", callback_data=f"mark_O_{student[0]}")
        ]
        reply_markup = InlineKeyboardMarkup([buttons])
        await update.message.reply_text(f"Отметьте статус для {student[1]}:", reply_markup=reply_markup)
    
    # Добавление кнопки "Завершить отметку"
    finish_button = InlineKeyboardButton("Завершить отметку", callback_data="finish_mark_attendance")
    finish_markup = InlineKeyboardMarkup([[finish_button]])
    await update.message.reply_text("Когда закончите отмечать, нажмите 'Завершить отметку'.", reply_markup=finish_markup)
    

    Обработка отметки "Н" или "О"

    @restricted async def handle_attendance_mark(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query await query.answer()

    data = query.data.split("_")
    if len(data) != 3:
        await query.edit_message_text("Некорректные данные.")
        return
    
    action, status, student_id = data
    student_id = int(student_id)
    
    # Проверка наличия уже отметки для этого студента сегодня
    today = datetime.now().strftime("%Y-%m-%d")
    exists = cursor.execute("SELECT * FROM attendance WHERE date = ? AND student_id = ?", (today, student_id)).fetchone()
    if exists:
        await query.edit_message_text("Статус уже был установлен.")
        return
    
    # Вставка отметки "Н" или "О"
    cursor.execute("INSERT INTO attendance (date, student_id, status) VALUES (?, ?, ?)", (today, student_id, status))
    conn.commit()
    
    student_name = cursor.execute("SELECT name FROM students WHERE id = ?", (student_id,)).fetchone()[0]
    status_text = {
        "N": "Не было",
        "O": "Опоздал"
    }.get(status, "Неизвестный статус")
    
    await query.edit_message_text(f"Статус для {student_name} установлен как '{status_text}'.")
    

    Обработка нажатия "Завершить отметку"

    @restricted async def finish_mark_attendance(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query await query.answer()

    today = datetime.now().strftime("%Y-%m-%d")
    
    # Получение всех студентов
    cursor.execute("SELECT id, name FROM students")
    all_students = cursor.fetchall()
    all_student_ids = {s[0] for s in all_students}
    
    # Получение студентов, кто были отмечены как "Н" или "O"
    cursor.execute("SELECT student_id FROM attendance WHERE date = ?", (today,))
    marked_students = {row[0] for row in cursor.fetchall()}
    
    # Определение студентов, которым нужно назначить "П"
    present_students = all_student_ids - marked_students
    
    # Назначение "П" (присутствовал) для остальных
    for student_id in present_students:
        cursor.execute("INSERT INTO attendance (date, student_id, status) VALUES (?, ?, ?)", (today, student_id, "P"))
    conn.commit()
    
    await query.edit_message_text("Отметка посещаемости завершена. Всем не отмеченным присвоен статус 'Присутствовал (П)'.")
    

    Команда /assign_duty

    @restricted async def assign_duty(update: Update, context: ContextTypes.DEFAULT_TYPE): today = datetime.now().strftime("%Y-%m-%d")

    # Получение студентов, которым можно назначить дежурство (не "Н")
    cursor.execute("""
        SELECT s.id, s.name, s.duty_count
        FROM students s
        LEFT JOIN attendance a ON s.id = a.student_id AND a.date = ?
        WHERE a.status != 'N' OR a.status IS NULL
        ORDER BY s.duty_count ASC, s.name ASC
    """, (today,))
    eligible_students = cursor.fetchall()
    
    # Исключаем студентов, которым "Н" (Не было)
    # Студенты, у которых нет отметки или отметка не равна "N", включаются
    
    if len(eligible_students) < 2:
        await update.message.reply_text(
            "Недостаточно студентов для назначения дежурств. Нужно минимум 2 присутствующих (или опоздавших) студента."
        )
        return
    
    # Определяем минимальное количество дежурств среди eligible
    min_duty = eligible_students[0][2]
    # Находим всех с минимальным duty_count
    min_duty_students = [s for s in eligible_students if s[2] == min_duty]
    
    if len(min_duty_students) >= 2:
        # Если достаточно студентов с минимальным duty_count, выбираем из них
        selected = random.sample(min_duty_students, 2)
    else:
        # Если недостаточно, выбираем всех с минимальными и дополняем из следующих
        additional_needed = 2 - len(min_duty_students)
        remaining_students = [s for s in eligible_students if s[2] > min_duty]
        if len(remaining_students) < additional_needed:
            await update.message.reply_text(
                "Недостаточно студентов с минимальным количеством дежурств для назначения."
            )
            return
        selected = min_duty_students + random.sample(remaining_students, additional_needed)
    
    duty_names = [s[1] for s in selected]
    
    # Обновляем счетчик дежурств
    for s in selected:
        cursor.execute("UPDATE students SET duty_count = duty_count + 1 WHERE id = ?", (s[0],))
    conn.commit()
    
    await update.message.reply_text(f"Назначенные дежурные: {duty_names[0]} и {duty_names[1]}.")
    

    Команда /stats

    @restricted async def stats(update: Update, context: ContextTypes.DEFAULT_TYPE): cursor.execute("SELECT name, duty_count FROM students ORDER BY duty_count, name") students = cursor.fetchall()

    if not students:
        await update.message.reply_text("Список студентов пуст.")
        return
    
    message = "Статистика дежурств:\n"
    for s in students:
        message += f"{s[0]}: {s[1]} раз(а)\n"
    
    await update.message.reply_text(message)
    

    Команда /reset_attendance (опционально, для сброса отметок)

    @restricted async def reset_attendance(update: Update, context: ContextTypes.DEFAULT_TYPE): today = datetime.now().strftime("%Y-%m-%d") cursor.execute("DELETE FROM attendance WHERE date = ?", (today,)) conn.commit() await update.message.reply_text("Отметка посещаемости на сегодня сброшена.")

    Основная функция

    def main(): # Замените 'YOUR_BOT_TOKEN' на токен вашего бота application = ApplicationBuilder().token("7570478046:AAGjr1gGiIu1OcBn8bYOWxnYcIf_cFMjjps").build()

    # Определение ConversationHandler для добавления студента
    conv_handler = ConversationHandler(
        entry_points=[CommandHandler('add_student', add_student)],
        states={
            ADDING_STUDENT: [MessageHandler(filters.TEXT & ~filters.COMMAND, add_student_name)]
        },
        fallbacks=[CommandHandler('cancel', cancel)]
    )
    
    # Обработчики команд
    application.add_handler(CommandHandler("start", start))
    application.add_handler(conv_handler)
    application.add_handler(CommandHandler("mark_attendance", mark_attendance))
    application.add_handler(CommandHandler("assign_duty", assign_duty))
    application.add_handler(CommandHandler("stats", stats))
    # Опционально, для сброса отметок
    application.add_handler(CommandHandler("reset_attendance", reset_attendance))
    
    # Обработчики кнопок
    application.add_handler(CallbackQueryHandler(handle_attendance_mark, pattern=r"^mark_[NO]_\d+$"))
    application.add_handler(CallbackQueryHandler(finish_mark_attendance, pattern=r"^finish_mark_attendance$"))
    
    # Запуск бота
    application.run_polling()
    

    if name == 'main': main() (сделай чтобы можно было заполнять студентов более удобно например списком пример {Аксенов Георгий Алексеевич Бойченко Сергей Петрович Болдырев Никита Сергеевич Ватутин Михаил Иванович Дружинин Вячеслав Владимирович Дьяков Кирилл Андреевич Евдокимов Сергей Иванович Заикин Игнат Олегович Касаткин Евгений Дмитриевич Леохин Юрий Иванович Морозов Ярослав Вадимович Новиков Артём Русланович Овчинникова Дарья Витальевна Пинаев Кирилл Сергеевич Плотников Евгений Александрович Рогачева Ирина Максимовна Рудников Никита Алексеевич Сидельников Владислав Сергеевич Солодков Константин Вячеславович Туровский Даниил Антонович Уколов Михаил Александрович Усольцев Юрий Алексеевич} ,Легко удалять и чтобы вместо полного писалась фамилия и в сокращённом виде имя и отчество. Администратор мог добавить пользователей с правами редактирования. Если написать команду /assign_duty и в то число дежурные уже были назначены, тогда сгенерируются новые, и тем, кого выбрали до этого, это не засчитается, после команды для генерации дежурных и тех, кто должны быть дежурными, должны быть 2 кнопки для смены одного дежурного и другого, и еще для генерации обоих.

  2. Assistant

    Конечно! Давайте модифицируем ваш Telegram-бот, чтобы добавить требуемые функции:

    1. Массовое добавление студентов: Команда /add_students позволит администратору добавить нескольких студентов сразу, используя список с разделением по строкам.
    2. Удаление студентов: Команда /delete_student позволит администратору легко удалять студентов из базы данных с помощью кнопок.
    3. Форматирование имён: Имя будет отображаться в виде "Фамилия И. О.".
    4. Управление администраторами: Администраторы смогут добавлять и удалять других администраторов с помощью команд /add_admin и /remove_admin.
    5. Изменения в назначении дежурств:
      • Если дежурства уже назначены на день, команда /assign_duty позволит пересоздать их. Предыдущие назначения не будут учитываться.
      • После назначения дежурств будут доступны кнопки для смены одного дежурного или обоих, а также для повторной генерации дежурных.

    Ниже представлен обновлённый код с комментариями, объясняющими внесённые изменения.

    import logging
    from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
    from telegram.ext import (
        ApplicationBuilder, CommandHandler, ContextTypes,
        CallbackQueryHandler, MessageHandler, filters, ConversationHandler
    )
    import sqlite3
    from datetime import datetime
    import random
    
    # Настройка логирования
    logging.basicConfig(
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        level=logging.INFO
    )
    logger = logging.getLogger(__name__)
    
    # Подключение к базе данных
    conn = sqlite3.connect('attendance_bot.db', check_same_thread=False)
    cursor = conn.cursor()
    
    # Создание таблиц, если они не существуют
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS students (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL UNIQUE,
            duty_count INTEGER DEFAULT 0
        )
    ''')
    
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS attendance (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            date TEXT NOT NULL,
            student_id INTEGER,
            status TEXT,
            FOREIGN KEY(student_id) REFERENCES students(id)
        )
    ''')
    
    # Таблица администраторов
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS admins (
            user_id INTEGER PRIMARY KEY
        )
    ''')
    
    # Ваш Telegram ID для начального администратора (замените на ваш фактический Telegram ID)
    INITIAL_ADMIN_USER_ID = 1525524847  # Замените на ваш Telegram ID
    
    # Добавление начального администратора
    cursor.execute("INSERT OR IGNORE INTO admins (user_id) VALUES (?)", (INITIAL_ADMIN_USER_ID,))
    conn.commit()
    
    # Определение состояний для ConversationHandler
    ADDING_STUDENT = 1
    ADDING_STUDENTS_LIST = 2
    DELETING_STUDENT = 3
    ADDING_ADMIN = 4
    REMOVING_ADMIN = 5
    
    def format_name(full_name):
        parts = full_name.strip().split()
        if len(parts) < 2:
            return full_name  # Если формат некорректен, возвращаем как есть
        surname = parts[0]
        initials = ' '.join([f"{name[0]}." for name in parts[1:]])
        return f"{surname} {initials}"
    
    def restricted(func):
        async def wrapped(update: Update, context: ContextTypes.DEFAULT_TYPE):
            user_id = update.effective_user.id
            cursor.execute("SELECT 1 FROM admins WHERE user_id = ?", (user_id,))
            if not cursor.fetchone():
                await update.message.reply_text("У вас нет доступа к этой команде.")
                return
            return await func(update, context)
        return wrapped
    
    # Команда /start
    async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
        await update.message.reply_text(
            "Привет! Я помогу вам вести посещаемость и распределять дежурства.\n\n" +
            "Команды:\n" +
            "/add_student - Добавить студента\n" +
            "/add_students - Добавить нескольких студентов\n" +
            "/delete_student - Удалить студента\n" +
            "/mark_attendance - Отметить посещаемость\n" +
            "/assign_duty - Назначить дежурство\n" +
            "/stats - Показать статистику\n" +
            "/add_admin - Добавить администратора\n" +
            "/remove_admin - Удалить администратора\n" +
            "/reset_attendance - Сбросить отметки посещаемости\n" +
            "/cancel - Отменить текущую операцию"
        )
    
    # Команда /add_student (Добавить одного студента)
    @restricted
    async def add_student(update: Update, context: ContextTypes.DEFAULT_TYPE):
        await update.message.reply_text("Введите имя студента (Фамилия Имя Отчество):")
        return ADDING_STUDENT
    
    # Команда /add_students (Массовое добавление студентов)
    @restricted
    async def add_students(update: Update, context: ContextTypes.DEFAULT_TYPE):
        await update.message.reply_text("Введите список студентов, каждый на новой строке (Фамилия Имя Отчество):")
        return ADDING_STUDENTS_LIST
    
    # Обработка имени одного студента
    @restricted
    async def add_student_name(update: Update, context: ContextTypes.DEFAULT_TYPE):
        name = update.message.text.strip()
        if not name:
            await update.message.reply_text("Имя не может быть пустым. Попробуйте снова:")
            return ADDING_STUDENT
        try:
            cursor.execute("INSERT INTO students (name) VALUES (?)", (name,))
            conn.commit()
            await update.message.reply_text(f"Студент '{format_name(name)}' добавлен.")
        except sqlite3.IntegrityError:
            await update.message.reply_text(f"Студент '{format_name(name)}' уже существует.")
        return ConversationHandler.END
    
    # Обработка списка студентов
    @restricted
    async def add_students_list(update: Update, context: ContextTypes.DEFAULT_TYPE):
        names = update.message.text.strip().split('\n')
        added = []
        skipped = []
        for name in names:
            formatted_name = format_name(name)
            if name:
                try:
                    cursor.execute("INSERT INTO students (name) VALUES (?)", (name,))
                    conn.commit()
                    added.append(formatted_name)
                except sqlite3.IntegrityError:
                    skipped.append(formatted_name)
        response = ""
        if added:
            response += "Добавлены следующие студенты:\n" + "\n".join(added) + "\n"
        if skipped:
            response += "Следующие студенты уже существуют и были пропущены:\n" + "\n".join(skipped)
        await update.message.reply_text(response)
        return ConversationHandler.END
    
    # Команда /delete_student
    @restricted
    async def delete_student(update: Update, context: ContextTypes.DEFAULT_TYPE):
        cursor.execute("SELECT id, name FROM students ORDER BY name")
        students = cursor.fetchall()
        if not students:
            await update.message.reply_text("Список студентов пуст.")
            return ConversationHandler.END
    
        keyboard = []
        for student in students:
            formatted_name = format_name(student[1])
            keyboard.append([InlineKeyboardButton(formatted_name, callback_data=f"delete_{student[0]}")])
    
        reply_markup = InlineKeyboardMarkup(keyboard)
        await update.message.reply_text("Выберите студента для удаления:", reply_markup=reply_markup)
        return DELETING_STUDENT
    
    # Обработка удаления студента
    @restricted
    async def handle_delete_student(update: Update, context: ContextTypes.DEFAULT_TYPE):
        query = update.callback_query
        await query.answer()
    
        data = query.data.split("_")
        if len(data) != 2 or data[0] != "delete":
            await query.edit_message_text("Некорректные данные.")
            return ConversationHandler.END
    
        student_id = int(data[1])
        student = cursor.execute("SELECT name FROM students WHERE id = ?", (student_id,)).fetchone()
        if student:
            cursor.execute("DELETE FROM students WHERE id = ?", (student_id,))
            conn.commit()
            await query.edit_message_text(f"Студент '{format_name(student[0])}' удалён.")
        else:
            await query.edit_message_text("Студент не найден.")
    
        return ConversationHandler.END
    
    # Команда /add_admin
    @restricted
    async def add_admin(update: Update, context: ContextTypes.DEFAULT_TYPE):
        await update.message.reply_text("Введите Telegram ID пользователя, которого нужно сделать администратором:")
        return ADDING_ADMIN
    
    # Команда /remove_admin
    @restricted
    async def remove_admin(update: Update, context: ContextTypes.DEFAULT_TYPE):
        await update.message.reply_text("Введите Telegram ID администратора, которого нужно удалить:")
        return REMOVING_ADMIN
    
    # Обработка добавления администратора
    @restricted
    async def add_admin_id(update: Update, context: ContextTypes.DEFAULT_TYPE):
        try:
            user_id = int(update.message.text.strip())
            cursor.execute("INSERT INTO admins (user_id) VALUES (?)", (user_id,))
            conn.commit()
            await update.message.reply_text(f"Пользователь с ID {user_id} добавлен как администратор.")
        except ValueError:
            await update.message.reply_text("Некорректный ID. Пожалуйста, введите числовой Telegram ID.")
        except sqlite3.IntegrityError:
            await update.message.reply_text(f"Пользователь с ID {user_id} уже является администратором.")
        return ConversationHandler.END
    
    # Обработка удаления администратора
    @restricted
    async def remove_admin_id(update: Update, context: ContextTypes.DEFAULT_TYPE):
        try:
            user_id = int(update.message.text.strip())
            if user_id == INITIAL_ADMIN_USER_ID:
                await update.message.reply_text("Нельзя удалить начального администратора.")
                return ConversationHandler.END
            cursor.execute("DELETE FROM admins WHERE user_id = ?", (user_id,))
            conn.commit()
            if cursor.rowcount > 0:
                await update.message.reply_text(f"Пользователь с ID {user_id} удалён из администраторов.")
            else:
                await update.message.reply_text(f"Пользователь с ID {user_id} не найден среди администраторов.")
        except ValueError:
            await update.message.reply_text("Некорректный ID. Пожалуйста, введите числовой Telegram ID.")
        return ConversationHandler.END
    
    # Команда /mark_attendance
    @restricted
    async def mark_attendance(update: Update, context: ContextTypes.DEFAULT_TYPE):
        today = datetime.now().strftime("%Y-%m-%d")
    
        # Проверка, была ли уже отмечена посещаемость сегодня
        existing = cursor.execute("SELECT COUNT(*) FROM attendance WHERE date = ?", (today,)).fetchone()[0]
        if existing > 0:
            await update.message.reply_text(
                "Посещаемость на сегодня уже была отмечена. Если хотите отметить заново, выполните /reset_attendance."
            )
            return
    
        cursor.execute("SELECT id, name FROM students ORDER BY name")
        students = cursor.fetchall()
    
        if not students:
            await update.message.reply_text("Список студентов пуст. Добавьте студентов с помощью /add_student или /add_students.")
            return
    
        # Отправка сообщения с кнопками "Не было (Н)" и "Опоздал (О)" для каждого студента
        for student in students:
            formatted_name = format_name(student[1])
            buttons = [
                InlineKeyboardButton("Не было (Н)", callback_data=f"mark_N_{student[0]}"),
                InlineKeyboardButton("Опоздал (О)", callback_data=f"mark_O_{student[0]}")
            ]
            reply_markup = InlineKeyboardMarkup([buttons])
            await update.message.reply_text(f"Отметьте статус для {formatted_name}:", reply_markup=reply_markup)
    
        # Добавление кнопки "Завершить отметку"
        finish_button = InlineKeyboardButton("Завершить отметку", callback_data="finish_mark_attendance")
        finish_markup = InlineKeyboardMarkup([[finish_button]])
        await update.message.reply_text("Когда закончите отмечать, нажмите 'Завершить отметку'.", reply_markup=finish_markup)
    
    # Обработка отметки "Н" или "О"
    @restricted
    async def handle_attendance_mark(update: Update, context: ContextTypes.DEFAULT_TYPE):
        query = update.callback_query
        await query.answer()
    
        data = query.data.split("_")
        if len(data) != 3:
            await query.edit_message_text("Некорректные данные.")
            return
    
        action, status, student_id = data
        if action != "mark" or status not in ["N", "O"]:
            await query.edit_message_text("Некорректные данные.")
            return
    
        try:
            student_id = int(student_id)
        except ValueError:
            await query.edit_message_text("Некорректный ID студента.")
            return
    
        # Проверка наличия уже отметки для этого студента сегодня
        today = datetime.now().strftime("%Y-%m-%d")
        exists = cursor.execute("SELECT * FROM attendance WHERE date = ? AND student_id = ?", (today, student_id)).fetchone()
        if exists:
            await query.edit_message_text("Статус уже был установлен.")
            return
    
        # Вставка отметки "Н" или "О"
        cursor.execute("INSERT INTO attendance (date, student_id, status) VALUES (?, ?, ?)", (today, student_id, status))
        conn.commit()
    
        student_name = cursor.execute("SELECT name FROM students WHERE id = ?", (student_id,)).fetchone()[0]
        status_text = {
            "N": "Не было",
            "O": "Опоздал"
        }.get(status, "Неизвестный статус")
    
        await query.edit_message_text(f"Статус для {format_name(student_name)} установлен как '{status_text}'.")
    
    # Обработка нажатия "Завершить отметку"
    @restricted
    async def finish_mark_attendance(update: Update, context: ContextTypes.DEFAULT_TYPE):
        query = update.callback_query
        await query.answer()
    
        today = datetime.now().strftime("%Y-%m-%d")
    
        # Получение всех студентов
        cursor.execute("SELECT id, name FROM students")
        all_students = cursor.fetchall()
        all_student_ids = {s[0] for s in all_students}
    
        # Получение студентов, кто были отмечены как "Н" или "O"
        cursor.execute("SELECT student_id FROM attendance WHERE date = ?", (today,))
        marked_students = {row[0] for row in cursor.fetchall()}
    
        # Определение студентов, которым нужно назначить "П"
        present_students = all_student_ids - marked_students
    
        # Назначение "П" (присутствовал) для остальных
        for student_id in present_students:
            cursor.execute("INSERT INTO attendance (date, student_id, status) VALUES (?, ?, ?)", (today, student_id, "P"))
        conn.commit()
    
        await query.edit_message_text("Отметка посещаемости завершена. Всем не отмеченным присвоен статус 'Присутствовал (П)'.")
    
    # Команда /assign_duty
    @restricted
    async def assign_duty(update: Update, context: ContextTypes.DEFAULT_TYPE):
        today = datetime.now().strftime("%Y-%m-%d")
    
        # Удаление предыдущих назначений дежурств за сегодня, если есть
        cursor.execute("""
            DELETE FROM attendance
            WHERE date = ? AND status LIKE 'D%'
        """, (today,))
        conn.commit()
    
        # Получение студентов, которым можно назначить дежурство (не "Н")
        cursor.execute("""
            SELECT s.id, s.name, s.duty_count
            FROM students s
            LEFT JOIN attendance a ON s.id = a.student_id AND a.date = ?
            WHERE a.status != 'N' OR a.status IS NULL
            ORDER BY s.duty_count ASC, s.name ASC
        """, (today,))
        eligible_students = cursor.fetchall()
    
        if len(eligible_students) < 2:
            await update.message.reply_text(
                "Недостаточно студентов для назначения дежурств. Нужно минимум 2 присутствующих (или опоздавших) студента."
            )
            return
    
        # Определяем минимальное количество дежурств среди eligible
        min_duty = eligible_students[0][2]
        # Находим всех с минимальным duty_count
        min_duty_students = [s for s in eligible_students if s[2] == min_duty]
    
        if len(min_duty_students) >= 2:
            # Если достаточно студентов с минимальным duty_count, выбираем из них
            selected = random.sample(min_duty_students, 2)
        else:
            # Если недостаточно, выбираем всех с минимальными и дополняем из следующих
            selected = min_duty_students.copy()
            additional_needed = 2 - len(selected)
            remaining_students = [s for s in eligible_students if s[2] > min_duty]
            if len(remaining_students) < additional_needed:
                await update.message.reply_text(
                    "Недостаточно студентов с минимальным количеством дежурств для назначения. Попробуйте позже."
                )
                return
            selected += random.sample(remaining_students, additional_needed)
    
        duty_names = [format_name(s[1]) for s in selected]
    
        # Обновляем счетчик дежурств и добавляем запись в attendance со статусом "D" (дежурный)
        for s in selected:
            cursor.execute("UPDATE students SET duty_count = duty_count + 1 WHERE id = ?", (s[0],))
            cursor.execute("INSERT INTO attendance (date, student_id, status) VALUES (?, ?, ?)", (today, s[0], "D"))
        conn.commit()
    
        # Сохранение текущих дежурств в context для дальнейших операций
        context.user_data['current_duty'] = selected
    
        # Создание кнопок для изменения дежурств
        buttons = [
            InlineKeyboardButton("Сменить одного дежурного", callback_data="swap_one"),
            InlineKeyboardButton("Сменить обоих дежурных", callback_data="swap_both"),
            InlineKeyboardButton("Перегенерировать дежурных", callback_data="regenerate")
        ]
        reply_markup = InlineKeyboardMarkup([buttons])
    
        await update.message.reply_text(
            f"Назначенные дежурные: {duty_names[0]} и {duty_names[1]}.",
            reply_markup=reply_markup
        )
    
    # Обработка кнопок после назначения дежурств
    @restricted
    async def handle_duty_buttons(update: Update, context: ContextTypes.DEFAULT_TYPE):
        query = update.callback_query
        await query.answer()
    
        action = query.data
        today = datetime.now().strftime("%Y-%m-%d")
    
        if action == "regenerate":
            # Перегенерация дежурств
            await assign_duty(update, context)
            await query.message.delete()
            return
    
        current_duty = context.user_data.get('current_duty')
        if not current_duty:
            await query.edit_message_text("Нет текущих назначений дежурств для изменения.")
            return
    
        if action == "swap_one":
            # Смена одного дежурного
            # Выбираем случайного нового дежурного из eligible, исключая текущих
            eligible_ids = cursor.execute("""
                SELECT id, name, duty_count FROM students
                WHERE id NOT IN (?, ?) AND (id IN (
                    SELECT student_id FROM attendance WHERE date = ? AND status != 'N'
                ) OR id NOT IN (
                    SELECT student_id FROM attendance WHERE date = ?
                ))
                ORDER BY duty_count ASC, name ASC
            """, (current_duty[0][0], current_duty[1][0], today, today)).fetchall()
    
            if not eligible_ids:
                await query.edit_message_text("Нет доступных студентов для замены.")
                return
    
            min_duty = eligible_ids[0][2]
            min_duty_students = [s for s in eligible_ids if s[2] == min_duty]
    
            new_duty = random.choice(min_duty_students)
    
            # Обновляем duty_count и attendance
            cursor.execute("UPDATE students SET duty_count = duty_count + 1 WHERE id = ?", (new_duty[0],))
            cursor.execute("INSERT INTO attendance (date, student_id, status) VALUES (?, ?, ?)", (today, new_duty[0], "D"))
    
            # Удаляем старого дежурного из attendance
            cursor.execute("DELETE FROM attendance WHERE date = ? AND student_id = ?", (today, current_duty[0][0]))
            # Обновляем duty_count если требуется
            cursor.execute("UPDATE students SET duty_count = duty_count - 1 WHERE id = ?", (current_duty[0][0],))
            conn.commit()
    
            # Обновляем current_duty
            context.user_data['current_duty'][0] = new_duty
    
            duty_names = [format_name(s[1]) for s in context.user_data['current_duty']]
    
            await query.edit_message_text(
                f"Дежурный заменён. Новые дежурные: {duty_names[0]} и {duty_names[1]}.",
                reply_markup=InlineKeyboardMarkup([
                    [
                        InlineKeyboardButton("Сменить одного дежурного", callback_data="swap_one"),
                        InlineKeyboardButton("Сменить обоих дежурных", callback_data="swap_both"),
                        InlineKeyboardButton("Перегенерировать дежурных", callback_data="regenerate")
                    ]
                ])
            )
            return
    
        elif action == "swap_both":
            # Смена обоих дежурных
            # Получение всех eligible студентов
            cursor.execute("""
                SELECT s.id, s.name, s.duty_count
                FROM students s
                LEFT JOIN attendance a ON s.id = a.student_id AND a.date = ?
                WHERE a.status != 'N' OR a.status IS NULL
                ORDER BY s.duty_count ASC, s.name ASC
            """, (today,))
            eligible_students = cursor.fetchall()
    
            if len(eligible_students) < 2:
                await query.edit_message_text("Недостаточно студентов для смены обоих дежурных.")
                return
    
            min_duty = eligible_students[0][2]
            min_duty_students = [s for s in eligible_students if s[2] == min_duty]
    
            if len(min_duty_students) >= 2:
                selected = random.sample(min_duty_students, 2)
            else:
                selected = min_duty_students.copy()
                additional_needed = 2 - len(selected)
                remaining_students = [s for s in eligible_students if s[2] > min_duty]
                if len(remaining_students) < additional_needed:
                    await query.edit_message_text("Недостаточно студентов для смены оба дежурных.")
                    return
                selected += random.sample(remaining_students, additional_needed)
    
            # Обновляем duty_count и attendance
            for s in selected:
                cursor.execute("UPDATE students SET duty_count = duty_count + 1 WHERE id = ?", (s[0],))
                cursor.execute("INSERT INTO attendance (date, student_id, status) VALUES (?, ?, ?)", (today, s[0], "D"))
    
            # Удаляем предыдущие дежурства
            previous_ids = [s[0] for s in current_duty]
            cursor.execute(f"DELETE FROM attendance WHERE date = ? AND student_id IN ({','.join(['?']*len(previous_ids))})", (today, *previous_ids))
            # Обновляем duty_count для предыдущих дежурных
            cursor.execute(f"UPDATE students SET duty_count = duty_count - 1 WHERE id IN ({','.join(['?']*len(previous_ids))})", (*previous_ids,))
            conn.commit()
    
            # Обновляем current_duty
            context.user_data['current_duty'] = selected
    
            duty_names = [format_name(s[1]) for s in selected]
    
            await query.edit_message_text(
                f"Дежурные заменены. Новые дежурные: {duty_names[0]} и {duty_names[1]}.",
                reply_markup=InlineKeyboardMarkup([
                    [
                        InlineKeyboardButton("Сменить одного дежурного", callback_data="swap_one"),
                        InlineKeyboardButton("Сменить обоих дежурных", callback_data="swap_both"),
                        InlineKeyboardButton("Перегенерировать дежурных", callback_data="regenerate")
                    ]
                ])
            )
            return
    
    # Команда /stats
    @restricted
    async def stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
        cursor.execute("SELECT name, duty_count FROM students ORDER BY duty_count, name")
        students = cursor.fetchall()
    
        if not students:
            await update.message.reply_text("Список студентов пуст.")
            return
    
        message = "Статистика дежурств:\n"
        for s in students:
            message += f"{format_name(s[0])}: {s[1]} раз(а)\n"
    
        await update.message.reply_text(message)
    
    # Команда /reset_attendance (опционально, для сброса отметок)
    @restricted
    async def reset_attendance(update: Update, context: ContextTypes.DEFAULT_TYPE):
        today = datetime.now().strftime("%Y-%m-%d")
        cursor.execute("DELETE FROM attendance WHERE date = ?", (today,))
        conn.commit()
        await update.message.reply_text("Отметка посещаемости на сегодня сброшена.")
    
    # Отмена операций
    async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE):
        await update.message.reply_text("Текущая операция отменена.")
        return ConversationHandler.END
    
    # Основная функция
    def main():
        # Замените 'YOUR_BOT_TOKEN' на токен вашего бота
        application = ApplicationBuilder().token("YOUR_BOT_TOKEN").build()
    
        # Определение ConversationHandler для добавления одного студента
        conv_handler_add = ConversationHandler(
            entry_points=[CommandHandler('add_student', add_student)],
            states={
                ADDING_STUDENT: [MessageHandler(filters.TEXT & ~filters.COMMAND, add_student_name)]
            },
            fallbacks=[CommandHandler('cancel', cancel)]
        )
    
        # Определение ConversationHandler для массового добавления студентов
        conv_handler_add_multiple = ConversationHandler(
            entry_points=[CommandHandler('add_students', add_students)],
            states={
                ADDING_STUDENTS_LIST: [MessageHandler(filters.TEXT & ~filters.COMMAND, add_students_list)]
            },
            fallbacks=[CommandHandler('cancel', cancel)]
        )
    
        # Определение ConversationHandler для удаления студента
        conv_handler_delete = ConversationHandler(
            entry_points=[CommandHandler('delete_student', delete_student)],
            states={
                DELETING_STUDENT: [CallbackQueryHandler(handle_delete_student, pattern=r"^delete_\d+$")]
            },
            fallbacks=[CommandHandler('cancel', cancel)]
        )
    
        # ConversationHandler для добавления администратора
        conv_handler_add_admin = ConversationHandler(
            entry_points=[CommandHandler('add_admin', add_admin)],
            states={
                ADDING_ADMIN: [MessageHandler(filters.TEXT & ~filters.COMMAND, add_admin_id)]
            },
            fallbacks=[CommandHandler('cancel', cancel)]
        )
    
        # ConversationHandler для удаления администратора
        conv_handler_remove_admin = ConversationHandler(
            entry_points=[CommandHandler('remove_admin', remove_admin)],
            states={
                REMOVING_ADMIN: [MessageHandler(filters.TEXT & ~filters.COMMAND, remove_admin_id)]
            },
            fallbacks=[CommandHandler('cancel', cancel)]
        )
    
        # Обработчики команд
        application.add_handler(CommandHandler("start", start))
        application.add_handler(conv_handler_add)
        application.add_handler(conv_handler_add_multiple)
        application.add_handler(conv_handler_delete)
        application.add_handler(conv_handler_add_admin)
        application.add_handler(conv_handler_remove_admin)
        application.add_handler(CommandHandler("mark_attendance", mark_attendance))
        application.add_handler(CommandHandler("assign_duty", assign_duty))
        application.add_handler(CommandHandler("stats", stats))
        application.add_handler(CommandHandler("reset_attendance", reset_attendance))
        application.add_handler(CommandHandler("cancel", cancel))
    
        # Обработчики кнопок
        application.add_handler(CallbackQueryHandler(handle_attendance_mark, pattern=r"^mark_[NO]_\d+$"))
        application.add_handler(CallbackQueryHandler(finish_mark_attendance, pattern=r"^finish_mark_attendance$"))
        application.add_handler(CallbackQueryHandler(handle_duty_buttons, pattern=r"^(swap_one|swap_both|regenerate)$"))
    
        # Запуск бота
        application.run_polling()
    
    if __name__ == '__main__':
        main()
    

    Объяснение внесённых изменений:

    1. Массовое добавление студентов:

      • Добавлена команда /add_students, которая запускает ConversationHandler для получения списка студентов.
      • Студенты вводятся списком через новую строку. Каждое имя преобразуется в формат "Фамилия И. О." перед добавлением.
    2. Удаление студентов:

      • Добавлена команда /delete_student, которая отображает всех студентов с кнопками для удаления.
      • При выборе студента его запись удаляется из базы данных.
    3. Форматирование имён:

      • Функция format_name преобразует полное имя "Фамилия Имя Отчество" в "Фамилия И. О.".
      • Все отображения имён в боте используют эту функцию для стандартизации формата.
    4. Управление администраторами:

      • Создана таблица admins для хранения идентификаторов администратора.
      • Функции add_admin и remove_admin позволяют добавлять и удалять администраторов.
      • Начальный администратор определяется через INITIAL_ADMIN_USER_ID.
      • Декоратор restricted проверяет наличие пользователя в таблице администраторов.
    5. Изменения в назначении дежурств:

      • При вызове /assign_duty предыдущие назначения дежурств за текущий день удаляются.
      • Назначаются новые дежурные, учитывая минимальное количество дежурств.
      • После назначения появляются кнопки для смены одного дежурного, обоих или перегенерации.
      • Функции handle_duty_buttons обрабатывают эти действия, обновляя назначения и счетчики.

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

    • Безопасность токена: Убедитесь, что вы заменили строку "YOUR_BOT_TOKEN" на настоящий токен вашего бота. Никогда не делитесь токеном публично.
    • Резервное копирование базы данных: Регулярно делайте резервные копии базы данных attendance_bot.db, чтобы избежать потери данных.
    • Расширение функциональности: В будущем можно добавить больше команд или улучшить интерфейс взаимодействия с пользователями.

    Если у вас возникнут вопросы или потребуется дополнительная помощь с кодом, не стесняйтесь обращаться!