Bot de Telegram en Python. Unha guía completa para escribir un bot con tipos de cambio desde cero

Os bots en Telegram son programas que axudan a establecer contacto coa audiencia ou simplifican accións que antes había que realizar manualmente. Estes programas están escritos especificamente para a plataforma de mensaxería. Os bots funcionan deste xeito: o usuario envía un comando a través da liña de entrada e o sistema responde cunha mensaxe de texto ou interactiva. Ás veces, o programa incluso imita as accións dunha persoa real: un bot así inspira máis confianza entre os clientes.

Existen varios tipos de sistemas de asistencia automática aos usuarios. Algúns bots só se comunican cos clientes, outros proporcionan información regularmente. É imposible dividir claramente os programas en tipos: os desenvolvedores adoitan combinar varias funcións nun bot.

Podes escribir un bot sinxelo para Telegram con elementos interactivos en forma de botóns en pantalla en 9 pasos. Vexamos cada un deles en detalle e respondamos a algunhas preguntas:

• como iniciar un bot;
• como rexistrar un teclado incorporado desde un ou máis botóns;
• como programar os botóns para as funcións desexadas;
• que é o modo en liña e como configuralo para un bot existente.

Paso 0: antecedentes teóricos sobre a API de robots de Telegram

A principal ferramenta utilizada para crear bots de Telegram é a Interface de Programación de Aplicacións HTML ou API HTML. Este elemento acepta solicitudes de visitantes e envía respostas en forma de información. Os deseños preparados simplifican o traballo no programa. Para escribir un bot para Telegram, debes usar este enderezo de correo electrónico: https://api.telegram.org/bot/METHOD_NAME

Para o correcto funcionamento do bot, tamén se necesita un token: unha combinación de caracteres que protexa o programa e abra o acceso a este aos desenvolvedores de confianza. Cada ficha é única. A cadea asígnase ao bot ao crearse. Os métodos poden ser diferentes: getUpdates, getChat e outros. A elección do método depende do algoritmo que os desenvolvedores esperan do bot. Exemplo de ficha:

123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11

Os bots usan solicitudes GET e POST. Os parámetros do método adoitan ser complementados, por exemplo, cando se supón que o método sendMessage envía a identificación do chat e algún texto. Os parámetros para o refinamento do método pódense pasar como cadea de consulta de URL mediante application/x-www-form-urlencoded ou mediante application-json. Estes métodos non son axeitados para descargar ficheiros. Tamén é necesaria a codificación UTF-8. Ao enviar unha solicitude á API, podes obter o resultado en formato JSON. Bótalle un ollo á resposta do programa para recuperar información a través do método getME:

OBTÉN https://api.telegram.org/bot/getMe{ ok: true, resultado: { id: 231757398, first_name: "Bot de taxa de cambio", nome de usuario: "exchangetestbot" } }

O resultado obterase se ok é igual certo. En caso contrario, o sistema indicará un erro.

Hai dúas formas de obter mensaxes personalizadas en bots. Ambos métodos son eficaces, pero son axeitados en diferentes casos. Para recibir mensaxes, pode escribir manualmente unha solicitude co método getUpdates: o programa mostrará na pantalla a matriz de datos de actualización. As solicitudes deben enviarse regularmente, despois de analizar cada matriz, o envío repítese. A compensación é un parámetro que determina o número de rexistros omitidos antes de cargar un novo resultado para evitar a reaparición de obxectos marcados. Os beneficios do método getUpdates entrarán en xogo se:

• non hai forma de configurar HTTPS;
• utilízanse linguaxes de script complexas;
• o servidor do bot cambia de cando en vez;
• o bot está cargado de usuarios.

O segundo método que se pode escribir para recibir mensaxes de usuario é setWebhook. Utilízase unha vez, sen necesidade de enviar novas solicitudes constantemente. O webhook envía actualizacións de datos ao URL especificado. Este método require un certificado SSL. Webhook será útil nestes casos:

• utilízanse linguaxes de programación web;
• o bot non está sobrecargado, non hai demasiados usuarios;
• o servidor non cambia, o programa permanece no mesmo servidor durante moito tempo.

