Bot télégramme en Python. Un guide complet pour écrire un bot avec des taux de change à partir de zéro

Les robots de Telegram sont des programmes qui aident à établir un contact avec le public ou à simplifier des actions qui devaient auparavant être effectuées manuellement. Ces programmes sont écrits spécifiquement pour la plate-forme de messagerie. Les robots fonctionnent de cette manière : l'utilisateur envoie une commande via la ligne d'entrée et le système répond par un texte ou un message interactif. Parfois, le programme imite même les actions d'une personne réelle - un tel bot inspire plus de confiance parmi les clients.

Il existe plusieurs types de systèmes d'assistance automatique aux utilisateurs. Certains bots communiquent simplement avec les clients, d'autres fournissent régulièrement des informations. Il est impossible de diviser clairement les programmes en types - les développeurs combinent souvent plusieurs fonctions dans un seul bot.

Vous pouvez écrire un bot simple pour Telegram avec des éléments interactifs sous la forme de boutons à l'écran en 9 étapes. Examinons chacun d'eux en détail et répondons à quelques questions :

• comment démarrer un bot ;
• comment enregistrer un clavier intégré à partir d'un ou plusieurs boutons ;
• comment programmer les boutons pour les fonctions souhaitées ;
• qu'est-ce que le mode en ligne et comment le configurer pour un bot existant.

Étape 0 : arrière-plan théorique sur l'API des bots Telegram

L'outil principal utilisé pour créer des bots Telegram est l'interface de programmation d'application HTML, ou API HTML. Cet élément accepte les demandes des visiteurs et envoie des réponses sous forme d'informations. Les conceptions prêtes à l'emploi simplifient le travail sur le programme. Pour écrire un bot pour Telegram, vous devez utiliser cette adresse e-mail : https://api.telegram.org/bot/METHOD_NAME

Pour le bon fonctionnement du bot, un jeton est également nécessaire - une combinaison de caractères qui protège le programme et en ouvre l'accès aux développeurs de confiance. Chaque jeton est unique. La chaîne est attribuée au bot lors de sa création. Les méthodes peuvent être différentes : getUpdates, getChat et autres. Le choix de la méthode dépend de l'algorithme que les développeurs attendent du bot. Exemple de jeton :

123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11

Les bots utilisent les requêtes GET et POST. Les paramètres de méthode doivent souvent être complétés - par exemple, lorsque la méthode sendMessage est censée envoyer l'identifiant de chat et du texte. Les paramètres de raffinement de la méthode peuvent être transmis sous forme de chaîne de requête d'URL à l'aide de application/x-www-form-urlencoded ou via application-json. Ces méthodes ne conviennent pas au téléchargement de fichiers. L'encodage UTF-8 est également requis. En envoyant une requête à l'API, vous pouvez obtenir le résultat au format JSON. Jetez un œil à la réponse du programme à la récupération d'informations via la méthode getME :

OBTENIR https://api.telegram.org/bot/getMe{ ok : true, result : { id : 231757398, first_name : "Exchange Rate Bot", username : "exchangetestbot" } }

Le résultat sera obtenu si ok équivaut à oui. Sinon, le système indiquera une erreur.

Il existe deux façons d'obtenir des messages personnalisés dans les bots. Les deux méthodes sont efficaces, mais conviennent dans des cas différents. Pour obtenir des messages, vous pouvez écrire manuellement une demande avec la méthode getUpdates - le programme affichera le tableau de données de mise à jour à l'écran. Les requêtes doivent être envoyées régulièrement, après analyse de chaque tableau, l'envoi est répété. Le décalage est un paramètre qui détermine le nombre d'enregistrements sautés avant de charger un nouveau résultat pour éviter la réapparition d'objets cochés. Les avantages de la méthode getUpdates entreront en jeu si :

• il n'y a aucun moyen de configurer HTTPS ;
• des langages de script complexes sont utilisés ;
• le serveur bot change de temps en temps ;
• le bot est chargé d'utilisateurs.

La deuxième méthode qui peut être écrite pour recevoir des messages utilisateur est setWebhook. Il est utilisé une seule fois, pas besoin d'envoyer constamment de nouvelles demandes. Le webhook envoie des mises à jour de données à l'URL spécifiée. Cette méthode nécessite un certificat SSL. Webhook sera utile dans ces cas :

• des langages de programmation Web sont utilisés ;
• le bot n'est pas surchargé, il n'y a pas trop d'utilisateurs ;
• le serveur ne change pas, le programme reste longtemps sur le même serveur.

