Tag: factotum

Factotum BOT – leggi_QR_code(…)

Ancora grazie agli amici del sito http://www.allafinedelpalo.it/ per il codice sulla lettura dei codice QR code che ho copiato dal loro post e che ho applicato all’interno del mio bot.

Pubblico anche le 3 immagini che contengono i codici QR che vengono riconosciuti dal bot. Non sono altro che 3 immagini che contengono le stringhe qrcode1, qrcode2 e qrcode3.

Quando viene inviata una immagine nella chat, il bot prova a controllare se nell’immagine è presente un QR code e legge il contenuto. Confronta il testo contenuto nel QR code con le 3 variabili definite a livello di programma e così definite:

QRCODE1="qrcode1"
QRCODE2="qrcode2"
QRCODE3="qrcode3"

Il bot, nella sua versione base, non fa altro che visualizzare il testo riconosciuto e comunicare se coincide con il valore di una delle 3 variabili.

Se il bot non riconosce nessun codice QR valido, visualizza un messaggio all’utente. E’ meglio stampare il codice QR e utilizzare la fotocamera dello smartphone per caricare l’immagine del QR code, perchè se si fotografa il codice QR dallo schermo del computer, il bot fa fatica a riconoscere correttamente il contenuto dell’immagine (forse i pixel disturbano l’identificazione).

Ecco il codice della funzione completa:

"""
=== LEGGI_QR_CODE ===
Funzione per analizzare l'immagine passata al BOT nella chat
e cerca se il testo presente nel QR code coincide con il testo
definito nelle 3 variabili di programma con lo scopo di
effettuare delle scelte sulla base del contenuto del QR code.
=====================
"""
def leggi_QR_code(bot,chat_id,msg):
    bot.sendMessage(chat_id, 'Ricerca dei QR Code in corso...')
    raw_img = BytesIO()
    bot.download_file(msg['photo'][-1]['file_id'], raw_img)
    img = Image.open(raw_img)
    qrcodes = decode(img)

    if len(qrcodes) > 0:
        for code in qrcodes:
            print("Il contenuto del QR code è:", qrcodes)
            qr_string=str(code.data)
            qr_string_unicode=qr_string[2:-1]

            bot.sendMessage(chat_id, "Il QRCode contiene il testo: " + qr_string_unicode)
            if qr_string_unicode==QRCODE1:
                bot.sendMessage(chat_id, "Trovato il QRCODE1")
            elif qr_string_unicode==QRCODE2:
                bot.sendMessage(chat_id, "Trovato il QRCODE2")
            elif qr_string_unicode==QRCODE3:
                bot.sendMessage(chat_id, "Trovato il QRCODE3")

    else:
        bot.sendMessage(chat_id, "Non ho trovato QRCode nella foto...")
    return

Permanent link to this article: http://www.andrea.rustichelli.name/factotum-bot-leggi_qr_code/

Factotum BOT – attiva_maggiordomo(…)

Di seguito riporto il codice per attivare l’Inline Keyboard all’interno di Telegram. Sinceramente pensavo che fosse più utili/pratica, ma alla fine non mi ha convinto come pensavo. Per questo motivo il codice non è ottimizzato e ho creato tante funzioni quante sono le Inline Keyboard da attivare. Ho anche creato una funzione che contiene molti cicli if per gestire i tasti premuti dall’utente, ma sono sicuro che ci sono modalità più raffinate per gestire questo tipo di input.

"""
=== ATTIVA MAGGIORDOMO ===
Funzione attivare l'Inline Keyboard presente in Telegram.
L'InlineKeyboard visualizza 3 pulsanti
 Il pulsante key1 visualizza un sottomenù con altri 2 pulsanti e quello per tornare indietro
 Il pulsante key2 visualizza un elenco di anni e il pulsante per tornare indietro
 Il pulsante key3 visualizza direttamente un testo
Questa è la funzione base. Ci sono altre funzioni per gestire le risposte dell'utente.
==========================
"""
def attiva_maggiordomo(chat_id):
    print("Maggiordomo attivato")

    keyboard = InlineKeyboardMarkup(inline_keyboard=[
                     [InlineKeyboardButton(text='Testo key1', callback_data='key1'),
                      InlineKeyboardButton(text='Testo key2', callback_data='key2'),
                      InlineKeyboardButton(text='Testo key3', callback_data='key3')]
                 ])
    bot.sendMessage(chat_id,"Attivazione del Maggiodomo in corso...",reply_markup=keyboard)

