Как сделать бота для телеграмма: 404 Page not found | База знаний Selectel

Как создать бота в Telegram

Что нужно знать, прежде чем создавать бота в Telegram

Боты являются своего рода программами, которые умеют выполнять разные функции — от предоставления информации до управления устройствами — и работают прямо в мессенджере.

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

Но так или иначе сначала бота нужно создать. Делается это следующим образом.

Как создать бота в Telegram

Чтобы сделать своего бота, понадобится другой бот — BotFather. Это официальный инструмент для создания ботов и управления ими. Найти BotFather можно через поиск. Обратите внимание на синюю галочку рядом с именем: именно она укажет на правильный чат.

Запустите диалог с ним и нажмите «Начать».

Кликните по кнопке меню и выберите /newbot.

BotFather попросит назвать вашего бота. Введите желаемое имя и нажмите «Отправить».

Следующим шагом нужно придумать боту никнейм. Он должен быть уникальным и заканчиваться на bot. Если эти условия не выполняются, BotFather просит сочинить другой.

Далее BotFather предоставит ссылку на созданного бота и токен для обращения к нему. Ссылка нужна для поиска бота, ею можно делиться. А вот токен — длинный набор символов — вещь секретная. Это своеобразный ключ, с помощью которого осуществляется управление программой. Сохраните его в надёжном месте и никому не показывайте.

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

Как настроить бота в Telegram

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

Также при желании можно добавить описание (/setdescription), прикрепить аватар (/setuserpic) или сменить имя (/setname). Все эти действия осуществляются через меню в BotFather. Если у вас несколько ботов, то сначала придётся выбрать нужный из списка.

В качестве наглядного примера мы создадим простого чат-бота с помощью бесплатного сервиса Manybot. Он не требует навыков программирования и работает прямо в Telegram. Наш бот будет предлагать полезную информацию для читателей: книги и подкасты Лайфхакера, а также открытые вакансии и возможность связи с редакцией. Принцип работы несложный: пользователь переходит в нужный чат по ссылке, запускает одну из команд, нажимая на кнопку в меню, и получает ответ на свой вопрос. Вот какие этапы включает настройка.

Подключение бота

Сначала нужно открыть чат с Manybot, перейдя по ссылке, и нажать «Начать».

Затем выбрать удобный для вас язык.

Кликните «Добавить нового бота».

А вот теперь понадобится токен созданного ранее бота, который выдал BotFather. Нажмите «Я скопировал токен» и отправьте его Manybot.

Добавьте описание бота, которое будут видеть пользователи, или пропустите этот шаг.

Создание команд

Далее вернитесь к своему боту, которого создали с помощью BotFather, и нажмите «Начать».

Выберите «Пользовательские команды».

Затем — «Создать команду».

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

Впишите текст, добавьте ссылки или фото, которые увидит пользователь после вызова команды. Сообщений может быть несколько. Нажмите «Отправить», а затем «Сохранить».

Таким же образом через меню «Создать команду» добавьте остальные команды, которые вам нужны. В нашем примере это подкасты, вакансии и обратная связь.

Добавление кнопок в меню

Чтобы пользователи могли взаимодействовать с ботом через графический интерфейс, а не вводить команды вручную, необходимо добавить кнопки для каждой из них. Для этого нажмите «Настроить гл. меню».

Кликните «Добавить пункт меню».

Выберите нужную команду.

Придумайте название для кнопки и нажмите «Отправить».

По такому же принципу добавьте кнопки для других команд.

Проверка работы бота

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

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

Читайте также 📱📳📲

Глава 1 Создаём бота, и отправляем с его помощью сообщения в telegram (1)

В этой главе мы разберёмся как создать телеграм бота, и отправлять с его помощью уведомления в telegram.

Создание телеграм бота

Для начала нам необходимо создать бота. Делается это с помощью специального бота BotFather, переходим по ссылке и пишем боту /start.

После чего вы получите сообщение со списком команд:

I can help you create and manage Telegram bots. If you're new to the Bot API, please see the manual (https://core.telegram.org/bots).

You can control me by sending these commands:

/newbot - create a new bot
/mybots - edit your bots [beta]

Edit Bots
/setname - change a bot's name
/setdescription - change bot description
/setabouttext - change bot about info
/setuserpic - change bot profile photo
/setcommands - change the list of commands
/deletebot - delete a bot

