Руководство по aiogram

Используемая версия aiogram: 3.0

Некоторые детали сознательно упрощены!

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

Так, например, во всех или почти во всех главах токен бота будет указываться прямо в исходных текстах.
Это плохой подход, поскольку может привести к раскрытию токена, если вы забудете его удалить перед заливкой
кода в публичный репозиторий (например, GitHub).

Или иногда в качестве хранилищ данных будут использоваться структуры, расположенные исключительно в
оперативной памяти (словари, списки…). В действительности такие объекты нежелательны, поскольку остановка
бота приведёт безвозвратной потере данных.

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

Важно помнить, что автор ставит перед собой цель объяснить именно работу с Telegram Bot API при помощи
aiogram, а не вообще весь Computer Science во всём его многообразии.

Терминология¶

Чтобы разговаривать в одних и тех же понятиях, введём некоторые термины, дабы в дальнейшем не путаться:

  • ЛС — личные сообщения, в контексте бота это диалог один-на-один с пользователем, а не группа/канал.
  • Чат — общее название для ЛС, групп, супергрупп и каналов.
  • Апдейт — любое событие из этого списка:
    сообщение, редактирование сообщения, колбэк, инлайн-запрос, платёж, добавление бота в группу и т.д.
  • Хэндлер — асинхронная функция, которая получает от диспетчера/роутера очередной апдейт
    и обрабатывает его.
  • Диспетчер — объект, занимающийся получением апдейтов от Telegram с последующим выбором хэндлера
    для обработки принятого апдейта.
  • Роутер — аналогично диспетчеру, но отвечает за подмножество множества хэндлеров.
    Можно сказать, что диспетчер — это корневой роутер.
  • Фильтр — выражение, которое обычно возвращает True или False и влияет на то, будет вызван хэндлер или нет.
  • Мидлварь — прослойка, которая вклинивается в обработку апдейтов.

Установка¶

Для начала давайте создадим каталог для бота, организуем там virtual environment (далее venv) и
установим библиотеку aiogram.
Проверим, что установлен Python версии 3.9 (если вы знаете, что установлен 3.9 и выше, можете пропустить этот раздел):