Dans d'autres instructions, nous utiliserons getUpdates.

Le service @BotFather Telegram est conçu pour créer des robots de discussion. Les paramètres de base sont également définis via ce système - BotFather vous aidera à faire une description, à mettre une photo de profil, à ajouter des outils de support. Des bibliothèques – ensembles de requêtes HTML pour les bots Telegram – sont disponibles sur Internet, elles sont assez nombreuses. Lors de la création du programme d'exemple, pyTelegramBotApi a été utilisé.

Étape 1 : Mise en œuvre des demandes de taux de change

Vous devez d'abord écrire le code qui effectue les requêtes. Nous utiliserons lors de l'écriture de l'API PrivatBank, ci-dessous un lien vers celle-ci : https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5. Vous devez utiliser ces méthodes dans votre code :

• load_exchange – trouve les taux de change et affiche les informations codées ;
• get_exchange – affiche des données sur une devise spécifique ;
• get_exchanges - affiche la liste des devises en fonction de l'échantillon.

Par conséquent, le code du fichier pb.py ressemble à ceci :

import re import requests import json URL = 'https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5' def load_exchange() : return json.loads(requests.get(URL).text) def get_exchange(ccy_key ): for exc in load_exchange() : if ccy_key == exc['ccy'] : return exc return False def get_exchanges(ccy_pattern) : result = [] ccy_pattern = re.escape(ccy_pattern) + '.*' for exc in load_exchange() : si re.match(ccy_pattern, exc['ccy'], re.IGNORECASE) n'est pas None : result.append(exc) renvoie le résultat

Le programme peut émettre la réponse suivante aux requêtes spécifiées :

[ { ccy:"USD", base_ccy:"UAH", achat :"25.90000", vente :"26.25000" }, { ccy:"EUR", base_ccy:"UAH", achat :"29.10000", vente:"29.85000 " }, { ccy:"RUR", base_ccy:"UAH", achat :"0.37800", vente :"0.41800" }, { ccy:"BTC", base_ccy:"USD", achat :"11220.0384", vente : "12401.0950" } ]

Étape 2 : Créez un bot Telegram avec @BotFather

Vous pouvez créer un programme pour recevoir des messages et y répondre à l'aide du service @BotFather. Allez sur sa page Telegram et entrez la commande /newbot. Des instructions apparaîtront dans le chat, selon lesquelles vous devez d'abord écrire le nom du bot, puis son adresse. Lorsque le compte du bot est créé, un message de bienvenue contenant un jeton apparaîtra à l'écran. Pour une configuration plus poussée, utilisez ces commandes :

• /setdescription – description ;
• /setabouttext – informations sur le nouveau bot ;
• /setuserpic – photo de profil ;
• /setinline – mode en ligne ;
• /setcommands – description des commandes.

À la dernière étape de configuration, nous décrivons /help et /exchange. Lorsque toutes les étapes sont terminées, il est temps de passer au codage.

Étape 3 : Configurer et lancer le bot

Créons un fichier config.py. Dans celui-ci, vous devez spécifier le code de bot unique et le fuseau horaire dans lequel le programme trouvera des informations.

JETON = '' # remplacer par le jeton de votre botTIMEZONE = 'Europe/Kiev' TIMEZONE_COMMON_NAME = 'Kiev'

Ensuite, nous créons un autre fichier avec l'importation du pb.py précédemment écrit, des bibliothèques et des autres composants nécessaires. Les bibliothèques manquantes sont installées à partir du système de gestion des packages (pip).

import telebotimport configimport pbimport datetimeimport pytzimport jsonimport traceback P_TIMEZONE = pytz.timezone(config.TIMEZONE) TIMEZONE_COMMON_NAME = config.TIMEZONE_COMMON_NAME

Utilisons le contenu de pyTelegramBotApi pour créer un bot. Nous envoyons le jeton reçu en utilisant le code suivant :

bot = telebot.TeleBot(config.TOKEN) bot.polling(none_stop=True)

Le paramètre none_stop garantit que les requêtes sont constamment envoyées. Le fonctionnement du paramètre ne sera pas affecté par les erreurs de méthode.

Étape 4 : écrivez le gestionnaire de commandes /start

