ProHoster > Blog > administration > Écrire un bot de télégramme dans R (partie 1) : Créer un bot et l'utiliser pour envoyer des messages dans un télégramme

Écrire un bot de télégramme dans R (partie 1) : Créer un bot et l'utiliser pour envoyer des messages dans un télégramme

L'audience de Telegram augmente de façon exponentielle chaque jour, ceci est facilité par la commodité du messager, la présence de chaînes, de chats et bien sûr la possibilité de créer des robots.

Les robots peuvent être utilisés à des fins complètement différentes, de l'automatisation des communications avec vos clients à la gestion de vos propres tâches.

Essentiellement, vous pouvez utiliser Telegram pour effectuer n'importe quelle opération via un bot : envoyer ou demander des données, exécuter des tâches sur le serveur, collecter des informations dans une base de données, envoyer des e-mails, etc.

J'ai l'intention d'écrire une série d'articles sur la façon de travailler avec API de robot de télégramme, et écrivez des robots adaptés à vos besoins.

Écrire un bot de télégramme dans R (partie 1) : Créer un bot et l'utiliser pour envoyer des messages dans un télégramme

Dans ce premier article, nous verrons comment créer un robot télégramme et l'utiliser pour envoyer des notifications par télégramme.

En conséquence, nous aurons un robot qui vérifiera l'état de la dernière exécution de toutes les tâches dans le Planificateur de tâches Windows et vous enverra des notifications en cas d'échec de l'une d'entre elles.

Mais le but de cette série d'articles n'est pas de vous apprendre à écrire un bot pour une tâche spécifique et étroite, mais de vous présenter de manière générale la syntaxe du package. telegram.botet des exemples de code avec lesquels vous pouvez écrire des robots pour résoudre vos propres problèmes.

Teneur

Si vous êtes intéressé par l'analyse des données, vous pourriez être intéressé par mon télégramme и Youtube canaux. La plupart du contenu est dédié au langage R.

  1. Créer un robot de télégramme
  2. Installation d'un package pour travailler avec un robot télégramme dans R
  3. Envoi de messages de R vers Telegram
  4. Configuration d'un calendrier pour l'exécution d'analyses de tâches
  5. Conclusion

Créer un robot de télégramme

Tout d’abord, nous devons créer un bot. Cela se fait à l'aide d'un bot spécial BotFather, aller à lien et écris au bot /start.

Après quoi vous recevrez un message avec une liste de commandes :

Message de 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

Pour créer un nouveau bot, envoyez la commande /newbot.

BotFather vous demandera de saisir le nom et la connexion du bot.

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

Vous pouvez saisir n'importe quel nom, mais la connexion doit se terminer par bot.

Si vous avez tout fait correctement, vous recevrez le message suivant :

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

Ensuite, vous aurez besoin du jeton API reçu, dans mon exemple c'est 123456789:abcdefghijklmnopqrstuvwxyz.

A cette étape, les travaux préparatoires à la création du bot sont terminés.

Installation d'un package pour travailler avec un robot télégramme dans R

Je suppose que vous avez déjà installé le langage R et l'environnement de développement RStudio. Si ce n'est pas le cas, vous pouvez consulter ceci didacticiel vidéo sur la façon de les installer.

Pour travailler avec l'API Telegram Bot, nous utiliserons le package R télégramme.bot.

L'installation des packages dans R se fait à l'aide de la fonction install.packages(), donc pour installer le package dont nous avons besoin, utilisez la commande install.packages("telegram.bot").

Vous pouvez en savoir plus sur l'installation de divers packages à partir de cette vidéo.

Après avoir installé le package, vous devez le connecter :

library(telegram.bot)

Envoi de messages de R vers Telegram

Le bot que vous avez créé peut être trouvé dans Telegram en utilisant le login spécifié lors de la création, dans mon cas c'est @my_test_bot.

Envoyez au robot n'importe quel message, tel que « Hey bot ». Pour le moment, nous en avons besoin pour obtenir l'identifiant de votre conversation avec le bot.

Maintenant, nous écrivons le code suivant dans R.

library(telegram.bot)

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

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

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

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

Dans un premier temps, nous créons une instance de notre bot avec la fonction Bot(), le jeton précédemment reçu doit y être passé en argument.

Il n'est pas considéré comme une bonne pratique de stocker le jeton dans le code, vous pouvez donc le stocker dans une variable d'environnement et le lire à partir de celle-ci. Par défaut dans le package telegram.bot La prise en charge des variables d'environnement portant les noms suivants a été implémentée : R_TELEGRAM_BOT_ИМЯ_ВАШЕГО_БОТА. Au lieu de ИМЯ_ВАШЕГО_БОТА remplacez le nom que vous avez spécifié lors de la création, dans mon cas ce sera une variable R_TELEGRAM_BOT_My Test Bot.

Il existe plusieurs façons de créer une variable d'environnement ; je vais vous parler de la plus universelle et multiplateforme. Créez dans votre répertoire personnel (vous pouvez le trouver en utilisant la commande path.expand("~")) fichier texte portant le nom .Renviron. Vous pouvez également le faire en utilisant la commande file.edit(path.expand(file.path("~", ".Renviron"))).

Et ajoutez-y la ligne suivante.

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

Ensuite, vous pouvez utiliser le jeton enregistré dans la variable d'environnement à l'aide de la fonction bot_token(), c'est à dire. comme ça: 

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

méthode getUpdates()nous permet d'obtenir des mises à jour du bot, c'est-à-dire messages qui lui ont été envoyés. Méthode from_chat_id(), permet d'obtenir l'ID du chat à partir duquel le message a été envoyé. Nous avons besoin de cet identifiant pour envoyer des messages depuis le bot.