Bot Settings
/token - generate authorization token
/revoke - revoke bot access token
/setinline - toggle inline mode (https://core.telegram.org/bots/inline)
/setinlinegeo - toggle inline location requests (https://core.telegram.org/bots/inline#location-based-results)
/setinlinefeedback - change inline feedback (https://core.telegram.org/bots/inline#collecting-feedback) settings
/setjoingroups - can your bot be added to groups?
/setprivacy - toggle privacy mode (https://core.  telegram.org/bots#privacy-mode) in groups

Games
/mygames - edit your games (https://core.telegram.org/bots/games) [beta]
/newgame - create a new game (https://core.telegram.org/bots/games)
/listgames - get a list of your games
/editgame - edit a game
/deletegame - delete an existing game
 

Для создания нового бота отправляем команду /newbot.

BotFather попросит вас ввести имя и логин бота.

BotFather, [25.07.20 09:39]
Alright, a new bot. How are we going to call it? Please choose a name for your bot.

Alexey Seleznev, [25.07.20 09:40]
My Test Bot

BotFather, [25.07.20 09:40]
Good. Now let's choose a username for your bot. It must end in `bot`. Like this, for example: TetrisBot or tetris_bot.

Alexey Seleznev, [25.07.20 09:40]
@my_test_bot 

Имя вы можете ввести произвольное, а логин должен заканчиваться на bot.

Если вы всё сделали правильно, то получите следующее сообщение:

Done! Congratulations on your new bot.  You will find it at t.me/my_test_bot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.

Use this token to access the HTTP API:
123456789:abcdefghijklmnopqrstuvwxyz

For a description of the Bot API, see this page: https://core.telegram.org/bots/api 

Далее вам понадобится полученный API токен, в моём примере это 123456789:abcdefghijklmnopqrstuvwxyz.

Более подробно о возможностях BotFather можно узнать из этой публикации. На этом шаге подготовительные работы по созданию бота завершены.

Установка пакета для работы с телеграм ботом на R

Я предполагаю, что у вас уже установлен язык R, и среда разработки RStudio. Если это не так, то вы можете посмотреть данный видео урок о том, как их установить.

Для работы с Telegram Bot API мы будем использовать R пакет telegram.bot.

Установка пакетов в R осуществляется функцией install.packages(), поэтому для установки нужного нам пакета используйте команду install.packages("telegram.bot").

Более подробно узнать об установке различных пакетов можно из этого видео.

После установки пакета его необходимо подключить:

Отправка сообщений из R в Telegram

Созданного вами бота можно найти в Telegram по заданному при создании логину, в моём случае это @my_test_bot.

Отправьте боту любое сообщение, например “Привет бот.” На данный момент это нам надо для того, что бы получить id вашего с ботом чата.

Теперь в R пишем следующий код.

library(telegram.bot)

# создаём экземпляр бота
bot <- Bot(token = "123456789:abcdefghijklmnopqrstuvwxyz")

# Запрашиваем информацию о боте
print(bot$getMe())

# Получаем обновления бота, т. е. список отправленных ему сообщений
updates <- bot$getUpdates()

# Запрашиваем идентификатор чата
# Примечание: перед запросом обновлений вы должны отправить боту сообщение
chat_id <- updates[[1L]]$from_chat_id()

Изначально мы создаём экземпляр нашего бота функцией Bot(), в качестве аргумента в неё необходимо передать полученный ранее токен.

Хранить токен в коде считается не лучшей практикой, поэтому вы можете хранить его в переменной среды, и считывать его из неё. По умолчанию в пакете telegram.bot реализована поддержка переменных среды следующего наименования: R_TELEGRAM_BOT_ИМЯ_ВАШЕГО_БОТА. Вместо ИМЯ_ВАШЕГО_БОТА подставьте имя которое вы задали при создании, в моём случае будет переменная R_TELEGRAM_BOT_My Test Bot.

Создать переменную среды можно несколькими способами, я расскажу о наиболее универсальном и кроссплатформенном. Создайте в вашей домашней директории (узнать её можно с помощью команды path.

И добавьте в него следующую строку.

R_TELEGRAM_BOT_ИМЯ_ВАШЕГО_БОТА=123456789:abcdefghijklmnopqrstuvwxyz

Далее вы можете использовать сохранённый в переменной среды токен с помощью функции bot_token(), т.е. вот так:

bot <- Bot(token = bot_token("My Test Bot"))

Метод getUpdates()позволяет нам получить обновления бота, т.е. сообщения которые были ему отправлены. Метод

Помимо id чата из объекта полученного методом getUpdates() вы получаете и некоторую другую полезную информацию. Например, информацию о пользователе, отправившем сообщение.

updates[[1L]]$message$from

$id
[1] 000000000

$is_bot
[1] FALSE

$first_name
[1] "Alexey"

$last_name
[1] "Seleznev"

$username
[1] "AlexeySeleznev"

$language_code
[1] "ru"

Итак, на данном этапе у нас уже есть всё, что необходимо для отправки сообщения от бота в телеграм.

# Отправка сообщения
bot$sendMessage(chat_id,
                text = "Привет, *жирный текст* _курсив_",
                parse_mode = "Markdown"
)

Если вам необходимо отправить сообщение от бота не в чат, а в публичный канал, то в chat_id указывайте адрс вашего канала, например

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

Пример ссылки приватного канала: https://t.me/c/012345678/11

Соответвенно, к id 012345678 вам необходимо добавить -100, в таком случае в chat_id надо указать -100012345678.

Основы форматирования Markdown разметки:

• Жирный шрифт выделяется с помощью знака *:
  • пример: *жирный шритф*
  • результат:
    жирный шритф
• Курсив задаётся нижним подчёркиванием:
  • пример: _курсив_
  • результат: курсив
• Моноширинный шрифт, которым обычно выделяется программный код, задаётся с помощью апострофов:
  • пример: `моноширинный шрифт`
  • результат: моноширинный шрифт

Основы форматирования HTML разметки:

В HTML вы заворачиваете часть текста, которую надо выделать, в теги, пример <тег>текст</тег>.

• <тег> — открывающий тег
• </тег> — закрывающий тег

Теги HTML разметки

• <b> — жирный шрифт
  • пример: <b>жирный шрифт</b>
  • результат жирный шрифт
• <i> — курсив
  • пример: <i>курсив</i>
  • результат: курсив
• <code> — моноширинный шрифт
  • пример: <code\>моноширинный шрифт</code\>
  • результат: моноширинный шрифт

Помимо текста вы можете отправлять и другой контент используя специальные методы:

# Отправить изображение
bot$sendPhoto(chat_id,
  photo = "https://telegram. org/img/t_logo.png"
)

# Отправка голосового сообщения
bot$sendAudio(chat_id,
  audio = "http://www.largesound.com/ashborytour/sound/brobob.mp3"
)

# Отправить документ
bot$sendDocument(chat_id,
  document = "https://github.com/ebeneditos/telegram.bot/raw/gh-pages/docs/telegram.bot.pdf"
)

# Отправить стикер
bot$sendSticker(chat_id,
  sticker = "https://www.gstatic.com/webp/gallery/1.webp"
)

# Отправить видео
bot$sendVideo(chat_id,
  video = "http://techslides.com/demos/sample-videos/small.mp4"
)

# Отправить gif анимацию
bot$sendAnimation(chat_id,
  animation = "https://media.giphy.com/media/sIIhZliB2McAo/giphy.gif"
)

# Отправить локацию
bot$sendLocation(chat_id,
  latitude = 51.521727,
  longitude = -0.117255
)

# Имитация действия в чате
bot$sendChatAction(chat_id,
  action = "typing"
)

Т. е. например с помощью метода sendPhoto() вы можете отправить сохранённый в виде изображения график, который вы построили с помощью пакета ggplot2.

Как отправить в telegram таблицу

К сожалению на момент написания книги telegram не поддерживает полноценные таблицы в HTML или Markdown, но вы можете иметировать подобие таблицы. Для этого воспользуйтесь кодом представленной ниже функции to_tg_table():

library(purrr)
library(tidyr)
library(stringr)

# функция для перевода data.frame в telegram таблицу 
to_tg_table <- function( table, align = NULL, indents = 3, parse_mode = 'Markdown' ) {
  
  # если выравнивание не задано то выравниваем по левому краю
  if ( is.null(align) ) {
    
    col_num <- length(table)
    align   <- str_c( rep('l', col_num), collapse = '' )
  
  }
  
  # проверяем правильно ли заданно выравнивание
  if ( length(table) != nchar(align) ) {
    
    align <- NULL
    
  }
  
  # новое выравнивание столбцов 
  side <- sapply(1:nchar(align), 
         function(x) { 
           letter <- substr(align, x, x)
           switch (letter,
                   'l' = 'right',
                   'r' = 'left',
                   'c' = 'both',
                   'left'
           )
  })
  
  # сохраняем имена
  t_names      <- names(table)

  # вычисляем ширину столбцов
  names_length <- sapply(t_names, nchar) 
  value_length <- sapply(table, function(x) max(nchar(as. character(x))))
  max_length   <- ifelse(value_length > names_length, value_length, names_length)
  
  # подгоняем размер имён столбцов под их ширину + указанное в indents к-во пробелов 
  t_names <- mapply(str_pad, 
                    string = t_names, 
                    width  = max_length + indents, 
                    side   = side)
  
  # объединяем названия столбцов
  str_names <- str_c(t_names, collapse = '')
  
  # аргументы для фукнции str_pad
  rules <- list(string = table, width = max_length + indents, side = side)

  # поочереди переводим каждый столбец к нужному виду
  t_str <-   pmap_df( rules, str_pad )%>%
              unite("data", everything(), remove = TRUE, sep = '') %>%
              unlist(data) %>%
              str_c(collapse = '\n') 
  
  # если таблица занимает более 4096 символов обрезаем её
  if ( nchar(t_str) >= 4021 ) {
    
    warning('Таблица составляет более 4096 символов!')
    t_str <- substr(t_str, 1, 4021)
    
  }
  
  # символы выделения блока кода согласно выбранной разметке
  code_block <- switch(parse_mode, 
                       'Markdown' = c('```', '```'),
                       'HTML' = c('<code>', '</code>'))
           
  # переводим в code
  res <- str_c(code_block[1], str_names, t_str, code_block[2], sep = '\n')
  
  return(res)
}

С помощью этой функци вы можете преобразовать любой data. frame и отправить в telegram:

# преобразуем таблицу iris 
tg_table <- to_tg_table( head(iris, 15) )

# отправляем таблицу в telegram
bot$sendMessage(194336771, 
                tg_table,
                "Markdown")

В telegram это буедет выглядеть так:

У функции to_tg_table() есть несколько дополнительных аргументов:

• align — выравнивнивание столбцов, тектовая строка, каждая буква соответвует одному столбцу, пример 'llrrc':
  • l — выравнивание по левой стороне
  • r — выравнивание по правой стороне
  • c — выравнивание по центру
• indents — количество пробелов для разделения столбцов.
• parse_mode — разметка сообщения, Markdown или HTML.

Пример с выравниванием столбцов:

# преобразуем таблицу iris 
tg_table <- to_tg_table( head(iris, 15), 
                         align = 'llccr')

# отправляем таблицу в telegram
bot$sendMessage(194336771, 
                tg_table,
                "Markdown")

Как добавить в сообщение Emoji

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

Получить полный список доступных смайлов можно по этой ссылке.

Таблица смайлов

Из таблицы нас интересует поле Unicode. Скопиройте код нужного вам смайла, и замените U+ на \U000. Т.е. если вам необходимо отправить смайл, код котого в таблице U+1F601, то в коде на R вам необходимо добавить его в текст сообщения вот так — \U0001F601.

Пример:

bot$sendMessage(chat_id, 
                'Сообщение со смайлом \U0001F601 код которого в таблице U+1F601')

Результат:

Проверка планировщика задач Windows, и отправка уведомления о задачах, работа которых была завершена аварийно

Для работы с планировщиком заданий Windows вам необходимо установить пакет taskscheduleR, и для удобства работы с данными установим пакет dplyr.

# Установка пакетов
install.packages(c('taskscheduleR', 'dplyr'))
# Подключение пакетов
library(taskscheduleR)
library(dplyr)

Далее с помощью функции taskscheduler_ls() мы запрашиваем информацию о задачах из нашего планировщика. С помощью функции filter() из пакета dplyr мы убираем из списка задач те, которые были успешно выполненны и имеют статус последнего результата 0, и те, которые ещё ни разу не запускались и имеют статус 267011, выключенные задачи, и задачи которые выполняются в данный момент.

# запрашиваем список задач
task <- task <- taskscheduler_ls() %>%
        filter(! `Last Result`  %in% c("0", "267011") & 
               `Scheduled Task State` == "Enabled" & 
               Status != "Running") %>%
        select(TaskName) %>%
        unique() %>%
        unlist() %>%
        paste0(., collapse = "\n")

В объекте task у нас теперь список задач, работа которых завершилась ошибкой, этот список нам надо отправить в Telegram.

Если рассмотреть каждую команду подробнее, то:

• filter() — фильтрует список задач, по описанным выше условиям
• select() — оставляет в таблице только одно поле с названием задач
• unique() — убирает дубли названий
• unlist() — переводит выбранный столбец таблицы в вектор
• paste0() — соединяет названия задач в одну строку, и ставит в качестве разделителя знак перевода строки, т. е. \n.

Всё что нам остаётся — отправить этот результат в телеграм.

bot$sendMessage(chat_id,
                text = task,
                parse_mode = "Markdown"
)

Итак, на данный момент код бота выглядит вот так:

# Подключение пакета
library(telegram.bot)
library(taskscheduleR)
library(dplyr)

# инициализируем бота
bot <- Bot(token = "123456789:abcdefghijklmnopqrstuvwxyz")

# идентификатор чата
chat_id <- 123456789

# запрашиваем список задач
task <- taskscheduler_ls() %>%
        filter(! `Last Result`  %in% c("0", "267011")  &
               `Scheduled Task State` == "Enabled" & 
               Status != "Running") %>%
        select(TaskName) %>%
        unique() %>%
        unlist() %>%
        paste0(., collapse = "\n")

# если есть проблемные задачи отправляем сообщение
if ( task != "" ) {

  bot$sendMessage(chat_id,
                  text = task,
                  parse_mode = "Markdown"
  )

}

При использовании приведённого выше примера подставьте в код токен вашего бота и ваш идентификатор чата.

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

Так же вы можете вынести различные настройки в отдельный файл конфигурации, и хранить в нём id чата и токен. Читать конфиг можно например с помощью пакета configr.

[telegram_bot]
;настройки телеграм бота и чата, в который будут приходить уведомления
chat_id=12345678
bot_token=123456789:abcdefghijklmnopqrstuvwxyz"

library(configr)

# чтение конфина
config <- read.config('C:/путь_к_конфигу/config.cfg', rcmd.parse = TRUE)

bot_token <- config$telegram_bot$bot_token
chat_id     <- config$telegram_bot$chat_id

Настраиваем расписание запуска проверки задач

Наиболее подробно процесс настройки запуска скриптов по расписанию описан в этой статье . Тут я лишь опишу шаги, которые для этого необходимо выполнить. Если какой-то из шагов вам не понятен, то обратитесь к статье на которую я указал ссылку.

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

1. Пропишите в системную переменную Path путь к папке в которой установлен R, в Windows путь будет примерно таким: C:\Program Files\R\R-4.0.2\bin.
2. Создайте исполняемый bat файл, в котором будет всего одна строка R CMD BATCH C:\rscripts\check_bot\check_bot.R. Замените C:\rscripts\check_bot\check_bot.R на полный путь к вашему R файлу.
3. Далее настройте с помощью планировщика задач Windows расписание запуска, например на каждые пол часа.

Заключение

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

Я описал задачу контроля планировщика заданий Windows, но вы можете использовать материал этой главы для отправки любых уведомлений, от прогноза погоды до котировок акций на фондовой бирже, т. к. R позволяет вам подключиться к огромному количеству источников данных.

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

Тесты и задания

Тесты

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

Задания

1. Создайте с помощью BotFather бота.
2. Перейдите к диалогу с ботом, и узнайте идентификатор вашего с ботом чата.
3. Отправьте с помощью созданного бота в telegram первые 20 строк из встроенного в R набора данных ToothGrowth.

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

Создаем Telegram-бота на Python. Часть два

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

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

В качестве места размещения мы будем использовать бесплатный сервис Heroku.

Установка и настройка Git

Для дальнейшей работы нам понадобится установить Git, зарегистрироваться на GitHub и создать репозиторий с именем нашего приложения. В нашем случае это MyFirstTestBot.

Скачать версии Git, соответствующие вашей операционной системе, можно по следующим ссылкам для macOS и для Windows. На Linux Git можно установить, выполнив такую команду:

sudo apt-get install git-all

Далее, желательно использовать виртуальную среду. Если она не установлена, при установке Python вы можете ее установить, выполнив команду:

pip install virtualenv

Создадим новую папку для нашего приложения и связи его с GitHub. В нашем случае это папка PythonApplication1 в корне диска C.

Выполним клонирование репозитория. Для этого находясь в нашей папке в консоли выполним команду, введя ссылку на ваш репозиторий:

git clone https://github.com/your_github_account/your_repository_name

После выполнения этой команды в нашей папке с именем PythonApplication1 мы получили еще одну папку – MyFirstTestBot.

В консоли перейдем в корень диска C и выполним команду:

virtualenv PythonApplication1

Если команда не выполняется, и вы на экране консоли видите «»virtualenv» не является внутренней или внешней командой…» — вам следует настроить системную переменную PATH и добавить в нее адреса расположения вашей папки с Python и подпапки со скриптами (в моем случае C:\Users\B\AppData\Local\Programs\Python\Python37-32\Scripts).

Будем в дальнейшем пользоваться консолью Git, которую мы установили ранее:

После выполнения этого скрипта в нашей папке будет такое содержимое:

Поместим скрипт в папку, полученную в результате выполнения команды git clone (папка MyFirstTestBot). Имя файла с нашим скриптом — mftb.py

Теперь запустим наше виртуальное окружение. Перейдем в консоли в папку C:\PythonApplication1 и выполним команду:

source C:\PythonApplication1\Scripts\activate

Если все сработало нормально – в консоли приглашение командной строки будет начинаться с имени нашей папки (PythonApplication1):

Перейдём в нашу папку репозитория и выполним команду:

pip install requests

Создадим список зависимостей для Heroku, введя команду:

pip freeze > requirements.txt

Обратите внимание – в файле requirements.txt указываются требования к серверу Huroku. Там должно быть приблизительно такое содержимое:

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

В папке MyFirstTestBot создадим файл с именем Procfile без расширения. В теле этого файла пропишем:

Видео курсы по схожей тематике:

web: python mftb.py

В папке MyFirstTestBot создадим также файл с именем __init__. py без содержимого.

Содержимое нашей папки MyFirstTestBot теперь такое:

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

git init
git add .
git commit -m “first commit – ваше сообщение комментарий к коммиту”
git push -u https://github.com/your_github_account/your_repository_name

Код нашего бота теперь загружен на GitHub и нам остается загрузить его на Heroku, где будет хоститься наш бот.

Рекомендуется ознакомиться с основами работы с Heroku по ссылке. По той же ссылке следует скачать установщик интерфейса командной строки (CLI) от Heroku и запустить его.

После установки CLI зарегистрируемся на Heroku через веб браузер.

Далее подключимся к Heroku через консоль используя команду:

heroku login

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

Выполним команду для создания приложения в Heroku:

heroku create

Дальнейшие наши команды отправят наш проект на сервер Heroku и укажут необходимую настройку:

git push heroku master
heroku ps:scale web=1

Последняя команда запустит наше приложение на сервере:

heroku open

Теперь наше предложение установлено и запущено на сервере. Мы можем проверить это, пообщавшись с нашим ботом в Telegram:

Как мы видим – все работает. Если по каким-то причинам бот не запустился, нужно ввести в консоли команду:

heroku logs –tail

И смотреть на коды ошибок на сайте.

Резюме.

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

Бесплатные вебинары по схожей тематике:

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

Чаще всего востребованные библиотеки для работы ботов сейчас пишут на Python. Именно поэтому мы рассмотрели этот простой пример.  Для дальнейшего развития вас как квалифицированного Python разработчика мы рекомендуем ознакомиться с курсом подготовки Python-разработчика на портале  ITVDN.

Научитесь создавать своего первого бота в Telegram с Python

Представьте себе, есть бот для сообщений, который отправит вам случайное изображение милой собаки, когда вы захотите, звучит круто, правда? Давай сделаем!

В этом руководстве мы будем использовать Python 3, python-telegram-bot, и общедоступный API RandomDog .

В конце этого урока у вас будет бот для снятия стресса, который будет отправлять вам милые изображения собак каждый раз, когда вам это нужно, ура!

Начало работы

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

1. Создайте нового бота в BotFather

Если вы хотите создать бота в Telegram, вы должны сначала «зарегистрировать» своего бота перед его использованием. Когда мы «зарегистрируем» нашего бота, мы получим токен для доступа к Telegram API.

Перейдите в BotFather (если вы откроете его на рабочем столе, убедитесь, что у вас установлено приложение Telegram), затем создайте нового бота, отправив команду / newbot . Следуйте инструкциям, пока не получите имя пользователя и токен для своего бота.Вы можете перейти к своему боту, перейдя по этому URL: https://telegram.me/YOUR_BOT_USERNAME , и ваш токен должен выглядеть так.

  704418931: AAEtcZ *************  

2. Установите библиотеку

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

  pip3 install python-telegram-bot  

Если библиотека успешно установлена, то все готово.

Напишите программу

Сделаем нашего первого бота.Этот бот должен возвращать изображение собаки, когда мы отправляем команду / bop . Чтобы сделать это, мы можем использовать общедоступный API из RandomDog , чтобы помочь нам сгенерировать случайные изображения собак.

Рабочий процесс нашего бота очень прост:

доступ к API -> получение URL-адреса изображения -> отправка изображения

1. Импортируйте библиотеки

Сначала импортируйте все необходимые библиотеки.

  из telegram.ext import Updater, CommandHandler
запросы на импорт
импорт ре  

2.Получите доступ к API и получите URL изображения

Давайте создадим функцию для получения URL. Используя библиотеку запросов, мы можем получить доступ к API и получить данные json.

  content = requests.get ('https://random.dog/woof.json') .json ()  

Вы можете проверить данные json, перейдя по этому URL-адресу: https://random.dog/ woof.json в вашем браузере. На экране вы увидите что-то вроде этого:

  {"url": "https://random.dog/*****.JPG"}  

Получите URL-адрес изображения, так как нам нужно, чтобы этот параметр был возможность отправить изображение.

  image_url = contents ['url']  

Оберните этот код в функцию с именем get_url () .

  def get_url ():
    content = requests.get ('https://random.dog/woof.json') .json ()
    url = содержимое ['url']
    return url  

3. Отправьте изображение

Чтобы отправить сообщение / изображение, нам нужны два параметра, URL изображения и ID получателя — это может быть ID группы или ID пользователя.

Мы можем получить URL изображения, вызвав нашу функцию get_url () .

  url = get_url ()  

Получите идентификатор получателя с помощью этого кода:

  chat_id = update.message.chat_id  

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

  bot.send_photo (chat_id = chat_id, photo = url)  

Оберните этот код в функцию с именем bop и убедитесь, что ваш код выглядит так:

  def bop (bot, update):
    url = get_url ()
    chat_id = обновить. message.chat_id
    bot.send_photo (chat_id = chat_id, photo = url)  

4.

Наконец, создайте еще одну функцию с именем main для запуска нашей программы. Не забудьте заменить YOUR_TOKEN на токен, который мы создали ранее в этом руководстве.

  def main ():
    updater = Updater ('ВАШ_ТОКЕН')
    dp = updater.dispatcher
    dp.add_handler (CommandHandler ('боп', боп))
    updater.start_polling ()
    апдейтер.праздный()
    
если __name__ == '__main__':
    main ()  

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

  из telegram.ext import Updater, InlineQueryHandler, CommandHandler
запросы на импорт
импорт ре

def get_url ():
    content = requests.get ('https://random.dog/woof.json') .json ()
    url = содержимое ['url']
    возвратный URL

def bop (бот, обновление):
    url = get_url ()
    chat_id = update.message.chat_id
    bot.send_photo (chat_id = chat_id, photo = url)

def main ():
    updater = Updater ('ВАШ_ТОКЕН')
    dp = средство обновления. диспетчер
    dp.add_handler (CommandHandler ('боп', боп))
    updater.start_polling ()
    updater.idle ()

если __name__ == '__main__':
    main ()  

5. Запускаем программу

Отлично! Вы закончили свою первую программу. А теперь проверим, работает ли. Сохраните файл, назовите его main.py , затем запустите его с помощью этой команды.

  python3 main.py  

Перейдите к своему боту Telegram, перейдя по этому URL-адресу: https://telegram.me/YOUR_BOT_USERNAME . Отправьте команду / bop .Если все работает идеально, бот ответит случайным изображением собаки. Симпатично, правда?

Ошибки обработки

Отлично! Теперь у вас есть бот, который будет присылать вам изображение милой собачки, когда вы захотите.

Это еще не все! API RandomDog не только генерирует изображения, но также видео и GIF-файлы. Если мы обращаемся к API и получаем видео или GIF-файл, возникает ошибка, и бот не отправляет его вам.

Давайте исправим это, чтобы бот отправлял сообщение только с вложенным изображением.Если мы получим видео или GIF, мы снова будем вызывать API, пока не получим изображение.

1. Сопоставьте расширение файла с помощью регулярного выражения

Мы собираемся использовать регулярное выражение для решения этой проблемы.

Чтобы отличить изображение от видео или GIF, мы можем взглянуть на расширение файла. Нам нужна только последняя часть нашего URL.

  https://random.dog/*****.JPG  

Сначала нам нужно определить, какие расширения файлов разрешены в нашей программе.

  allowed_extension = ['jpg', 'jpeg', 'png']  

Затем используйте регулярное выражение для извлечения расширения файла из URL-адреса..] *) $ «, url) .group (1) .lower () URL возврата

2. Измените код

Отлично! Теперь для последней части замените строку url = get_url () в функции bop () на url = get_image_url () , и ваш код должен выглядеть так:

  из telegram. ext import Updater , InlineQueryHandler, CommandHandler
запросы на импорт
импорт ре

def get_url ():
    content = requests.get ('https://random.dog/woof.json') .json ()
    url = содержимое ['url']
    возвратный URL

def get_image_url ():
    allowed_extension = ['jpg', 'jpeg', 'png']
    file_extension = ''
    пока file_extension не входит в allowed_extension:
        url = get_url ()
        file_extension = re..] *) $ ", url) .group (1) .lower ()
    возвратный URL

def bop (бот, обновление):
    url = get_image_url ()
    chat_id = update.message.chat_id
    bot.send_photo (chat_id = chat_id, photo = url)

def main ():
    updater = Updater ('ВАШ_ТОКЕН')
    dp = updater.dispatcher
    dp.add_handler (CommandHandler ('боп', боп))
    updater.start_polling ()
    updater.idle ()

если __name__ == '__main__':
    main ()  

Красиво! Все должно работать отлично. Вы также можете проверить мою учетную запись GitHub, чтобы получить код.

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

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

Спасибо и удачи в тренировках! 🙂

Как создать чат-бота на Python для Telegram за 9 простых шагов — блог MindK

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

Теперь давайте перейдем к делу и узнаем, как создать бота для Python Telegram.

Подробнее: 8 вопросов, которые вы должны задать себе перед созданием чат-бота .

Содержание :

Шаг № 0: Немного теории Telegram Bot API

Вот простой вопрос, чтобы начать наше руководство: как вы разрабатываете чат-ботов Telegram?

Ответ очень прост: вы используете HTTP API как для чтения сообщений, отправленных пользователями, так и для обратной передачи сообщений. Это требует использования URL-адреса, который выглядит так:

 https://api.telegram.org/bot/METHOD_NAME 

Токен — это уникальная строка символов, необходимая для аутентификации бота в системе. Он генерируется при создании бота и выглядит так:

 123456: ABC-DEF1234ghIkl-zyx57W2v1u123ew11 

METHOD_NAME (и это очевидно из его названия) — это метод, например, getUpdates , sendMessage , getChat и т. Д.

Для выполнения запросов вы можете использовать запросы GET и POST.Многие методы требуют дополнительных параметров (например, при использовании метода sendMessage необходимо указывать chat_id и text). Параметры могут быть переданы в виде строки запроса URL, application / x-www-form-urlencoded и application-json (кроме загрузки файлов).

Еще одно требование — кодировка UTF-8.

После отправки запроса API вы получите ответ в формате JSON. Например, если мы получим данные с помощью метода « getMe », мы получим что-то вроде этого:

 ПОЛУЧИТЬ https: // api. telegram.org/bot/getMe 

 {
   ок: правда,
   результат: {
       id: 231757398,
       first_name: "Обменный курс Бот",
       имя пользователя: "exchangetestbot"
   }
} 

Если «ok» равно true, запрос был успешным, и результат будет отображаться в поле «результат». Если «ok» равно false, вы увидите сообщение об ошибке в поле «description».

Здесь вы можете найти список всех типов данных и методов Telegram Bot API.

Следующий вопрос: как получать сообщения пользователей?

Это можно сделать двумя способами.

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

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

Единственное ограничение — вам нужен HTTPS (однако разрешены и самозаверяющие сертификаты).

А как выбрать оптимальный способ приема сообщений?

Метод getUpdates лучше всего подходит, если:

1. Вы не хотите или не можете настраивать HTTPS во время разработки.
2. Вы используете языки сценариев, которые сложно интегрировать в веб-сервер.
3. Ваш бот перегружен.
4. Вы время от времени меняете сервер бота.

Метод перехвата является лучшим выбором, если:

1. Вы кодируете на веб-языке (например, PHP).
2. У ​​вашего бота низкая нагрузка, и нет смысла регулярно запрашивать обновления вручную.
3. Ваш бот постоянно интегрирован в веб-сервер.

В этом руководстве я буду использовать метод getUpdates.

Теперь, как сделать программу-бот?

@BotFather используется для создания ботов Telegram. Он также позволяет выполнять базовую настройку (описание, фото профиля, встроенную поддержку и т. Д.).

Существует множество библиотек, которые могут упростить работу с Telegram Bot API. Назову несколько:

По своей сути все эти библиотеки являются оболочками HTTP-запросов. Многие из них написаны с использованием ООП и отражают все типы данных Telegram Bot API в классах.

В этом руководстве по боту Telegram я собираюсь создать чат-бота Python с помощью библиотеки pyTelegramBotApi.

Шаг №1: Реализуйте запросы обменных курсов

Давайте напишем сценарий Python, который будет реализовывать логику для запросов конкретных курсов обмена валют.Мы собираемся использовать API ПриватБанка.

Пример ответа:

 [
    {
        ccy: "EUR",
        base_ccy: "UAH",
        купить: «28. 70000»,
        продажа: "29.10000"
    },
    {
        ccy: «RUR»,
        base_ccy: "UAH",
        купить: "0,39300",
        продажа: "0.40300"
    },
    {
        ccy: "USD",
        base_ccy: "UAH",
        купить: "25.40000",
        продажа: "25.70000"
    }
]
 

Создадим файл pb.ру и напишем следующий код:

 # - * - кодировка: utf-8 - * -
импорт ре
запросы на импорт
импортировать json 

URL = 'https: // api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5 '

 def load_exchange ():
   вернуть json.loads (requests.get (URL) .text)

def get_exchange (ccy_key):
   для exc в load_exchange ():
       если ccy_key == exc ['ccy']:
           вернуть отл
   вернуть ложь

def get_exchanges (ccy_pattern):
   результат = []
   ccy_pattern = re.escape (ccy_pattern) + '. *'
   для exc в load_exchange ():
       если re.match (ccy_pattern, exc ['ccy'], re.IGNORECASE) не равно None:
           result. append (искл.)
   вернуть результат 

Мы реализовали три метода:

• load_exchange: загружает курсы обмена по указанному URL-адресу и возвращает тип dict .
• get_exchange: возвращает обменные курсы для запрошенной валюты.
• get_exchanges: возвращает список валют в соответствии с шаблоном (требуется при поиске валют во встроенных запросах).

Шаг № 2: Создайте бота Telegram с помощью @BotFather

Свяжитесь с ботом @BotFather, чтобы получить список команд чата Telegram.

Теперь используйте команду / newbot и дождитесь инструкций по выбору имени и имени пользователя.После успешного создания бота вы получите следующее сообщение:

 Готово! Поздравляю с приобретением нового бота. Вы найдете его на telegram.me/ <имя пользователя>.
Теперь вы можете добавить описание, раздел и изображение профиля для вашего бота, см. / Help для получения списка команд.
Кстати, когда вы закончите создавать своего крутого бота, обратитесь в нашу службу поддержки ботов, если вы хотите получить для него лучшее имя пользователя. 
Просто убедитесь, что бот полностью работает, прежде чем делать это.

Используйте этот токен для доступа к HTTP API:
<токен> (здесь идет токен бота)

Описание Bot API см. На этой странице: https: // core.telegram.org/bots/api 

Давайте настроим настройки бота. Укажите описание и текст (команды / setdescription и / setabouttext ), фотографию профиля ( / setuserpic ), включите встроенный режим ( / setinline ), добавьте подсказки команд ( / setcommands ).

Вам нужно будет использовать две команды: / help и / exchange . Опишем их в / setcommand s.

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

Шаг № 3: Настройте и инициализируйте бота

Начнем с создания файла config.py для настройки:

 # - * - кодировка: utf-8 - * -
TOKEN = '<токен бота> ’'
TIMEZONE = 'Европа / Киев'
TIMEZONE_COMMON_NAME = 'Киев' 

Вот токен бота и часовой пояс, в котором он будет работать (он понадобится вам в будущем, чтобы указать время обновления сообщения. Telegram API не позволяет узнать часовой пояс пользователя, поэтому время обновления должно отображаться с подсказкой часового пояса).

Давайте создадим файл bot.py , импортируем все необходимые библиотеки, файлы конфигурации и ранее созданный pb.py . Если какие-то библиотеки отсутствуют, установите их через pip .

 # - * - кодировка: utf-8 - * -
импортный телебот
конфигурация импорта
импорт pb
дата и время импорта
импорт pytz
импортировать json
отслеживание импорта

P_TIMEZONE = pytz.часовой пояс (config.TIMEZONE)
TIMEZONE_COMMON_NAME = config.TIMEZONE_COMMON_NAME 

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

 бот = телебот.TeleBot (config.TOKEN)
bot.polling (none_stop = True) 

Шаг №4: Напишите обработчик команд / start

Теперь ваш чат-бот Python инициализирован и постоянно запрашивает метод getUpdates. Параметр none_stop отвечает за продолжение опроса, даже если API возвращает ошибку при выполнении метода.

Тогда можно вызывать любые методы Telegram Bot API из переменной бота.

Начнем с написания обработчика команд / start и добавим его перед строкой bot.polling (none_stop = True) :

 @ bot.message_handler (commands = ['start'])
def start_command (сообщение):
   bot.send_message (
       message.chat.id,
       'Привет! Я могу показать вам курсы обмена ПриватБанка. \ N '+
       'Чтобы узнать курсы обмена, нажмите /exchange.\n' +
       'Чтобы получить помощь, нажмите / help.'
   ) 

Как видите, pyTelegramBotApi использует декораторы Python для инициализации обработчиков различных команд Telegram. Вы также можете перехватывать сообщения, используя регулярное выражение, их тип содержимого и лямбда-функции.

В нашем случае, если условие command = [‘start’] истинно, будет вызвана функция start_command . В эту функцию будет передан объект сообщения (десериализованный тип сообщения). После этого вы просто выполняете send_message в том же чате с указанным сообщением.

Уф, это было легко, не так ли?

Шаг 5: Создайте обработчик команд / help

Давайте добавим в наш обработчик команд / help встроенную кнопку, связывающую вашу учетную запись Telegram. Назовем кнопку «Написать разработчику».

 @ bot.message_handler (commands = ['help'])
def help_command (сообщение):
   keyboard = telebot.types.InlineKeyboardMarkup ()
   keyboard.add (
       telebot.types.InlineKeyboardButton (
           «Сообщение разработчику», url = 'telegram.я / artiomtb '
       )
   )
   bot.send_message (
       message.chat.id,
       '1) Чтобы получить список доступных валют, нажмите /exchange.\n' +
       '2) Нажмите на интересующую вас валюту. \ N' +
       «3) Вы получите сообщение, содержащее информацию об исходной и целевой валютах», +
       'курсы покупки и продажи.  \ n' +
       '4) Нажмите «Обновить», чтобы получить текущую информацию о запросе. '+
       Также бот покажет разницу между предыдущим и текущим курсами обмена.\ n '+
       5) Бот поддерживает inline. Введите @  в любом чате и первые буквы валюты. ',
       reply_markup = клавиатура
   )
 

