Esperimenti con Tornado

Da qualche giorno mi è venuta in mente qualche idea e per questo ho dato un po un’occhiata a qualche strumento che mi poteva aiutare nello sviluppo. lo avevo già provicchiato, ma in questo weekend l’ho testato un pochettino di piu e credo sia la soluzione ad alcuni dei miei problemi. Vi starete chiedendo di cosa parlo, non se avete letto il titolo del post, ma se utilizzate  FriendFeed allora avete già testato le alcune delle potenzialità di  Tornado, un web server open source scritto in Python. Tornado realizzato dagli sviluppatori di Facebook, il noto social network per chi non lo sapesse, e messo a disposizioni di tutti distribuendo i sorgenti da settembre 2009 sotto Apache Licence Versione 2.0.
Ma cosa è Tornado e cosa fa? Come ho detto prima è un web server scalabile, non-bloccante, snello ad alte prestazioni che lo rendono particolarmente utile per i servizi web in real time. Il core, composto da un codice molto snello, quasi minimale direi, va a tutto vantaggio della velocità d’esecuzione e di una certa libertà concessa al programmatore. Non so se questa snellezza è dovuta all'”immaturità” del progetto, idea rafforzata dall’approccio piuttosto essenziale nella gestione del logging e della sicurezza, oppure se c’è stata una scelta ponderata nello scrivere il codice non tenendo conto di queste caratteristiche.
Esistono altri framework web che adempiono agli stessi scopi e molto più noti e popolari come Django o  Twisted, quest’ultimo, certamente più complesso e anche più sofisticato nei meccanismi interni visto anche il supporto a molti più protocolli. Tornado invece si come approccio e semplicità si avvicina molto più a web.py o all’AppEngine di Google, ma con ottimizzazione sul non-blocking e su alcuni strumenti.
Tornado può essere scaricato all’indirizzo tornado-0.2.tar.gz ed io l’ho provato su Snow Leopard su Linux, richiede PycURL e le librerie JSON.
Ma vediamo un po come si installa e qualche linea di codice per metterlo in moto, il resto è demandata alla vostra fantasia.
Scaricate lo zip dal link precedente e aprite una finestra di terminale e digitate:

Mac OS X 10.5/10.6

sudo easy_install setuptools pycurl==7.16.2.1 simplejson

Ubuntu Linux

sudo apt-get install python-dev python-pycurl python-simplejson

e poi decomprimete Tornado, posizionatevi nella cartella e procedete con l’installazione:

tar xvzf tornado-0.2.tar.gz
cd tornado-0.2
python setup.py build
sudo python setup.py install

Ora non ci resta che aprire il nostro editor di fiducia e creare il nostro primo web server:

import tornado.httpserver
import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Ciao, giasone")
        
class MyHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("My custom request")

application = tornado.web.Application([
    (r"/", MainHandler),
    (r"/myrequest", MyHandler),
])

if __name__ == "__main__":
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(8888)
    tornado.ioloop.IOLoop.instance().start() 

ora non vi resta che salvare, poi aprite il terminale e chiamare il vostro script python nomefile.py e visitate l’indirizzo http://localhost:8888/ o http://localhost:8888/myrequest dovreste vedere nel vostro browser le 2 stringhe. Non so se questo vi puo bastare, ma come potrete ben capire le potenzialità sono tante se poi consideriamo che l’integrazione con i più diffusi database come SQLite e MySQL è semplice allora vi si aprira un mondo.
Non vi resta che mettervi a lavoro quindi per il momento è tutto, se avete dubbi commentate o contattatemi.

– Fine –
Postato con Kblogo

Python e la linea di comando

Scrivo questo breve post spinto dalla voglia di provare ciò che ho appena scoperto sul blog di WordPress e cioè come formattare meglio il codice postato, speriamo che funzioni. Tornando al post, come da titolo, sicuramente vi sarà capitato di lanciare dai vostri script qualcosa sulla linea di comando, e chissà quante volte avreste voluto raccogliere l’output, bhe il codice riportato fa esattamente questo:

import popen2
(stdout, stdin, stderr) = popen2.popen3("ls -la")
lines = stdout.readlines()
for line in lines:
    print line

