ProHoster > Blogg > Administration > Skriver en telegram-bot i R (del 1): Skapar en bot och skickar med dess hjälp meddelanden till telegram.

Skriver en telegram-bot i R (del 1): Skapar en bot och skickar med dess hjälp meddelanden till telegram.

Telegram-publiken växer varje dag med geometrisk progression, vilket beror på bekvämligheten hos meddelandetjänsten, tillgången till kanaler, chattar och självklart möjligheten att skapa bots.

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

I princip kan du via en bot använda Telegram för att utföra alla typer av operationer: skicka eller begära data, starta uppgifter på servern, samla information i en databas, skicka e-post och så vidare.

Jag planerar att skriva en serie artiklar om hur man arbetar med telegram bot API, och skriver bots för sina egna behov.

Skriver en telegram-bot i R (del 1): Skapar en bot och skickar med dess hjälp meddelanden till telegram.

I denna första artikel ska vi gå igenom hur man skapar en Telegram-bot och skickar notifieringar via den.

Som resultat får vi en bot som kommer att kontrollera statusen för den senaste körningen av alla uppgifter i Windows Task Scheduler och skicka notifieringar till dig om några har avslutats med fel.

Men syftet med denna serie artiklar är inte bara att lära er att skriva en bot för ett specifikt, smalt syfte, utan att ge en allmän introduktion till syntaxen för paketet telegram.bot, och exempel på kod som ni kan använda för att skriva bots för att lösa egna uppgifter.

Innehåll

Om du är intresserad av dataanalys kan du vara intresserad av mina telegram och YouTube kanaler. Största delen av innehållet handlar om R-språket.

  1. Skapa en Telegram-bot
  2. Installera paketet för att arbeta med Telegram-boten i R
  3. Skicka meddelanden från R till Telegram
  4. Inställning av schemaläggning för att kontrollera uppgifter
  5. Slutsats

Skapa en Telegram-bot

För att börja måste vi skapa en bot. Detta görs med hjälp av en särskild bot BotFather, gå till länken och skriv till boten /start.

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

Meddelande från BotFather

