En este artículo, mostraré cómo aprovechar las herramientas previamente entrenadas para crear un chatbot que use inteligencia artificial y reconocimiento de voz, por lo que es una IA que habla.

El NLP o Procesamiento del lenguaje natural es el campo de la inteligencia artificial que estudia las interacciones entre las computadoras y los lenguajes humanos, en particular, cómo programar las computadoras para procesar y analizar grandes cantidades de datos del lenguaje natural. La investigación de NLP siempre se ha centrado en hacer que los chatbots sean cada vez más inteligentes.

Los chatbots son aplicaciones de software que se utilizan para realizar conversaciones vía chat de forma automáticas a través de texto o texto a voz, imitando la interacción con un agente humano. El primero de ellos fue ELIZA (1966) que usó la metodología de coincidencia de patrones y sustitución para simular una conversación textual (no podía escuchar ni hablar). Actualmente la más avanzada del mercado es Amazon ALEXA, un asistente personal inteligente que entiende la voz del usuario y le responde.

En este tutorial, mostraré cómo crear un chatbot conversacional utilizando API de reconocimiento de voz y modelos de transformadores previamente entrenados. Presentaré un código de Python útil que se puede aplicar fácilmente en otros casos similares (solo copia, pega, ejecuta) y recorreré cada línea de código con comentarios para que puedas replicar este ejemplo.
En particular, pasaré por:

• Configurar el entorno
• Reconocimiento de voz con las API de Google
• Modelo de lenguaje con Transformers

Configuración

En primer lugar, necesitamos instalar las siguientes bibliotecas:

# for speech to text
pip install SpeechRecognition #(3.8.1)
# for text to speech
pip install gTTS #(2.2.3)
# for language model
pip install transformers #(4.11.3)
pip install tensorflow #(2.6.0, or pytorch)

Vamos a necesitar también otros paquetes que seguro que te son familiares:

import numpy as np

Empecemos por crear una clase vacía que iremos enriqueciendo paso a paso. Para probar el Chatbot, debemos inicializarlo y ejecutar todo el script. Llamaré a mi bot «Maya«:

# Build the AI
class ChatBot():
def __init__(self, name):
print("--- starting up", name, "---")
self.name = name
# Run the AI
if __name__ == "__main__":
ai = ChatBot(name="Maya")

Reconocimiento de voz

El reconocimiento de voz es un subcampo interdisciplinario de la NLP que desarrolla metodologías y tecnologías para permitir el reconocimiento y la traducción del lenguaje hablado a texto por parte de las computadoras. Los primeros sistemas de reconocimiento de voz (1950) podían entender números pero no palabras, IBM Shoebox (1960) fue el primero en entender y responder a pocas palabras en inglés.

Hoy en día, los sistemas más utilizados son las API de Google y una manera fácil de usarlas es a través de la biblioteca SpeechRecognition:

import speech_recognition as sr
def speech_to_text(self):
recognizer = sr.Recognizer()
with sr.Microphone() as mic:
print("listening...")
audio = recognizer.listen(mic)
try:
self.text = recognizer.recognize_google(audio)
print("me --> ", self.text)
except:
print("me --> ERROR")

Esa es la primera función NLP de nuestra clase Chatbot que realiza la tarea de conversión de voz a texto. Básicamente, brinda la capacidad de escuchar y comprender su voz al transformar la señal de audio en texto. Puedes probarlo ejecutando e intentando decir algo:

# Run the AI
if __name__ == "__main__":
ai = ChatBot(name="maya")
while True:
ai.speech_to_text()

Ahora tenemos que darle a la IA la capacidad de responder. Para decirlo de otra manera, queremos que el Chatbot entienda la entrada, produzca una salida y la hable. Agreguemos una nueva función a la clase:

def wake_up(self, text):
return True if self.name in text.lower() else False

