ProHoster > blogg > administration > Skriva en telegrambot i R (del 1): Skapa en bot och använda den för att skicka meddelanden i telegram

Skriva en telegrambot i R (del 1): Skapa en bot och använda den för att skicka meddelanden i telegram

Telegrampubliken växer exponentiellt varje dag, detta underlättas av budbärarens bekvämlighet, närvaron av kanaler, chattar och naturligtvis möjligheten att skapa bots.

Bots kan användas för helt andra syften, från att automatisera kommunikationen med dina kunder till att hantera dina egna uppgifter.

I huvudsak kan du använda telegram för att utföra alla operationer genom en bot: skicka eller begära data, köra uppgifter på servern, samla in information i en databas, skicka e-postmeddelanden och så vidare.

Jag planerar att skriva en serie artiklar om hur man arbetar med telegram bot API, och skriv bots som passar dina behov.

Skriva en telegrambot i R (del 1): Skapa en bot och använda den för att skicka meddelanden i telegram

I den här första artikeln kommer vi att ta reda på hur man skapar en telegrambot och använder den för att skicka meddelanden i telegram.

Som ett resultat kommer vi att ha en bot som kommer att kontrollera statusen för den senaste körningen av alla uppgifter i Windows Task Scheduler, och skicka meddelanden till dig om någon av dem misslyckades.

Men syftet med den här artikelserien är inte att lära dig hur man skriver en bot för en specifik, smal uppgift, utan att allmänt introducera dig till paketets syntax telegram.bot, och kodexempel med vilka du kan skriva bots för att lösa dina egna problem.

Innehåll

Om du är intresserad av dataanalys kan du vara intresserad av min telegram и Youtube kanaler. Det mesta av innehållet är tillägnat R-språket.

  1. Skapa en telegrambot
  2. Installera ett paket för att arbeta med en telegrambot i R
  3. Skicka meddelanden från R till Telegram
  4. Ställa in ett schema för att köra uppgiftssökningar
  5. Slutsats

Skapa en telegrambot

Först måste vi skapa en bot. Detta görs med hjälp av en speciell bot BotFader, gå till länk och skriv till boten /start.

Därefter får du ett meddelande med en lista med kommandon:

Meddelande från BotFather

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

För att skapa en ny bot, skicka kommandot /newbot.

BotFather kommer att be dig ange botens namn och inloggning.

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

Du kan ange vilket namn som helst, men inloggningen måste sluta med bot.

Om du gjorde allt korrekt får du följande meddelande:

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

Därefter behöver du den mottagna API-token, i mitt exempel är det det 123456789:abcdefghijklmnopqrstuvwxyz.

I detta steg är det förberedande arbetet för att skapa boten slutfört.

Installera ett paket för att arbeta med en telegrambot i R

Jag antar att du redan har R-språket och RStudio-utvecklingsmiljön installerad. Om så inte är fallet kan du titta på detta videolektion om hur man installerar dem.

För att arbeta med Telegram Bot API kommer vi att använda R-paketet telegram.bot.

Installation av paket i R görs med funktionen install.packages(), så för att installera paketet vi behöver, använd kommandot install.packages("telegram.bot").

Du kan lära dig mer om att installera olika paket från den här videon.

När du har installerat paketet måste du ansluta det:

library(telegram.bot)

Skicka meddelanden från R till Telegram

Boten du skapade kan hittas i Telegram med den inloggning som angavs under skapandet, i mitt fall är det det @my_test_bot.

Skicka ett meddelande till boten, till exempel "Hej bot." För tillfället behöver vi detta för att få ID för din chatt med boten.

Nu skriver vi följande kod i R.

library(telegram.bot)

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

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

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

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

Till en början skapar vi en instans av vår bot med funktionen Bot(), måste den tidigare mottagna token skickas in i den som ett argument.

Det anses inte vara bästa praxis att lagra token i kod, så du kan lagra den i en miljövariabel och läsa den från den. Som standard i paketet telegram.bot Stöd för miljövariabler med följande namn har implementerats: R_TELEGRAM_BOT_ИМЯ_ВАШЕГО_БОТА. Istället för ИМЯ_ВАШЕГО_БОТА ersätt namnet du angav när du skapade, i mitt fall kommer det att vara en variabel R_TELEGRAM_BOT_My Test Bot.

Det finns flera sätt att skapa en miljövariabel; Jag kommer att berätta om den mest universella och plattformsoberoende. Skapa i din hemkatalog (du kan hitta den med kommandot path.expand("~")) textfil med namnet .Omgivning. Du kan också göra detta med kommandot file.edit(path.expand(file.path("~", ".Renviron"))).

Och lägg till följande rad.

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

Därefter kan du använda token som sparats i miljövariabeln med funktionen bot_token(), dvs. så här: 

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

metod getUpdates()tillåter oss att få botuppdateringar, d.v.s. meddelanden som skickades till honom. Metod from_chat_id(), låter dig få ID för chatten som meddelandet skickades från. Vi behöver detta ID för att skicka meddelanden från boten.

Förutom chatt-id från objektet som erhålls med metoden getUpdates() du får även annan användbar information. Till exempel information om användaren som skickade meddelandet.

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"