[groosha@main lesson_01]$ python3.9
Python 3.9.9 (main, Jan 11 2022, 16:35:07) 
[GCC 11.1.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()
[groosha@main lesson_01]$

Теперь создадим файл requirements.txt, в котором укажем используемую нами версию aiogram. Также нам понадобится
библиотека python-dotenv для файлов конфигурации.

О версиях aiogram

В этой главе используется aiogram 3.x, перед началом работы рекомендую заглянуть в
канал релизов библиотеки и проверить наличие более новой версии. Подойдёт любая
более новая, начинающаяся с цифры 3, поскольку aiogram 2.x более рассматриваться не будет и считается устаревшим.

[groosha@main 01_quickstart]$ python3.9 -m venv venv
[groosha@main 01_quickstart]$ echo "aiogram==3.0" > requirements.txt
[groosha@main 01_quickstart]$ echo "python-dotenv==1.0.0" >> requirements.txt
[groosha@main 01_quickstart]$ source venv/bin/activate
(venv) [groosha@main 01_quickstart]$ pip install -r requirements.txt 
# ...здесь куча строк про установку...
Successfully installed ...тут длинный список...
[groosha@main 01_quickstart]$

Обратите внимание на префикс «venv» в терминале. Он указывает, что мы находимся в виртуальном окружении с именем «venv».
Проверим, что внутри venv вызов команды python указывает на всё тот же Python 3.9: 

(venv) [groosha@main 01_quickstart]$ python
Python 3.9.9 (main, Jan 11 2022, 16:35:07) 
[GCC 11.1.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()
(venv) [groosha@main 01_quickstart]$ deactivate 
[groosha@main 01_quickstart]$

Последней командой deactivate мы вышли из venv, чтобы он нам не мешал.

Если для написания ботов вы используете PyCharm, рекомендую также установить сторонний плагин
Pydantic для поддержки автодополнения кода
в телеграмных объектах.

Первый бот¶

Давайте создадим файл bot.py с базовым шаблоном бота на aiogram:

bot.py

import asyncio
import logging
from aiogram import Bot, Dispatcher, types
from aiogram.filters.command import Command

# Включаем логирование, чтобы не пропустить важные сообщения
logging.basicConfig(level=logging.INFO)
# Объект бота
bot = Bot(token="12345678:AaBbCcDdEeFfGgHh")
# Диспетчер
dp = Dispatcher()

# Хэндлер на команду /start
@dp.message(Command("start"))
async def cmd_start(message: types.Message):
    await message.answer("Hello!")

# Запуск процесса поллинга новых апдейтов
async def main():
    await dp.start_polling(bot)

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

Первое, на что нужно обратить внимание: aiogram — асинхронная библиотека, поэтому ваши хэндлеры тоже должны быть асинхронными,
а перед вызовами методов API нужно ставить ключевое слово await, т.к. эти вызовы возвращают корутины.

Асинхронное программирование в Python

Не стоит пренебрегать официальной документацией!
Прекрасный туториал по asyncio доступен на сайте Python.

Если вы в прошлом работали с какой-то другой библиотекой для Telegram, например, pyTelegramBotAPI, то концепция
хэндлеров (обработчиков событий) вам сразу станет понятна, разница лишь в том, что в aiogram хэндлерами управляет диспетчер.
Диспетчер регистрирует функции-обработчики, дополнительно ограничивая перечень вызывающих их событий через фильтры.
После получения очередного апдейта (события от Telegram), диспетчер выберет нужную функцию обработки, подходящую по всем
фильтрам, например, «обработка сообщений, являющихся изображениями, в чате с ID икс и с длиной подписи игрек». Если две
функции имеют одинаковые по логике фильтры, то будет вызвана та, что зарегистрирована раньше.

Чтобы зарегистрировать функцию как обработчик сообщений, нужно сделать одно из двух действий:
1. Навесить на неё декоратор, как в примере выше.
С различными типами декораторов мы познакомимся позднее.
2. Напрямую вызвать метод регистрации у диспетчера или роутера.

Рассмотрим следующий код: 

# Хэндлер на команду /test1
@dp.message(Command("test1"))
async def cmd_test1(message: types.Message):
    await message.reply("Test 1")

# Хэндлер на команду /test2
async def cmd_test2(message: types.Message):
    await message.reply("Test 2")

Давайте запустим с ним бота:
Команда /test2 не работает

Хэндлер cmd_test2 не сработает, т.к. диспетчер о нём не знает. Исправим эту ошибку
и отдельно зарегистрируем функцию: 

# Хэндлер на команду /test2
async def cmd_test2(message: types.Message):
    await message.reply("Test 2")

# Где-то в другом месте, например, в функции main():
dp.message.register(cmd_test2, Command("test2"))

Снова запустим бота:
Обе команды работают

Синтаксический сахар¶

Для того чтобы сделать код чище и читабельнее, aiogram расширяет возможности стандартных объектов Telegram.
Например, вместо bot.send_message(...) можно написать message.answer(...) или message.reply(...). В последних
двух случаях не нужно подставлять chat_id, подразумевается, что он такой же, как и в исходном сообщении.
Разница между answer и reply простая: первый метод просто отправляет сообщение в тот же чат, второй делает «ответ» на
сообщение из message: 

@dp.message(Command("answer"))
async def cmd_answer(message: types.Message):
    await message.answer("Это простой ответ")


@dp.message(Command("reply"))
async def cmd_reply(message: types.Message):
    await message.reply('Это ответ с "ответом"')

Разница между message.answer() и message.reply()

Более того, для большинства типов сообщений есть вспомогательные методы вида
«answer_{type}» или «reply_{type}», например: 

@dp.message(Command("dice"))
async def cmd_dice(message: types.Message):
    await message.answer_dice(emoji="🎲")

что значит ‘message: types.Message’ ?

Python является интерпретируемым языком с сильной, но динамической типизацией,
поэтому встроенная проверка типов, как, например, в C++ или Java, отсутствует. Однако начиная с версии 3.5
в языке появилась поддержка подсказок типов, благодаря которой
различные чекеры и IDE вроде PyCharm анализируют типы используемых значений и подсказывают
программисту, если он передаёт что-то не то. В данном случае подсказка types.Message соообщает
PyCharm-у, что переменная message имеет тип Message, описанный в модуле types библиотеки
aiogram (см. импорты в начале кода). Благодаря этому IDE может на лету подсказывать атрибуты и функции.

При вызове команды /dice бот отправит в тот же чат игральный кубик. Разумеется, если его надо отправить в какой-то
другой чат, то придётся по-старинке вызывать await bot.send_dice(...). Но объект bot (экземпляр класса Bot) может быть
недоступен в области видимости конкретной функции. В aiogram 3.x объект бота, которому пришёл апдейт, неявно
прокидывается в хэндлер и его можно достать как аргумент bot. Предположим, вы хотите по команде /dice
отправлять кубик не в тот же чат, а в канал с ID -100123456789. Перепишем предыдущую функцию:

# не забудьте про импорт
from aiogram.enums.dice_emoji import DiceEmoji

@dp.message(Command("dice"))
async def cmd_dice(message: types.Message, bot: Bot):
    await bot.send_dice(-100123456789, emoji=DiceEmoji.DICE)

Иногда при запуске бота может потребоваться передать одно или несколько дополнительных значений. Это может быть
объект конфигурации, список администраторов группы, отметка времени и что угодно ещё. Для этого достаточно передать
параметры как дополнительные именованные (!) аргументы функции start_polling(...) (для вебхуков есть аналогичный
способ). В хэндлерах для получения этих значений достаточно указать их как те же аргументы. Более того, изменение таких
объектов в одних хэндлерах влияют на их содержимое в других. Рассмотрим на примере:

@dp.message(Command("add_to_list"))
async def cmd_add_to_list(message: types.Message, mylist: list[int]):
    mylist.append(7)
    await message.answer("Добавлено число 7")


@dp.message(Command("show_list"))
async def cmd_show_list(message: types.Message, mylist: list[int]):
    await message.answer(f"Ваш список: {mylist}")

Теперь список mylist можно читать и писать в разных хэндлерах. Существует также ещё один вариант, более подходящий
в других ситуациях. Речь, конечно же, о мидлварях, про которые подробно рассказывается
в соответствующей главе.

Аргумент mylist может быть изменён между вызовами

Файлы конфигурации¶

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

Итак, создадим рядом с bot.py отдельный файл config_reader.py со следующим содержимым

config_reader.py

from pydantic_settings import BaseSettings, SettingsConfigDict
from pydantic import SecretStr


class Settings(BaseSettings):
    # Желательно вместо str использовать SecretStr 
    # для конфиденциальных данных, например, токена бота
    bot_token: SecretStr

    # Начиная со второй версии pydantic, настройки класса настроек задаются
    # через model_config
    # В данном случае будет использоваться файла .env, который будет прочитан
    # с кодировкой UTF-8
    model_config = SettingsConfigDict(env_file='.env', env_file_encoding='utf-8')


# При импорте файла сразу создастся 
# и провалидируется объект конфига, 
# который можно далее импортировать из разных мест
config = Settings()

Теперь немного отредактируем наш bot.py:

bot.py

# импорты
from config_reader import config

# Для записей с типом Secret* необходимо 
# вызывать метод get_secret_value(), 
# чтобы получить настоящее содержимое вместо '*******'
bot = Bot(token=config.bot_token.get_secret_value())

Наконец, создадим файл .env (с точкой в начале), где опишем токен бота:

.env

BOT_TOKEN = 0000000000:AaBbCcDdEeFfGgHhIiJjKkLlMmNn

Если всё сделано правильно, то при запуске python-dotenv подгрузит переменные из файла .env, pydantic
их провалидирует и объект бота успешно создастся с нужным токеном.

На этом мы закончим знакомство с библиотекой, а в следующих главах рассмотрим другие «фишки» aiogram и Telegram Bot API.

Источник

Уровень сложности
Простой

Время на прочтение
7 мин

Количество просмотров 56K

Вступление

Захотев однажды научиться разрабатывать ботов для Telegram на языке программирования Python, я просто зашёл в Яндекс и вбил что-то вроде «telegram бот на python для новичков» и нашёл казалось бы огромное множество гайдов и туториалов. Однако копнув немного глубже стало понятно, что большая часть гайдов заканчивается на прикреплении клавиатур к сообщениям, или ещё хуже, на написании эхо-бота.

Пришлось копаться в документации, шерстить форумы и учиться на примерах кода с GitHub. Этот гайд создан как полное руководство по разработке полноценного Telegram бота для работы с нейросетями, такими как ChatGPT и Dall-e, начиная установкой IDE и получением токена и заканчивая подключением оплаты, базы данных и загрузки бота на сервер.

Я считаю что гайд будет полезен прежде всего тем, кто уже пробовал разобраться в теме и имеет базовые знания. Чтобы гайд был полезным необходимо иметь базовые знания в Python, всё остальное вы можете изучить в процессе. Продвинутым разработчикам ботов большая часть будет знакома и вряд ли принесёт пользу, однако есть шанс, что и вы найдёте для себя что-то полезное. Жду любую конструктивную критику как по коду и его стилю, так и по изложению.

Что мы получим в итоге?

В конце гайда у нас получится полностью функционирующий бот, с админкой, оплатой, базой данных, реферальной программой и подключенным API OpenAI. По мере выхода статей код будет появляться в репозитории на GitHub.

Используемые технологии

Будут использованы следующие технологии:

  • VS Code (или любой другой удобный редактор или IDE)

  • Python

  • Aiogram 3

  • PostgreSQL

  • API OpenAI

Подготовка окружения

Разработка любой программы начинается с подготовки среды, так что приступим. Для начала устанавливаем VS Code или любую другую вашу любимую IDE или редактор кода. Скачиваем установщик с сайта, запускаем, устанавливаем. По умолчанию среда уже готова к работе, но рекомендую установить дополнительные расширения для Python, а также по желанию темы и другие плюшки. 

Конечно же надо установить сам Python, но раз вы читаете это, то уверен, что либо уже сделали это, либо разберётесь сами. Скажу лишь, что использую версию 3.10, однако код также должен работать на версиях Python 3.8 и выше.

В VS Code переходим на вкладку Git, скачиваем и устанавливаем Git. Далее инициализируйте репозиторий и желательно опубликуйте его на GitHub (для удобства дальнейшей работы), это можно сделать прямо из VS Code.

Создание и публикация репозитория на GitHub

Создание и публикация репозитория на GitHub

После этого создадим виртуальное окружение, чтобы не засорять пакетами глобальyую среду. Подробнее про виртуальные окружения и преимущества их использования можете почитать здесь. Открываем палитру команд (Ctrl-Shift-P на Windows) и запускаем команду Python: Create Environment.

Далее выбираем venv и интерпретатор Python. Чтобы активировать виртуальное окружение, в терминале выполните команду .\.venv\Scripts\activate. Также выберите интерпретатор Python по умолчанию.

Выбранный интерпретатор должен находиться в папке .venv

Выбор интерпретатора по умолчанию

Выбор интерпретатора по умолчанию

Теперь пришло время установить все используемые библиотеки. Их список вы можете найти у меня на github. Там же я буду выкладывать весь код по мере выхода статей. Если вы скачали файл, то установить библиотеки можно командой:

pip install -r requirements.txt

Обратите внимание что мы будем использовать aiogram версии 3, который ещё находится в бета-тестировании, 3 версия НЕ совместима с предыдущими, так что не забывайте об этом. 

Следующий шаг — установка PostgreSQL. Сама установка не является чем-то сложным, поэтому не будем её подробно рассматривать. Для более удобной работы с базами данных можете установить графический клиент, такой как pgAdmin (идущий в комплекте с PostgreSQL), DBeaver или Navicat, самый удобный и используемый мною каждый день в работе (имеет бесплатную пробную версию).

На этом настройка окружения завершена, можно приступать к созданию структуры бота.

Создание структуры

Наш бот будет разделён на несколько логических частей — файлов. Можно писать весь код в одном файле — он будет также работать, однако отладка и поиск нужной функции или класса станет сущим адом.

Файловая структура нашего бота:

  • main.py — точка входа, код запуска бота и инициализации всех остальных модулей

  • config.py — файл со всеми конфигурационными параметрами, такими как токен бота и данные подключения к БД. Хранение настроек в Python-файле является не самой лучшей практикой, однако если настройки меняются очень редко, то такой способ является самым простым. Можно также хранить настройки в переменных окружения или специальных файлах (ini, json) и через config.py лишь предоставлять абстракцию данных, однако в этом боте будет использован самый простой способ

  • db.py — функции подключения и работы с базой данных. Данный файл будет являться абстракцией базы данных от основного кода

  • text.py — все тексты, используемые ботом. В этом файле будут лежать все приветствия, сообщения об ошибках и другие текстовые данные для бота. Хранение текста в Python-файле также является не лучшей практикой, так как изменить тексты можно только через код, однако тексты меняются не так часто (чаще всего никогда), поэтому снова пойдём самым простым путём

  • kb.py — все клавиатуры, используемые ботов. В этом файле будут находиться абсолютно все клавиатуры, как статические, так и динамически генерируемые через функции

  • middlewares.py — название файла говорит само за себя. В этом файле будут лежать все используемые мидлвари (их будет всего две)

  • states.py — будет хранить вспомогательные классы для FSM (машины состояний), а также фабрики Callback Data для кнопок Inline клавиатур

  • utils.py — различные функции. В этом файле будут лежать функции для рассылки, генерации текста и изображений через API и другие

  • handlers.py — основной файл, в котором будет содержать почти весь код бота. Будет состоять из функций-обработчиков с декораторами (фильтрами)

  • admin.py — обработчики событий, клавиатуры, классы и весь остальной код админки бота. Опять же если придерживаться лучших практик, стоило бы вынести это в отдельную папку, в которой уже создать модули клавиатур, текстов, хэндлеров (обработчиков) и всего остального. Наша админка будет иметь базовый функционал, поэтому реализуем всё в одном файле

В итоге ваша папка должна выглядеть так:

Получение токена

На эту тему написано настолько много материала, что крайне не хочется дублировать его, поэтому дам краткую инструкцию по получению токена:

  1. Запустите бота BotFather

  2. Создайте бота командой /newbot

  3. Следуя указаниям бота введите все данные, типа названия

  4. Скопируйте токен и вставьте его в переменную BOT_TOKEN в файле config.py

Можно также произвести настройку бота в BotFather, к примеру настроить описание, аватарку и другие параметры. 

Пишем первый код!

Теперь, когда все подготовительные действия сделаны, можем приступить к написанию кода. Мы не будем писать эхо-бота, а сразу перейдём к чему-то более полезному — бот, отправляющий пользователю его ID.

В файле main.py пишем следующий код:

import asyncio
import logging

from aiogram import Bot, Dispatcher
from aiogram.enums.parse_mode import ParseMode
from aiogram.fsm.storage.memory import MemoryStorage

import config
from handlers import router


async def main():
    bot = Bot(token=config.BOT_TOKEN, parse_mode=ParseMode.HTML)
    dp = Dispatcher(storage=MemoryStorage())
    dp.include_router(router)
    await bot.delete_webhook(drop_pending_updates=True)
    await dp.start_polling(bot, allowed_updates=dp.resolve_used_update_types())


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    asyncio.run(main())

Сначала мы импортируем все нужные нам классы и модули:

  • asyncio — для асинхронного запуска бота

  • logging — для настройки логгирования, которое поможет в отладке

  • aiogram — основной модуль библиотеки aiogram, из которого мы импортируем классы Bot и Dispatcher

  • aiogram.enums.parse_mode — содержит настройки разметки сообщений (HTML, Markdown)

  • aiogram.fsm.storage.memory — хранилища данных для состояний пользователей

  • config — настройки бота, пока что только токен

  • handlers — пока пустой, но скоро мы напишем в нём функционал нашего бота

Затем мы объявляем функцию main(), в которой будет запускаться бот. Далее мы создаём объект бота с нашим токеном. Обратите внимание на параметр parse_mode, он отвечает за используемую по умолчанию разметку сообщений. Мы используем HTML, чтобы избежать проблем с экранированием символов. Затем мы создаём объект диспетчера, параметр storage=MemoryStorage() говорит о том, что все данные бота, которые мы не сохраняем в БД (к примеру состояния), будут стёрты при перезапуске. Этот вариант является оптимальным, так как хранение состояний диспетчера требуется редко. 

Строка dp.include_router(router) подключает к нашему диспетчеру все обработчики, которые используют router, их вы увидите в следующем файле. Строка await bot.delete_webhook(drop_pending_updates=True) удаляет все обновления, которые произошли после последнего завершения работы бота. Это нужно, чтобы бот обрабатывал только те сообщения, которые пришли ему непосредственно во время его работы, а не за всё время. следующая строка запускает бота. Однако если сейчас попытаться запустить файл, бот не запустится, а выдаст исключение, так как файл handlers.py пустой. Давайте исправим это.

from aiogram import Router

router = Router()

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

Логи при успешном запуске бота

Логи при успешном запуске бота

Это означает, что наш бот запущен и слушает обновления, однако пока что он ничего не делает, так как мы не добавили ни одного обработчика. Давайте исправим это, написав в файле handlers.py следующий код: 

from aiogram import types, F, Router
from aiogram.types import Message
from aiogram.filters import Command


router = Router()


@router.message(Command("start"))
async def start_handler(msg: Message):
    await msg.answer("Привет! Я помогу тебе узнать твой ID, просто отправь мне любое сообщение")


@router.message()
async def message_handler(msg: Message):
    await msg.answer(f"Твой ID: {msg.from_user.id}")

Сначала мы импортируем все необходимое из aiogram. После этого создаём роутер для дальнешей привязки к нему обработчиков. Затем мы объявили две функции-обработчика событий, а также назначили им фильтры. Рассмотрим их подробнее. Декоратор @router.message означает, что функция является обработчиком входящих сообщений. Command("start") запускает обработчик только если входящее сообщение — команда /start. Далее мы объявляем саму функцию и в её теле отвечаем пользователю на сообщение текстом приветствия. Если мы имеем доступ к объекту сообщения, то всегда можем отправить в тот же чат любое сообщение методом msg.answer("Text"), что является аналогом await bot.send_message(msg.chat.id, "Text"). 

Второй обработчик реагирует на все сообщения, так как у него не задан ни один фильтр. В теле функции мы снова отвечаем пользователю сообщением и подставляем в него значение msg.chat.id. Запустим снова код и посмотрим на результат. Обратите внимание, что запускать надо не handlers.py, а main.py, так как именно он является точкой входа в нашу программу. В консоли снова появится аналогичное сообщение об успешном запуске бота, можно перейти в чат с ботом и отправить ему команду /start.

Мы должны получить следующие ответы от бота:

Бот работает исправно

Бот работает исправно

Если у вас получилось также, то поздравляю, вы настроили всё правильно и запустили минимально рабочего бота.

Заключение

В следующей части мы сделаем меню бота и подключим к боту API OpenAI. Так как это моя первая статья на Хабре, жду любой конструктивной критики в комментариях по оформлению, стилю изложения и разумеется коду.

UPD: Обновил код, удалил использование глобального объекта диспетчера, заменил на роутер. Спасибо более опытным коллегам за подсказку

Источник

Edit this page

Toggle table of contents sidebar

MIT License
PyPi status
PyPi Package Version
Downloads
Supported python versions
Telegram Bot API
Tests
Codecov

aiogram is a modern and fully asynchronous framework for
Telegram Bot API written in Python 3.8 using
asyncio and
aiohttp.

Make your bots faster and more powerful!

Documentation:

  • 🇺🇸 English

  • 🇺🇦 Ukrainian

Features#

  • Asynchronous (asyncio docs, PEP 492)

  • Has type hints (PEP 484) and can be used with mypy

  • Supports PyPy

  • Supports Telegram Bot API 6.9 and gets fast updates to the latest versions of the Bot API

  • Telegram Bot API integration code was autogenerated and can be easily re-generated when API gets updated

  • Updates router (Blueprints)

  • Has Finite State Machine

  • Uses powerful magic filters

  • Middlewares (incoming updates and API calls)

  • Provides Replies into Webhook

  • Integrated I18n/L10n support with GNU Gettext (or Fluent)

Simple usage#

import asyncio
import logging
import sys
from os import getenv

from aiogram import Bot, Dispatcher, Router, types
from aiogram.enums import ParseMode
from aiogram.filters import CommandStart
from aiogram.types import Message
from aiogram.utils.markdown import hbold

# Bot token can be obtained via https://t.me/BotFather
TOKEN = getenv("BOT_TOKEN")

# All handlers should be attached to the Router (or Dispatcher)
dp = Dispatcher()


@dp.message(CommandStart())
async def command_start_handler(message: Message) -> None:
    """
    This handler receives messages with `/start` command
    """
    # Most event objects have aliases for API methods that can be called in events' context
    # For example if you want to answer to incoming message you can use `message.answer(...)` alias
    # and the target chat will be passed to :ref:`aiogram.methods.send_message.SendMessage`
    # method automatically or call API method directly via
    # Bot instance: `bot.send_message(chat_id=message.chat.id, ...)`
    await message.answer(f"Hello, {hbold(message.from_user.full_name)}!")


@dp.message()
async def echo_handler(message: types.Message) -> None:
    """
    Handler will forward receive a message back to the sender

    By default, message handler will handle all message types (like a text, photo, sticker etc.)
    """
    try:
        # Send a copy of the received message
        await message.send_copy(chat_id=message.chat.id)
    except TypeError:
        # But not all the types is supported to be copied so need to handle it
        await message.answer("Nice try!")


async def main() -> None:
    # Initialize Bot instance with a default parse mode which will be passed to all API calls
    bot = Bot(TOKEN, parse_mode=ParseMode.HTML)
    # And the run events dispatching
    await dp.start_polling(bot)


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO, stream=sys.stdout)
    asyncio.run(main())

Contents#

  • Installation
    • From PyPI
    • From Arch Linux Repository
      • Development build (3.x)
    • From PyPI
    • From GitHub
  • Migration FAQ (2.x -> 3.0)
    • Dispatcher
    • Filtering events
    • Bot API
    • Middlewares
    • Keyboard Markup
    • Callbacks data
    • Finite State machine
    • Sending Files
    • Webhook
    • Telegram API Server
  • Bot API
    • Bot
    • Client session
      • Use Custom API server
      • Base
      • aiohttp
      • Client session middlewares
    • Types
      • Inline mode
      • Available types
      • Telegram Passport
      • Getting updates
      • Stickers
      • Payments
      • Games
    • Methods
      • Available methods
      • Payments
      • Stickers
      • Games
      • Getting updates
      • Telegram Passport
      • Updating messages
      • Inline mode
    • Enums
      • BotCommandScopeType
      • ChatAction
      • ChatMemberStatus
      • ChatType
      • ContentType
      • Currency
      • DiceEmoji
      • EncryptedPassportElement
      • InlineQueryResultType
      • InputMediaType
      • MaskPositionPoint
      • MenuButtonType
      • MessageEntityType
      • ParseMode
      • PassportElementErrorType
      • PollType
      • StickerFormat
      • StickerType
      • TopicIconColor
      • UpdateType
    • How to download file?
      • Download file manually
      • Download file in short way
    • How to upload file?
      • Upload from file system
      • Upload from buffer
      • Upload from url
  • Handling events
    • Router
      • Router
      • Event observers
      • Nested routers
    • Dispatcher
      • Dispatcher
      • Simple usage
      • Handling updates
    • Dependency injection
      • How it works in aiogram
      • Injecting own dependencies
    • Filtering events
      • Builtin filters
      • Writing own filters
      • Combining Filters
    • Long-polling
      • Example
    • Webhook
      • aiohttp integration
      • With using other web framework
    • Finite State Machine
      • Usage example
      • Read more
    • Middlewares
      • Base theory
      • Basics
      • Arguments specification
      • Examples
      • Facts
    • Errors
      • Handling errors
      • ErrorEvent
      • Error types
    • Flags
      • Via decorators
      • Via handler registration method
      • Via filters
      • Use in middlewares
      • Use in utilities
    • Class based handlers
      • BaseHandler
      • CallbackQueryHandler
      • ChosenInlineResultHandler
      • ErrorHandler
      • InlineQueryHandler
      • MessageHandler
      • PollHandler
      • PreCheckoutQueryHandler
      • ShippingQueryHandler
      • ChatMemberHandler
  • Utils
    • Keyboard builder
      • Usage example
      • Inline Keyboard
      • Reply Keyboard
    • Translation
      • Installation
      • Make messages translatable
      • Configuring engine
      • Deal with Babel
    • Chat action sender
      • Sender
      • Middleware
    • WebApp
      • Usage
      • Functions
      • Types
    • Callback answer
      • Simple usage
      • Advanced usage
      • Description of objects
    • Formatting
      • Usage
      • Available methods
      • Available elements
    • Media group builder
      • Usage
      • References
  • Changelog
    • 3.1.0 (2023-09-22)
      • Features
      • Bugfixes
    • 3.0.0 (2023-09-01)
      • Bugfixes
    • 3.0.0rc2 (2023-08-18)
      • Bugfixes
      • Improved Documentation
      • Misc
    • 3.0.0rc1 (2023-08-06)
      • Features
      • Bugfixes
      • Improved Documentation
      • Misc
    • 3.0.0b9 (2023-07-30)
      • Features
      • Bugfixes
      • Improved Documentation
      • Deprecations and Removals
    • 3.0.0b8 (2023-07-17)
      • Features
      • Bugfixes
      • Improved Documentation
      • Deprecations and Removals
      • Misc
    • 3.0.0b7 (2023-02-18)
      • Features
      • Bugfixes
      • Misc
    • 3.0.0b6 (2022-11-18)
      • Features
      • Bugfixes
      • Improved Documentation
      • Misc
    • 3.0.0b5 (2022-10-02)
      • Features
      • Bugfixes
      • Improved Documentation
      • Deprecations and Removals
      • Misc
    • 3.0.0b4 (2022-08-14)
      • Features
      • Bugfixes
      • Misc
    • 3.0.0b3 (2022-04-19)
      • Features
      • Bugfixes
      • Misc
    • 3.0.0b2 (2022-02-19)
      • Features
      • Bugfixes
      • Misc
    • 3.0.0b1 (2021-12-12)
      • Features
      • Bugfixes
      • Misc
    • 3.0.0a18 (2021-11-10)
      • Features
      • Bugfixes
      • Misc
    • 3.0.0a17 (2021-09-24)
      • Misc
    • 3.0.0a16 (2021-09-22)
      • Features
      • Misc
    • 3.0.0a15 (2021-09-10)
      • Features
      • Bugfixes
      • Misc
    • 3.0.0a14 (2021-08-17)
      • Features
      • Bugfixes
      • Improved Documentation
      • Misc
    • 2.14.3 (2021-07-21)
    • 2.14.2 (2021-07-26)
    • 2.14 (2021-07-27)
    • 2.13 (2021-04-28)
    • 2.12.1 (2021-03-22)
    • 2.12 (2021-03-14)
    • 2.11.2 (2021-11-10)
    • 2.11.1 (2021-11-10)
    • 2.11 (2021-11-08)
    • 2.10.1 (2021-09-14)
    • 2.10 (2021-09-13)
    • 2.9.2 (2021-06-13)
    • 2.9 (2021-06-08)
    • 2.8 (2021-04-26)
    • 2.7 (2021-04-07)
    • 2.6.1 (2021-01-25)
    • 2.6 (2021-01-23)
    • 2.5.3 (2021-01-05)
    • 2.5.2 (2021-01-01)
    • 2.5.1 (2021-01-01)
    • 2.5 (2021-01-01)
    • 2.4 (2021-10-29)
    • 2.3 (2021-08-16)
    • 2.2 (2021-06-09)
    • 2.1 (2021-04-18)
    • 2.0.1 (2021-12-31)
    • 2.0 (2021-10-28)
    • 1.4 (2021-08-03)
    • 1.3.3 (2021-07-16)
    • 1.3.2 (2021-05-27)
    • 1.3.1 (2018-05-27)
    • 1.3 (2021-04-22)
    • 1.2.3 (2018-04-14)
    • 1.2.2 (2018-04-08)
    • 1.2.1 (2018-03-25)
    • 1.2 (2018-02-23)
    • 1.1 (2018-01-27)
    • 1.0.4 (2018-01-10)
    • 1.0.3 (2018-01-07)
    • 1.0.2 (2017-11-29)
    • 1.0.1 (2017-11-21)
    • 1.0 (2017-11-19)
    • 0.4.1 (2017-08-03)
    • 0.4 (2017-08-05)
    • 0.3.4 (2017-08-04)
    • 0.3.3 (2017-07-05)
    • 0.3.2 (2017-07-04)
    • 0.3.1 (2017-07-04)
    • 0.2b1 (2017-06-00)
    • 0.1 (2017-06-03)
  • Contributing
    • Developing
      • Use virtualenv
      • Activate the environment
      • Setup project
      • Making changes in code
      • Format the code (code-style)
      • Run tests
      • Docs
      • Docs translations
      • Describe changes
      • Complete
    • Star on GitHub
    • Guides
    • Take answers
    • Funding
Источник

#Руководства


  • 0

Большой гайд по работе с Aiogram на примере эхо‑бота — чат‑бота, который повторяет за пользователем его фразы. Весь код — внутри статьи.

Иллюстрация: Polina Vari для Skillbox Media

Антон Яценко

Изучает Python, его библиотеки и занимается анализом данных. Любит путешествовать в горах.

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

Благодаря этой статье вы научитесь с нуля создавать чат-ботов с помощью Python и библиотеки Aiogram. Мы напишем эхо-бота, который отвечает на сообщения пользователя точно такими же сообщениями. Это первая часть урока по Aiogram — во второй части мы добавим боту кнопки и новые фичи.

Содержание

  • Библиотеки для создания бота
  • Краткое описание Aiogram
  • Создаём эхо-бота
  • Шаг 1. Устанавливаем Python
  • Шаг 2. Создаём виртуальное окружение
  • Шаг 3. Создаём бота
  • Шаг 4. Подключаем Aiogram
  • Шаг 5. Пишем код для эхо-бота
  • Шаг 6. Запускаем бота и проверяем работу
  • Что дальше?

Для создания телеграм-ботов на Python существует несколько десятков библиотек. Они различаются популярностью, размером комьюнити и функциональностью. Рассмотрим самые популярные.

Aiogram. Современная библиотека, набирающая популярность: многие чат-боты написаны на ней. В этой и последующих статьях цикла мы будем работать именно с Aiogram. Библиотека реализует асинхронное выполнение кода, что позволяет не останавливать работу бота в ожидании ответа пользователя. Кроме того, у Aiogram есть подробная документация и большое русскоязычное комьюнити.

Python-telegram-bot. Одна из первых библиотек для создания ботов. Отличается от Aiogram синхронным подходом к работе, то есть при ожидании ответа от пользователя выполнение кода останавливается.

TeleBot. Библиотека для создания простых ботов, позволяющая работать с асинхронным и синхронным подходом на выбор. Подходит для небольших проектов. Подробнее можно узнать в документации.

Перед тем как приступить к написанию нашего бота, остановимся подробнее на одной технической особенности Aiogram.

Как уже было сказано ранее, одно из главных достоинств библиотеки — полная асинхронность. Она использует синтаксис async/await, который позволяет программе выполнять несколько задач одновременно и эффективно управлять потоком выполнения.

Вот простой пример функции, использующей механизм async/await:

# Хендлер для команды /start
@dp.message(Command("start"))
async def start(message: types.Message):
    await message.answer("Привет, пользователь!")

Функция, которая обрабатывает сообщение пользователя в Telegram, называется хендлером, то есть обработчиком. У каждой команды или группы команд свой обработчик.

В хендлере мы прописываем, что бот должен сделать в ответ на сообщение. А для того, чтобы для каждой команды вызывался нужный обработчик, функция оборачивается в декоратор, которому передаётся имя команды без символа /.

Служебное слово async указывает интерпретатору, что функция будет работать в асинхронном режиме. Это означает, что интерпретатору не нужно ждать, пока выполняется код функции, — он может выполнять следующие инструкции, пока start что-нибудь не вернёт. Это «что-нибудь» следует за служебным словом await («ожидать»), а не return, как в обычном коде.

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

Вот несколько полезных источников, которые помогут разобраться в библиотеке и следить за её обновлениями:

  • официальная документация,
  • репозиторий библиотеки на GitHub,
  • русскоязычный телеграм-чат, посвящённый Aiogram,
  • англоязычный чат, посвящённый Aiogram,
  • канал с новостями библиотеки,
  • тестовый бот на основе Aiogram.

Переходим к созданию телеграм-бота. Потренируемся на простом примере — создадим эхо-бота, который отвечает на сообщения пользователя его же словами.

Для этого нам необходимо:

  • установить Python и настроить виртуальное окружение;
  • зарегистрировать бота в специальном телеграм-канале @BotFather;
  • установить библиотеку Aiogram;
  • написать код эхо-бота, связав его по API с Telegram.

На macOS или Linux. Python установлен в эти операционные системы изначально. Чтобы проверить его наличие, откройте терминал и введите команду:

python --version

Если Python установлен, то терминал покажет его версию:

Скриншот: Aiogram / Skillbox Media

На Windows требуется установка Python. Сделать это проще всего по нашей инструкции.

После установки и проверки Python требуется установить виртуальное окружение с помощью virtualenv. Это специальный инструмент, который позволяет изолировать друг от друга проекты в разработке, независимо устанавливая для них библиотеки и пакеты. Удобно, когда вы работаете над разными приложениями одновременно.

virtualenv устанавливается через терминал:

sudo pip3 install virtualenv

После этого необходимо создать директорию для проекта, внутри которой будет работать виртуальное окружение:

mkdir telegram_bot
cd telegram_bot

Команда mkdir создаст папку telegram_bot, а команда cd переведёт нас в неё. Теперь в этой директории будут храниться файлы проекта, связанные с нашим ботом.

Развернём виртуальное окружение внутри папки telegram_bot:

virtualenv venv -p python3

Теперь его активируем. Если этого не сделать, то оно не будет работать.

source venv/bin/activate

Виртуальное окружение запущено, и мы готовы перейти к следующему шагу.

Для создания бота необходимо воспользоваться Telegram и ботом @BotFather. Откройте мессенджер и введите название бота в поисковой строке:

Скриншот: Aiogram / Skillbox Media

Открываем его, жмём кнопку «Запустить» и вводим команду /newbot:

Скриншот: Aiogram / Skillbox Media

Теперь напишем название и юзернейм для нашего бота. Назовём его echo_skillbox_bot (теперь это имя занято, так что вам надо будет придумать своё). В ответ придёт наш токен, который мы будем использовать для подключения к API Telegram.

Скриншот: Aiogram / Skillbox Media

Этот токен мы сохраняем — он потребуется нам в будущем.

Для установки Aiogram воспользуемся менеджером пакетов PIP. Вводим в терминал:

pip install aiogram

Важно! Библиотека устанавливается в созданное ранее виртуальное окружение, связанное с папкой telegram_bot. Если вы решите создать нового бота в другой директории на компьютере, то установку будет необходимо провести заново, иначе Aiogram не будет работать.

Писать код на Python лучше всего в IDE, а не в окне терминала. В проекте ниже мы будем использовать бесплатный редактор Visual Studio Code, но вы можете воспользоваться любым удобным для вас инструментом.

Откроем IDE и создадим файл main.py. Для этого проекта нам потребуется только он. Импортируем из Aiogram нужные классы и модуль:

from aiogram import Bot, Dispatcher, executor, types

Разберёмся, что каждый из них делает. Начнём с классов:

  • Bot определяет, на какие команды от пользователя и каким способом отвечать.
  • Dispatcher позволяет отслеживать обновления.
  • Executor запускает бота и выполняет функции, которые следует выполнить.

Модуль types позволит нам использовать базовые классы для аннотирования, то есть восприятия сообщений. Например, мы будем использовать types.Message, позволяющий работать с приёмом текстовых сообщений пользователя. Подробно об этом можно прочесть в документации.

Импортируем наш токен, который поможет коммуницировать с API Telegram:

API_TOKEN = '5602787567:AAGYv7NrSjwyW7qPs_yvu70C060zrcfZDbQ' #В одинарных кавычках размещаем токен, полученный от @BotFather.

Теперь необходимо инициализировать объекты bot и Dispatcher, передав первому наш токен. Если их не инициализировать, то код не будет работать.

bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)

