Ez a harmadik cikk a „Telegram bot írása R-ben” sorozatban. A korábbi publikációkban megtanultuk, hogyan lehet táviratbotot létrehozni, üzeneteket küldeni rajta, parancsokat és üzenetszűrőket adtunk hozzá a bothoz. Ezért, mielőtt elkezdi olvasni ezt a cikket, nagyon ajánlom, hogy olvassa el , mert Itt most nem fogok tovább foglalkozni a botépítés korábban leírt alapjaival.
Ebben a cikkben egy billentyűzet hozzáadásával javítjuk a robotunk használhatóságát, amely intuitív és könnyen használhatóvá teszi a bot felületét.
Az összes cikk a „Telegram bot írása R-ben” sorozatból
Tartalom
Ha érdekel az adatelemzés, akkor az én oldalam is érdekelheti и csatornák. A tartalom nagy része az R nyelvnek szól.
3.1.
3.2.
3.3.
Milyen típusú billentyűzeteket támogat a telegram bot?
Jelen írás idején telegram.bot kétféle billentyűzet létrehozását teszi lehetővé:
- Válasz – A fő, normál billentyűzet, amely az üzenet szövegbeviteli panelje alatt található. Egy ilyen billentyűzet egyszerűen szöveges üzenetet küld a botnak, és szövegként azt a szöveget küldi el, amely magára a gombra van írva.
- Inline – Egy adott botüzenethez társított billentyűzet. Ez a billentyűzet elküldi a megnyomott gombhoz tartozó botadatokat; ezek az adatok eltérhetnek a gombon lévő szövegtől. És az ilyen gombokat feldolgozzák CallbackQueryHandler.
Ahhoz, hogy a bot megnyithassa a billentyűzetet, ez szükséges, amikor üzenetet küld a módszerrel sendMessage(), adja át a korábban létrehozott billentyűzetet argumentumként reply_markup.
Az alábbiakban néhány példát nézünk meg.
Válasz billentyűzet
Ahogy fentebb is írtam, ez a fő botvezérlő billentyűzet.
Példa válasz-billentyűzet létrehozására a hivatalos súgóból
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Create Custom Keyboard
text <- "Aren't those custom keyboards cool?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Yes, they certainly are!")),
list(KeyboardButton("I'm not quite sure")),
list(KeyboardButton("No..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Send Custom Keyboard
bot$sendMessage(chat_id, text, reply_markup = RKM)A fenti egy példa a csomag hivatalos súgójából telegram.bot. Billentyűzet létrehozásához használja a funkciót ReplyKeyboardMarkup(), amely viszont a funkció által létrehozott gombok listáját tartalmazza KeyboardButton().
Miért ReplyKeyboardMarkup() Nem csak egy listát kell átadnia, hanem egy listát is? A helyzet az, hogy átadja a fő listát, és abban minden gombsort külön listákban határoz meg, mert Egy sorban több gombot is elhelyezhet.
Érv resize_keyboard lehetővé teszi a billentyűzet gombjainak optimális méretének és argumentumának automatikus kiválasztását one_time_keyboard lehetővé teszi a billentyűzet elrejtését minden gombnyomás után.
Írjunk egy egyszerű botot, aminek 3 gombja lesz:
- Chat ID – A bottal folytatott párbeszéd csevegési azonosítójának kérése
- A nevem – Kérje a nevét
- Saját bejelentkezés - Kérje felhasználónevét táviratban
1. kód: Egyszerű bot Válasz billentyűzettel
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# создаём методы
## метод для запуска клавиатуры
start <- function(bot, update) {
# создаём клавиатуру
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# отправляем клавиатуру
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
}
## метод возвразающий id чата
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Чат id этого диалога: ", update$message$chat_id),
parse_mode = "Markdown")
}
## метод возвращающий имя
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Вас зовут ", update$message$from$first_name),
parse_mode = "Markdown")
}
## метод возвращающий логин
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ваш логин ", update$message$from$username),
parse_mode = "Markdown")
}
# создаём фильтры
## сообщения с текстом Чат ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Чат ID"
}
)
## сообщения с текстом Моё имя
MessageFilters$name <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Моё имя"
}
)
## сообщения с текстом Мой логин
MessageFilters$username <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Мой логин"
)
# создаём обработчики
h_start <- CommandHandler('start', start)
h_chat_id <- MessageHandler(chat_id, filters = MessageFilters$chat_id)
h_name <- MessageHandler(my_name, filters = MessageFilters$name)
h_username <- MessageHandler(my_username, filters = MessageFilters$username)
# добавляем обработчики в диспетчер
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# запускаем бота
updater$start_polling()Futtassa a fenti kódpéldát, miután lecserélte a „YOUR BOT TOKEN” szót arra a valódi tokenre, amelyet a bot létrehozásakor kapott BotFather (A bot létrehozásáról beszéltem ).
Az indítás után adjon parancsot a botnak /start, mert Pontosan ezt határoztuk meg a billentyűzet elindításához.
Ha pillanatnyilag nehezen tudja értelmezni az adott kódpéldát metódusok, szűrők és kezelők létrehozásával, akkor térjen vissza az előzőhöz , amelyben mindezt részletesen leírtam.
4 módszert hoztunk létre:
- start — A billentyűzet elindítása
- chat_id – Csevegésazonosító kérése
- my_name — Kérje el a nevét
- my_username — Kérje bejelentkezési adatait
Tiltakozni Üzenetszűrők hozzáadott 3 üzenetszűrőt a szövegük alapján:
- chat_id – Üzenetek szöveggel
"Чат ID" - név — szöveges üzenetek
"Моё имя" - felhasználónév — szöveges üzenetek
"Мой логин"
És létrehoztunk 4 kezelőt, amelyek a megadott parancsok és szűrők alapján végrehajtják a megadott metódusokat.
# создаём обработчики
h_start <- CommandHandler('start', start)
h_chat_id <- MessageHandler(chat_id, filters = MessageFilters$chat_id)
h_name <- MessageHandler(my_name, filters = MessageFilters$name)
h_username <- MessageHandler(my_username, filters = MessageFilters$username)Maga a billentyűzet a metóduson belül jön létre start() csapat ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)Esetünkben az összes gombot egymás alá helyeztük, de a gomblisták listáját módosítva egy sorba is rendezhetjük. Mert A billentyűzeten belül egy sor egy beágyazott gomblistán keresztül jön létre, majd ahhoz, hogy gombjainkat egy sorban jelenítsük meg, át kell írnunk a kód egy részét a billentyűzet felépítéséhez, így:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
A billentyűzet a módszerrel kerül elküldésre a chatbe sendMessage(), az érvelésben reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)Beépített billentyűzet
Ahogy fentebb írtam, az Inline billentyűzet egy adott üzenethez van kötve. Valamivel nehezebb vele dolgozni, mint a fő billentyűzettel.
Kezdetben hozzá kell adni egy módszert a bothoz az Inline billentyűzet meghívásához.
Ha válaszolni szeretne egy Inline gombra kattintásra, használhatja a bot módszert is answerCallbackQuery(), amely értesítést jeleníthet meg a távirati felületen az Inline gombot megnyomó felhasználó számára.
Az Inline gombról küldött adatok nem szövegesek, így azok feldolgozásához speciális kezelőt kell létrehozni a paranccsal CallbackQueryHandler().
Az Inline billentyűzet elkészítésének kódja, amely a csomag hivatalos súgójában található telegram.bot.
Inline billentyűzet készítésének kódja a hivatalos súgóból
# Initialize bot
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Create Inline Keyboard
text <- "Could you type their phone number, please?"
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(1),
InlineKeyboardButton(2),
InlineKeyboardButton(3)
),
list(
InlineKeyboardButton(4),
InlineKeyboardButton(5),
InlineKeyboardButton(6)
),
list(
InlineKeyboardButton(7),
InlineKeyboardButton(8),
InlineKeyboardButton(9)
),
list(
InlineKeyboardButton("*"),
InlineKeyboardButton(0),
InlineKeyboardButton("#")
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id, text, reply_markup = IKM)A parancs segítségével be kell építeni egy Inline billentyűzetet InlineKeyboardMarkup(), ugyanazon az elven, mint a Válasz billentyűzet. BAN BEN InlineKeyboardMarkup() át kell adni az Inline gombok listáját, minden egyes gombot a funkció hozza létre InlineKeyboardButton().
Egy soron belüli gomb argumentum segítségével adhat át adatokat a botnak callback_data, vagy nyissa meg az argumentummal megadott bármely HTML-oldalt url.
Az eredmény egy lista lesz, amelyben minden elem egyben egy sorba egyesítendő Inline gombok listája is.
A következőkben számos példát tekintünk meg az Inline gombokkal rendelkező robotokra.
Példa egy egyszerű botra, amely támogatja az InLine gombokat
Először is írunk egy robotot a Covid-19 expressz teszteléséhez. Parancs alapján /test, küld Önnek egy két gombos billentyűzetet, a megnyomott gombtól függően üzenetet küld a tesztelés eredményével.
2. kód: A legegyszerűbb bot Inline billentyűzettel
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# метод для отправки InLine клавиатуры
test <- function(bot, update) {
# создаём InLine клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Да", callback_data = 'yes'),
InlineKeyboardButton("Нет", callback_data = 'no')
)
)
)
# Отправляем клавиатуру в чат
bot$sendMessage(update$message$chat_id,
text = "Вы болете коронавирусом?",
reply_markup = IKM)
}
# метод для обработки нажатия кнопки
answer_cb <- function(bot, update) {
# полученные данные с кнопки
data <- update$callback_query$data
# получаем имя пользователя, нажавшего кнопку
uname <- update$effective_user()$first_name
# обработка результата
if ( data == 'no' ) {
msg <- paste0(uname, ", поздравляю, ваш тест на covid-19 отрицательный.")
} else {
msg <- paste0(uname, ", к сожалени ваш тест на covid-19 положительный.")
}
# Отправка сообщения
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# сообщаем боту, что запрос с кнопки принят
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# создаём обработчики
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# добавляем обработчики в диспетчер
updater <- updater + inline_h + query_handler
# запускаем бота
updater$start_polling()Futtassa a fenti kódpéldát, miután lecserélte a „YOUR BOT TOKEN” szót arra a valódi tokenre, amelyet a bot létrehozásakor kapott BotFather (A bot létrehozásáról beszéltem ).
Eredmény:
Két módszert hoztunk létre:
- teszt – Csevegésbe küldése Inline billentyűzet
- válasz_cb — A billentyűzetről küldött adatok feldolgozásához.
Az egyes gombokról küldendő adatok az argumentumban vannak megadva callback_data, gomb létrehozásakor. A gombról küldött adatokat a konstrukció segítségével fogadhatja update$callback_query$data, a módszeren belül válasz_cb.
Ahhoz, hogy a bot reagáljon az Inline billentyűzetre, módszer válasz_cb speciális kezelő által feldolgozva: CallbackQueryHandler(answer_cb). Amely az Inline gombra kattintva a megadott metódust futtatja. Kezelő CallbackQueryHandler két érvet vesz fel:
callback— A módszer, amelyet le kell futtatnipattern— Szűrés a gombhoz kötött adatok alapján argumentum segítségévelcallback_data.
Ennek megfelelően az érvelést felhasználva pattern Minden gombnyomásra külön módszert írhatunk:
3. kód: Külön módszer minden Inline gombhoz
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# метод для отправки InLine клавиатуры
test <- function(bot, update) {
# создаём InLine клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Да", callback_data = 'yes'),
InlineKeyboardButton("Нет", callback_data = 'no')
)
)
)
# Отправляем клавиатуру в чат
bot$sendMessage(update$message$chat_id,
text = "Вы болете коронавирусом?",
reply_markup = IKM)
}
# метод для обработки нажатия кнопки Да
answer_cb_yes <- function(bot, update) {
# получаем имя пользователя, нажавшего кнопку
uname <- update$effective_user()$first_name
# обработка результата
msg <- paste0(uname, ", к сожалени ваш текст на covid-19 положительный.")
# Отправка сообщения
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# сообщаем боту, что запрос с кнопки принят
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# метод для обработки нажатия кнопки Нет
answer_cb_no <- function(bot, update) {
# получаем имя пользователя, нажавшего кнопку
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", поздравляю, ваш текст на covid-19 отрицательный.")
# Отправка сообщения
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# сообщаем боту, что запрос с кнопки принят
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# создаём обработчики
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# добавляем обработчики в диспетчер
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# запускаем бота
updater$start_polling()Futtassa a fenti kódpéldát, miután lecserélte a „YOUR BOT TOKEN” szót arra a valódi tokenre, amelyet a bot létrehozásakor kapott BotFather (A bot létrehozásáról beszéltem ).
Most 2 külön módszert írtunk i.e. egy módszert minden gombnyomásra, és használta az argumentumot pattern, kezelőik létrehozásakor:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')A módszer kódja véget ér válasz_cb csapat bot$answerCallbackQuery(callback_query_id = update$callback_query$id), amely közli a bottal, hogy a beépített billentyűzetről származó adatok érkeztek.
Példa egy robotra, amely egy kiválasztott város aktuális időjárását jelenti
Próbáljunk meg írni egy botot, amely időjárási adatokat kér.
Munkájának logikája a következő lesz. Kezdetben a csapat által /start hívja a fő billentyűzetet, amelyen csak egy „Időjárás” gomb van. Erre a gombra kattintva üzenetet kap az Inline billentyűzettel, hogy válassza ki azt a várost, amelynek aktuális időjárását szeretné megtudni. Válasszon egyet a városok közül, és tekintse meg az aktuális időjárást.
Ebben a kódpéldában több további csomagot fogunk használni:
httr— egy csomag a HTTP kérésekkel való munkavégzéshez, amely alapján bármilyen API-val való munka épül. Esetünkben az ingyenes API-t fogjuk használni .stringr— egy csomag szöveggel való munkához, esetünkben ezzel fogunk üzenetet generálni a kiválasztott város időjárásáról.
4-es kód: Egy bot, amely a kiválasztott város aktuális időjárását jelenti
library(telegram.bot)
library(httr)
library(stringr)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# создаём методы
## метод для запуска основной клавиатуры
start <- function(bot, update) {
# создаём клавиатуру
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Погода")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# отправляем клавиатуру
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
}
## Метод вызова Inine клавиатуры
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Москва', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Санкт-Петербург', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'Нью-Йорк', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Екатеринбург', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Берлин', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Париж', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Рим', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Одесса', callback_data = 'Odessa,ua'),
InlineKeyboardButton(text = 'Киев', callback_data = 'Kyiv,fr')
),
list(
InlineKeyboardButton(text = 'Токио', callback_data = 'Tokyo'),
InlineKeyboardButton(text = 'Амстердам', callback_data = 'Amsterdam,nl'),
InlineKeyboardButton(text = 'Вашингтон', callback_data = 'Washington,us')
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id = update$message$chat_id,
text = "Выберите город",
reply_markup = IKM)
}
# метод для сообщения погоды
answer_cb <- function(bot, update) {
# получаем из сообщения город
city <- update$callback_query$data
# отправляем запрос
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'ru',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# парсим ответ
result <- content(ans)
# формируем сообщение
msg <- str_glue("{result$name} погода:n",
"Текущая температура: {result$main$temp}n",
"Скорость ветра: {result$wind$speed}n",
"Описание: {result$weather[[1]]$description}")
# отправляем информацию о погоде
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)
# создаём обработчики
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# добавляем обработчики в диспетчер
updater <- updater +
h_start +
h_weather +
h_query_handler
# запускаем бота
updater$start_polling()Futtassa a fenti kódpéldát, miután lecserélte a „YOUR BOT TOKEN” szót arra a valódi tokenre, amelyet a bot létrehozásakor kapott BotFather (A bot létrehozásáról beszéltem ).
Ennek eredményeként a robotunk a következőképpen fog működni:
Sematikusan ez a bot a következőképpen ábrázolható:
Három módszert hoztunk létre az időjárás-robotunkon belül:
- kezdet — Indítsa el a fő bot-billentyűzetet
- időjárás — Indítsa el az Inline billentyűzetet a város kiválasztásához
- válasz_cb — A fő módszer, amely lekéri az időjárást az API-tól egy adott városhoz, és elküldi a chatnek.
módszer kezdet paranccsal elindítjuk /start, amelyet a kezelő valósít meg CommandHandler('start', start).
Egy módszer futtatásához időjárás létrehoztunk egy azonos nevű szűrőt:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)És ezt a metódust a következő üzenetkezelővel hívjuk: MessageHandler(weather, filters = MessageFilters$weather).
És a végén a fő módszerünk válasz_cb reagál az Inline gombok megnyomására, amelyet egy speciális kezelő valósít meg: CallbackQueryHandler(answer_cb).
Egy módszer belsejében válasz_cb, beolvassuk a billentyűzetről küldött adatokat és beírjuk egy változóba city: city <- update$callback_query$data. Ezután kérünk időjárási adatokat az API-tól, generálunk és küldünk egy üzenetet, végül használjuk a metódust answerCallbackQuery annak érdekében, hogy tájékoztassuk a botot, hogy feldolgoztuk az Inline gomb kattintását.
Példa egy robotra, amely megjeleníti a legfrissebb cikkek listáját a megadott központra mutató hivatkozásokkal .
Ezt a botot azért mutatom be, hogy megmutassam, hogyan jeleníthetők meg a weboldalakra vezető Inline gombok.
Ennek a botnak a logikája hasonló az előzőhöz, kezdetben a fő billentyűzetet indítjuk el a paranccsal /start. Ezután a bot megad egy listát, amely 6 központ közül választhat, mi kiválasztjuk a minket érdeklő hubot, és megkapjuk a kiválasztott Hub 5 legfrissebb kiadványát.
Amint megérti, ebben az esetben meg kell szereznünk a cikkek listáját, és ehhez egy speciális csomagot fogunk használni habR, amely lehetővé teszi cikkek kérését a Habrától és néhány statisztikát az R-ben.
Telepítse a csomagot habR csak githubból lehetséges, amihez szükség lesz egy kiegészítő csomagra devtools. A telepítéshez használja az alábbi kódot.
install.packages('devtools')
devtools::install_github('selesnow/habR')Most nézzük meg a fent leírt bot felépítésének kódját:
5. kód: Egy bot, amely megjeleníti a kiválasztott Hub legfrissebb cikkeinek listáját
library(telegram.bot)
library(habR)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# создаём методы
## метод для запуска основной клавиатуры
start <- function(bot, update) {
# создаём клавиатуру
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Список статей")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# отправляем клавиатуру
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
}
## Метод вызова Inine клавиатуры
habs <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'R', callback_data = 'R'),
InlineKeyboardButton(text = 'Data Mining', callback_data = 'data_mining'),
InlineKeyboardButton(text = 'Data Engineering', callback_data = 'data_engineering')
),
list(
InlineKeyboardButton(text = 'Big Data', callback_data = 'bigdata'),
InlineKeyboardButton(text = 'Python', callback_data = 'python'),
InlineKeyboardButton(text = 'Визуализация данных', callback_data = 'data_visualization')
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id = update$message$chat_id,
text = "Выберите Хаб",
reply_markup = IKM)
}
# метод для сообщения погоды
answer_cb <- function(bot, update) {
# получаем из сообщения город
hub <- update$callback_query$data
# сообщение о том, что данные по кнопке получены
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Подождите несколько минут, запрос обрабатывается')
# сообщение о том, что надо подождать пока бот получит данные
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Подождите несколько минут пока, я соберу данные по выбранному Хабу")
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)
# удаляем сообщение о том, что надо подождать
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# отправляем информацию о погоде
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 наиболее свежих статей из Хаба ", hub),
reply_markup = IKM)
}
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$hubs <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Список статей"
}
)
# создаём обработчики
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# добавляем обработчики в диспетчер
updater <- updater +
h_start +
h_hubs +
h_query_handler
# запускаем бота
updater$start_polling()Futtassa a fenti kódpéldát, miután lecserélte a „YOUR BOT TOKEN” szót arra a valódi tokenre, amelyet a bot létrehozásakor kapott BotFather (A bot létrehozásáról beszéltem ).
Ennek eredményeként a következő eredményt kapjuk:
A metódusban kiválasztható Hubok listáját keményen kódoltuk habs:
## Метод вызова Inine клавиатуры
habs <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'R', callback_data = 'r'),
InlineKeyboardButton(text = 'Data Mining', callback_data = 'data_mining'),
InlineKeyboardButton(text = 'Data Engineering', callback_data = 'data_engineering')
),
list(
InlineKeyboardButton(text = 'Big Data', callback_data = 'bigdata'),
InlineKeyboardButton(text = 'Python', callback_data = 'python'),
InlineKeyboardButton(text = 'Визуализация данных', callback_data = 'data_visualization')
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id = update$message$chat_id,
text = "Выберите Хаб",
reply_markup = IKM)
}A paranccsal megkapjuk a cikkek listáját a megadott Hubról habr_hub_posts(), a csomagból habR. Ugyanakkor felhívjuk a figyelmet arra, hogy nem a teljes időre vonatkozó cikklistára van szükségünk, hanem csak az első oldalra, amelyen 20 cikk található. Az eredményül kapott táblázatból a paranccsal head() Csak az első 5-öt hagyjuk meg, amelyek a legfrissebb cikkek.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)A logika nagyon hasonló az előző bothoz, de ebben az esetben dinamikusan generálunk egy Inline billentyűzetet cikkek listájával a függvény segítségével lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)A gomb szövegébe beillesztjük a cikk címét posts$title[x], és az érvelésben url link a cikkhez: url = posts$link[x].
Ezután létrehozunk egy szűrőt, kezelőket, és elindítjuk a botunkat.
Következtetés
Mostantól sokkal kényelmesebb lesz az Ön által írt robotok használata, mivel a billentyűzetről vezérelhetők, nem pedig parancsok beírásával. Ha egy bottal okostelefonon keresztül kommunikál, a billentyűzet jelentősen leegyszerűsíti a használat folyamatát.
A következő cikkben kitaláljuk, hogyan építhetünk fel logikai párbeszédet egy bottal és hogyan dolgozhatunk adatbázisokkal.
Forrás: will.com