Как вы можете видеть в приведенном выше примере, я использовал дополнительный параметр ( reply_markup ) для метода send_message . Метод получил InlineKeyboardMarkup, состоящий из одной кнопки InlineKeyboardButton с текстом: «Сообщение разработчику» и url = ’telegram.me / artiomtb’.

Это выглядит так:

Шаг №6: Добавьте обработчик команд / exchange

Обработчик команд / exchange отображает меню выбора валюты и встроенную клавиатуру бота, состоящую из 3 кнопок: USD, EUR и RUR (это валюты, поддерживаемые банковским API).

 @ bot. message_handler (commands = ['exchange'])
def exchange_command (сообщение): 
 keyboard = telebot.types.InlineKeyboardMarkup ()
  keyboard.row (
      telebot.types.InlineKeyboardButton ('USD', callback_data = 'get-USD')
  )
  keyboard.row (
    telebot.types.InlineKeyboardButton ('EUR', callback_data = 'get-EUR'),
    telebot.types.InlineKeyboardButton ('RUR', callback_data = 'get-RUR')
  )

  bot.send_message (message.chat.id, «Нажмите на выбранную валюту:», reply_markup = keyboard)
 

Позвольте мне объяснить, что такое callback-данные в InlineKeyboardButton.Когда пользователь нажимает эту кнопку, вы получите CallbackQuery (его параметр data будет содержать callback-data ) в getUpdates . Таким образом, вы будете точно знать, какую кнопку нажал пользователь, и обрабатывать ее соответствующим образом.