Di seguito riporto le altre funzioni necessarie per attivare e gestire i sotto menù dell’Inline Keyboard. Ricordo che il valore presente nel campo callback_data è quello che viene utilizzato per gestire il flusso all’interno del programma.

def attiva_maggiordomo_key1(chat_id):
    print("Maggiordomo KEY1 attivato")
    key1_keyboard = InlineKeyboardMarkup(inline_keyboard=[
                     [InlineKeyboardButton(text='Testo key1 sub 1', callback_data='key1_1'),
                     InlineKeyboardButton(text='Testo key1 sub 2', callback_data='key1_2')],
                     [InlineKeyboardButton(text='Torna indietro', callback_data='from_key1_back')]
                 ])
    bot.sendMessage(chat_id, "Entro nella sezione KEY1...",reply_markup=key1_keyboard)

def attiva_maggiordomo_key2(chat_id):
    print("Maggiordomo KEY2 attivato")
    key2_keyboard = InlineKeyboardMarkup(inline_keyboard=[
                     [InlineKeyboardButton(text='2016', callback_data='2016')],
                     [InlineKeyboardButton(text='2017', callback_data='2017')],
                     [InlineKeyboardButton(text='2018', callback_data='2018')],
                     [InlineKeyboardButton(text='Torna indietro', callback_data='from_key2_back')]
                 ])
    bot.sendMessage(chat_id, "Entro nella sezione KEY2...",reply_markup=key2_keyboard)

def attiva_maggiordomo_key3(chat_id):
    print("Maggiordomo KEY3 attivato")
    bot.sendMessage(chat_id, "Entro nella sezione KEY3...")

Infine, ecco la funzione per gestire i pulsanti una volta che vengono premuti dall’utente.

def on_callback_query(msg):
    query_id, chat_id, query_data = telepot.glance(msg, flavor='callback_query')
    print('Callback Query:', query_id, chat_id, query_data)
    if query_data=="key1":
        attiva_maggiordomo_key1(chat_id)
    elif query_data=="key2":
        attiva_maggiordomo_key2(chat_id)
    elif query_data=="key3":
        attiva_maggiordomo_key3(chat_id)
    elif query_data == 'from_key1_back':
        attiva_maggiordomo(chat_id)
    elif query_data == 'from_key2_back':
        attiva_maggiordomo(chat_id)
    elif query_data == 'from_key3_back':
        attiva_maggiordomo(chat_id)
    elif query_data == '2016':
        bot.sendMessage(chat_id, "Hai scelto l'anno 2016")
    elif query_data == '2017':
        bot.sendMessage(chat_id, "Hai scelto l'anno 2017")
    elif query_data == '2018':
        bot.sendMessage(chat_id, "Hai scelto l'anno 2018")
    elif query_data == 'key1_1':
        bot.sendMessage(chat_id, "Hai premuto il tasto KEY1_1")
    elif query_data == 'key1_2':
        bot.sendMessage(chat_id, "Hai premuto il tasto KEY1_2")
    elif query_data == 'key2_1':
        bot.sendMessage(chat_id, "Hai premuto il tasto KEY2_1")
    elif query_data == 'key2_2':
        bot.sendMessage(chat_id, "Hai premuto il tasto KEY2_2")

Permanent link to this article: http://www.andrea.rustichelli.name/factotum-bot-attiva_maggiordomo/

Factotum BOT – trova_posizione(…)

Ed eccoci alla funzione che, quando viene passata una posizione geografica al bot, tramite l’interrogazione di un web service, vengono visualizzati dei punti geografici nelle vicinanze del punto indicato. Ovviamente questa funzione ha uno scopo solo dimostrativo, ma serve per testare le potenzialità legate alla geolocalizzazione.

Inoltre è presente un pezzo di codice molto utile per la gestione del risultato dell’interrogazione del web service, in quanto l’output in formato json è stato reso “leggibile” tramite una conversione utilizzando la codifica UTF-8.