Si toutes les étapes précédentes sont effectuées correctement, le bot a commencé à fonctionner. Le programme génère régulièrement des requêtes car il utilise la méthode getUpdates. Avant la ligne avec l'élément none_stop, nous avons besoin d'un morceau de code qui traite la commande /start :

@bot.message_handler(commands=['start']) def start_command(message): bot.send_message( message.chat.id, 'Salutations ! Je peux vous montrer les taux de change.n' + 'Pour obtenir les taux de change, appuyez sur / exchange.n' + 'Pour obtenir de l'aide, appuyez sur /help.' )

RџСўРё commandes=['démarrer'] égal à Vrai start_command est appelé. Le contenu du message y va. Ensuite, vous devez implémenter la fonction d'envoi_message par rapport à un message particulier.

Étape 5 : Créer un gestionnaire de commandes /help

La commande /help peut être implémentée sous forme de bouton. En cliquant dessus, l'utilisateur sera redirigé vers le compte Telegram du développeur. Donnez un nom au bouton, par exemple "Demander au développeur". Définissez le paramètre reply_markup, qui redirige l'utilisateur vers un lien, pour la méthode send_message. Écrivons dans le code le paramètre qui crée le clavier (InlineKeyboardMarkup). Vous n'avez besoin que d'un seul bouton (InlineKeyboardButton).

Le code du gestionnaire de commandes final ressemble à ceci :

@bot.message_handler(commands=['help']) def help_command(message): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.add( telebot.types.InlineKeyboardButton( 'Demander au développeur', url='ваша ссылка на профиль' ) ) bot.send_message( message.chat.id, '1) Pour recevoir une liste des devises disponibles, appuyez sur /exchange.n' + '2) Cliquez sur la devise qui vous intéresse.n' + '3) Vous recevra un message contenant des informations concernant la source et les devises cibles, ' + 'taux d'achat et taux de vente.n' + '4) Cliquez sur "Mettre à jour" pour recevoir les informations actuelles concernant la demande. ' + 'Le bot affichera également la différence entre le taux de change précédent et le taux de change actuel.n' + '5) Le bot prend en charge en ligne. Taper @ dans n'importe quel chat et les premières lettres d'une devise.', reply_markup=keyboard )

Action de code dans le chat Telegram :

Étape 6 : Ajout du gestionnaire de commandes /exchange

Cette étape est nécessaire pour afficher les boutons avec les symboles des devises disponibles dans le chat. Un clavier à l'écran avec des options vous aidera à éviter les erreurs. PrivatBank fournit des informations sur le rouble, le dollar et l'euro. L'option InlineKeyboardButton fonctionne comme ceci :

1. L'utilisateur clique sur le bouton avec la désignation souhaitée.
2. getUpdates reçoit un rappel (CallbackQuery).
3. On sait comment gérer l'appui sur le clavier - les informations sur le bouton enfoncé sont transmises.

/code du gestionnaire d'échange :

@bot.message_handler(commands=['exchange']) def exchange_command(message): clavier = telebot.types.InlineKeyboardMarkup() keyboard.row( telebot.types.InlineKeyboardButton('USD', callback_data='get-USD') ) keyboard.row( telebot.types.InlineKeyboardButton('EUR', callback_data='get-EUR'), telebot.types.InlineKeyboardButton('RUR', callback_data='get-RUR') ) bot.send_message( message.chat .id, 'Cliquez sur la devise de votre choix :', reply_markup=keyboard )

Le résultat du code dans Telegram :

Étape 7 : écriture d'un gestionnaire pour les boutons du clavier intégré

Le package pyTelegramBot Api contient la fonction de décoration @bot.callback_query_handler. Ce composant est conçu pour traduire le rappel en une fonction - l'API déballe et recrée l'appel. Il s'écrit comme ceci :

@bot.callback_query_handler(func=lambda call : True) def iq_callback(query): data = query.data if data.startswith('get-'): get_ex_callback(query)

Écrivons également la méthode get_ex_callback :

def get_ex_callback(query): bot.answer_callback_query(query.id) send_exchange_result(query.message, query.data[4:])

Il existe une autre méthode utile - answer_callback_query. Cela aide à supprimer la charge entre l'appui sur le bouton et l'affichage du résultat à l'écran. Vous pouvez envoyer un message à send_exchange_query en transmettant un code de devise et un message. Écrivons send_exchange_result :

def send_exchange_result(message, ex_code): bot.send_chat_action(message.chat.id, 'typing') ex = pb.get_exchange(ex_code) bot.send_message( message.chat.id, serialize_ex(ex), reply_markup=get_update_keyboard(ex ), parse_mode='HTML' )