ovviamente dovete installare il plugin, maggiori info sui linguaggi supportati o iparametri opzionali da passare li trovate qui.

Python e XML-RPC, una semplice introduzione

L’XML-RPC è un ottimo strumento per stabilire una vasta gamma di connessioni tra i computer, per integrare ambienti e piattaforme diverse, ma senza condividere direttamente strutture di dati complesse, permette dunque di condividere tali connessioni in modo semplice e veloce. Questa tecnologia permette a Python, in questo caso, di parlare con Perl, con Java, con PHP e cosi via. L’XML-RPC da l’opportunità di usare un “vocabolario standard” per lo scambio di informazioni, creando interfacce di programmazione aperte grazie all’utilizzo e alla combinazione ti tecnologie consolidate come l’architettura RPC (Remote Procedure Call) e le tecnologie XML e HTTP permettendo agli utenti accesso diretto alle informazioni richieste per l’elaborazione. Dopo questa breve introduzione passiamo all’attività pratica rimandandovi alla rete per informazioni piu dettagliate sul protocollo (wikipedia, RFC, ecc). Questo fine settimana mi sono messo un po a testare la libreria pySuseStudio che ho creato per vedere di migliorare l’implementazione e volevo avere un ambiente di testing personalizzato senza usare direttamente quello di Suse Studio cosi mi sono creato qualche script ad hoc per il test della libreria. Per creare un server XML-RPC in python è molto semplice visto che dalla versione 2.2 abbiamo il modulo SimpleXMLRPCServer nella libreria standard e come dice il nome stesso serve all’implementazione di un semplice server. Il modulo fornisce una classe con lo stesso nome, SimpleXMLRPCServer, che istanziata con un indirizzo ed una porta crea il nostro server. Un esempio di codice potrebbe essere questo:

from SimpleXMLRPCServer import *

class My_Web_Service:
    def __init__(self):
        pass

    # not callable through XML RPC because starts with '_'
    def _private(self):
        pass
    
    def tellme(self, msg):
        return "You wrote: "+msg

if __name__ == "__main__":
    server = SimpleXMLRPCServer(("localhost", 8080))
    server.register_instance(My_Web_Service())
    print "Starting ..."
    server.serve_forever()

In poche parole istanziamo un oggetto server, registriamo una istanza della nostra classe My_Web_Service e serviamo la nostra funzione tellme().
Ma come si usa questa roba, nel mio caso uso la mia libreria ma nel vostro potreste aver bisogno di un client, se avete letto la documentazione che vi ho consigliato di cercare prima allora saprete che un client non fa altro che chiamare la funzione che mettiamo a disposizione con il nostro server. Per farlo un semplice client potrebbe essere quello che segue:

import xmlrpclib
server = xmlrpclib.Server('http://localhost:8080')
msg = "Ich bin Giasone"
print server.tellme(msg)

Entschuldigung per il mio tedesco, ma se avviamo prima il server e poi il client potremo vedere in azione un sistema XML-RPC funzionante, si spera. Cosa è successo? XML-RPC utilizza come trasporto l’XML trasferito via HTTP, Con questo metodo, il client può chiamare metodi con parametri su server remoti (nel nostro caso localhost) e gli vengono restituiti dei dati strutturati. Visto che gli oggetti XML vengono inviati e gestiti attraverso richieste POST abbiamo una funzione apposita, do_POST(), che fa al caso nostro. Non è implementato però un handler per le richieste di tipo GET, possiamo ovviare al problema semplicemente implementando un nostro handler e passarlo durante la creazione del nostro oggetto server come vediamo in questo esempio:

from SimpleXMLRPCServer import *
class ExtendedXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
    def do_GET(self):
        msg = "This is a GET result!"
        #write the data to the socket along with valid HTTP headers
        res = 'HTTP/1.0 200 OK\r\nDate: %s\r\n\r\n%s' % \
          (self.date_time_string(),msg)
        self.wfile.write(res)
        self.log_request(200)