Настроим приветственное окно для нового пользователя, которое будет появляться при нажатии команды /start. Для этого создаём message_handler и прописываем функцию ответа:

@dp.message_handler(commands=['start']) #Явно указываем в декораторе, на какую команду реагируем. 
async def send_welcome(message: types.Message):
   await message.reply("Привет!\nЯ Эхо-бот от Skillbox!\nОтправь мне любое сообщение, а я тебе обязательно отвечу.") #Так как код работает асинхронно, то обязательно пишем await.

Теперь при нажатии на кнопку Начать или при вводе команды /start пользователь будет получать от бота приветственное сообщение.

Разберёмся в коде:

  • message_handler — это декоратор, который реагирует на входящие сообщения и содержит в себе функцию ответа. Декоратор — это «обёртка» вокруг функций, позволяющая влиять на их работу без изменения кода самих функций. В нашем случае мы управляем функцией, считая команды пользователя.
  • commands=[‘start’] — это команда, которая связана с декоратором и запускает вложенную в него функцию.
  • async def send_welcome — создаёт асинхронную функцию, которая принимает в себя сообщение пользователя message, определяемое через тип Message. Саму функцию можно назвать любым образом. Мы выбрали send_welcome, чтобы название было понятным и осмысленным.
  • await message.reply — определяет ответ пользователя, используя await из-за асинхронности работы библиотеки.

