Bot de telegrama em Python. Um guia completo para escrever um bot com taxas de câmbio do zero

Bots no Telegram são programas que ajudam a estabelecer contato com o público ou simplificar ações que antes precisavam ser realizadas manualmente. Esses programas são escritos especificamente para a plataforma de mensagens. Os bots funcionam desta forma: o usuário envia um comando pela linha de entrada e o sistema responde com um texto ou mensagem interativa. Às vezes, o programa até imita as ações de uma pessoa real – esse bot inspira mais confiança entre os clientes.

Existem vários tipos de sistemas para atendimento automático aos usuários. Alguns bots apenas se comunicam com os clientes, outros fornecem informações regularmente. É impossível dividir claramente os programas em tipos – os desenvolvedores geralmente combinam várias funções em um bot.

Você pode escrever um bot simples para o Telegram com elementos interativos na forma de botões na tela em 9 etapas. Vamos analisar cada um deles em detalhes e responder a algumas perguntas:

• como iniciar um bot;
• como registrar um teclado embutido de um ou mais botões;
• como programar os botões para as funções desejadas;
• o que é o modo inline e como configurá-lo para um bot existente.

Etapa 0: embasamento teórico sobre a API de bots do Telegram

A principal ferramenta usada para criar bots do Telegram é a HTML Application Programming Interface, ou HTML API. Este elemento aceita solicitações de visitantes e envia respostas na forma de informação. Projetos prontos simplificam o trabalho no programa. Para escrever um bot para o Telegram, você precisa usar este endereço de e-mail: https://api.telegram.org/bot/METHOD_NAME

Para o correto funcionamento do bot, também é necessário um token – uma combinação de caracteres que protege o programa e abre o acesso a ele para desenvolvedores confiáveis. Cada token é único. A string é atribuída ao bot na criação. Os métodos podem ser diferentes: getUpdates, getChat e outros. A escolha do método depende de qual algoritmo os desenvolvedores esperam do bot. Exemplo de token:

123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11

Os bots usam solicitações GET e POST. Os parâmetros do método geralmente precisam ser complementados – por exemplo, quando o método sendMessage deve enviar o ID do chat e algum texto. Parâmetros para refinamento de método podem ser passados ​​como uma string de consulta de URL usando application/x-www-form-urlencoded ou via application-json. Esses métodos não são adequados para baixar arquivos. A codificação UTF-8 também é necessária. Ao enviar uma solicitação para a API, você pode obter o resultado no formato JSON. Dê uma olhada na resposta do programa para recuperar informações através do método getME:

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

O resultado será obtido se ok é igual a verdadeiro. Caso contrário, o sistema indicará um erro.

Existem duas maneiras de obter mensagens personalizadas em bots. Ambos os métodos são eficazes, mas são adequados em casos diferentes. Para obter mensagens, você pode escrever manualmente uma solicitação com o método getUpdates – o programa exibirá a matriz de dados de atualização na tela. As solicitações devem ser enviadas regularmente, após a análise de cada matriz, o envio é repetido. Offset é um parâmetro que determina o número de registros ignorados antes de carregar um novo resultado para evitar o reaparecimento de objetos marcados. Os benefícios do método getUpdates entrarão em jogo se:

• não há como configurar HTTPS;
• linguagens de script complexas são usadas;
• o servidor do bot muda de tempos em tempos;
• o bot é carregado com usuários.

O segundo método que pode ser escrito para receber mensagens do usuário é setWebhook. Ele é usado uma vez, não há necessidade de enviar constantemente novas solicitações. O webhook envia atualizações de dados para a URL especificada. Este método requer um certificado SSL. O webhook será útil nestes casos:

• linguagens de programação web são usadas;
• o bot não está sobrecarregado, não há muitos usuários;
• o servidor não muda, o programa permanece no mesmo servidor por muito tempo.

Em outras instruções, usaremos getUpdates.