class My_Web_Service:
    def __init__(self):
        pass

    # not callable through XML RPC because starts with '_'
    def _private(self):
        pass
    
    def tellme(self, msg):
        return "You wrote: "+msg

if __name__ == "__main__":
    server = SimpleXMLRPCServer(('', 8080), ExtendedXMLRPCRequestHandler)
    server.register_instance(My_Web_Service())
    print "Starting ..."
    server.serve_forever()

ora puntate il vostro browser su localhost:8080 ed ecco la vostra richiesta accolta. Se volete maggiori informazioni, e vi consiglio di dargli un’attenta lettura, potete spulciare la documentazione dei due moduli. Come sempre per maggiori informazioni o chiarimenti chiedete pure.

– Fine –
Postato con Kblogo

Python e SQLite3

Pitone Albino

Oggi vediamo un po come utilizzare python con il noto db engine SQLite versione 3. Mi è venuto in mente di fare un post su questo solo perche oggi mi è servito per dei test che stavo facendo. Iniziamo col dire che SQLite è una libreria software che implementa un DBMS SQL incorporabile all’interno di applicazioni e utilizzata in molti grandi ed importanti progetti, Mozilla Firefox per fare un esempio, esistono molti binding per i più diffusi linguaggi di programmazione ed è portabile su molte piattaforme. Detto questo passiamo a python che ovviamente ha un binding per questo db nelle versioni piu nuove dovrebbe esserci gia il supporto per SQLite altrimenti basta installare sqlite3, ovviamente per questo vi basta googlare ma se avete problemi chiedete pure, quindi passiamo subito al vivo dell’attività e cioè per prima cosa creiamo un db con SQLite digitando nel terminale:


$ sqlite3 example_db
SQLite version 3.6.11
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>


Ora creiamo una tabella al suo interno ed inseriamo dei dati di esempio


sqlite> create table tbl1(one varchar(10), two smallint);
sqlite> insert into tbl1 values('hello!',10);
sqlite> insert into tbl1 values('goodbye', 20);


Possiamo ora testare effettivamente il contenuto della nostra tabella


sqlite> select * from tbl1;
hello!|10
goodbye|20
sqlite>


Ora vediamo come possiamo interrogare questo db da python, per prima cosa importiamo il modulo e ci connettiamo:


import sqlite3.dbapi2 as sqlite3

#create connection to db
conn = sqlite3.connect(‘example_db’)

ora abbiamo bisogno di un cursore per poter eseguire le nostre query sul db per crearne uno:


#create cursor
c = conn.cursor()


per eseguire delle query ora dobbiamo semplicemente richiamare


# Create table
c.execute('''create table stocks (date text, trans text, symbol text, qty real, price real)''')
# Insert a row of data
c.execute("""insert into stocks values ('2006-01-05','BUY','RHAT',100,35.14)""")


e per scrivere i cambiamenti sul db basta eseguire


# Save (commit) the changes
conn.commit()


Se volessimo sapere invece quale è stato l’ultimo id inserito potremo usare


lastid = cursor.lastrowid


Se tentate di chiudere una connessione prima che le modifiche siano state salvate con il metodo commit SQLite solleverà un’eccezzione. Se non volete salvare le modifiche appena fatte vi viene messo a disposizione una funzione apposita per tornare indietro, rollback appunto, che ha il potere di cancellare tutte le vostre malefatte dal db


conn.rollback()


Fino ad ora abbiamo visto solo come inserire, ma per leggere? facciamo in questo modo


# Read all the rows from the given table
cursor.execute('SELECT * FROM stocks')
print cursor.fetchall()


Riceveremo una lista di tuple ed ognuna di esse rappresenta una riga, ma se avessimo voluto solo alcune delle righe avremmo potuto usare al posto di fetchall() un bel fetchmany() che prende come unico parametro un integer che definisce il numero di righe da tirare fuori se poi volessimo prendere solo il primo risultato allora potremmo usare un fetchone()


#fetch only 4 row from results
print cursor.fetchmany(4)
#fetch only the first row from results
print cursor.fetchone()


Ovviamente quando abbiamo finito bisogna chiudere il tutto chiamando le funzioni per chiudere il cursore e la connessione


