Гайд к 14 февраля: пишем тг-бота на Aiogram с коплиментами

			typical-pickup-bot/
├── config/
│   └── __init__.py
├── handlers/
│   └── user.py
├── keyboards/
│   └── reply.py
├── utils/
│   └── compliments.py
├── bot.py
├── .env
└── requirements.txt

		

			TOKEN=111111:AAAAAAAAAAAAAAAAAAA

		

			from decouple import config

BOT_TOKEN = config('TOKEN')

# словари для хранения состояний
compliment_tasks = {}
current_indices = {}

		

			COMPLIMENTS = [
   "Ты — моя главная зависимость, без которой не компилируется этот день ",
   "Даже самый мощный процессор не справится с вычислением моей любви к тебе ",
   "Ты — тот редкий баг, который не хочется исправлять, а хочется любить ещё больше "
]

		

			import asyncio
from aiogram import types

from aiogram import Bot
from aiogram.client.default import DefaultBotProperties
from aiogram.enums import ParseMode
from config import compliment_tasks, current_indices
from keyboards.reply import get_stop_keyboard, get_interval_keyboard
from utils.compliments import COMPLIMENTS
from config import BOT_TOKEN


bot = Bot(token=BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))


# функция отправки комплиментов
async def send_periodic_compliments(chat_id: int, interval_hours: int):
    while current_indices[chat_id] < len(COMPLIMENTS):
        if chat_id not in compliment_tasks:
            break
        compliment = COMPLIMENTS[current_indices[chat_id]]
        await asyncio.sleep(interval_hours * 3600)
        await bot.send_message(chat_id, compliment)
        current_indices[chat_id] += 1

    if chat_id in compliment_tasks:
        del compliment_tasks[chat_id]
        del current_indices[chat_id]


# функция для выбора интервала отправки
async def process_interval_choice(callback: types.CallbackQuery):
    chat_id = callback.message.chat.id
    interval_hours = int(callback.data.split("_")[1])

    if chat_id not in current_indices:
        current_indices[chat_id] = 0

    if chat_id in compliment_tasks:
        compliment_tasks[chat_id].cancel()

    await bot.send_message(chat_id, COMPLIMENTS[current_indices[chat_id]],
                           reply_markup=get_stop_keyboard())
    current_indices[chat_id] += 1

    task = asyncio.create_task(
        send_periodic_compliments(chat_id, interval_hours)
    )
    compliment_tasks[chat_id] = task

    await callback.answer(f"Установлен интервал: {interval_hours} час(ов)")
    await callback.message.delete()


# функция для команды /start
async def cmd_start(message: types.Message):
    chat_id = message.chat.id
    if chat_id in current_indices:
        del current_indices[chat_id]

    await message.answer(
        f"Привет, {message.from_user.full_name}!\n\n"
        "На связи пикап-бот от медиа Tproger — он будет отправлять тебе айтишные комплименты."
        " Не отключай уведомления и наслаждайся 14-м февраля!❤️"
    )

    await message.answer(
        "Выбери, как часто ты хочешь получать комплименты:",
        reply_markup=get_interval_keyboard()
    )


# функция обработки кнопки stop
async def handle_stop(message: types.Message):
    if message.chat.id in compliment_tasks:
        compliment_tasks[message.chat.id].cancel()
        del compliment_tasks[message.chat.id]
        await message.answer(
            "Отправка комплиментов остановлена. Выбери новый интервал:",
            reply_markup=get_interval_keyboard()
        )


# функция обработки кнопки start
async def handle_start(message: types.Message):
    await message.answer(
        "Выбери, как часто ты хочешь получать комплименты:",
        reply_markup=get_interval_keyboard()
    )

		

			from aiogram import types
from aiogram.utils.keyboard import InlineKeyboardBuilder


# функция клавиатуры с кнопкой stop
def get_stop_keyboard():
    keyboard = [[types.KeyboardButton(text="stop")]]
    return types.ReplyKeyboardMarkup(keyboard=keyboard, resize_keyboard=True)


# функция клавиатуры с кнопкой stop
def get_start_keyboard():
    keyboard = [[types.KeyboardButton(text="start")]]
    return types.ReplyKeyboardMarkup(keyboard=keyboard, resize_keyboard=True)


# функция inline-клавиатуры с кнопками выбора интервала
def get_interval_keyboard():
    builder = InlineKeyboardBuilder()
    builder.button(text="Каждый час", callback_data="interval_1")
    builder.button(text="Каждые 3 часа", callback_data="interval_3")
    builder.button(text="Каждые 6 часов", callback_data="interval_6")
    builder.adjust(1)
    return builder.as_markup()

		

			import asyncio
import logging
from aiogram import Bot, Dispatcher
from aiogram.client.default import DefaultBotProperties
from aiogram.enums import ParseMode
from aiogram.fsm.storage.memory import MemoryStorage
from aiogram.filters.command import Command

from config import BOT_TOKEN
from handlers.user import cmd_start, process_interval_choice, handle_stop, handle_start

# уровень логированиря
logging.basicConfig(level=logging.INFO)

bot = Bot(token=BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
dp = Dispatcher(storage=MemoryStorage())


# функция регистрации хэндлеров
def register_handlers():
    dp.message.register(cmd_start, Command("start"))
    dp.message.register(handle_stop, lambda message: message.text == "stop")
    dp.message.register(handle_start, lambda message: message.text == "start")
    dp.callback_query.register(process_interval_choice, lambda c: c.data.startswith("interval_"))


# функция запуска бота
async def main():
    register_handlers()
    await dp.start_polling(bot)

if __name__ == "__main__":
    asyncio.run(main())