Kyçi i tretë në serinë "Krijimi i një boti telegram në gjuhën R". Në publikimet e mëparshme, ne mësuam si të krijojmë një bot telegrami, si të dërgojmë mesazhe përmes tij, dhe si t'i shtojmë atij komandat dhe filtrat e mesazheve. Prandaj, para se të filloni këtë artikull, ju rekomandoj të lexoni , sepse këtu nuk do të ndalem në bazat e ndërtimit të botit që janë përmendur më parë.
Në këtë artikull do të rrisim përdorshmërinë e botit tonë duke shtuar një tastierë, e cila do ta bëjë ndërfaqen e botit intuitiv dhe të lehtë në përdorim.
Të gjithë artikujt e serisë "Po shkruajmë një bot telegram në gjuhën R"
Përmbajtja
Nëse jeni të interesuar për analizën e të dhënave, ndoshta do t'ju interesojnë kanalet e mia dhe në të cilat shumica e përmbajtjes është e kushtuar gjuhës R.
3.1.
3.2.
3.3.
Çfarë lloj tastierash mbështetur nga boti telegram
Në momentin e shkruar telegram.bot ju lejon të krijoni tastiera të dy tipeve:
- Tastiera e përgjigjes — Tastiera kryesore, zakonisht ndodhet nën panelin e hyrjes së mesazhit. Kjo tastierë thjesht dërgon një mesazh tekstual në bot, duke dërguar si tekst atë që është shkruar në butonin e saj.
- Tastiera inline — Tastiera që është e lidhur me një mesazh të caktuar të botit. Kjo tastierë dërgon në bot të dhënat e lidhura me butonin e shtypur, të cilat mund të ndryshojnë nga teksti i shkruar mbi buton. Këto butona përpunohen përmes CallbackQueryHandler.
Për të hapur tastierën, është e nevojshme që gjatë dërgimit të mesazhit përmes metodës sendMessage(), të kalosh tastierën e krijuar më parë në argumentin reply_markup.
Më poshtë do të shqyrtojmë disa shembuj.
Tastiera e përgjigjes
Siç e kam thënë më parë, kjo është tastiera kryesore për menaxhimin e botit.
Shembulli i krijimit të një tastiere përgjigjeje nga dokumentacioni zyrtar
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Krijo Tastierën e Personalizuar
text <- "A thoni se këto tastiera të personalizuara janë të mrekullueshme?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Po, ato me të vërtetë janë!")),
list(KeyboardButton("Nuk jam aq i sigurt")),
list(KeyboardButton("Jo..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Dërgo Tastierën e Personalizuar
bot$sendMessage(chat_id, text, reply_markup = RKM)Më sipër është një shembull nga dokumentacioni i paketës telegram.bot. Për të krijuar tastierën përdoret funksioni ReplyKeyboardMarkup(), i cili merr si input një listë listash të butonave, të cilat krijohen nga funksioni KeyboardButton().
Pse në ReplyKeyboardMarkup() duhet të kaloni jo vetëm një listë, por një listë listash? Sepse ju dërgoni listën kryesore, dhe në të përveçse listave jepni çdo rresht butonash, sepse në një rresht mund të vendosen disa butona.
Argumenti resize_keyboard lejon përshtatjen automatikisht të madhësisë optimale të butonave të tastierës, ndërsa argumenti one_time_keyboard lejon fshehjen e tastierës pas çdo shtypjeje të butonit.
Le të shkruajmë një bot të thjeshtë, i cili do të ketë 3 butona:
- ID Bisedës — Kërkoni ID bisedës me botin
- Emri im — Kërkoni emrin tuaj
- Emri im në Telegram — Kërkoni emrin tuaj të përdoruesit në telegram
Kodi 1: Bot i thjeshtë me tastierë përgjigjeje
library(telegram.bot)
# krijojmë një instancë të klasës Updater
updater <- Updater('TOKEN E BOTIT TUAJ')
# krijojmë metodat
## metoda për të aktivizuar tastierën
start <- function(bot, update) {
# krijojmë tastierën
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("ID Bisedës")),
list(KeyboardButton("Emri im")),
list(KeyboardButton("Emri im në Telegram"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# dërgojmë tastierën
bot$sendMessage(update$message$chat_id,
text = 'Zgjidhni komandën',
reply_markup = RKM)
}
## metoda që kthen id bisedës
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("ID e bisedës në këtë dialog: ", update$message$chat_id),
parse_mode = "Markdown")
}
## metoda që kthen emrin
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ju quani ", update$message$from$first_name),
parse_mode = "Markdown")
}
## metoda që kthen emrin e përdoruesit
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Emri juaj ", update$message$from$username),
parse_mode = "Markdown")
}
# krijojmë filtrat
## mesazhet me tekstin ID Bisedës
MessageFilters$chat_id <- BaseFilter(function(message) {
# kontrollojmë tekstin e mesazhit
message$text == "ID Bisedës"
}
)
## mesazhet me tekstin Emri im
MessageFilters$name <- BaseFilter(function(message) {
# kontrollojmë tekstin e mesazhit
message$text == "Emri im"
}
)
## mesazhet me tekstin Emri im në Telegram
MessageFilters$username <- BaseFilter(function(message) {
# kontrollojmë tekstin e mesazhit
message$text == "Emri im në Telegram"
)
# krijojmë menaxherët
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)
# shtojmë menaxherët në menaxherin
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# aktivizojmë botin
updater$start_polling()Shkruani shembullin e mësipërm të kodit, duke zëvendësuar ‘TOKENI I BOTIT TUAJ’ me tokenin real që keni marrë kur krijuat botin përmes BotFather (për krijimin e botit kam folur në ).
Pas aktivizimit, caktoni një komandë për botin /start, sepse pikërisht atë e kemi caktuar për të aktivizuar tastierën.
Nëse momentalisht ju duket e vështirë të kuptoni shembullin e dhënë të kodit, me krijimin e metodave, filtrave dhe trajtuesve, duhet t'i ktheheni versionit të mëparshëm , ku e kam përshkruar gjithçka në detaje.
Ne krijuam 4 metoda:
- start — Aktivizimi i tastierës
- chat_id — Kërkesa për identifikimin e bisedës
- my_name — Kërkesa për emrin tuaj
- my_username — Kërkesa për emrin tuaj të përdoruesit
Në objekt MessageFilters shtuam 3 filtra mesazhesh, sipas tekstit të tyre:
- chat_id — Mesazhe me tekstin
"Chat ID" - name — Mesazhe me tekstin
"Emri im" - username — Mesazhe me tekstin
"Emri im i përdoruesit"
Dhe krijuam 4 trajtues, të cilët do të ekzekutojnë metodat e caktuara sipas komandave dhe filtrave të vendosur.
# создаём обработчики
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)Kjo tastierë krijohet brenda metodës start() me komandën ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Emri im")),
list(KeyboardButton("Emri im i përdoruesit"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)Në rastin tonë, ne i vendosëm të gjitha butonat njëri mbi tjetrin, por mund t'i vendosim në një rresht, duke bërë ndryshime në listën e listave të butonave. Duke qenë se një rresht brenda tastierës krijohet përmes një liste të thelluar butonash, për t'i nxjerrë butonat tanë në një rresht duhet të ribëjmë një pjesë të kodit për ndërtimin e tastierës kështu:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Chat ID"),
KeyboardButton("Emri im"),
KeyboardButton("Emri im i përdoruesit")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Tastiera dërgohet në bisedë përmes metodës sendMessage(), në argumentin reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Zgjidhni komandën',
reply_markup = RKM)Tastiera inline
Siç e kam thënë më lart, tastiera Inline është e lidhur me një mesazh të caktuar. Punimi me të është pak më i komplikuar se me tastierën kryesore.
Fillimisht, duhet t'i shtoni botit një metodë për të thirrur tastierën Inline.
Për të përgjigjur për klikimin e butonit Inline mund të përdorni gjithashtu metodën e botit answerCallbackQuery(), e cila mund të nxjerrë një njoftim në ndërfaqen e telegramit për përdoruesin që ka klikuar butonin Inline.
Të dhënat e dërguara me butonin Inline nuk janë tekst, prandaj për t'i procesuar ato është e nevojshme të krijoni një trajtues të veçantë duke përdorur komandën CallbackQueryHandler().
Kodu për ndërtimin e tastierës Inline që jepet në dokumentacionin zyrtar të paketës telegram.bot.
Kodi për ndërtimin e tastierës Inline nga dokumentacioni zyrtar
# 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)Tastiera Inline duhet të ndërtohet me anë të komandës InlineKeyboardMarkup(), sipas të njëjtit parim si tastiera Reply. Në InlineKeyboardMarkup() duhet të kaloni një listë, listash butonash Inline, çdo buton i veçantë krijohet nga funksioni InlineKeyboardButton().
Butoni Inline mund të dërgojë disa të dhëna botit përmes argumentit callback_data, ose të hapë një faqe HTML, e cila përcaktohet përmes argumentit url.
Si rezultat, do të kemi një listë, ku çdo element gjithashtu është një listë butonash Inline, që duhet të mblidhen në një rresht.
Më pas, do të shqyrtojmë disa shembuj botësh me butona Inline.
Shembulli i një boti të thjeshtë me mbështetje për butona InLine
Për fillim, do të shkruajmë një bot për testimin e shpejtë për covid-19. Me komandën /test, ai do t'ju dërgojë një tastierë me dy butona, dhe në varësi të butonit të shtypur, ai do t'ju dërgojë një mesazh me rezultatet e testit tuaj.
Kodi 2: Një bot i thjeshtë me tastierë Inline
library(telegram.bot)
# krijojmë një instancë të klasës Updater
updater <- Updater('TOKENI I BOTIT TUAJ')
# metoda për dërgimin e tastierës InLine
test <- function(bot, update) {
# krijojmë tastierën InLine
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Po", callback_data = 'yes'),
InlineKeyboardButton("Jo", callback_data = 'no')
)
)
)
# Dërgojmë tastierën në bisedë
bot$sendMessage(update$message$chat_id,
text = "A jeni i sëmurë nga koronavirusi?",
reply_markup = IKM)
}
# metoda për përpunimin e shtypjes së butonit
answer_cb <- function(bot, update) {
# të dhënat e marra nga butoni
data <- update$callback_query$data
# marrim emrin e përdoruesit që ka shtypur butonin
uname <- update$effective_user()$first_name
# përpunimi i rezultatit
if ( data == 'no' ) {
msg <- paste0(uname, ", përgëzime, testi juaj për covid-19 është negativ.")
} else {
msg <- paste0(uname, ", me keqardhje testi juaj për covid-19 është pozitiv.")
}
# Dërgimi i mesazhit
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# njoftojmë botin se kërkesa nga butoni është pranuar
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# krijojmë trajtuesit
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# shtojmë trajtuesit në menaxher
updater <- updater + inline_h + query_handler
# aktivizojmë botin
updater$start_polling()Shkruani shembullin e mësipërm të kodit, duke zëvendësuar ‘TOKENI I BOTIT TUAJ’ me tokenin real që keni marrë kur krijuat botin përmes BotFather (për krijimin e botit kam folur në ).
Rezultati:
Krijuam dy metoda:
- test — Për dërgimin e tastierës Inline në bisedë
- answer_cb — Për përpunimin e të dhënave të dërguara nga tastiera.
Të dhënat që do të dërgohen nga çdo buton përcaktohen në argumentin callback_data, gjatë krijimit të butonit. Të dhenat e dërguara nga butoni mund të merren me anë të konstrukcionit update$callback_query$data, brenda metodës answer_cb.
Për të bërë që boti të reagojë ndaj tastierës Inline, metoda answer_cb përpunohen nga një trajtues të veçantë: CallbackQueryHandler(answer_cb). Cili aktivizon metodin e caktuar me klikimin e butonit Inline. Menaxheri CallbackQueryHandler pranon dy argumente:
callback— Metoda që duhet të ekzekutohetpattern— Filtri mbi të dhënat që janë lidhur me butonin përmes argumentitcallback_data.
Për pasojë, me ndihmën e argumentit pattern mund të shkruajmë metoda të veçanta për çdo buton:
Kodi 3: Ndajmë metodat për çdo buton Inline
library(telegram.bot)
# krijojmë një ekzemplar të klasës Updater
updater <- Updater('TOKEN I BOTIT TUAJ')
# metoda për dërgimin e tastierës InLine
test <- function(bot, update) {
# krijojmë tastierën InLine
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Po", callback_data = 'yes'),
InlineKeyboardButton("Jo", callback_data = 'no')
)
)
)
# Dërgojmë tastierën në bisedë
bot$sendMessage(update$message$chat_id,
text = "A jeni të prekur nga koronavirusi?",
reply_markup = IKM)
}
# metoda për trajtimin e klikimit të butonit Po
answer_cb_yes <- function(bot, update) {
# marrim emrin e përdoruesit që e shtypi butonin
uname <- update$effective_user()$first_name
# përpunimi i rezultatit
msg <- paste0(uname, ", fatkeqësisht testi juaj për covid-19 doli pozitiv.")
# Dërgimi i mesazhit
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informojmë botin që kërkesa nga butoni është pranuar
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# metoda për trajtimin e klikimit të butonit Jo
answer_cb_no <- function(bot, update) {
# marrim emrin e përdoruesit që e shtypi butonin
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", urime, testi juaj për covid-19 doli negativ.")
# Dërgimi i mesazhit
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informojmë botin që kërkesa nga butoni është pranuar
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# krijojmë menaxherët
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# shtojmë menaxherët në menaxherin
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# nisim botin
updater$start_polling()Shkruani shembullin e mësipërm të kodit, duke zëvendësuar ‘TOKENI I BOTIT TUAJ’ me tokenin real që keni marrë kur krijuat botin përmes BotFather (për krijimin e botit kam folur në ).
Tani kemi shkruar 2 metoda të veçanta, domethënë një metodë për secilin buton, dhe kemi përdorur argumentin pattern, gjatë krijimit të menaxherëve të tyre:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Kushtet e metodës përfundon answer_cb me komandën bot$answerCallbackQuery(callback_query_id = update$callback_query$id), e cila i njofton botin se të dhënat nga tastiera inline janë pranuar.
Shembulli i një boti që raporton motin aktual për qytetin e zgjedhur
Le të tentojmë të shkruajmë një bot që kërkon të dhënat për motin.
Logjika e saj do të jetë e tillë. Fillimisht me komandën /start aktivizoni tastierën kryesore, e cila përmban vetëm një buton "Moti". Duke klikuar në këtë buton, merrni një mesazh me një tastierë Inline, për të zgjedhur qytetin për të cilin dëshironi të dini motin aktual. Zgjidhni një nga qytetet dhe merrni motin aktual.
Në këtë shembull të kodit do të përdorim disa paketa shtesë:
httr— paketa për të punuar me kërkesat HTTP, mbi të cilat është e ndërtuar puna me çdo API. Në rastin tonë, do të përdorim një API falas .stringr— paketa për të punuar me tekstin; në rastin tonë do ta përdorim për formimin e mesazhit për motin në qytetin e zgjedhur.
Kodi 4: Bot që raporton motin aktual për qytetin e zgjedhur
library(telegram.bot)
library(httr)
library(stringr)
# krijojmë një instancë të klasës Updater
updater <- Updater('TOKENI I BOTE YOUR')
# krijojmë metodat
## metoda për të aktivizuar tastierën kryesore
start <- function(bot, update) {
# krijojmë tastierën
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Mot")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# dërgojmë tastierën
bot$sendMessage(update$message$chat_id,
text = 'Zgjidhni komandën',
reply_markup = RKM)
}
## Metoda për aktivizimin e tastierës Inline
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Moska', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Shkoder', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'Nju Jork', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Ekaterinburg', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Berlin', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Paris', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Romë', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Odessa', callback_data = 'Odessa,ua'),
InlineKeyboardButton(text = 'Kyiv', callback_data = 'Kyiv,fr')
),
list(
InlineKeyboardButton(text = 'Tokio', callback_data = 'Tokyo'),
InlineKeyboardButton(text = 'Amsterdam', callback_data = 'Amsterdam,nl'),
InlineKeyboardButton(text = 'Washington', callback_data = 'Washington,us')
)
)
)
# Dërgo Tastierën Inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Zgjidhni qytetin",
reply_markup = IKM)
}
# metoda për mesazhin e motit
answer_cb <- function(bot, update) {
# marrim qytetin nga mesazhi
city <- update$callback_query$data
# dërgojmë kërkesën
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'sq',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# analizojmë përgjigjen
result <- content(ans)
# formojmë mesazhin
msg <- str_glue("{result$name} moti:n",
"Temperatura aktuale: {result$main$temp}n",
"Shpejtësia e erës: {result$wind$speed}n",
"Përshkrimi: {result$weather[[1]]$description}")
# dërgojmë informacionin për motin
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# krijojmë filtrat
## mesazhet me tekstin Mot
MessageFilters$weather <- BaseFilter(function(message) {
# kontrollojmë tekstin e mesazhit
message$text == "Mot"
}
)
# krijojmë trajtuesit
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# shtojmë trajtuesit në menaxher
updater <- updater +
h_start +
h_weather +
h_query_handler
# aktivizojmë botin
updater$start_polling()Shkruani shembullin e mësipërm të kodit, duke zëvendësuar ‘TOKENI I BOTIT TUAJ’ me tokenin real që keni marrë kur krijuat botin përmes BotFather (për krijimin e botit kam folur në ).
Si rezultat, boti ynë do të funksionojë kështu:
Skematikisht, ky bot mund të përshkruhet kështu:
Ne krijuam 3 metoda, të disponueshme brenda botit tonë të motit:
- start — Aktivizimi i tastierës kryesore të botit
- mot — Aktivizimi i tastierës Inline për të zgjedhur qytetin
- answer_cb — Metoda kryesore, e cila për qytetin e dhënë kërkon motin në API dhe e dërgon atë në bisedë.
Metoda start ne aktivizojmë me komandën /start, që është realizuar me trajtuesin CommandHandler('start', start).
Për të aktivizuar metodën mot ne krijuam një filtër me të njëjtin emër:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Dhe e thërrasim këtë metodë me trajtuesit e mesazheve: MessageHandler(weather, filters = MessageFilters$weather).
Dhe në fund, metoda jonë kryesore answer_cb reagon ndaj klikimeve të butonëve Inline, që realizohet me një trajtues të veçantë: CallbackQueryHandler(answer_cb).
Brenda metodës answer_cb, ne lexojmë të dhënat e dërguara nga tastiera dhe i ruajmë ato në një variabël city: city <- update$callback_query$data. Pas kësaj, kërkojmë të dhënat për motin nga API, formojmë dhe dërgojmë mesazhin, dhe në fund përdorim metodën answerCallbackQuery për të informuar botin se ne kemi përpunuar klikimin e butonit Inline.
Një shembull boti që tregon listën më të fundit të artikujve me lidhje nga Hub-i i caktuar .
Unë e paraqes këtë bot për të ju treguar se si të nxjerrni butona Inline që çojnë në faqe të internetit.
Logjika e këtij boti është e ngjashme me të mëparshmin, fillimisht ne aktivizojmë tastierën kryesore me komandën /start. Më pas boti na ofron një listë prej 6 Hub-esh, ne zgjedhim Hub-in që na intereson, dhe marrim 5 publikimet më të fundit nga Hub-i i zgjedhur.
Siç e kuptoni, në këtë rast na nevojitet të marrim një listë artikujsh, dhe për këtë do të përdorim paketën speciale habR, që lejon të kërkojmë artikuj nga Habra dhe disa statistika për to në R.
Të instaloni paketën habR mund të bëhet vetëm nga github, për çfarë do ju nevojitet paketa shtesë devtools. Për instalimin e saj përdorni kodin e mëposhtëm.
install.packages('devtools')
devtools::install_github('selesnow/habR')Tani le të shikojmë kodin për ndërtimin e botit të përshkruar më sipër:
Kodi 5: Boti që tregon listën më të freskët të artikujve për Hub-in e zgjedhur
library(telegram.bot)
library(habR)
# krijojmë një instancë të klasës Updater
updater <- Updater('TOKENI I BOTIT TUAJ')
# krijojmë metodat
## metoda për të nisur tastierën kryesore
start <- function(bot, update) {
# krijojmë tastierën
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Lista e artikujve")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# dërgojmë tastierën
bot$sendMessage(update$message$chat_id,
text = 'Zgjidhni komandën',
reply_markup = RKM)
}
## Metoda për thirrjen e tastierës Inline
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 = 'Vizualizimi i të dhënave', callback_data = 'data_visualization')
)
)
)
# Dërgo tastierën Inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Zgjidhni Hub-in",
reply_markup = IKM)
}
# metoda për mesazhin e kohës
answer_cb <- function(bot, update) {
# marrim qytetin nga mesazhi
hub <- update$callback_query$data
# mesazh mbi marrjen e të dhënave nga dügjuese
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Përni një minutë, kërkesa po përpunohet')
# mesazh që të presim që boti të marrë të dhënat
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Përni një minutë derisa, unë të mbledh të dhënat për Hub-in e zgjedhur")
# parasojmë Habr
posts <- head(habr_hub_posts(hub, 1), 5)
# fshijmë mesazhin e pritjes
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# formojmë listën e butonave
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# formojmë tastierën
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# dërgojmë informacionin mbi motin
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 artikujt më të rinj nga Habi ", hub),
reply_markup = IKM)
}
# krijojmë filtrat
## mesazhe me tekstin Mot
MessageFilters$hubs <- BaseFilter(function(message) {
# kontrollojmë tekstin e mesazhit
message$text == "Lista e artikujve"
}
)
# krijojmë trajtuesit
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# shtojmë trajtuesit në menaxherin
updater <- updater +
h_start +
h_hubs +
h_query_handler
# nisim botin
updater$start_polling()Shkruani shembullin e mësipërm të kodit, duke zëvendësuar ‘TOKENI I BOTIT TUAJ’ me tokenin real që keni marrë kur krijuat botin përmes BotFather (për krijimin e botit kam folur në ).
Në rezultat, ne do të kemi një rezultat të tillë:
Lista e Hubeve të disponueshëm për zgjedhje e kemi futur hardcod'd, në metodën 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)
}Lista e artikujve nga Hub-i i specifikuar e marrim me komandën habr_hub_posts(), nga paketa habR. Ndërkohë, ne e specifikojmë se nuk na nevojitet lista e artikujve për të gjithë kohën, por vetëm faqja e parë ku ndodhen 20 artikuj. Nga tabela e marrë, me anë të komandës head() lëmë vetëm 5 artikujt më të sipërm, që janë dhe artikujt më të rinj.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Logjika është shumë e ngjashme me botin e mëparshëm, por në këtë rast ne gjenerojmë tastierën Inline me listën e artikujve dinamikisht me anë të funksionit lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Në tekstin e butonit ne vendosim titullin e artikullit posts$title[x], dhe në argumentin url linkun në artikull: url = posts$link[x].
Më pas, krijojmë filtrin, trajtuesit dhe nisim botin tonë.
Përfundimi
Tani, botet e shkruara prej jush do të jenë ndjeshëm më të lehta në përdorim, nga fakti se menaxhimi i tyre do të bëhet nga tastiera, dhe jo nga futja e komandave. Të paktën gjatë ndërveprimit me botin përmes telefonit inteligjent, tastiera do të thjeshtojë ndjeshëm procesin e përdorimit të saj.
Në artikullin e ardhshëm do të analizojmë si të ndërtojmë një dialog logjik me botin dhe si të punojmë me bazat e të dhënave.
Burimi: habr.com