"""
=== TROVA_POSIZIONE ===
Funzione per scrivere i dati sulla posizione che viene passata al Bot
tramite l'interrogazione di un web service
=======================
"""
def trova_posizione(bot, chat_id, msg):
    bot.sendMessage(chat_id,'Mi hai passato la posizione geografica')
    print(msg["from"] ["first_name"])
    gps_lat=msg["location"] ["latitude"]
    gps_lon=msg["location"] ["longitude"]
    gps_url="http://www.geoplugin.net/extras/nearby.gp?lat=" + str(gps_lat) + "&lon=" + str(gps_lon) + "&format=json"
    with urlopen(gps_url) as response:
      html_response = response.read()
      encoding = response.headers.get_content_charset('utf-8')
      decoded_html = html_response.decode(encoding)

    data_json=json.loads(decoded_html)
    for posti in data_json:
        print(posti["geoplugin_place"], posti["geoplugin_distanceKilometers"], posti["geoplugin_directionHeading"])
        bot.sendMessage(chat_id, "Ti trovi a " + str(posti["geoplugin_distanceKilometers"]) + " Km da " + str(posti["geoplugin_place"]) + " in direzione " + str(posti["geoplugin_directionHeading"]))
    return

Permanent link to this article: http://www.andrea.rustichelli.name/factotum-bot-trova_posizione/

Factotum BOT – formula_risposta(…)

Vediamo la prima funzione utilizzata all’interno del BOT Factotum.

Il suo scopo è quello di prendere in input il testo digitato dall’utente all’interno della chat, spezzare la frase nelle singole parole che la compongono e confrontare le parole con le 3 HOT WORD inserite come variabili all’interno del programma stesso (e quindi a “compile time” e non a “run time”).

"""
=== FORMULA_RISPOSTA ===
Funzione per analizzare il testo digitato dall'utente nella chat
e formulare la risposta più appropriata sulla base delle 3 HOT_WORD definite
a livello di programma
========================
"""
def formula_risposta(bot, chat_id, msg, domanda):
    print("Funzione FORMULA_RISPOSTA: START")
    print("Funzione FORMULA_RISPOSTA: La domanda è ",domanda)

    parole=domanda.split(" ")
    parole_chiave=[]
    risposta=""
    for i in parole:
      if i in HOT_WORD1:
          parole_chiave.append(i)
          bot.sendMessage(chat_id,"Trovata la HOT_WORD1")
      if i in HOT_WORD2:
          parole_chiave.append(i)
          bot.sendMessage(chat_id,"Trovata la HOT_WORD2")
          #bot.sendDocument(chat_id, open('file_name.pdf', 'rb'))
      if i in HOT_WORD3:
          parole_chiave.append(i)
          bot.sendMessage(chat_id,"Trovata la HOT_WORD3")
          #bot.sendMessage(chat_id, "https://www.google.it")

    if len(parole_chiave)==0:
      bot.sendMessage(chat_id,"Spiacente, non sono riuscito a individuare la richiesta.")
    return

Le HOT_WORD non sono altro che liste che contengono le parole chiave che fanno attivare il BOT. Nel BOT di esempio sono descritte nel seguente modo:

HOT_WORD1=["pippo","Pippo","PIPPO"]
HOT_WORD2=["pluto","Pluto","PLUTO"]
HOT_WORD3=["paperino","Paperino","PAPERINO"]

Permanent link to this article: http://www.andrea.rustichelli.name/factotum-bot-formula_risposta/

Caleb Hattingh – 20 Python Libraries You Aren’t Using (But Should)

Giusto per affinare ulteriormente la programmazione in Python (e poter implementare migliorie al bot Factotum che sto realizzando) mi sono letto questo libro.

L’ho scaricato dal sito della biblioteca di Reggio Emilia tra le risorse disponibili gratuitamente.

Le librerie più utili sono le collections (soprattutto l’oggetto namedtuple) e il modulo logging (per evitare di inserire il comando print come se non ci fosse un domani). Usando opportunamente il modulo logging è possibile utilizzare i livelli di debug per avere un output di controllo più o meno “verboso” a seconda delle necessità e scrivendo poco codice aggiuntivo.

Permanent link to this article: http://www.andrea.rustichelli.name/caleb-hattingh-20-python-libraries-you-arent-using-but-should/