O serviço @BotFather Telegram foi projetado para criar bots de bate-papo. As configurações básicas também são definidas através deste sistema – BotFather irá ajudá-lo a fazer uma descrição, colocar uma foto de perfil, adicionar ferramentas de suporte. Bibliotecas – conjuntos de solicitações HTML para bots do Telegram – estão disponíveis na Internet, existem muitas delas. Ao criar o programa de exemplo, foi usado pyTelegramBotApi.

Etapa 1: implementar solicitações de taxa de câmbio

Primeiro você precisa escrever o código que realiza as consultas. Usaremos ao escrever a API do PrivatBank, abaixo está um link para ela: https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5. Você precisa usar estes métodos em seu código:

• load_exchange – encontra taxas de câmbio e exibe informações codificadas;
• get_exchange – exibe dados sobre uma moeda específica;
• get_exchanges – mostra a listagem de moedas de acordo com a amostra.

Como resultado, o código no arquivo pb.py fica assim:

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 em 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(): se re.match(ccy_pattern, exc['ccy'], re.IGNORECASE) não for None: result.append(exc) return result

O programa pode emitir a seguinte resposta às solicitações especificadas:

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

Etapa 2: crie um bot de telegrama com @BotFather

Você pode criar um programa para receber mensagens e respondê-las usando o serviço @BotFather. Vá para a página do Telegram e digite o comando /newbot. As instruções aparecerão no bate-papo, segundo as quais você precisa escrever primeiro o nome do bot e depois seu endereço. Quando a conta do bot for criada, uma mensagem de boas-vindas contendo um token aparecerá na tela. Para configuração adicional, use estes comandos:

• /setdescrição – descrição;
• /setabouttext – informações sobre o novo bot;
• /setuserpic – foto do perfil;
• /setinline – modo embutido;
• /setcommands – descrição dos comandos.

Na última etapa de configuração, descrevemos /help e /exchange. Quando todas as etapas forem concluídas, é hora de passar para a codificação.

Etapa 3: configurando e iniciando o bot

Vamos criar um arquivo config.py. Nele, você precisa especificar o código do bot exclusivo e o fuso horário em que o programa encontrará informações.

TOKEN = '' # substitua pelo token do seu bot TIMEZONE = 'Europe/Kiev' TIMEZONE_COMMON_NAME = 'Kiev'

Em seguida, criamos outro arquivo com a importação do pb.py previamente escrito, bibliotecas e outros componentes necessários. As bibliotecas ausentes são instaladas a partir do sistema de gerenciamento de pacotes (pip).

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

Vamos usar o conteúdo de pyTelegramBotApi para criar um bot. Enviamos o token recebido usando o seguinte código:

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

O parâmetro none_stop garante que as solicitações sejam enviadas constantemente. A operação do parâmetro não será afetada por erros de método.

Etapa 4: escreva o manipulador de comando /start

Se todas as etapas anteriores forem feitas corretamente, o bot começou a funcionar. O programa gera solicitações regularmente porque usa o método getUpdates. Antes da linha com o elemento none_stop, precisamos de um trecho de código que processe o comando /start:

@bot.message_handler(commands=['start']) def start_command(message): bot.send_message( message.chat.id, 'Saudações! Posso mostrar as taxas de câmbio.n' + 'Para obter as taxas de câmbio, pressione / exchange.n' + 'Para obter ajuda, pressione /help.' )

RџСўРё comandos=['iniciar'] igual a Verdade start_command é chamado. O conteúdo da mensagem vai para lá. Em seguida, você precisa implementar a função de envio_mensagem em relação a uma determinada mensagem.

Etapa 5: criar um manipulador de comando /help

O comando /help pode ser implementado como um botão. Ao clicar nele, o usuário será levado para a conta do desenvolvedor no Telegram. Dê um nome ao botão, como “Pergunte ao desenvolvedor”. Defina o parâmetro reply_markup, que redireciona o usuário para um link, para o método send_message. Vamos escrever no código o parâmetro que cria o teclado (InlineKeyboardMarkup). Você só precisa de um botão (InlineKeyboardButton).

O código do manipulador de comando final se parece com isso:

@bot.message_handler(commands=['help']) def help_command(message): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.add( telebot.types.InlineKeyboardButton( 'Pergunte ao desenvolvedor', url='ваша ссылка на профиль' ) ) bot.send_message( message.chat.id, '1) Para receber uma lista de moedas disponíveis pressione /exchange.n' + '2) Clique na moeda que você está interessado.n' + '3) Você receberá uma mensagem contendo informações sobre as moedas de origem e destino, ' + 'taxas de compra e taxas de venda.n' + '4) Clique em “Atualizar” para receber as informações atuais sobre a solicitação. ' + 'O bot também mostrará a diferença entre as taxas de câmbio anteriores e atuais.n' + '5) O bot suporta inline. Modelo @ em qualquer chat e as primeiras letras de uma moeda.', reply_markup=keyboard )

Ação de código no chat do Telegram:

Etapa 6: Adicionando o manipulador de comando /exchange

Esta etapa é necessária para exibir botões com símbolos de moedas disponíveis no chat. Um teclado na tela com opções ajudará você a evitar erros. PrivatBank fornece informações sobre o rublo, dólar e euro. A opção InlineKeyboardButton funciona assim:

1. O usuário clica no botão com a designação desejada.
2. getUpdates recebe um retorno de chamada (CallbackQuery).
3. Torna-se conhecido como lidar com o pressionamento do teclado – as informações sobre o botão pressionado são transmitidas.

/exchange código do manipulador:

@bot.message_handler(commands=['exchange']) def exchange_command(message): keyboard = 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, 'Clique na moeda escolhida:', reply_markup=keyboard )

O resultado do código no Telegram:

Etapa 7: escrever um manipulador para os botões do teclado integrado

O pacote pyTelegramBot Api contém a função de decorador @bot.callback_query_handler. Este componente foi projetado para traduzir o retorno de chamada em uma função – a API desempacota e recria a chamada. Está escrito assim:

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

Vamos também escrever o método get_ex_callback:

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

Existe outro método útil – answer_callback_query. Ajuda a remover a carga entre pressionar o botão e exibir o resultado na tela. Você pode enviar uma mensagem para send_exchange_query passando algum código de moeda e Message. Vamos escrever 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')

Enquanto o chatbot recebe o resultado da solicitação do banco API, o visitante vê a inscrição “digitando uma mensagem”. Parece que uma pessoa real está respondendo. Para exibir esse indicador na tela, você precisará adicionar linhas de status de entrada. Em seguida, usaremos get_exchange – com sua ajuda, o programa receberá a designação da moeda (rublos, euros ou dólares). send_message usa métodos adicionais: serialize_ex converte a moeda para outro formato e get_update_keyboard configura softkeys que atualizam informações e enviam dados de mercado de moeda para outros chats.

Vamos escrever o código para get_update_keyboard. Dois botões precisam ser mencionados – t e e significam tipo e troca. O item switch_inline_query para o botão Compartilhar é necessário para que o usuário possa escolher entre vários chats. O visitante poderá escolher para quem enviar a taxa de câmbio atual do dólar, rublo ou euro.

def get_update_keyboard(ex): teclado = telebot.types.InlineKeyboardMarkup() keyboard.row( telebot.types.InlineKeyboardButton( 'Update', callback_data=json.dumps({ 't': 'u', 'e': { ' b': ex['comprar'], 's': ex['venda'], 'c': ex['ccy'] } }).replace(' ', '') ), telebot.types.InlineKeyboardButton ('Share', switch_inline_query=ex['ccy']) ) retornar teclado

Às vezes você precisa ver o quanto a taxa de câmbio mudou em um curto espaço de tempo. Vamos escrever dois métodos para o botão Atualizar para que os usuários possam ver os cursos em comparação.

A diferença entre as taxas de câmbio é passada para o serializador através do parâmetro diff.

Os métodos prescritos funcionam somente após a atualização dos dados, eles não afetarão a primeira exibição do curso.