Теперь создадим событие, которое будет обрабатывать введённое пользователем сообщение:

@dp.message_handler() #Создаём новое событие, которое запускается в ответ на любой текст, введённый пользователем.
async def echo(message: types.Message): #Создаём функцию с простой задачей — отправить обратно тот же текст, что ввёл пользователь.
   await message.answer(message.text)

Так как бот должен реагировать на любое текстовое сообщение от пользователя, то скобки в @dp.message_handler мы оставляем пустыми. Параметр message не отличается от использованного в предыдущих шагах.

Для ответа мы также используем метод message, указывая, что возвращаем исходный текст, принятый в message.

Остаётся последний этап — настроить получение сообщений от сервера в Telegram. Если этого не сделать, то мы не получим ответы бота. Реализовать получение новых сообщений можно с помощью поллинга. Он работает очень просто — метод start_polling опрашивает сервер, проверяя на нём обновления. Если они есть, то они приходят в Telegram. Для включения поллинга необходимо добавить две строчки:

if __name__ == '__main__':
   executor.start_polling(dp, skip_updates=True)

Всё, теперь код нашего бота полностью готов:

from aiogram import Bot, Dispatcher, executor, types
 
API_TOKEN = '5602787567:AAGYv7NrSjwyW7qPs_yvu70C060zrcfZDbQ'
 
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
 