Pendant que le chatbot reçoit le résultat de la requête de la banque API, le visiteur voit l'inscription « taper un message ». On dirait qu'une vraie personne répond. Pour afficher un tel indicateur à l'écran, vous devrez ajouter des lignes d'état d'entrée. Ensuite, nous utiliserons get_exchange - avec son aide, le programme recevra la désignation de la devise (roubles, euros ou dollars). send_message utilise des méthodes supplémentaires : serialize_ex convertit la devise dans un autre format et get_update_keyboard configure des touches programmables qui mettent à jour les informations et envoient les données du marché des devises à d'autres chats.

Écrivons le code pour get_update_keyboard. Deux boutons doivent être mentionnés - t et e représentent le type et l'échange. L'élément switch_inline_query pour le bouton Partager est nécessaire pour que l'utilisateur puisse choisir parmi plusieurs chats. Le visiteur pourra choisir à qui envoyer le taux de change actuel du dollar, du rouble ou de l'euro.

def get_update_keyboard(ex): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.row( telebot.types.InlineKeyboardButton( 'Update', callback_data=json.dumps({ 't': 'u', 'e': { ' b' : ex['acheter'], 's' : ex['vente'], 'c' : ex['ccy'] } }).replace(' ', '') ), telebot.types.InlineKeyboardButton ('Partager', switch_inline_query=ex['ccy']) ) retour clavier

Parfois, vous avez besoin de voir combien le taux de change a changé en peu de temps. Écrivons deux méthodes pour le bouton Mettre à jour afin que les utilisateurs puissent voir les cours en comparaison.

La différence entre les taux de change est transmise au sérialiseur via le paramètre diff.

Les méthodes prescrites ne fonctionnent qu'après la mise à jour des données, elles n'affecteront pas le premier affichage du parcours.

def serialize_ex(ex_json, diff=None): result = '' + ex_json['base_ccy'] + ' -> ' + ex_json['ccy'] + ' :nn' + 'Acheter : ' + ex_json['acheter'] si diff : résultat += ' ' + serialize_exchange_diff(diff['acheter_diff']) + 'n' + 'Vendre : ' + ex_json['vente'] + ' ' + serialize_exchange_diff(diff['sale_diff']) + 'n' else: result += 'nSell: ' + ex_json['sale'] + 'n' return result def serialize_exchange_diff(diff): result = '' if diff > 0 : résultat = '(' + str(diff) + ' " src="https://sworg/images/core/emoji/2.3/svg/2197.svg">" src="https://sworg/images /core/emoji/72x72/2197.png">" src="https://sworg/images/core/emoji/72x72/2197.png">)' elif diff < 0 : result = '(' + str( diff)[1:] + ' " src="https://sworg/images/core/emoji/2.3/svg/2198.svg">" src="https://sworg/images/core/emoji/72x72 /2198.png">" src="https://sworg/images/core/emoji/72x72/2198.png">)' renvoie le résultat

Imaginez que le visiteur veuille connaître le taux de change du dollar. Voici ce qui se passe si vous sélectionnez USD dans le message :

Étape 8 : Implémentation du gestionnaire de bouton de mise à jour

Écrivons le code pour gérer les actions avec le bouton Mettre à jour et ajoutons-y la partie iq_callback_method. Lorsque les éléments de programme commencent par le paramètre get, vous devez écrire get_ex_callback. Dans d'autres situations, nous analysons JSON et essayons d'obtenir la clé t.

@bot.callback_query_handler(func=lambda call: True) def iq_callback(query): data = query.data if data.startswith('get-'): get_ex_callback(query) else: try: if json.loads(data)[ 't'] == 'u' : edit_message_callback(query) except ValueError : pass

Si t est égal à u, vous devrez écrire un programme pour la méthode edit_message_callback. Décomposons ce processus étape par étape :