# We can also close the cursor and connection if we are done with it
c.close()
conn.close()


SQLite è un database engine interessante a differenza degli altri non ha bisogno di un database server, infatti funziona come una libreria che utilizza un semplice file come database ed in alcuni casi le prestazioni sono veramente eccellenti. Il binding di Python sfrutta questi benefici e dà la possibilità agli sviluppatori di utlizzarlo facilmente nei propri progetti. Per il momento è tutto sperando di esservi stato d’aiuto.

– Fine –

Post scritto con KBlogo

Simulare l’accelerometro sull’IPhone SDK 2.2.1

Mentre cercavo come utilizzare l’accellerometro del mio MacBook mi sono imbattuto in questo articolo che spiega come simulare l’accelerometro sul nostro IPhone Simulator visto che non c’è di default, senza l’ausilio di un vero IPhone. Come spiega Karan Vasudeva, autore dell’articolo, bisogna scaricare UniMotion che legge l’SMS (Sudden Motion Sensor) del Mac e che ritorna i valori in vari formati. Poi bisogna scaricare un’altro software, scritto da Otto Chrons, e che trovate qui. Quest’ultimo software e diviso in due parti, uno va installato sul simulatore e l’altro va incluso nei vostri programmi sotto forma di libreria semplicemente inserendo un

#import "AccelerometerSimulation.h"

a questo punto, sempre Karan, usa il suo script python che lega i 2 software e passa il risultato di UniMotion all’IPhone Simulator attraverso il codice di Otto. Ma come funziona e cosa centro io? Allora ricapitoliamo: il software di Otto, ACCSim, è diviso in 2 parti, un server e un client, il server sta in ascolto sulla porta 10552 in attesa di una stringa tipo:

ACC: , timestamp, x, y, z

il client invece e costituito in questo caso dallo script di Karan che raccoglie dalla periferica questa stringa e passata al server. A questo punto entro in gioco io, che grazie alla libreria python trovata, PyAppleSMS e di cui parlo nel post precedente, ho modificato lo script di Karan per utilizzare questo modulo in modo da rendere il tutto piu leggero e facile e con l’utilizzo di un unico script.
Per testare il tutto quindi scaricate il software di Otto, copiate ed incollate questo script python nel vostro editor preferito:

import sys, socket, time, traceback
import applesms

kCFAbsoluteTimeIntervalSince1970 = 978307200.0 # from CFDate.c

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(('',0))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

while 1:
try:
x, y, z = map(lambda x: -1 * x, applesms.coords())
# change epoch to be compatible with CFAbsoluteTimeGetCurrent()
currentTime = time.time() - kCFAbsoluteTimeIntervalSince1970

accdata = ','.join(map(str,('ACC: 0',currentTime,x,y,z)))

sock.sendto(accdata, ('', 10552))
# print '% .2f % .2f % .2f' % (x, y, z)
except (ValueError, KeyboardInterrupt):
sock.close()
sys.exit(-1)
except applesms.error, e:
print 'An error occurred in PyAppleSMS module: %s' % str(e)
sys.exit(-1)
except:
traceback.print_exc()

che altro non è che lo script di Karan che però utilizza la libreria PyAppleSMS. Avviando AccelerometerGraph, un programma di esempio che trovate nella Knowledge Base di ADC e che vedete nell’immagine sopra, e lo script che trovate sopra vi accorgerete che funziona, non so quanta attendibilità può esserci nel formato fornito, ma so che funziona e legge i dati. Vi rimando alle pagine linkate quà e là per il post per le rispettve informazioni.
Spero di essere stato chiaro, se pero cosi non fosse sentitevi liberi di chiedere delucidazioni in merito, i commenti esistono per questo!!

EDIT: Funziona anche con le nuove versioni dell’IPhone SDK 3.0

– Fine –
Post scritto con KBlogo

Controllare l’accelerometro del Macbook con Python