@dp.message_handler(commands=['start'])
async def send_welcome(message: types.Message):
   await message.reply("Привет!\nЯ Эхо-бот от Skillbox!\nОтправь мне любое сообщение, а я тебе обязательно отвечу.")
 
@dp.message_handler()
async def echo(message: types.Message):
   await message.answer(message.text)
 
if __name__ == '__main__':
   executor.start_polling(dp, skip_updates=True)

Сохраняем его в нашей папке telegram_bot под именем main.py.

Для запуска бота нам необходим терминал. Открываем его и переходим в нашу папку telegram_bot. После этого вводим команду:

python3 main.py

В ответ терминал пришлёт сообщение, что обновления успешно пропущены:

Скриншот: Aiogram / Skillbox Media

Находим нашего бота в Telegram по имени @echo_skillbox_bot и запускаем его, нажав на кнопку Начать. В ответ на это или на команду /start нам придёт приветственное сообщение:

Скриншот: Aiogram / Skillbox Media

Попробуем написать что-то:

Скриншот: Aiogram / Skillbox Media

Как мы видим — всё работает. Бот возвращает нам наши сообщения.

Расширять функциональность бота, указывая для разных команд пользователя разные ответы. Например, добавить раздел помощи, который будет появляться по команде /help. Или настроить запуск кода на виртуальном сервере, чтобы бот работал независимо от вашего компьютера.