1. Téléchargement d'informations à jour sur l'état du marché des devises (exchange_now = pb.get_exchange(data['c']).

2. Écrire un nouveau message via un sérialiseur avec diff.
3. Ajouter une signature (get_edited_signature).

Si le message initial ne change pas, appelez la méthode edit_message_text.

def edit_message_callback(query): data = json.loads(query.data)['e'] exchange_now = pb.get_exchange(data['c']) text = serialize_ex( exchange_now, get_exchange_diff( get_ex_from_iq_data(data), exchange_now ) ) + 'n' + get_edited_signature() si query.message : bot.edit_message_text( text, query.message.chat.id, query.message.message_id, reply_markup=get_update_keyboard(exchange_now), parse_mode='HTML' ) elif query.inline_message_id : bot.edit_message_text( text, inline_message_id=query.inline_message_id, reply_markup=get_update_keyboard(exchange_now), parse_mode='HTML' )

Écrivons la méthode get_ex_from_iq_data pour analyser JSON :

def get_ex_from_iq_data(exc_json): return { 'buy': exc_json['b'], 'sale': exc_json['s'] }

Vous aurez besoin de quelques méthodes supplémentaires : par exemple, get_exchange_diff, qui lit les anciennes et les nouvelles informations sur le coût des devises et affiche la différence.

def get_exchange_diff(last, now): return { 'sale_diff': float("%.6f" % (float(now['sale']) - float(last['sale']))), 'buy_diff': float ("%.6f" % (float(now['buy']) - float(last['buy']))) }

Le dernier, get_edited_signature, indique l'heure à laquelle le cours a été mis à jour pour la dernière fois.

def get_edited_signature() : renvoie 'Mis à jour ' + str(datetime.datetime.now(P_TIMEZONE).strftime('%H:%M:%S')) + ' (' + TIMEZONE_COMMON_NAME + ')'

En conséquence, le message mis à jour du bot avec un taux de change stable ressemble à ceci :

Lorsque le cours change, les différences entre les valeurs sont affichées dans le message en raison des paramètres prescrits.

Étape 9 : Implémentation du mode intégré

Le mode intégré est nécessaire pour envoyer rapidement des informations du programme à n'importe quel chat - maintenant, vous n'avez plus besoin d'ajouter un bot à la conversation en tant que participant. Lorsqu'un utilisateur de Telegram saisit un nom de bot précédé d'un signe @, les options de conversion doivent apparaître au-dessus de la ligne de saisie. Si vous cliquez sur l'un des éléments, le bot enverra un message à la conversation avec les résultats et les boutons de mise à jour et d'envoi des données. Le nom de l'expéditeur contiendra la légende "via " .

InlineQuery est passé à query_text via la bibliothèque. Le code utilise la fonction answer_line pour récupérer les résultats de la recherche sous forme de tableau de données et l'élément inline_query_id. Nous utilisons get_exchanges pour que le bot trouve plusieurs devises sur demande.

@bot.inline_handler(func=requête lambda : Vrai) def query_text(inline_query): bot.answer_inline_query( inline_query.id, get_iq_articles(pb.get_exchanges(inline_query.query)))

Nous passons un tableau de données à get_iq_articles afin de renvoyer des objets de InlineQueryResultArticle via cette méthode.

def get_iq_articles(exchanges): result = [] for exc in exchanges: result.append( telebot.types.InlineQueryResultArticle( id=exc['ccy'], title=exc['ccy'], input_message_content=telebot.types.InputTextMessageContent ( serialize_ex(exc), parse_mode='HTML' ), reply_markup=get_update_keyboard(exc), description='Convertir ' + exc['base_ccy'] + ' -> ' + exc['ccy'], thumb_height=1 ) ) résultat de retour

Maintenant, si vous écrivez @ et un espace dans la ligne, les résultats de la recherche apparaîtront à l'écran - options de conversion dans les trois devises disponibles.

Les utilisateurs peuvent filtrer les résultats en saisissant la devise souhaitée.

Après avoir cliqué sur la devise souhaitée dans la liste, le chat reçoit le même message que les utilisateurs du bot reçoivent. Vous pouvez également utiliser le bouton Mettre à jour. L'image ci-dessous montre le message mis à jour envoyé via le bot :

Conclusion

Vous savez maintenant comment créer un bot pour Telegram. Vous pouvez ajouter des outils utiles à votre programme : des boutons pour mettre à jour et envoyer le résultat à d'autres utilisateurs de la messagerie et un mode intégré qui vous permet d'utiliser les fonctions du bot en dehors du chat avec lui. Sur la base de cette instruction, vous pouvez créer n'importe quel bot simple avec d'autres fonctions - pas seulement celle qui affichera les taux de change. N'ayez pas peur d'expérimenter avec des bibliothèques, des API et du code pour créer un assistant automatisé qui discutera avec les clients sur Telegram et renforcera la connexion des personnes intéressées avec l'entreprise.