Una delle cose che mi piacciono di più del mio nuovo MacBook è proprio l’accelerometro (Sudden Motion Sensor) montato ormai su quasi tutti i modelli Mac e che servono a far bloccare le testine dell’hard disk in caso di caduta del portatile. Quello che ho cercato è come usare questo accessorio per qualche altro utilizzo. Cercando un po su Google sono arrivato su questa pagina, in italiano, dove questo ragazzo ha creato un modulo scritto in C per interrogare l’SMS con Python. Vi basta scaricare il modulo, PyAppleSMS, decomprimerlo e installarlo con un semplice

python setup.py install

una volta installato potete leggere i valori dell’SMS semplicemente importando il modulo e chiamare il metodo per leggere le coordinate. Un esempio lo trovate nell’archivio del modulo altrimenti bastano queste due righe di codice:

import applesms
(x, y, z) = applesms.coords()

Ora sta a voi farci qualcosa di utile, potete usarlo nelle vostre applicazioni o nei vostri giochi.
Buon lavoro a tutti!!!

– Fine –
Post scritto con KBlogo

Python e Mysql

Durante questo fine settimana mi sono un po concentrato sull’utilizzo di python per gestire uno dei database piu famosi al mondo, MySql. Avevo già scritto qualche cosa ma ho voluto creare una interfaccia visuale al semplice e potente client da riga di comando. Il programmino è scritto in python e QT come librerie grafiche, il perché non lo so, forse la settimana prossima faro un porting su GTK. Per il momento il programmino non fa altro che eseguire delle query e fornire i risultati. Ma vediamo velocemente come creare un piccolo script per eseguire delle query su un db Mysql. Per prima cosa abbiamo bisogno del modulo che permette a python di interagire con Mysql, il suo nome è python-MySqldb per installarlo su sistemi Debian based basta digitare, da amministratore:

# apt-get install python-MySqldb

a questo punto abbiamo tutto il necessario per iniziare . Per prima cosa apriamo il nostro nuovo file .py nel nostro editor preferito ed iniziamo con l’importare il modulo:

import MySQLdb

a questo punto non ci resta che creare una connessione con il DB:

 conn = MySQLdb.connect (host = "localhost",
                           user = "testuser",
                           passwd = "testpass",
                           db = "test")

ora abbiamo un oggetto connessione che punta ad un database all’indirizzo “localhost” con utente “testuser” e password “testpassword” ed abbiamo chiesto di utilizzare il database “test”. Una volta ottenuta la connessione abbiamo bisogno di qualcosa che ci indichi sempre come e dove comunicare con il DB quindi creiamo un oggetto cursore:

cursor = conn.cursor()

Fatto questo ora possiamo iniziare ad interrogare il nostro DB lanciando delle query semplicemente lanciandole attraverso il metodo appropriato:

cursor.execute ("SELECT * FROM testtable")

dove estraiamo tutto il contenuto della tabella “testtable” all’interno del DB “test” per vedere il risultato della query abbiamo bisogno di prendercelo:

   row = cursor.fetchone ()
   print row

Quindi avremo stamapato a schermo il risultato dell’interrogazione. Gli statement sopra non sono ilmassimo dato che potremmo avere piu righe e piu colonne per ogni riga quindi sarebbe meglio ciclare, magari con un for, sul risultato e poi utilizzarlo come meglio crediamo.
Possiamo fare tutte le interrogazioni che vogliamo l’importante è lanciarle con il metodo “execute” l’importante è che al termine di tutte le nostre operazioni chiudiamo la connessione con il DB eseguendo un:

   cursor.close()
   conn.close()

Sinceramente la chiusura del cursore al momento mi da errore ma non so non ho letto per bene la documentazione, quindi assicuratevi di chiudere almeno la connessione con il db. Questo e tutto non vi resta che mettervi e provare, per maggiori info potete visitare il sito del modulo su SourceForge.
Se invece volete usare il mio programmino, chiamato QSql potete scaricarlo dal link qui sotto. Ogni commento o critica è benvenuta, per qualsiasi chiarimento non vi resta che chiedere.

QSql v 1.0

– Fine –
Post scritto con KBlogo

Installare e configurare mod_python