Jag kan hjälpa dig att skapa och hantera Telegram-botar. Om du är ny på Bot API, vänligen se manualen (https://core.telegram.org/bots).

Du kan styra mig genom att skicka dessa kommandon:

/newbot - skapa en ny bot
/mybots - redigera dina bots [beta]

Redigera bots
/setname - ändra botens namn
/setdescription - ändra botbeskrivning
/setabouttext - ändra information om boten
/setuserpic - ändra botens profilbild
/setcommands - ändra kommandolistan
/deletebot - ta bort en bot

Botinställningar
/token - generera auktoriseringstoken
/revoke - återkalla botens åtkomsttoken
/setinline - växla inline-läge (https://core.telegram.org/bots/inline)
/setinlinegeo - växla inline-lägesförfrågningar (https://core.telegram.org/bots/inline#location-based-results)
/setinlinefeedback - ändra inline feedback (https://core.telegram.org/bots/inline#collecting-feedback) inställningar
/setjoingroups - kan din bot läggas till i grupper?
/setprivacy - växla sekretessläge (https://core.telegram.org/bots#privacy-mode) i grupper

Spel
/mygames - redigera dina spel (https://core.telegram.org/bots/games) [beta]
/newgame - skapa ett nytt spel (https://core.telegram.org/bots/games)
/listgames - få en lista över dina spel
/editgame - redigera ett spel
/deletegame - ta bort ett befintligt spel

För att skapa en ny bot skickar vi kommandot /newbot.

BotFather kommer be dig att ange botens namn och användarnamn.

BotFather, [25.07.20 09:39]
Okej, en ny bot. Vad ska vi kalla den? Vänligen välj ett namn för din bot.

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

BotFather, [25.07.20 09:40]
Bra. Låt oss nu välja ett användarnamn för din bot. Det måste sluta med `bot`. Som detta, exempelvis: TetrisBot eller tetris_bot.

Alexey Seleznev, [25.07.20 09:40]
@my_test_bot

Du kan ange ett valfritt namn, men användarnamnet måste sluta med bot.

Om du har gjort allt rätt får du följande meddelande:

Klart! Grattis till din nya bot. Du hittar den på t.me/my_test_bot. Du kan nu lägga till en beskrivning, en om-sektion och en profilbild för din bot, se /help för en lista över kommandon. Förresten, när du har slutfört skapandet av din coola bot, kontakta vår Bot Support om du vill ha ett bättre användarnamn för den. Se bara till att boten är helt fungerande innan du gör detta.

Använd denna token för att komma åt HTTP API:
123456789:abcdefghijklmnopqrstuvwxyz

För en beskrivning av Bot API, se denna sida: https://core.telegram.org/bots/api

Du kommer sedan att behöva den erhållna API-token, i mitt exempel är den 123456789:abcdefghijklmnopqrstuvwxyz.

I det här steget är förberedelsearbetet för att skapa boten klart.

Installera paketet för att arbeta med Telegram-boten i R

Jag förutsätter att du redan har installerat R-språket och utvecklingsmiljön RStudio. Om inte kan du titta på denna videolektion om hur du 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 det paket vi behöver, använd kommandot install.packages("telegram.bot").

För mer information om installation av olika paket kan du se denna video.

Efter installationen behöver paketet kopplas in:

library(telegram.bot)

Skicka meddelanden från R till Telegram

Den bot som du har skapat kan hittas på Telegram med det användarnamn som angavs vid skapandet, i mitt fall är 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)

# Skapa en instans av boten
bot <- Bot(token = "123456789:abcdefghijklmnopqrstuvwxyz")

# Begära information om boten
print(bot$getMe())

# Hämta botens uppdateringar, dvs. listan över meddelanden som skickats till den
updates <- bot$getUpdates()

# Begära chatt-id
# Obs: innan du begär uppdateringar måste du skicka ett meddelande till boten
chat_id <- updates[[1L]]$from_chat_id()

Till att börja med skapar vi en instans av vår bot med funktionen Bot(), där du behöver ange den token du fick tidigare som argument.

Att lagra token i koden anses inte vara bästa metoden, så du kan lagra den i en miljövariabel och hämta den därifrån. Som standard stöder paketet telegram.bot miljövariabler med följande namn: R_TELEGRAM_BOT_DITT_BOT_NAVN. Istället för DITT_BOT_NAVN använd namnet som du angav vid skapandet, i mitt fall blir variabeln R_TELEGRAM_BOT_My Test Bot.

Du kan skapa en miljövariabel på flera sätt, jag ska berätta om den mest universella och plattformoberoende metoden. Skapa en textfil med namnet i din hemkatalog (du kan ta reda på den med kommandot path.expand("~")) med namnet .Renviron. Du kan också göra detta med kommandot file.edit(path.expand(file.path("~", ".Renviron"))).

Och lägg till följande rad i den.

R_TELEGRAM_BOT_DITT_BOT_NAVN=123456789:abcdefghijklmnopqrstuvwxyz

Därefter kan du använda den sparade token från miljövariabeln med hjälp av funktionen bot_token(), dvs. så här:

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

Metod getUpdates()tillåter oss att hämta botens uppdateringar, dvs. meddelanden som har skickats till den. Metoden from_chat_id(), låter oss få chatt-id från vilken meddelandet skickades. Detta id behövs för att skicka meddelanden från boten.

Förutom chatt-id får du också viss annan nyttig information från objektet som du fått från metoden getUpdates() Där får du också lite annan nyttig 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å, vid detta stadium har vi redan allt som behövs för att skicka ett meddelande från boten i Telegram. Låt oss använda metoden sendMessage(), som måste innehålla chat-ID, meddelandetext och typ av meddelandeformatering. Typen av formatering kan vara Markdown eller HTML och ställs in med ett argument parse_mode.

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

Grunderna för Markdown-formatering:

  • Fet stil markeras med ett *:
    • exempel: *fet stil*
    • resultat: fet stil
  • Kursiv stil anges med understreck:
    • exempel: _kursiv_
    • resultat: kursiv
  • Monospace, som vanligtvis används för att markera programkod, anges med backticks `:
    • exempel: `monospace`
    • resultat: monospace

Grunderna för HTML-formatering:
I HTML omger du den del av texten som ska markeras med taggar, exempel text.

  • — öppnande tagg
  • — stängande tagg

HTML-formateringstaggar

  • <b> — fet stil
    • exempel: <b>fetstil</b>
    • resultatet fetstil
  • — kursiv
    • exempel: kursiv
    • resultat: kursiv
  • — monospace
    • exempel: monospace
    • resultat: monospace

Förutom text kan du också 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"
)

Det vill säga till exempel med metoden sendPhoto() kan du skicka en graf som sparats som en bild, som du har skapat med paketet ggplot2.

Kontrollera Windows schemaläggare och skicka ett meddelande om uppgifter vars arbete har avbrutits

För att arbeta med Windows schemaläggare 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)

Sedan med funktionen taskscheduler_ls() begär vi information om uppgifter från vår schemaläggare. Med funktionen filter() från paketet dplyr tar vi bort de uppgifter som har slutförts framgångsrikt och har slutstatus 0, samt de som aldrig har körts och har status 267011, avstängda uppgifter, och uppgifter som för närvarande körs.

# запрашиваем список задач
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 har vi nu en lista med uppgifter vars arbete har misslyckats, denna lista måste vi skicka till Telegram.

Om vi ser närmare på varje kommando så:

  • filter() — filtrerar listan över uppgifter enligt ovan beskrivna kriterier
  • select() — behåller endast ett fält med uppgiftsnamnen i tabellen
  • unique() — tar bort dubbletter av namnen
  • unlist() — konverterar den valda kolumnen i tabellen till en vektor
  • paste0() — sammanfogar uppgiftsnamnen till en sträng och sätter som separator ett radbyte, det vill säga. n.

Det enda som återstår är att skicka detta resultat till Telegram.

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

Så, för tillfället ser båtens kod ut så här:

Koden för båt som kontrollerar uppgifter

# Подключение пакета
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, se till att sätta in din bots token och ditt chatt-ID i koden.

Du kan lägga till filtreringsvillkor för uppgifter, till exempel genom att bara kontrollera de uppgifter som skapats av dig, exklusive systemuppgifter.

Du kan också flytta olika inställningar till en separat konfigurationsfil och lagra ditt chatt-ID och token i den. Du kan läsa konfigurationsfilen med hjälp av paketet configr.

Exempel på ini-konfiguration

[telegram_bot]
;inställningar för telegram-boten och chatten som ska ta emot meddelanden
chat_id=12345678
bot_token=123456789:abcdefghijklmnopqrstuvwxyz"

Exempel på hur man läser variabler från konfigurationen i R

library(configr)

# läser konfigurationen
config <- read.config('C:/sökväg_till_konfiguration/config.cfg', rcmd.parse = TRUE)

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

Inställning av schemat för att kontrollera uppgifter

Processen för att schemalägga körning av skript beskrivs mer detaljerat i denna artikeln. Här kommer jag bara att beskriva de steg som måste utföras för detta. Om något av stegen är oklart för dig, gå till artikeln som jag har angivit som referens.

Anta att vi har sparat vår bots kod i fil check_bot.R. För att schemalägga en regelbunden körning av denna fil, följ dessa steg:

  1. Skriv in sökvägen till mappen där R är installerat i systemvariabeln Path, på Windows ser sökvägen ungefär ut så här: C:Program FilesRR-4.0.2bin.
  2. Skapa en körbar bat-fil som endast innehåller en rad R CMD BATCH C:rscriptscheck_botcheck_bot.R. Byt ut C:rscriptscheck_botcheck_bot.R mot den fullständiga sökvägen till din R-fil.
  3. Konfigurera sedan med hjälp av Windows uppgiftsschemaläggare schemat för körning, till exempel var tredje halvtimme.

Slutsats

I denna artikel har vi gått igenom hur man skapar en bot och skickar olika meddelanden till telegram med hjälp av den.

Jag har beskrivit uppgiften att kontrollera Windows uppgiftsschemaläggare, men du kan använda materialet i denna artikel för att skicka vilken typ av meddelanden som helst, från väderprognoser till aktiekurser på börsen, eftersom R tillåter dig att ansluta till en stor mängd datakällor.

I nästa artikel kommer vi att gå igenom hur man lägger till kommandon och tangentbord till botten, så att den inte bara kan skicka meddelanden utan också utföra mer komplexa åtgärder.

Källa: habr.com

Köp pålitlig webbhotell med DDoS-skydd, VPS VDS-servrar 🔥 Köp pålitlig webbhotell med DDoS-skydd, VPS VDS-servrar | ProHoster