def serialize_ex(ex_json, diff=Nenhum): resultado = '' + ex_json['base_ccy'] + ' -> ' + ex_json['ccy'] + ':nn' + 'Comprar: ' + ex_json['comprar'] if diff: resultado += ' ' + serialize_exchange_diff(diff['comprar_diff']) + 'n' + 'Vender: ' + ex_json['venda'] + ' ' + 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: resultado = '(' + 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: resultado = '(' + 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">)' retorna o resultado

Imagine que o visitante quisesse saber a cotação do dólar. Veja o que acontece se você selecionar USD na mensagem:

Etapa 8: implementando o manipulador de botão de atualização

Vamos escrever o código para manipular ações com o botão Update e adicionar a parte iq_callback_method a ele. Quando os itens do programa começam com o parâmetro get, você deve escrever get_ex_callback. Em outras situações, analisamos JSON e tentamos obter a chave 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) exceto ValueError: pass

Se t for igual a u, você precisará escrever um programa para o método edit_message_callback. Vamos detalhar esse processo passo a passo:

1. Baixando informações atualizadas sobre o estado do mercado de câmbio (exchange_now = pb.get_exchange(data['c']).

2. Escrevendo uma nova mensagem através de um serializador com diff.
3. Adicionando uma assinatura (get_edited_signature).

Se a mensagem inicial não mudar, chame o método 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() if 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' )

Vamos escrever o método get_ex_from_iq_data para analisar JSON:

def get_ex_from_iq_data(exc_json): return { 'comprar': exc_json['b'], 'venda': exc_json['s'] }

Você precisará de mais alguns métodos: por exemplo, get_exchange_diff, que lê as informações antigas e novas sobre o custo das moedas e exibe a diferença.

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']))) }

O último, get_edited_signature, mostra a hora em que o curso foi atualizado pela última vez.

def get_edited_signature(): return 'Atualizado ' + str(datetime.datetime.now(P_TIMEZONE).strftime('%H:%M:%S')) + ' (' + TIMEZONE_COMMON_NAME + ')'

Como resultado, a mensagem atualizada do bot com uma taxa de câmbio estável fica assim:

Quando o curso muda, as diferenças entre os valores são exibidas na mensagem devido aos parâmetros prescritos.

Etapa 9: implementação do modo incorporado

O modo integrado é necessário para enviar rapidamente informações do programa para qualquer bate-papo – agora você não precisa adicionar um bot à conversa como participante. Quando um usuário do Telegram insere um nome de bot com um sinal @ na frente dele, as opções de conversão devem aparecer acima da linha de entrada. Se você clicar em um dos itens, o bot enviará uma mensagem para a conversa com os resultados e botões para atualização e envio de dados. O nome do remetente conterá a legenda “via ".

InlineQuery é passado para query_text por meio da biblioteca. O código usa a função answer_line para recuperar os resultados da pesquisa como uma matriz de dados e o elemento inline_query_id. Usamos get_exchanges para que o bot encontre várias moedas mediante solicitação.

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

Passamos uma matriz de dados para get_iq_articles para retornar objetos de InlineQueryResultArticle por meio desse método.

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='Convert ' + exc['base_ccy'] + ' -> ' + exc['ccy'], thumb_height=1 ) ) retornar resultado

Agora, se você escrever @ e um espaço na linha, os resultados da busca aparecerão na tela – opções para conversão em três moedas disponíveis.

Os usuários podem filtrar os resultados inserindo a moeda desejada.

Após clicar na moeda desejada da lista, o chat recebe a mesma mensagem que os usuários do bot recebem. Você também pode usar o botão Atualizar. A imagem abaixo mostra a mensagem atualizada enviada pelo bot:

Conclusão

Agora você sabe como criar um bot para o Telegram. Você pode adicionar ferramentas úteis ao seu programa: botões para atualizar e enviar o resultado para outros usuários do messenger e um modo embutido que permite usar as funções do bot fora do chat com ele. Com base nesta instrução, você pode criar qualquer bot simples com outras funções – não apenas aquele que mostrará as taxas de câmbio. Não tenha medo de experimentar bibliotecas, APIs e códigos para criar um assistente automatizado que conversará com os clientes no Telegram e fortalecerá a conexão das pessoas interessadas com a empresa.