Dato che ogni tanto mi metto a provare qualche idea che mi viene i mente oggi mi sono messo a giocherellare un po con il mod_python [1], ma sul mio server non era configurato quindi, se a qualcuno puo servire, metto qui i semplici passi per configurarlo.
Per prima cosa bisogna installarlo, io uso una Debian quindi un semplice:

sudo apt-get install libapache2-mod-python

Non ci rsta che configurare Apache per interpretare i nostri file Python. Esistono 2 modi per farlo, fargli interpretare file python puri, .py per intenderci, oppure file Python Server Pages , .psp, che permettono di integrare codice python direttamente nell’HTML. Io ho scelto la seconda, non conosco i vantaggi e solo perche ricordavo di aver fatto questa in precedenza e quindi l’ho usata.
passiamo quindi alla configurazione di apache quindi apriamo il file di configurazione di default dei virtual host di Apache, la posizione varia in base alla distribuzione e dipende se avete altre configurazioni di virtual host, richiamando il file in questo modo:

vi /etc/apache2/sites-available/default

e aggiungo le linee che mancano alla vostra configurazione:

[...]

                Options Indexes FollowSymLinks MultiViews
                AllowOverride None
                Order allow,deny
                allow from all
		## Queste linee abilitano l'interpretazione dei file .py
                AddHandler mod_python .py
                PythonHandler mod_python.publisher
                PythonDebug On
		## fine

[...]

fatto questo salviamo e riavviamo il server Apache:

sudo /etc/init.d/apache2 restart

Ora bisogna testare se il tutto funziona, sempre che fino ad ora tutto sia andato liscio, lo facciamo creando due file, un semplice form in HTML, lo chiameremo test.html:

<html>
<head><title> Mod_python test form</title></head>
<body>
<form action=”form.py/processa” method=”POST”>
Inserisci il tuo nome:<br />
<input type=”text” name=”name”><br />
<input type=”submit”><br />
</form>
</body>
</html>

e un file python che processi i dati del form, lo chiameremo form.py:

def processa(req, name):
    if not name:
        return "Who are you?"
    else:
        return "Ciao %s!" % name

salviamo questi file nella directori radice di Apache, nel mio caso /var/www ed apriamo il nostro browser all’indirizzo, sempre nel mio caso, http://localhost/test.html apparirà un form molto semplice inserite il vostro nome o quello che vi pare e cliccate sul bottone. il risultato sara qualcosa tipo Ciao quellocheavetenserito. Se fino ad ora tutto non ha restituito errori ed ha funzionato allora potete iniziare a divertirvi a scriptare quanto volete, ma se invece qualcosa non funziona allora vi verrà segnalato.
Mod_python utilizza un oggetto request che possiamo utilizzare per processare i nostri dati alcune funzioni utili allo scopo possono essere req.write() e req.read() per scrivere e leggere sull’oggetto o si possono sollevare eccezzioni con apache.SERVER_ERROR. Questo dovrebbe essere tutto se avete problemi chiedete cerchero di rispondervi e chiarire i vostri dubbi.

[1] www.modpython.org

— Fine —
Post scritto con KBlogo

My Pycon’s ticket

Oggi ho comprato il mio biglietto per la PyCon Uno alla modica cifra di 30 euro,se vi sembrano troppi sappiate che inclusi ci sono 2 giorni di conferenze, pause caffe e 2 pranzi. Se non sbaglio questo prezzo rimarrà tale fino al 27/05 poi ci sarà da sganciare almeno 50 euro. Per informazioni comunque il sito di riferimento è www.pycon.it e se qualcuno di voi ci va me lo faccia sapere…

PyCon Uno – Firenze 9 e 10 Giugno 2007

PyCon Uno è la prima conferenza italiana dedicata al linguaggio di programmazione Python, e si terrà a Firenze il 9 e il 10 Giugno 2007. La conferenza è organizzata da un gruppo di appassionati e senza finalità di lucro; si prefigge la divulgazione di Python, e di dare visibilità agli sviluppatori professionisti, studenti, aziende e semplici interessati al linguaggio. Io molto probabilmente sarò presente ed invito ognuno di voi ad aderire se nelle condizioni di farlo.

Per maggiori informazioni e per registrarsi cliccate su www.pycon.it