En plus de l'identifiant de chat de l'objet obtenu par la méthode getUpdates() vous recevez également d’autres informations utiles. Par exemple, des informations sur l'utilisateur qui a envoyé le message.

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"

Donc, à ce stade, nous avons déjà tout ce dont nous avons besoin pour envoyer un message d’un bot à Telegram. Utilisons la méthode sendMessage(), dans lequel vous devez transmettre l'ID de discussion, le texte du message et le type de balisage du texte du message. Le type de balisage peut être Markdown ou HTML et est défini par l'argument parse_mode.

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

Bases du formatage Markdown :

  • La police en gras est mise en évidence par * :
    • exemple: *жирный шритф*
    • résultat: caractère gras
  • Les italiques sont indiqués par des traits de soulignement :
    • exemple: _курсив_
    • résultat: italique
  • La police monospace, qui est généralement utilisée pour mettre en évidence le code du programme, est spécifiée à l'aide d'apostrophes - ` :
    • exemple : `police monospace`
    • résultat: моноширинный шрифт

Bases du formatage du balisage HTML :
En HTML, vous enveloppez la partie du texte qui doit être mise en évidence dans des balises, exemple <тег>текст</тег>.

  • <tag> - balise d'ouverture
  • -balise de fermeture

Balises de balisage HTML

  • <b> - caractère gras
    • exemple: <b>жирный шрифт</b>
    • entraîner gras
  • <i> - italique
    • exemple: <i>курсив</i>
    • résultat: italique
  • — моноширинный шрифт
    • exemple : моноширинный шрифт
    • résultat: моноширинный шрифт

En plus du texte, vous pouvez envoyer d'autres contenus en utilisant des méthodes spéciales :

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

Ceux. par exemple en utilisant la méthode sendPhoto() vous pouvez envoyer un graphique enregistré sous forme d'image que vous avez créé à l'aide du package ggplot2.

Vérification du planificateur de tâches Windows et envoi de notifications sur les tâches qui se sont terminées anormalement

Pour travailler avec le Planificateur de tâches Windows, vous devez installer le package taskscheduleR, et pour faciliter le travail avec les données, installez le package dplyr.

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

Ensuite, en utilisant la fonction taskscheduler_ls() nous demandons des informations sur les tâches à notre planificateur. Utilisation de la fonction filter() du paquet dplyr Nous supprimons de la liste des tâches celles qui ont été terminées avec succès et ont un dernier statut de résultat de 0, et celles qui n'ont jamais été lancées et ont un statut de 267011, les tâches désactivées et les tâches en cours d'exécution. 

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

Dans l'objet task Nous avons maintenant une liste de tâches qui ont échoué, nous devons envoyer cette liste à Telegram.

Si nous examinons chaque commande plus en détail, alors :

  • filter() — filtre la liste des tâches selon les conditions décrites ci-dessus
  • select() — ne laisse qu'un seul champ dans le tableau avec le nom des tâches
  • unique() - supprime les noms en double
  • unlist() — convertit la colonne du tableau sélectionnée en vecteur
  • paste0() — connecte les noms des tâches sur une seule ligne et place un saut de ligne comme séparateur, c'est-à-dire n.

Il ne nous reste plus qu'à envoyer ce résultat par télégramme.

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

Ainsi, pour le moment, le code du bot ressemble à ceci :

Code du robot d'examen des tâches

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

}

Lorsque vous utilisez l'exemple ci-dessus, remplacez votre jeton de bot et votre identifiant de chat dans le code.

Vous pouvez ajouter des conditions pour filtrer les tâches, par exemple en vérifiant uniquement les tâches que vous avez créées, à l'exclusion de celles du système.

Vous pouvez également placer divers paramètres dans un fichier de configuration distinct et y stocker l'identifiant de discussion et le jeton. Vous pouvez lire la configuration, par exemple, en utilisant le package configr.

Exemple de configuration ini

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

Un exemple de lecture de variables à partir d'une configuration dans 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

Configuration d'un calendrier pour l'exécution d'analyses de tâches

Le processus de configuration du lancement des scripts selon un calendrier est décrit plus en détail dans ce document. article. Ici, je décrirai uniquement les étapes à suivre pour cela. Si l'une des étapes ne vous semble pas claire, reportez-vous à l'article vers lequel j'ai fourni un lien.

Supposons que nous ayons enregistré notre code de bot dans un fichier check_bot.R. Pour planifier l'exécution régulière de ce fichier, procédez comme suit :

  1. Écrivez le chemin du dossier dans lequel R est installé dans la variable système Path ; sous Windows, le chemin ressemblera à ceci : C:Program FilesRR-4.0.2bin.
  2. Créez un fichier bat exécutable avec une seule ligne R CMD BATCH C:rscriptscheck_botcheck_bot.R. Remplacer C:rscriptscheck_botcheck_bot.R au chemin complet de votre fichier R.
  3. Ensuite, utilisez le Planificateur de tâches Windows pour configurer un calendrier de lancement, par exemple toutes les demi-heures.

Conclusion

Dans cet article, nous avons découvert comment créer un bot et l'utiliser pour envoyer diverses notifications par télégramme.

J'ai décrit la tâche de surveillance du Planificateur de tâches Windows, mais vous pouvez utiliser le matériel de cet article pour envoyer des notifications, des prévisions météorologiques aux cotations boursières, car R vous permet de vous connecter à un grand nombre de sources de données.

Dans le prochain article, nous verrons comment ajouter des commandes et un clavier au bot afin qu'il puisse non seulement envoyer des notifications, mais également effectuer des actions plus complexes.

Source: habr.com

Ajouter un commentaire