Кстати, вот как выглядит ответ / exchange :

Шаг 7: Напишите встроенный обработчик нажатия кнопки

pyTelegramBotAPI предлагает использовать декоратор @ bot. callback_query_handler , который передаст объект CallbackQuery во вложенную функцию.

 @ bot.callback_query_handler (func = лямбда-вызов: True)
def iq_callback (запрос):
   data = query.data
   если data.startswith ('get-'):
       get_ex_callback (запрос) 

Давайте реализуем метод get_ex_callback :

 def get_ex_callback (запрос):
   bot.answer_callback_query (query.id)
   send_exchange_result (query.message, query.data [4:]) 

Метод answer_callback_query требуется для удаления состояния загрузки, которое появляется при нажатии кнопки.Давайте отправим сообщение на send_exchange_query . Вам нужно будет передать ему Сообщение и код валюты (вы можете получить его из query.data. Если это было, например, get-USD, передайте USD).

Давайте реализуем send_exchange_result :

 def send_exchange_result (сообщение, ex_code):
   bot. send_chat_action (message.chat.id, 'набор текста')
   ex = pb.get_exchange (ex_code)
   bot.send_message (
       message.chat.id, serialize_ex (ex),
       reply_markup = get_update_keyboard (ex),
       parse_mode = 'HTML'
   ) 