En instrucións posteriores, usaremos getUpdates.

O servizo @BotFather Telegram está deseñado para crear bots de chat. A configuración básica tamén se establece a través deste sistema: BotFather axudarache a facer unha descrición, poñer unha foto de perfil e engadir ferramentas de soporte. As bibliotecas (conxuntos de solicitudes HTML para os robots de Telegram) están dispoñibles en Internet, hai bastantes. Ao crear o programa de exemplo, utilizouse pyTelegramBotApi.

Paso 1: implementación de solicitudes de tipos de cambio

Primeiro cómpre escribir o código que realiza as consultas. Usaremos ao escribir a API de PrivatBank, a continuación hai unha ligazón a ela: https://api.privatbank.ua/p24api/pubinfo?json&exchange&coursid=5. Debes usar estes métodos no teu código:

• load_exchange: atopa tipos de cambio e mostra información codificada;
• get_exchange: mostra datos sobre unha moeda específica;
• get_exchanges: mostra a lista de moedas segundo a mostra.

Como resultado, o código do ficheiro pb.py ten o seguinte aspecto:

importar solicitudes de importación importar URL json = '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 ): para exc en load_exchange(): if ccy_key == exc['ccy']: return exc return Falso def get_exchanges(ccy_pattern): resultado = [] ccy_pattern = re.escape (ccy_pattern) + '.*' para exc en load_exchange(): se re.match(ccy_pattern, exc['ccy'], re.IGNORECASE) non é None: result.append(exc) devolve o resultado

O programa pode emitir a seguinte resposta ás solicitudes especificadas:

[ { ccy:"USD", base_ccy:"UAH", comprar:"25.90000", venda:"26.25000" }, { ccy:"EUR", base_ccy:"UAH", comprar:"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" } ]

Paso 2: crea un Bot de Telegram con @BotFather

Podes crear un programa para recibir mensaxes e responder a elas usando o servizo @BotFather. Vaia á súa páxina de Telegram e introduza o comando /newbot. No chat aparecerán instrucións segundo as cales debes escribir primeiro o nome do bot e despois o seu enderezo. Cando se crea a conta do bot, aparecerá na pantalla unha mensaxe de benvida que contén un token. Para máis configuración, use estes comandos:

• /setdescription – descrición;
• /setabouttext – información sobre o novo bot;
• /setuserpic – foto de perfil;
• /setinline – modo en liña;
• /setcommands: descrición dos comandos.

No último paso de configuración, describimos /help e /exchange. Cando se completen todos os pasos, é hora de pasar á codificación.

Paso 3: Configurar e iniciar o bot

Imos crear un ficheiro config.py. Nel, cómpre especificar o código de bot único e a zona horaria na que o programa atopará información.

TOKEN = '' # substituír co token do teu botTIMEZONE = 'Europa/Kiev' TIMEZONE_COMMON_NAME = 'Kiev'

A continuación, creamos outro ficheiro coa importación do pb.py previamente escrito, bibliotecas e outros compoñentes necesarios. As bibliotecas que faltan instálanse desde o sistema de xestión de paquetes (pip).

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

Usemos o contido de pyTelegramBotApi para crear un bot. Enviamos o token recibido usando o seguinte código:

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

O parámetro none_stop garante que as solicitudes se envíen constantemente. O funcionamento do parámetro non se verá afectado por erros de método.

Paso 4: escriba o controlador de comandos /start

Se todos os pasos anteriores se fan correctamente, o bot comezou a funcionar. O programa xera solicitudes regularmente porque usa o método getUpdates. Antes da liña co elemento none_stop, necesitamos un anaco de código que procese o comando /start:

@bot.message_handler(commands=['iniciar']) def start_command(mensaxe): bot.send_message( message.chat.id, 'Saúdos! Podo mostrarche os tipos de cambio.n' + 'Para obter os tipos de cambio preme / exchange.n' + 'Para obter axuda, preme /axuda.' )

RџSЂRё comandos=['iniciar'] igual a True chámase comando_inicio. O contido da mensaxe vai aí. A continuación, cómpre implementar a función de envío_mensaxe en relación a unha determinada mensaxe.