Во второй части статьи мы добавим к нашему боту кнопки и новые возможности. Так что обязательно заходите и читайте :)

Как зарабатывать больше с помощью нейросетей?
Бесплатный вебинар: 15 экспертов, 7 топ-нейросетей. Научитесь использовать ИИ в своей работе и увеличьте доход.
Узнать больше

Источник

В этом уроке мы изучим базовые аспекты работы с библиотекой aiogram.

799
показов

1.2K
открытий

Зачем изучать еще одну библиотеку?

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

Установка и настройка aiogram.

Для работы с библиотекой aiogram ее необходимо сначала установить. Для этого совершите следующие действия: File -> Settings -> Project: (ваш проект) -> Python Interpreter -> над словом «package» нажмите на + -> в поиске введите название библиотеки aiogram -> Install Package.

Теперь, когда библиотека установлена, мы можем ее подключить. Вместо полного подключения библиотеки, я предлагаю подключить только определенные классы, которые нам понадобятся. Для этого мы импортируем из библиотеки aiogram такие классы, как Bot, Dispatcher, executor и types. Затем нам нужно создать объект bot, который будет ссылаться на наш токен в telegram. Для этого мы создаем бота и обращаемся к Bot, а в качестве значения указываем наш токен. Также, чтобы бот корректно работал, нам нужно воспользоваться классом Dispatcher. Создаем объект, например, dis, где обращаемся к Dispatcher, и устанавливаем нашу переменную bot. Теперь мы можем работать с нашим ботом. Также давайте в самом низу пропишем то, что наша команда будет работать постоянно. Для этого нам необходимо обратиться к executor и вызвать start_polling, куда передаем наш объект dis. Это будет базовым синтаксисом для настройки бота.