Это тоже довольно просто.

Давайте сначала отправим состояние набора текста в чат, чтобы бот отображал индикатор набора текста, пока банковский API получает запрос. Теперь давайте вызовем метод get_exchange из файла pb.py, который получит код валюты (например, доллар США). Вам также нужно будет вызвать два новых метода в send_message : serialize_ex, в сериализаторе валюты и get_update_keyboard (который возвращает клавиатуру к кнопкам «Обновить» и «Поделиться»).

 def get_update_keyboard (например):
   keyboard = telebot.types.InlineKeyboardMarkup ()
   keyboard.row (
       telebot.types.InlineKeyboardButton (
           'Обновлять',
           callback_data = json. dumps ({
               'т': 'у',
               'e': {
                   'b': ex ['купить'],
                   's': ex ['распродажа'],
                   'c': ex ['ccy']
               }
           }).заменять(' ', '')
       ),
       telebot.types.InlineKeyboardButton ('Поделиться', switch_inline_query = ex ['ccy'])
   )
   возврат клавиатуры 

Запишем в get_update_keyboard текущий обменный курс в callback_data в формате JSON.JSON намеренно сжат, поскольку максимально допустимый размер файла составляет 64 байта.

t ключ означает тип, а e ключ означает обмен. Остальное делается по тому же принципу.

