Tag: python

Factotum BOT – analizza_audio(…)

Ed eccoci all’ultima funzione del bot.

Quella che mi ha dato più problemi e quella che mi ha dato maggiori soddisfazioni.

Quando passiamo al bot un messaggio audio registrato all’interno di Telegram, questa funzione, come prima cosa, converte il file audio dal formato OGG al formato WAV. E per fare questo ho trovato una meravigliosa quanto pratica libreria PYDUB.

Successivamente la funzione passa il file audio in formato WAV all’engine di speech recognition di Google per riconoscere il messaggio vocale ed ottenere una stringa di testo.

Infine, la stringa di testo riconosciuta dal messaggio vocale, viene passata alla funzione formula_risposta(…) per formulare una risposta basata sul testo dettato (direi meraviglioso).

"""
=== ANALIZZA_AUDIO ===
Funzione per convertire in WAV il file audio registrato
in Telegram (nativo in formato OGG) e analizzare il messaggio audio
contenuto nel file WAV
======================
"""
def analizza_audio(bot, chat_id, msg):
    print("Funzione ANALIZZA_AUDIO: START")
    ogg_file_id=msg["voice"] ["file_id"]
    print("Funzione ANALIZZA_AUDIO:",ogg_file_id)
    print("Funzione ANALIZZA_AUDIO: Downloading file in formato OGG...")
    bot.download_file(ogg_file_id, "audio_da_telegram.ogg")
    print("Funzione ANALIZZA_AUDIO: Salvataggio file OGG terminato.")
    file_ogg = AudioSegment.from_ogg("audio_da_telegram.ogg")
    file_handle = file_ogg.export("output.wav", format="wav")
    print("Funzione ANALIZZA_AUDIO: Convesione file WAV terminato.")

    r = sr.Recognizer()
    with sr.WavFile("output.wav") as source:
        audio = r.record(source)

    try:
        domanda=r.recognize_google(audio,language="it_IT")
        print("Trascrizione del file audio: " + domanda)   # recognize speech using Google Speech Recognition
        formula_risposta(bot,chat_id,msg,domanda)
    except LookupError:                                 # speech is unintelligible
        print("Impossibile riconoscere del testo nel file audio analizzato")

    return

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

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/

Factotum BOT – La presentazione

Finalmente, dopo un lungo periodo di preparazione, sono riuscito a terminare la presentazione per il progetto Factotum BOT.

Cos’è Factotum BOT? E’ sostanzialmente un bot per Telegram creato in Python utilizzando la libreria TELEPOT (anche se al momento il progetto di sviluppo di questa libreria è fermo) per testare alcune funzionalità e possibilità offerte da questo tipo di implementazione.

Come prima cosa devo ringraziare gli amici del sito “Alla fine del palo” perchè ho letteralmente utilizzato il loro codice per la parte che si occupa di leggere un QR Code (ma ho chiesto preventivamente l’autorizzazione).

Qui di seguito trovate la presentazione (l’attuale versione pubblicata è aggiornata a Settembre 2019) del progetto e nei prossimi giorni pubblicherò sia le singole funzioni sia il codice dell’intero bot funzionante. Ovviamente se lo volete provare dovrete creare un vostro bot tramite TheBotFather e utilizzare il vostro codice di attivazione del bot.

Permettetemi un’ultima divagazione…

Mi sono imposto (per motivi etici) di realizzare il progetto unicamente con software libero e quindi anche la presentazione l’ho voluta realizzare con lo strumento Impress della suite per ufficio LibreOffice. L’impressione che ho avuto è che sia un programma orrendo rispetto al suo parente più blasonato di casa Microsoft.

E a questo proposito mi viene in mente la diatriba tra Torvalds e Stallman quando, nella conferenza del 1996 organizzata dalla Free Software Foundation, Torvalds ammise di ammirare il software per la presentazioni delle diapositive della Microsoft. “Da qualche parte nell’universo del software libero stava nascosto un programma che forse un giorno qualche hacker avrebbe trasformato in alternativa a Power Point. Ma fino a quel momento, perchè invidiare alla Microsoft l’idea di aver realizzato quel programma e di essersene riservata i diritti?”

Beh posso tranquillamente dire che quel giorno non è ancora arrivato. Per fortuna di Microsoft e per sfortuna nostra.

Trovate tutti i link utili nell’apposita sezione del sito.

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

Convertire un file OGG in WAV con Python

Avevo la necessità (all’interno di un progetto più ampio di cui vi parlerò in seguito) di convertire un file audio OGG in un file WAV. Dopo una lunga ricerca su internet (e in particolare su GitHub) ho trovato la libreria PyDub. Per l’installazione della libreria ho utilizzato, per la prima volta, direttamente i file di progetto prelevati direttamente da GitHub.

Quindi come prima cosa ho scaricato la libreria con il seguente comando:

git clone https://github.com/jiaaro/pydub.git