El método wake_up se asegura de que la IA responda cuando dices su nombre. Por ejemplo, activaré mi Chatbot diciendo «Hola Maya».

Una vez que el Chatbot escuche su nombre, responderá algo, por lo tanto, debes realizar una tarea de texto a voz. Voy a usar la biblioteca de Google Text-to-Speech (gtts) para guardar un archivo mp3 en el sistema de archivos que se puede reproducir fácilmente con el sistema operativo de la biblioteca.

from gtts import gTTS
import os
@staticmethod
def text_to_speech(text):
print("ai --> ", text)
speaker = gTTS(text=text, lang="en", slow=False)
speaker.save("res.mp3")
os.system("afplay res.mp3") #macbook->afplay | windows->start
os.remove("res.mp3")

Puedes probar esas dos nuevas funciones así:

# Run the AI
if __name__ == "__main__":
ai = ChatBot(name="maya")
while True:
ai.speech_to_text()
## wake up
if ai.wake_up(ai.text) is True:
res = "Hello I am Maya the AI, what can I do for you?"
ai.text_to_speech(res)

También podemos programar el bot para que reaccione a algunos comandos específicos, como cualquier otro asistente virtual (Siri, Alexa, Cortana, …). Por ejemplo, quiero que mi IA me diga la hora cuando se lo pido y que responda amablemente cuando le doy las gracias (“ella”, sí, ya la amo). Así que voy a agregar esta función a la clase Chatbot:

import datetime
@staticmethod
def action_time():
return datetime.datetime.now().time().strftime('%H:%M')

y ejecuta el script:

# Run the AI
if __name__ == "__main__":
ai = ChatBot(name="maya")
while True:
ai.speech_to_text()
## wake up
if ai.wake_up(ai.text) is True:
res = "Hello I am Maya the AI, what can I do for you?"
## action time
elif "time" in ai.text:
res = ai.action_time()
## respond politely
elif any(i in ai.text for i in ["thank","thanks"]):
res = np.random.choice(
["you're welcome!","anytime!",
"no problem!","cool!",
"I'm here if you need me!","peace out!"])
ai.text_to_speech(res)

Hasta ahora, hemos utilizado técnicas de reconocimiento de voz para hablar con nuestro Chatbot, pero el bot sigue siendo bastante tonto, ya que no puede responder a nada que no esté predeterminado. Es hora de poner Inteligencia Artificial real dentro de nuestro Chatbot, es decir, un modelo de machine learning entrenado para NLP.

Modelo de lenguaje

Usaré un modelo de lenguaje transformador, una nueva técnica de modelado presentada por Google (2017) que reemplaza los modelos tradicionales de secuencia a secuencia (como LSTM) con mecanismos de atención. Estos modelos de lenguaje pueden realizar cualquier tarea de PNL porque comprenden dinámicamente los contextos. Los modelos más famosos son BERT de Google y GPT de OpenAI, con miles de millones de parámetros.

El paquete principal para estos modelos son los transformadores de HuggingFace. Es una herramienta popular que proporciona modelos preentrenados útiles para una variedad de tareas de NLP. En concreto, el que voy a utilizar es DialogGPT, un modelo de GPT entrenado por Microsoft sobre millones de conversaciones extraídas de Reddit.

import transformers
nlp = transformers.pipeline("conversational",
model="microsoft/DialoGPT-medium")

Probemos:

 input_text = "hello!"
nlp(transformers.Conversation(input_text))

Ten en cuenta que la versión actual de la biblioteca muestra una advertencia cuando no especifica pad_token_id (como puede ver en la imagen de arriba). Para evitar esto, simplemente puedes agregarlo como un parámetro:

nlp(transformers.Conversation(input_text), pad_token_id=50256)

Además, la canalización genera toda la conversación (como puede ver en la imagen de arriba), por lo que convertiré toda la salida en una cadena y extraeré solo la respuesta del chatbot.