Отслеживание команд.

Давайте для начала отследим команду /start. Для этого мы прописываем почти один и тот же синтаксис. Мы обращаемся к диспетчеру (то есть объекту dis), затем обращаемся к message_handler() и также указываем commands = [‘start’]. Затем мы должны создать функцию, например, start, и здесь будет использоваться принцип асинхронности, поэтому перед функцией мы должны прописать ключевое слово async. Также перед всеми действиями, которые вы будете выполнять, нужно прописывать await. В функции мы указываем точно такой же параметр message и указываем тип этого параметра. Для этого ставим двоеточие, затем указываем types и тип этого параметра, то есть message. Теперь давайте выведем сообщение пользователю. Сначала мы прописываем await, затем обращаемся к bot.send_message(), указываем message.chat.id, а затем в фигурных скобках пишем наше сообщение пользователю.

Если запустить бота и нажать кнопку /start, то все будет работать корректно.

Типы получаемых данных. Также, как и ранее, если мы внутри диспетчера напишем не commands = [‘start’], а, например, content_types = [‘photo’], то наш бот будет отвечать только тогда, когда ему будут отправлять фотографию.

То же самое будет происходить, если мы в content_types пропишем video — наш бот будет отслеживать видео, если audio — аудио, если text — текст.

Отправка файлов.