Paso 5: cree un controlador de comandos /help

O comando /help pódese implementar como un botón. Ao facer clic nel, o usuario dirixirase á conta de Telegram do programador. Dálle un nome ao botón, como "Preguntar ao programador". Establece o parámetro reply_markup, que redirixe o usuario a unha ligazón, para o método send_message. Escribamos no código o parámetro que crea o teclado (InlineKeyboardMarkup). Só precisa un botón (InlineKeyboardButton).

O código do controlador de comandos final é así:

@bot.message_handler(commands=['axuda']) def help_command(mensaxe): keyboard = telebot.types.InlineKeyboardMarkup() keyboard.add( telebot.types.InlineKeyboardButton('Preguntar ao programador', url='ваша ссылка на профиль' ) ) bot.send_message( message.chat.id, '1) Para recibir unha lista das moedas dispoñibles prema /exchange.n' + '2) Fai clic na moeda que che interesa.n' + '3) Ti recibirá unha mensaxe que conterá información sobre a fonte e as moedas de destino, ' + 'taxas de compra e de venda.n' + '4) Fai clic en "Actualizar" para recibir a información actual sobre a solicitude. ' + 'O bot tamén mostrará a diferenza entre os tipos de cambio anteriores e os actuais.n' + '5) O bot admite inline. Escriba @ en calquera chat e as primeiras letras dunha moeda.', reply_markup=keyboard )

Acción de código no chat de Telegram:

Paso 6: Engadir o controlador de comandos /exchange

Este paso é necesario para mostrar botóns con símbolos das moedas dispoñibles no chat. Un teclado en pantalla con opcións axudarache a evitar erros. PrivatBank ofrece información sobre o rublo, o dólar e o euro. A opción InlineKeyboardButton funciona así:

1. O usuario fai clic no botón coa designación desexada.
2. getUpdates recibe unha devolución de chamada (CallbackQuery).
3. Sábese como manexar a presión do teclado: transmítese información sobre o botón presionado.

/ código do controlador de intercambio:

@bot.message_handler(commands=['exchange']) def exchange_command(mensaxe): 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, 'Fai clic na moeda que elixe:', reply_markup=keyboard )

O resultado do código en Telegram:

Paso 7: Escribir un controlador para os botóns do teclado integrados

O paquete pyTelegramBot Api contén a función decoradora @bot.callback_query_handler. Este compoñente está deseñado para traducir a devolución de chamada nunha función: a API desenvoltura e volve crear a chamada. Escríbese así:

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

Escribamos tamén o método get_ex_callback:

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

Hai outro método útil: answer_callback_query. Axuda a eliminar a carga entre premer o botón e mostrar o resultado na pantalla. Podes enviar unha mensaxe a send_exchange_query pasando algún código de moeda e Mensaxe. Escribamos send_exchange_result:

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

Mentres o chatbot recibe o resultado da solicitude do banco API, o visitante ve a inscrición "escribindo unha mensaxe". Parece que unha persoa real responde. Para mostrar tal indicador na pantalla, terá que engadir liñas de estado de entrada. A continuación, usaremos get_exchange: coa súa axuda, o programa recibirá a designación da moeda (rublos, euros ou dólares). send_message usa métodos adicionais: serialize_ex converte a moeda a outro formato e get_update_keyboard configura teclas programables que actualizan a información e envían datos do mercado de divisas a outros chats.

Escribamos o código para get_update_keyboard. Hai que mencionar dous botóns: t e e significan tipo e intercambio. O elemento switch_inline_query para o botón Compartir é necesario para que o usuario poida escoller entre varios chats. O visitante poderá escoller a quen enviar o tipo de cambio actual do dólar, o rublo ou o euro.

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

Ás veces cómpre ver canto cambiou o tipo de cambio en pouco tempo. Escribamos dous métodos para o botón Actualizar para que os usuarios poidan ver os cursos en comparación.

A diferenza entre os tipos de cambio pásase ao serializador a través do parámetro diff.

Os métodos prescritos só funcionan despois de que se actualicen os datos, non afectarán á primeira visualización do curso.