chat = nlp(transformers.Conversation(ai.text), pad_token_id=50256)
res = str(chat)
res = res[res.find("bot >> ")+6:].strip()

Finalmente, estamos listos para ejecutar el Chatbot y tener una conversación divertida con nuestra IA. Aquí está el código completo:

¡Estupendo! El bot puede realizar algunas tareas específicas como un asistente virtual (es decir, decir la hora cuando se le pregunta) y tener conversaciones informales. Y si crees que la Inteligencia Artificial llegó para quedarse, ella está de acuerdo:

Conclusión

Este artículo ha sido un tutorial para demostrar cómo construir un chatbot conversacional que escuche y responda como un ser humano. Usé herramientas de reconocimiento de voz para realizar tareas de conversión de voz a texto y de texto a voz, y aproveché los modelos de lenguaje de Transformers previamente entrenados para darle al bot algo de inteligencia artificial. Ahora puede crear su propio Chatbot, que puede incluir más tareas de asistente virtual, como buscar cosas en Wikipedia o reproducir videos en Youtube.

¡Espero que lo hayas disfrutado! No dudes en ponerte en contacto conmigo para preguntas y comentarios o simplemente para compartir sus proyectos interesantes.

Let’s Connect

The post IA Chatbot con NLP: reconocimiento de voz + transformadores first appeared on Planeta Chatbot.

Resumen

En este artículo, usando Telegram y Python, mostraré cómo construir un Bot amigable con múltiples funciones que puede chatear con conversaciones de respuesta a preguntas (información a corto plazo) y almacenar datos del usuario para recordarlos en el futuro (información a largo plazo).

Ejemplo de chat (Imagen del autor)

Todo esto empezó porque una amiga mía me gritó por no recordar su cumpleaños. No sé si eso te ha pasado alguna vez. Así que pensé que podía fingir que recordaba los cumpleaños mientras en realidad tengo un Bot haciéndolo por mí. Ahora sé lo que estás pensando, ¿por qué crear algo desde cero en lugar de usar una de las millones de aplicaciones de calendario que existen? Y tienes razón, pero para nerds como nosotros … ¿qué hay de divertido en eso?

A través de este tutorial, explicaré paso a paso cómo construir un Telegram Bot inteligente con Python y MongoDB y cómo implementarlo gratis con Heroku y Cron-Job, usando mi Dates Reminder Bot como ejemplo (enlace a continuación).

Presentaré un código Python útil que se puede aplicar fácilmente en otros casos similares (simplemente copie, pegue, ejecute) y recorreré cada línea de código con comentarios para que pueda replicar este ejemplo (enlace al código completo a continuación).

En particular, pasaré por:

• Configuración: descripción general de la arquitectura, nueva generación de Telegram Bot, conexión MongoDB, entorno Python.
• Front-end: codifica los comandos del Bot para la interacción del usuario con pyTelegramBotAPI.
• Back-end: crea la aplicación del lado del servidor con flask y threading.
• Implementar el bot a través de Heroku y Cron-Job

Configuración

Quiero comenzar con la arquitectura general de esta aplicación para que todos tengamos una idea clara de cuál es el destino final de este breve pero divertido viaje. Voy a crear una aplicación Python, implementada en Heroku, que interactúa con los usuarios a través de un Telegram Bot, almacena información en un MongoDB y les envía mensajes recurrentes gracias a un Cron-Job.

Esta arquitectura es bastante estándar para aplicaciones web / móviles. De hecho, estás desarrollando una aplicación adecuada que utiliza Telegram como front-end.

Antes de que empieces a codificar, tienes que generar el Bot con Telegram y crear la instancia de MongoDB.

Telegram te permite generar un nuevo bot en menos de un minuto, simplemente envía un mensaje a BotFather y sigue tus instrucciones, así:

BotFather proporciona un TOKEN de API secreto que usarás más adelante. En cuanto a los posibles comandos de nuestro Bot, estableceré las siguientes opciones:

• función de inicio (esto se ejecuta cuando los usuarios inician el bot)
• guardar y eliminar eventos
• consultar los eventos de hoy y ver todos mis eventos guardados
• función de ayuda

Eso te permitirá visualizar y elegir los comandos en el chat con el Bot cuando esté en funcionamiento:

Pasa a la configuración de MongoDB y regístrate / inicie sesión en MongoDB Atlas, un servicio de base de datos en la nube. Te dan una cuenta gratuita con 500 MB de almacenamiento (selecciona la opción M0 Sandbox al crear el clúster).

En “colecciones”, puedes crear tu base de datos y colección:

En “conectar”, puedes crear tu usuario y establecer tu contraseña, la cual deberás ingresar en la cadena que te dan para conectar tu aplicación a la base de datos. Guarda la cadena completa porque la necesitarás más tarde.

Para codificar la aplicación, necesitas configurar el entorno Python. Instalarás las siguientes bibliotecas a través de la terminal:

pip install pyTelegramBotAPI
pip install pymongo
pip install dnspython
pip install dateparser
pip install flask

Creo que pyTelegramBotAPI es la mejor biblioteca de Python para las API de Telegram, ya que proporciona todas las herramientas para construir fácilmente un chatbot complejo. Se podría trabajar directamente con las API de Telegram, pero no es necesario reinventar la rueda aquí. Los paquetes pymongo y dnspython son necesarios para conectarse a MongoDB con Python. Para que el Bot comprenda las fechas, usaré dateparser.

Si estás leyendo esto, supongo que ya conoces Flask (ten en cuenta que si no planea implementar su bot, no lo vas a necesitar).

Ahora que está todo listo, toca comenzar.

Interfaz (Telegram Bot)

Puedes empezar a codificar el Bot. En primer lugar, llama a la instancia de pyTelegramBotAPI e inserta el TOKEN de la API de Telegram proporcionado por BotFather:

import telebotbot = telebot.TeleBot("insert the Telegram API TOKEN")

En segundo lugar, conéctate a la base de datos usando pymongo y la cadena de MongoDB Atlas:

import pymongoclient = pymongo.MongoClient("mongodb+srv://...")
db_name = "Telegram_DatesReminderBot"
collection_name = "users"
db = client[db_name][collection_name]

Luego, definirás un diccionario vacío que tiene la tarea de almacenar información temporal del usuario (como la identificación del usuario):

dic_user = {}

Ahora, revisarás los comandos principales previamente definidos (iniciar, guardar, …) y escribir las acciones apropiadas para el Bot. Comienza con “/ start”, el comando que se ejecuta automáticamente cuando comienzas a chatear con el Bot por primera vez. Deja que el Bot comience con un mensaje de bienvenida y una sugerencia de qué hacer a continuación:

@bot.message_handler(commands=['start'])
def _start(message):
 msg = "Hello "+str(message.chat.username)+\
 ", I'm a date reminder. Tell me birthdays and events to remind you. To learn how to use me, use \n/help"
 bot.send_message(message.chat.id, msg)

¿Hay detalles que no reconoces? Deja que te ayude:

Fácil ¿verdad? Pero eso fue solo un calentamiento. Ahora, el comando “/ save” será bastante más complicado, ya que implica una conversación de preguntas y respuestas:

@bot.message_handler(commands=['save'])
def _save(message):
 msg = "Set an event in the format 'month dd', for example: \n\
 xmas day: Dec 25 \n\
I also understand: \n\
today, tomorrow, in 3 days, in 1 week, in 6 months, yesterday, 3 days ago ... so you can do: \n\
 meeting: tomorrow"
 message = bot.reply_to(message, msg)
 bot.register_next_step_handler(message, save_event)