Чтобы отправить нашему пользователю какой-либо файл в ответ на его сообщение, мы сначала открываем файл с помощью функции open, затем асинхронно прописываем message.answer_ и выбираем тип файла, который мы хотим отправить пользователю.

Можно заметить, что библиотеки для создания ботов очень схожи.

Создание кнопок inline.

Теперь давайте создадим функцию, которая будет отслеживать наши кнопки. Для этого обращаемся к диспетчеру, далее обращаемся к message_handler() и здесь прописываем commands = [‘text’]. То есть, когда мы напишем текст, то наши кнопки будут срабатывать. Далее прописываем async, потом прописываем функцию, например, second, и тут мы указываем также параметр message и его тип types. Для создания кнопок мы будем делать почти все то же самое. Мы прописываем markup, далее обращаемся к types, и если мы делаем встроенные кнопки, то обращаемся к InlineKeyboardMarkup(). Далее для добавления кнопок я пишу markup.add и внутри обращаемся к types.InlineKeyboardButton. Здесь мы указываем текст, который будет на наших кнопках. Например, создадим кнопку на нашу группу в Telegram. Напишу текст ‘Telegram канал’, тут же пропишем url и пишем ссылку на нашу группу. По схожему принципу добавим еще одну кнопку ‘Привет’, только вместо url мы добавим callbackdata. Также вместе с этими кнопками давайте будем выводить текст, например, ‘Привет!’. Для этого мы пишем await, потом bot.send_message(message.chat.id, ‘Привет!’) и дополнительно описываем replymarkup = markup, чтобы наши кнопки работали.

Теперь давайте создадим обработчик callback_data. Для этого обращаемся к диспетчеру, далее к callback_query_handler(). Здесь же мы с вами создаем асинхронную функцию, например, callback, которая принимает параметр call. И здесь мы будем выводить сообщение на экран. Для этого мы пишем await, обращаемся к call.message.answer и будем выводить те данные, которые передаются при нажатии (в моем случае это будет help).

Создание кнопок reply.

Теперь давайте создадим кнопки reply. Для этого также обращаемся к регистру, к message_handler() и пусть наши кнопки будут появляться при команде /reply. Для этого пишем внутри commands = ‘reply’. Теперь создаем функцию, например, reply. Тут также мы принимаем один параметр и указываем его тип. Далее мы прописываем почти то же самое, что писали ранее. Создаем объект markup, далее обращаемся к types, потом ReplyKeyboardMarkup. Далее мы добавляем кнопки с помощью markup.add. Тут же мы указываем types.KeyboardButton и далее указываем название кнопки, например, help. Потом мы выводим некое сообщение с помощью await bot.send_message(message.chat.id, ‘Приветствуем вас в нашем Telegram боте’) и также указываем reply_markup=markup.

Также вы можете подписаться на telegram канал, где будут выкладываться все коды с моих уроков, а также сами уроки: https://t.me/pythotelegram.

А также после каждого урока вы можете заходить на моего telegram бота, чтобы посмотреть результат работы, после каждого урока:

Источник

Понравилась статья? Поделить с друзьями:
  • Тетрациклина гидрохлорид инструкция по применению ветеринария
  • Гепатит в прививка инструкция по применению детям
  • Руководство пользователя телевизора lg smart tv
  • Фигурная штукатурка стен своими руками пошаговая инструкция
  • Вариативные модули классное руководство