Кнопка «Поделиться» будет иметь параметр switch_inline_query . Нажатие кнопки предложит пользователю выбрать один из своих чатов, открыть этот чат и вставить имя пользователя бота и указанный встроенный запрос в поле ввода.

Затем давайте представим метод serialize_ex и вспомогательный serialize_exchange_diff , необходимые для отображения разницы между текущим и старым обменными курсами при нажатии кнопки «Обновить».

 def serialize_ex (ex_json, diff = None):
   результат = '' + ex_json ['base_ccy'] + '->' + ex_json ['ccy'] + ':  \ n \ n' + \
            'Купить:' + ex_json ['купить']
   если разница:
       результат + = '' + serialize_exchange_diff (diff ['buy_diff']) + '\ n' + \
                 'Продать:' + ex_json ['распродажа'] + \
                 '' + serialize_exchange_diff (diff ['sale_diff']) + '\ n'
   еще:
       result + = '\ nSell:' + ex_json ['sale'] + '\ n'
   вернуть результат

def serialize_exchange_diff (разница):
   результат = ''
   если diff> 0:
       result = '(' + str (diff) + '

Как видите, метод serialize_ex получает необязательный параметр diff. Здесь вы передадите разницу между обменными курсами в формате {‘buy_diff’: , ‘sale_diff’: }.Это произойдет во время сериализации, когда вы нажмете кнопку «Обновить». Он нам не понадобится при первом отображении курсов валют на экране.