Como puedes ver, esta vez utilicé bot.reply_to () en lugar de bot.send_message (). Mientras que el segundo envía un mensaje general en el chat, el primero envía un mensaje en respuesta a una entrada específica. Lo estoy usando porque esta es una conversación real entre el usuario y el Bot: el usuario pide guardar información, el Bot responde a eso y espera que el usuario responda. El nuevo mensaje del usuario será procesado por bot.register_next_step_handler () como entrada para la función save_event (), que ahora definirás y luego codificarás.

Siguiendo el ejemplo anterior, quiero salvar el cumpleaños de mi madre. Con ese fin, escribo “mamá: 15 de octubre”. El Bot tiene que reconocer el nombre del evento, “mamá” y la fecha “15 de octubre” en el texto. Después de eso, la información debe almacenarse, considerando tanto los casos de usuarios que regresan (ya en la base de datos, por lo que necesitamos actualizar los eventos del usuario) como los nuevos (deben agregarse en la base de datos).

En términos de Python:

import dateparserdef save_event(message):
 dic_user["id"] = str(message.chat.id)

 ## get text
 txt = message.text
 name= txt.split(":")[0].strip() 
 date = txt.split(":")[1].strip() 

## check date
 date = dateparser.parse(date).strftime('%b %d') 

## save
 lst_users = db.distinct(key="id")
 if dic_user["id"] not in lst_users:
 db.insert_one({"id":dic_user["id"], "events":{name:date}})
 else:
 dic_events = db.find_one({"id":dic_user["id"]})["events"]
 dic_events.update({name:date})
 db.update_one({"id":dic_user["id"]}, {"$set":
 {"events":dic_events}})

## send done
 msg = name+": "+date+" saved."
 bot.send_message(message.chat.id, msg)

Ten en cuenta que utilicé dateparser para reconocer fechas legibles por humanos. Esto permite al usuario escribir la fecha en diferentes formatos:

De manera similar, puede crear las otras funciones para verificar y eliminar los eventos en la base de datos (proporcionaré el código completo al final del artículo, o puede consultar el enlace de GitHub al comienzo de este tutorial).

¿Qué pasa si el usuario envía algunos textos aleatorios no vinculados a ningún comando específico? El Bot no hará nada si no incluimos este tipo de evento. Por lo tanto, anticiparé 2 tipos de situaciones a las que el Bot responderá adecuadamente (saludos y mensajes de agradecimiento) y todos los demás casos a los que el Bot responderá con un mensaje estándar.

@bot.message_handler(func=lambda m: True)
def chat(message):
 txt = message.text
 if any(x in txt.lower() for x in ["thank","thx","cool"]):
 msg = "anytime"
 elif any(x in txt.lower() for x in ["hi","hello","yo","hey"]):
 msg = "yo" if str(message.chat.username) == "none" else 
 "yo "+str(message.chat.username)
 else:
 msg = "save a date with \n/save"
 bot.send_message(message.chat.id, msg)

Manten esta parte bastante básica porque no es el enfoque principal de este tutorial, pero se podrían usar técnicas de PNL más avanzadas para hacer que el chatbot sea más inteligente y conversador.

Dicho esto, nuestro Bot ya tiene la habilidad suficiente para ejecutarlo y probarlo. Puedes simplemente agregar la siguiente línea al final de tu código y ejecutar todo el script.

bot.infinity_polling(True)

Ahora tu Bot está en funcionamiento, alojado en tu computadora portátil. Puedes jugar con él en Telegram. Si no planeas implementar tu bot, puedes detenerte aquí, ya que el resto del artículo explica los pasos para la implementación.

Back-end (aplicación Flask)

Comienza creando un nuevo proyecto de aplicación en Heroku, una plataforma en cloud como servicio que permite implementar una aplicación PoC con solo una cuenta gratuita. Puedes vincular tu proyecto de GitHub e implementar una de las ramas.

Por el momento, aún no estamos listos para implementar la aplicación. Solo necesitamos la dirección web de la aplicación generada por Heroku. Guárdalo; lo necesitarás pronto.