sono entrato nella cartella che si è creata (nella cartella documenti) e ho lanciato il seguente comando:

sudo python3 setup.py install

per sicurezza ho installato anche delle librerie aggiuntive per essere sicuro di avere a disposizione le librerie per poter gestire i vari formati audio installando il pacchetto ffmpeg con il seguente comando:

sudo apt-get install ffmpeg libavcodec-extra

Ed ecco il programma in python che, con 3 righe, permette di convertire un file audio.

from pydub import AudioSegment
file_ogg = AudioSegment.from_ogg("input.ogg")
file_handle = file_ogg.export("output.wav", format="wav")


Permanent link to this article: http://www.andrea.rustichelli.name/convertire-un-file-ogg-in-wav-con-python/

Dove mi trovo? Un aiuto inaspettato dal Python

A volte capita di svegliarsi dopo una serata intensa e non sapere dove ci si trova. A questo viene in aiuto il sito geoPlugin che offre molti servizi legati alla geo localizzazione. In particolare ho trovato simpatico il servizio che, data la latitudine e la longitudine, fornisce, tramite un oggetto json, l’elenco di alcune località vicine a noi e con informazioni utili come ad esempio la distanza in miglia e kilometri e la direzione.

Questo è un esempio di url da lanciare per avere un’idea dell’output che viene prodotto:

http://www.geoplugin.net/extras/nearby.gp?lat=44.6983&lon=10.6312&format=json

Il passo successivo è stato quello di scrivere un programma in python per gestire l’output. Questo programma non prevede la modifica delle coordinate geografiche in input, se non modificando il sorgente del programma prima della sua esecuzione, però è solamente un primo passo verso qualcosa di più evoluto (ad esempio un bot Telegram).

Infatti ho trovato delle difficoltà nella formattazione corretta del tracciato json di output e della sua successiva gestione tramite la libreria json di python. Ho risolto questo problema convertendo l’output in formato UTF-8.

Molto utile anche l’utilizzo del ciclo for per la lettura dei dati json e degli elementi in esso contenuti.

Riporto di seguito il codice funzionante… andrebbe migliorato… ma funziona.

Permanent link to this article: http://www.andrea.rustichelli.name/dove-mi-trovo-un-aiuto-inaspettato-dal-python/

MusicBrainz Picard

Picard è un programma cross-platform scritto in Pyton per taggare i file musicali attingendo le informazioni dal sito MusicBrainz.

Come prima cosa è necessario installare il programma; da Linux Mint è possibile installarlo tramite riga di comando, tramite gestore delle applicazioni o, a partire dalla versione 18.3, anche tramite Flathub.

Una volta aperto Picard è possibile aggiungere un singolo file o una cartella… in questo caso ho caricato l’album Ok Computer dei Radiohead.

E’ possibile premere il pulsante Raggruppa per chiedere al programma di raggruppare i file (e quindi le canzoni) per Album. A questo punto è possibile premere il pulsante Analizza; in questo modo Picard trova (o meglio prova a trovare) le informazioni delle canzoni su Musicbrainz.

A questo punto, se l’analisi va a buon fine, l’album viene visualizzato nella parte destra della finestra (e contestualmente viene eliminato dalla parte sinistra) con l’icona del CD in colore giallo oro per confermare che l’analisi è andata a buon fine. Espandendo il CD è possibile vedere le canzoni che sono state etichettate con i TAG ricevuti dal portale Musicbrainz.

L’utilità di questo TAG è opinabile… aggiunge informazioni utili soprattutto se le canzoni vengono gestite con programmi, come ad esempio Kodi, che permettono di avere una gestione molto complessa e precisa dei file musicali presenti sul proprio computer.

Come ultima cosa è necessario selezionare il CD e premere il tasto Salva in modo da salvare le informazioni sui file di origine. L’operazione viene confermata dall’icona a forma di segno di spunta verde davanti ad ogni file salvato con successo.

Permanent link to this article: http://www.andrea.rustichelli.name/musicbrainz-picard/

Sebastian Raschka – Machine Learning con Python

Libro interessante ma, per quanto mi riguarda, poco pratico.

Questo libro parla delle principali tecniche di machine learning, ovvero:

  • apprendimento con supervisione
  • apprendimento senza supervisione
  • apprendimento di rafforzamento

Dopo una ampia ed esaustiva introduzione teorica, si inizia a parlare in Python e le librerie utilizzate sono:

  • NumPy
  • SciPy
  • scikit-learn
  • matplotlib
  • pandas.

Permanent link to this article: http://www.andrea.rustichelli.name/sebastian-raschka-machine-learning-con-python/

Roger… il primo bot per Telegram scritto in Python

Partiamo con il primo bot per Telegram scritto in python.

Come prima cosa utilizzare il bot BotFather di Telegram per creare un nuovo bot e copiare il codice di attivazione che dovrà essere inserito nel codice del programma.