Вот как выглядит ответ бота при нажатии кнопки USD:

Шаг № 8: Реализуйте обработчик кнопки обновления

Теперь вы готовы реализовать обработчик кнопки «Обновить». После дополнения метода iq_callback он будет выглядеть следующим образом:

 @ bot.callback_query_handler (func = лямбда-вызов: True)
def iq_callback (запрос):
   данные = запрос. данные
   если data.startswith ('get-'):
       get_ex_callback (запрос)
   еще:
       пытаться:
           если json.loads (data) ['t'] == 'u':
               edit_message_callback (запрос)
       кроме ValueError:
           пройти 

Если данные обратного вызова начинаются с get- ’ ( get- долларов США, get- евро и т. Д.), Тогда давайте вызовем get_ex_callback , как мы делали раньше. В противном случае давайте попробуем разобрать JSON и получить его ключ t . Если он равен «u», вызовите метод edit_message_callback .Давайте реализуем это:

 def edit_message_callback (запрос):
   data = json.loads (query.data) ['e']
   exchange_now = pb.get_exchange (данные ['c'])
   текст = serialize_ex (
       exchange_now,
       get_exchange_diff (
           get_ex_from_iq_data (данные),
           exchange_now
       )
   ) + '\ n' + get_edited_signature ()
   если query. message:
       bot.edit_message_text (
           текст,
           query.message.chat.id,
           query.message.message_id,
           reply_markup = get_update_keyboard (exchange_now),
           parse_mode = 'HTML'
       )
   elif запрос.inline_message_id:
       bot.edit_message_text (
           текст,
           inline_message_id = query.inline_message_id,
           reply_markup = get_update_keyboard (exchange_now),
           parse_mode = 'HTML'
       )
 

Как это работает?

1. Загрузить текущий обменный курс ( exchange_now = pb.get_exchange (data [‘c’] ).
2. Сгенерируйте текст для нового сообщения, сериализуя текущий обменный курс с параметром diff , который вы получите с помощью новых методов (о них я напишу ниже).Давайте также добавим подпись редактирования — get_edited_signature .
3. Вызовите метод edit_message_text , если исходное сообщение является обычным. Если это ответ на встроенный запрос, передайте другие параметры.

Метод get_ex_from_iq_data анализирует JSON из callback_data :

 def get_ex_from_iq_data (exc_json):
   возвращение {
       'buy': exc_json ['b'],
       'распродажа': exc_json ['s']
   } 

Метод get_exchange_diff получает старый и текущий обменные курсы и возвращает разницу в {‘buy_diff’: , ‘sale_diff’: } format:

 def get_exchange_diff (последний, сейчас):
   возвращение {
       'sale_diff': float ("%.6f "% (float (now ['sale']) - float (last ['sale']))),
       'buy_diff': float ("%. 6f"% (float (now ['buy']) - float (last ['buy']))))
   }
 

get_edited_signature генерирует «обновлено…» текст:

 def get_edited_signature ():
   return ' Обновлено' + \
          str (datetime. datetime.now (P_TIMEZONE) .strftime ('% H:% M:% S')) + \
          '(' + TIMEZONE_COMMON_NAME + ') ' 

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