Vuelve a la codificación y comienza agregando una nueva aplicación del lado del servidor con flask al script de Python que has editado hasta ahora:

import flaskserver = flask.Flask(__name__)

Tienes que configurar un webhook, una metodología común en el desarrollo web para pasar información en tiempo real de una aplicación a otra. Gracias al webhook, Telegram Bot envía datos en tiempo real a la aplicación Heroku.

@server.route('/Telegram API TOKEN', methods=['POST'])
def getMessage():
 bot.process_new_updates([telebot.types.Update.de_json(
flask.request.stream.read().decode("utf-8"))])
 return "!", 200@server.route("/")
def webhook():
 bot.remove_webhook()
 bot.set_webhook(url='Heroku App Web Address /'
 +'Telegram API TOKEN')
 return "!", 200

Entonces ahora tu Bot lo tiene casi todo, todavía necesita la última y más importante función: el recordatorio. Chatea y guarda la información, pero el objetivo principal de esta aplicación es enviar alertas automáticamente. Por lo tanto, voy a crear un programador que verifique los eventos de hoy cada vez que se ejecute y envíe recordatorios de eventos.

import datetimedef scheduler():
 lst_users = db.distinct(key="id")
 for user in lst_users:
 dic_events = db.find_one({"id":user})["events"]
 today = datetime.datetime.today().strftime('%b %d')
 res = [k for k,v in dic_events.items() if v == today]
 if len(res) > 0:
 msg = "Today's events: "+", ".join(res)
 bot.send_message(user, msg)

Cuando se ejecuta la aplicación, este programador se ejecutará en un thread diferente al de la aplicación principal del matraz. En otras palabras, la aplicación tendrá dos cosas sucediendo a la vez: las funcionalidades del chatbot y el recordatorio programado. Puede poner esas 2 acciones principales al final de la secuencia de comandos, y cuando se ejecute el código completo, harán que todo funcione.

import threading
import osif __name__ == "__main__":
threading.Thread(target=scheduler).start()
 server.run(host="0.0.0.0", 
 port=int(os.environ.get("PORT", 5000)))

Desplegar

Finalmente, es el momento de implementar la aplicación. Antes de continuar, mostraré la estructura de mi repositorio:

No necesariamente tienes que mantener la misma estructura de repositorio, pero definitivamente necesitas los 2 archivos que Heroku requiere: los requisitos.txt, que puedes crear desde la terminal

pip freeze > requirements.txt

y el Procfile (sin extensión), que contiene el comando que se ejecutará después del despliegue

web: python telegram_bot.py

Con respecto a las claves de Telegram y MongoDB, debes ponerlas en Heroku como variables de configuración (las llamaré “telegram_key” y “mongodb_key”):

El archivo config.py en la carpeta de configuración tiene el trabajo de recuperar y usar las claves cuando la aplicación se ejecuta en Heroku. Aquí está el código completo en config.py:

import osENV = "PROD"#<--- change here DEV or PROD## keys
if ENV == "DEV":
from settings import keys
 telegram_key = keys.telegram_key
 mongodb_key = keys.mongodb_keyelif ENV == "PROD":
 import ast
 telegram_key = ast.literal_eval(os.environ["telegram_key"])
 mongodb_key = ast.literal_eval(os.environ["mongodb_key"])## server
host = "0.0.0.0"
port = int(os.environ.get("PORT", 5000))

Y aquí está el código completo en telegram_bot.py, el script principal con el bot y la aplicación en el que has estado trabajando en todo este tutorial:

###############################################################################
#                            RUN MAIN                                         #
###############################################################################

# setup
## pkg
import telebot
import logging
import datetime
import dateparser
import pymongo
from settings import config

## bot
bot = telebot.TeleBot(config.telegram_key)
dic_user = {}

## setup db
client = pymongo.MongoClient(config.mongodb_key)
db_name = "Telegram_DatesReminderBot"
collection_name = "users"
db = client[db_name][collection_name]