Questo bot farà una cosa molto semplice, ovvero analizza il formato del messaggio digitato e non farà altro che riproporlo nel formato:

Roger... TESTO DIGITATO SU TELEGRAM... passo...

Oltre ad interagire direttamente all’interno di Telegram, il programma visualizzaerà anche i messaggi digitati all’interno della finestra dove lo script è in esecuzione.

Anticipo che Telegram può essere scaricato per qualsiasi piattaforma compreso iOS e Linux… in questo modo è possibile utilizzare dispositivi più comodi rispetto al solito smartphone.

Qui di seguito è riportato il testo funzionante di questo primo e semplice bot.

import time
import telepot
import json
from telepot.loop import MessageLoop

def handle(msg):
content_type, chat_type, chat_id = telepot.glance(msg)
print(content_type, chat_type, chat_id)

if content_type == 'text':
text = msg['text']
bot.sendMessage(chat_id, 'Roger... ' + text + '...passo...')
print(msg["from"] ["first_name"] + " ha scritto " + msg["text"])

bot = telepot.Bot('COPIARE_CODICE_ATTIVAZIONE_BOT')
MessageLoop(bot, handle).run_as_thread()
print('BOT in ascolto ...')
# Questo ciclo itera il programma (agisce come un processo sempre attivo)
while 1:
time.sleep(10)

Questa è una schermata tratta da Telegram (questa è la versione per linux)

e questo è lo stesso output che si può leggere nella console.

Permanent link to this article: http://www.andrea.rustichelli.name/roger-il-primo-bot-per-telegram-scritto-in-python/

Telegram… vieni a me

Voglio programmare un Bot in Telegram usando il linguaggio Python. Queste sono le premesse.

Ovviamente occorre installare Python e un editor sulla macchina.  Successivamente è necessario installare la libreria TELEPOT (per interfacciarsi con le API di Telegram) e PPRINT per avere delle funzionalità aggiuntive sulla scrittura dei messaggi.

Entrambe le librerie le ho installate con il comando:

sudo easy_install3 telepot
sudo easy_install3 pprint

Per l’installazione delle librerie Python preferisco utilizzare il programma easy_install al posto di pip perchè con pip su Linux Mint 18.3 ottengo sempre dei messaggi di errore.

Apro IDLE (un veloce e leggero IDE per Python) e scrivo i seguenti comandi :

import telepot [con questa istruzione importiamo la libreria 'telepot' per gestire il bot]

bot = telepot.Bot('***** PUT YOUR TOKEN HERE *****') [richiamo il bot utilizzando 
il token associato al bot]

bot.getMe() [eseguo la funzione per visualizzare i dati principali del bot]

Ecco quello che viene visualizzato:

Se visualizziamo un testo come quello sopra riportato significa che ci siamo correttamente collegati al nostro Bot di Telegram che, in questo caso, si chiama zaccabot.

 

Permanent link to this article: http://www.andrea.rustichelli.name/telegram-vieni-a-me/

Atom per la programmazione in Python

Ok, decido di iniziare a smanettare un po’ più seriamente con il Python. La prima cosa di cui ho bisogno (e qui rimembro i bei tempi andati quando la Borland sviluppava degli IDE fotonici) è un buon editor… completo ma non troppo complicato visto che voglio dedicarmi alla programmazione e non alla configurazione dell’editor.
Dopo un paio di installazioni fatte seguendo suggerimenti trovati su internet, decido di installare l’editor Atom.
La cosa migliore da fare è andare sul sito https://atom.io/ e scaricare il pacchetto di installazione .DEB… al termine del download viene eseguito il programma di gestione di questo tipo di pacchetti e l’installazione viene completata con successo.

Una volta terminata l’installazione, è necessario installare alcuni package per aggiungere delle funzionalità all’editor. Per installare i package è necessario andare nel menù Edit – Preferences e poi, nella finestra Settings che si apre nella parte centrale dell’editor, è necessario andare nella sezione Install.

Ho deciso di installare i seguenti package:
– atom-python-run: questo permette di eseguire il codice scritto in python. Ho scelto questo package perchè è veloce da configurare per l’utilizzo con il python3 (come da schermata sotto riportata) e consente di eseguire il codice tramite 2 tasti funzione (F5 e F6).

– autocomplete-python: per avere suggerimenti durante la scrittura del codice in python.

– minimap: per visualizzare sulla destra una anteprima del testo che è possibile scorrere per raggiungere velocemente la parte di programma selezionata. E’ molto comoda per i programmi molto lunghi, ma è comunque una figata anche per gli script più corti.

– file-icons: per visualizzare, nell’albero di progetto, i file con una icona che rappresenta il contenuto. Questa funzione, oltre a migliorare il look & feel permette di rendere più agevole individuare i file in progetti con molti file.

E adesso non rimane che iniziare a scrivere un po’ di codice.

Permanent link to this article: http://www.andrea.rustichelli.name/atom-per-la-programmazione-in-python/