А вот как это выглядит при изменении курса валют:

Шаг № 9: Реализуйте встроенный режим

Внедрение inline означает, что запись @ + имени бота в любом чате активирует поиск введенного текста и предложит результаты.Щелкнув по одному из них, бот отправит результат от вашего имени (с пометкой «через бота»).

 @ bot.inline_handler (func = лямбда-запрос: True)
def query_text (inline_query):
   bot.answer_inline_query (
       inline_query.id,
       get_iq_articles (pb.get_exchanges (inline_query.query))
   ) 

Вуаля, вы реализовали встроенный обработчик запросов.

Библиотека передаст объект InlineQuery в функцию query_text . Внутри вы используете функцию answer_inline_query , которая должна получить inline_query_id и массив объектов (результаты поиска).

Давайте воспользуемся get_exchanges из pb.py для поиска нескольких валют, соответствующих поисковому запросу. Давайте передадим этот массив в метод get_iq_articles , который вернет массив из InlineQueryResultArticle:

 def get_iq_articles (обмены):
   результат = []
   за отл в обменах:
       result.append (
           telebot.types.InlineQueryResultArticle (
               id = exc ['ccy'],
               title = exc ['ccy'],
               input_message_content = телебот.types.InputTextMessageContent (
                   serialize_ex (exc),
                   parse_mode = 'HTML'
               ),
               reply_markup = get_update_keyboard (отлично),
               description = 'Конвертировать' + exc ['base_ccy'] + '->' + exc ['ccy'],
               thumb_height = 1
           )
       )
   вернуть результат
 

Теперь, когда вы вводите @exchnagetestbot + пробел в любом чате, вы увидите следующее:

Введите usd и результат будет мгновенно отфильтрован:

Щелкните предложенный результат:

Также действует кнопка «Обновить»:

Молодец! Вы успешно реализовали встроенный режим!

Завершение

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

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

Каталожные номера:

Подробнее о чат-ботах:

Telegram Bot — Пример использования — Как создать бота в Telegram и научить его реагировать на определенные условия

 api.telegram.org/bot/setWebHook?url=  

 api.telegram.org/bot000000:AAAAAAAAAAAAA/setWebHook?url=https://panel.chatcompose.com/telegram/yourbot 

 {"ok": true, "result": true, "description": "Webhook был установлен"} 

 api. telegram.org/bot/getWebhookInfo 

  импорт журнала
из telegram.ext import Updater, Filters, CommandHandler, MessageHandler  

  лесозаготовка.basicConfig (format = '% (asctime) s -% (name) s -% (levelname) s -% (message) s', # время выполнения, уровень, имя
                    level = logging.INFO)
logger = logging.getLogger (__ имя__)  

  ТОКЕН = «ВВЕДИТЕ СВОЙ ТОКЕН»  

  def start (бот, обновление):
    name = update. message.from_user.first_name # имя пользователя сообщения
    reply = "Привет !! {}". format (name)
    bot.send_message (chat_id = update.message.chat_id, text = reply) # отправка сообщения

def help (бот, обновление):
    reply = "Чем могу вам помочь"
    bot.send_message (chat_id = update.message.chat_id, text = reply) # отправка сообщения

def echo_text (бот, обновление):
    reply = update.message.text
    bot.send_message (chat_id = update.message.chat_id, text = ответ)

стикер def (бот, обновление):
    reply = update.message.sticker.file_id
    bot.send_sticker (chat_id = update.message.chat_id, стикер = ответ)

ошибка def (бот, обновление):
    logger.error («Дерьмо !! Обновление {} вызвало ошибку {}». format (update, update.error))  

  def main ():
    Updater = Updater (TOKEN) # принимать обновления
    dp = updater.dispatcher # обрабатывать обновления

    dp.add_handler (CommandHandler ("начало", начало))
    dp.add_handler (CommandHandler ("справка", справка))
    дп.add_handler (MessageHandler (Filters.text, echo_text)) # если пользователь отправляет текст
    dp.add_handler (MessageHandler (Filters.sticker, sticker)) # если пользователь отправляет стикер
    dp.add_error_handler (ошибка)
    updater.start_polling ()
    logger.info ("Начато ...")
    updater.idle ()

если __name __ == "__ main__":
    основной ()  

  импорт ОС

из импорта телеграммы Обновить
из telegram.ext import Updater, CommandHandler, MessageHandler, Filters, CallbackContext


def help_command (обновление: Обновление, контекст: CallbackContext) -> Нет:
    htext = '' '
Добро пожаловать
Отправьте сообщение, чтобы сохранить его.
Отправить / получить, чтобы получить самое последнее сообщение '' '
    Обновить.message.reply_text (htext)


def main ():
    updater = Updater (os.getenv ("ТОКЕН"))

    диспетчер = updater.dispatcher
    dispatcher.add_handler (CommandHandler ("начало", help_command))
    dispatcher.add_handler (CommandHandler ("справка", help_command))

    updater.start_polling ()

    updater.idle ()


если __name__ == '__main__':
    основной ()  

  updater = Updater (os.getenv ("TOKEN"))  

  dispatcher.add_handler (CommandHandler ("начало", help_command))  

  dispatcher.add_handler (CommandHandler ("справка", help_command))  

  updater.start_polling ()  

  из реплита импорт БД  

  def latest_key ():
    ks = db.keys ()
    если len (ks):
        вернуть max (map (int, ks))
    еще:
        возврат -1  

  def log (обновление: Обновление, контекст: CallbackContext) -> Нет:
    db [str (latest_key () + 1)] = update.message.text  

  dispatcher.add_handler (MessageHandler (Filters.text & ~ Filters.command, log))  

  def fetch (обновление: Обновление, контекст: CallbackContext) -> Нет:
    update.message.reply_text (db.get (str (latest_key ()), 'Пока сообщений нет.'))  

  dispatcher.add_handler (CommandHandler ("выборка", выборка))  

  из математического импорта ceil
из флакона import render_template
из фляги импорт фляги
app = Flask (__ имя__)

@ app.route ('/')
@приложение.маршрут ('/ ')
def home (page = None):
    ks = отсортировано (map (int, db.keys ()))
    pages = ceil (len (ks) / 10)
    если страница отсутствует:
        page = страницы

    если страница <страницы:
        next_page = page + 1
    еще:
        next_page = Нет
    если страница> 1:
        prev_page = page - 1
    еще:
        prev_page = Нет

    messages = tuple (db [str (key)] для ключа в ks [(page-1) * 10: page * 10])

    return render_template ('home.html', messages = messages, next_page = next_page, page = page, prev_page = prev_page)  

  
 
 Сообщения - Страница {{page}} 
 

 {% для сообщения в сообщениях%}
 
 {{msg | escape}} 
 {% endfor%}


{% if prev_page%}  Предыдущая страница  {% endif%}
{% if prev_page и next_page%} | {% endif%}
{% if next_page%}  Следующая страница  {% endif%}  

  страниц = ceil (len (ks) / 10)  

 , если страница отсутствует:
    page = страницы  

 
app.run (хост = '0.0.0.0', порт = 8080)  

  имя пользователя = update.message.from_user.username