# logging
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
logger = logging.getLogger(__name__)



# /start
@bot.message_handler(commands=['start'])
def _start(message):
    ## reset
    dic_user["id"] = str(message.chat.id)
    db.delete_one({'id':dic_user["id"]})
    logging.info(str(message.chat.username)+" - "+str(message.chat.id)+" --- START")

    ## send first msg
    msg = "Hello "+str(message.chat.username)+\
          ", I'm a date reminder. Tell me birthdays and events to remind you. To learn how to use me, use \n/help"
    bot.send_message(message.chat.id, msg)



# /help
@bot.message_handler(commands=['help'])
def _help(message):
    msg = "Set an event, like someone's birthday, for example: \n\
            Nadia: Oct 25 \nAnd I'm gonna save the date and every Oct 25 I will remind you of Nadia's birthday. \n\
Save a date with \n/save \n\
You can always check for today's event with \n/check"
    bot.send_message(message.chat.id, msg)



# /save
@bot.message_handler(commands=['save'])
def _save(message):
    msg = "Set an event in the format 'month dd', for example: \n\
            xmas day: Dec 25 \n\
I also understand: \n\
today, tomorrow, in 3 days, in 1 week, in 6 months, yesterday, 3 days ago ... so you can do: \n\
            meeting: tomorrow"
    message = bot.reply_to(message, msg)
    bot.register_next_step_handler(message, save_event)


def save_event(message):
    dic_user["id"] = str(message.chat.id)

    ## get text
    txt = message.text
    logging.info(str(message.chat.username)+" - "+str(message.chat.id)+" --- SAVE - "+txt)
    name, date = txt.split(":")[0].strip(), txt.split(":")[1].strip()

    ## check date
    date = dateparser.parse(date).strftime('%b %d')

    ## save
    lst_users = db.distinct(key="id")
    if dic_user["id"] not in lst_users:
        db.insert_one({"id":dic_user["id"], "events":{name:date}})
    else:
        dic_events = db.find_one({"id":dic_user["id"]})["events"]
        dic_events.update({name:date})
        db.update_one({"id":dic_user["id"]}, {"$set":{"events":dic_events}})
    
    ## send done
    msg = name+": "+date+" saved."
    bot.send_message(message.chat.id, msg)



# /check
@bot.message_handler(commands=['check'])
def _check(message):
    dic_user["id"] = str(message.chat.id) 

    ## error
    lst_users = db.distinct(key="id")
    if dic_user["id"] not in lst_users:
        msg = "First you need to save an event with \n/save"

    ## query
    else:
        dic_events = db.find_one({"id":dic_user["id"]})["events"]
        today = datetime.datetime.today().strftime('%b %d')
        logging.info(str(message.chat.username)+" - "+str(message.chat.id)+" --- CHECKING")
        res = [k for k,v in dic_events.items() if v == today]
        msg = "Today's events: "+", ".join(res) if len(res) > 0 else "No events today"
    
    bot.send_message(message.chat.id, msg)



# /view
@bot.message_handler(commands=['view'])
def _view(message):
    dic_user["id"] = str(message.chat.id) 

    ## error
    lst_users = db.distinct(key="id")
    if dic_user["id"] not in lst_users:
        msg = "You have no events. Save an event with \n/save"

    ## query
    else:
        dic_events = db.find_one({"id":dic_user["id"]})["events"]
        logging.info(str(message.chat.username)+" - "+str(message.chat.id)+" --- VIEW ALL")
        msg = "\n".join(k+": "+v for k,v in dic_events.items())
    
    bot.send_message(message.chat.id, msg)



# /delete
@bot.message_handler(commands=['delete'])
def _delete(message):
    ## ask name
    msg = "Tell me the event to Delete, for example: \n\
            xmas day \nAnd I'm gonna stop the reminder."
    message = bot.reply_to(message, msg)
    bot.register_next_step_handler(message, delete_event)