Så i detta skede har vi redan allt vi behöver för att skicka ett meddelande från en bot till Telegram. Låt oss använda metoden sendMessage(), som du måste skicka in chatt-ID, meddelandetext och meddelandetextmarkeringstyp. Uppmärkningstypen kan vara Markdown eller HTML och ställs in av argumentet parse_mode.

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

Grunderna i Markdown-formatering:

  • Fet teckensnitt är markerat med *:
    • exempel: *жирный шритф*
    • resultat: fetstil
  • Kursiv stil indikeras med understreck:
    • exempel: _курсив_
    • resultat: kursiv
  • Monospace-teckensnittet, som vanligtvis används för att markera programkod, anges med apostrof - `:
    • exempel: "monospace font".
    • resultat: моноширинный шрифт

Grunderna för att formatera HTML-uppmärkning:
I HTML slår du in den del av texten som ska markeras i taggar, till exempel <тег>текст</тег>.

  • <tag> - öppningstagg
  • - stängningsbricka

HTML-markeringstaggar

  • <b> - fetstil
    • exempel: <b>жирный шрифт</b>
    • resultat fetstil
  • <i> - kursiv
    • exempel: <i>курсив</i>
    • resultat: kursiv
  • — моноширинный шрифт
    • exempel: моноширинный шрифт
    • resultat: моноширинный шрифт

Förutom text kan du skicka annat innehåll med hjälp av speciella metoder:

# Отправить изображение
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"
)

De där. till exempel med metoden sendPhoto() du kan skicka en graf sparad som en bild som du skapat med paketet ggplot2.

Kontrollera Windows Task Scheduler och skicka meddelanden om uppgifter som har avslutats på ett onormalt sätt

För att arbeta med Windows Task Scheduler måste du installera paketet taskscheduleR, och för att underlätta arbetet med data, installera paketet dplyr.

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

Därefter använder du funktionen taskscheduler_ls() vi begär information om uppgifter från vår schemaläggare. Använder funktionen filter() från paketet dplyr Vi tar bort från listan över uppgifter de som har slutförts framgångsrikt och har en sista resultatstatus på 0, och de som aldrig har lanserats och har statusen 267011, inaktiverade uppgifter och uppgifter som körs för närvarande. 

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

I objektet task Vi har nu en lista över uppgifter som misslyckades, vi måste skicka den här listan till Telegram.

Om vi ​​tittar på varje kommando mer detaljerat, då:

  • filter() — filtrerar listan med uppgifter enligt villkoren som beskrivs ovan
  • select() — lämnar bara ett fält i tabellen med namnet på uppgifterna
  • unique() - tar bort dubbletter av namn
  • unlist() — konverterar den valda tabellkolumnen till en vektor
  • paste0() — kopplar samman namnen på uppgifter till en rad, och sätter en radmatning som avgränsare, dvs. n.

Allt som återstår för oss är att skicka detta resultat via telegram.

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

Så för tillfället ser botkoden ut så här:

Uppgift granskning bot-kod

# Подключение пакета
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"
  )

}

När du använder exemplet ovan, ersätt din bottoken och ditt chatt-ID med koden.

Du kan lägga till villkor för att filtrera uppgifter, till exempel kontrollera endast de uppgifter som du har skapat, exklusive systemuppgifter.

Du kan också lägga in olika inställningar i en separat konfigurationsfil och lagra chatt-id och token i den. Du kan till exempel läsa konfigurationen med paketet configr.

Exempel ini config

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

Ett exempel på att läsa variabler från en konfiguration i R

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

Ställa in ett schema för att köra uppgiftssökningar

Processen för att sätta upp lanseringen av skript enligt ett schema beskrivs mer i detalj i detta artikeln. Här kommer jag bara att beskriva de steg som måste följas för detta. Om något av stegen inte är tydligt för dig, se artikeln som jag gav en länk till.

Låt oss anta att vi sparat vår botkod till en fil check_bot.R. För att schemalägga den här filen att köras regelbundet, följ dessa steg:

  1. Skriv sökvägen till mappen där R är installerad i Path systemvariabeln; i Windows kommer sökvägen att vara ungefär så här: C:Program FilesRR-4.0.2bin.
  2. Skapa en körbar bat-fil med bara en rad R CMD BATCH C:rscriptscheck_botcheck_bot.R. Byta ut C:rscriptscheck_botcheck_bot.R till den fullständiga sökvägen till din R-fil.
  3. Använd sedan Windows Task Scheduler för att ställa in ett startschema, till exempel varje halvtimme.

Slutsats

I den här artikeln kom vi på hur man skapar en bot och använder den för att skicka olika meddelanden i telegram.

Jag beskrev uppgiften att övervaka Windows Task Scheduler, men du kan använda materialet i den här artikeln för att skicka alla meddelanden, från väderprognosen till aktiekurser på börsen, eftersom R låter dig ansluta till ett stort antal datakällor.

I nästa artikel kommer vi att ta reda på hur man lägger till kommandon och ett tangentbord till boten så att den inte bara kan skicka meddelanden utan också utföra mer komplexa åtgärder.

Källa: will.com

Lägg en kommentar