def serialize_ex (ex_json, diff=None): resultado = '' + ex_json['base_ccy'] + ' -> ' + ex_json['ccy'] + ':nn' + 'Comprar: ' + ex_json['comprar'] se 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' devolve resultado 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">)' diferencia elif < 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">)' devolve o resultado

Imaxina que o visitante quería saber o tipo de cambio do dólar. Isto é o que ocorre se selecciona USD na mensaxe:

Paso 8: implementación do controlador de botóns de actualización

Escribamos o código para xestionar accións co botón Actualizar e engadimos a parte iq_callback_method. Cando os elementos do programa comezan co parámetro get, debes escribir get_ex_callback. Noutras situacións, analizamos JSON e tentamos obter a clave t.

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

Se t é igual a u, terás que escribir un programa para o método edit_message_callback. Imos desglosar este proceso paso a paso:

1. Descargando información actualizada sobre o estado do mercado de divisas (exchange_now = pb.get_exchange(data['c']).

2. Escribindo unha nova mensaxe a través dun serializador con diff.
3. Engadindo unha sinatura (get_edited_signature).

Se a mensaxe inicial non cambia, chame ao método edit_message_text.

def edit_message_callback(consulta): 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(texto, inline_message_id=query.inline_message_id, reply_markup=get_update_keyboard(exchange_now), parse_mode='HTML' )

Escribamos o método get_ex_from_iq_data para analizar JSON:

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

Necesitarás algúns métodos máis: por exemplo, get_exchange_diff, que le a información antiga e nova sobre o custo das moedas e mostra a diferenza.

def get_exchange_diff(último, agora): return { 'sale_diff': float("%.6f" % (float(agora['venda']) - float(último['venda']))), 'buy_diff': flotante ("%.6f" % (float(agora['comprar']) - float(último['comprar']))) }

O último, get_edited_signature, mostra a hora da última actualización do curso.

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

Como resultado, a mensaxe actualizada do bot cun tipo de cambio estable ten o seguinte aspecto:

Cando o curso cambia, as diferenzas entre os valores móstranse na mensaxe debido aos parámetros prescritos.

Paso 9: Implementación do modo incorporado

O modo integrado é necesario para enviar rapidamente información do programa a calquera chat; agora non necesitas engadir un bot á conversa como participante. Cando un usuario de Telegram introduce un nome de bot cun signo @ diante del, as opcións de conversión deberían aparecer enriba da liña de entrada. Se fai clic nun dos elementos, o bot enviará unha mensaxe á conversa cos resultados e botóns para actualizar e enviar datos. O nome do remitente conterá a lenda “vía ".

InlineQuery pásase a query_text a través da biblioteca. O código usa a función answer_line para recuperar os resultados da busca como unha matriz de datos e o elemento inline_query_id. Usamos get_exchanges para que o bot atope varias moedas a petición.

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

Pasamos unha matriz de datos a get_iq_articles para devolver obxectos de InlineQueryResultArticle a través deste método.

def get_iq_articles(intercambios): 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) ) devolver o resultado

Agora, se escribes @ e un espazo na liña, os resultados da busca aparecerán na pantalla: opcións para converter en tres moedas dispoñibles.

Os usuarios poden filtrar os resultados introducindo a moeda desexada.

Despois de facer clic na moeda desexada da lista, o chat recibe a mesma mensaxe que reciben os usuarios do bot. Tamén pode usar o botón Actualizar. A seguinte imaxe mostra a mensaxe actualizada enviada a través do bot:

Conclusión

Agora xa sabes como crear un bot para Telegram. Podes engadir ferramentas útiles ao teu programa: botóns para actualizar e enviar o resultado a outros usuarios do messenger e un modo incorporado que che permite utilizar as funcións do bot fóra do chat con el. Con base nesta instrución, podes crear calquera bot sinxelo con outras funcións, non só a que mostrará os tipos de cambio. Non teñas medo de experimentar con bibliotecas, API e código para crear un asistente automatizado que conversará cos clientes en Telegram e reforzará a conexión das persoas interesadas coa empresa.