def delete_event(message):
    dic_user["id"] = str(message.chat.id)

    ## get text
    txt = message.text
    logging.info(str(message.chat.username)+" - "+str(message.chat.id)+" --- DELETE - "+txt)

    ## delete
    dic_events = db.find_one({"id":dic_user["id"]})["events"]
    dic_events.pop(txt)
    db.update_one({"id":dic_user["id"]}, {"$set":{"events":dic_events}})
    
    ## send done
    msg = txt+" deleted."
    bot.send_message(message.chat.id, msg)



# non-command message
@bot.message_handler(func=lambda m: True)
def chat(message):
    txt = message.text
    if any(x in txt.lower() for x in ["thank","thx","cool"]):
        msg = "anytime"
    elif any(x in txt.lower() for x in ["hi","hello","yo"]):
        msg = "yo" if str(message.chat.username) is "none" else "yo "+str(message.chat.username)
    else:
        msg = "save a date with \n/save"
    bot.send_message(message.chat.id, msg)



# scheduler
def scheduler():
    lst_users = db.distinct(key="id")
    logging.info("--- SCHEDULER for "+str(len(lst_users))+" users ---")
    for user in lst_users:
        #res = requests.get("https://api.telegram.org/bot1494658770:"+config.telegram_key+"/sendMessage?chat_id="+user+"&text=yo")
        dic_events = db.find_one({"id":user})["events"]
        today = datetime.datetime.today().strftime('%b %d')
        res = [k for k,v in dic_events.items() if v == today]
        if len(res) > 0:
            msg = "Today's events: "+", ".join(res)
            bot.send_message(user, msg)



# run
if config.ENV == "DEV":
    bot.infinity_polling(True)  #bot.polling()


elif config.ENV == "PROD":
    import flask
    import threading

    server = flask.Flask(__name__)

    @server.route('/'+config.telegram_key, methods=['POST'])
    def getMessage():
        bot.process_new_updates([telebot.types.Update.de_json(flask.request.stream.read().decode("utf-8"))])
        return "!", 200

    @server.route("/")
    def webhook():
        bot.remove_webhook()
        bot.set_webhook(url='https://botdatereminder.herokuapp.com/'+config.telegram_key)
        return 'Chat with the Bot  <a href ="https://t.me/DatesReminderBot">here</a> \
          or   Check the project code <a href ="https://github.com/mdipietro09/Bot_TelegramDatesReminder">here</a>', 200

    if __name__ == "__main__":
        threading.Thread(target=scheduler).start()
        server.run(host=config.host, port=config.port)

Genial, ahora lo despliegas en Heroku:

Ahora deberías tener la aplicación web Heroku en funcionamiento y poder usar el Bot en Telegram. ¡Pruébalo!

Por último, pero no menos importante, establecerás un Cron-Job para hacer ping a la dirección web de Heroku. Eso hará que la página se vuelva a cargar, la aplicación se reinicie y el recordatorio programado se ejecutará en su thread.

Así que mañana, cuando nos despertemos, encontraremos un mensaje con los eventos del día.

Ejemplo de chat (Imagen del autor)

Conclusión

Este artículo ha sido un tutorial para mostrar cómo construir un bot de Telegram con Python que almacena datos de usuario en MongoDB y recupera información a través de Cron-Job. Ahora que sabe cómo funciona, puede desarrollar su propio chatbot y jugar con él.

¡Espero que lo hayan disfrutado! No dudéis en ponerse en contacto conmigo en LinkedIn y Twitter si tenéis preguntas y comentarios o simplemente para compartir los proyectos interesantes.

Many thanks to Planeta Chatbot for translating and publishing this article. You can find the original piece (English) here:

The post Crea e implementa un bot de Telegram con memoria a corto y largo plazo first appeared on Planeta Chatbot.