Google AppEngine propose est un service de développement web assez puissant et très intéressant qui permet de faire une application "scalable" en Java, Python et maintenant en Go. Le souci, si comme moi vous avez "MyPaint" et par conséquent le paquet protobuf-python... vous allez vous taper une erreur monstrueuse au démarrage de votre application... on va trouver une méthode simple pour contourner ce souci

Car effectivement, au premier lancement de votre application:

 ./google_appengine/dev_appserver.py helloworld/
Traceback (most recent call last):
  File "./google_appengine/dev_appserver.py", line 125, in <module>
    run_file(__file__, globals())
  File "./google_appengine/dev_appserver.py", line 121, in run_file
    execfile(script_path, globals_)
  File "/home/patachou/Dev/google_appengine/google/appengine/tools/dev_appserver_main.py", line 138, in <module>
    from google.appengine.tools import os_compat
ImportError: No module named appengine.tools

Pourquoi ? tout simplement parce que le paquet protobuf contient un module nommé... google ! du coup, python ne va pas voir ailleurs que dans le site-package protobuf et plante misérablement, lachant son dernier souffle en vous insultant... et vous, vous n'avez que pour seule solution de vous rabattre tant bien que mal sur des discussions sur le net où tout le monde vous demande de supprimer protobuf.

Sauf que moi, j'utilise MyPaint et j'ai pas envie de me remettre le paquet à chaque fois que je veux dessiner. Et puis de toutes manières j'aime pas les méthodes où il faut supprimer un paquet tout simplement parce qu'une implémentation sent la fosse septique...

La solution ? oui oui deux secondes...

Elle est simple ma solution... utiliser un environnement virtuel ! Attention, pas un LXC ou une VM qui va vous plomber tout votre espace disque... non ! juste un outil python qui rend tellement service, et dont je me sers tout le temps pour tester mes "setup.py" et autres joyeusetés qui peut simplement foutre le boxon dans mes répertoires.

Bref, on va faire ça propre !

On crée un environnement virtuel

mkdir -p ~/Dev/appengine
virtualenv ~/Dev/appengine

Voilà, c'est fait... on copie maintenant le répertoire "google" fournis avec le SDK Python de Google App Engine:

cp -ra ~chemin/vers/google_appengine/google ~/Dev/appengine/lib/python2.7/site-packages/

Et pour lancer l'engin google, on active l'environnement:

source ~/Dev/appengine/bin/activate

Du coup, on voit notre prompt terminal commencer par: (appengine), chez moi ça donne:

(appengine)[patachou@patrice-laptop ~]$

Vous pouvez maintenant lancer votre programme (prenez le tutorial python 2.7 de google) de cette manières:

~chemin/vers/google_appengine/dev_appserver.py helloworld/

Pour sortir de l'environnement virutel:

deactivate

Voilà, c'est simple, assez propre, et en plus ça marche...

Google vient de sortir Google Drive, comprenez un espace de stockage dans le "cloud" (à distance, sur les serveur Google, avec mix des documents de google-docs). L'application de disque dur distant est accessible de plusieurs manières: Android, PC ou directement sur le net. Or sous Windows et Mac on a la possibilité d'utiliser un programme qui monte un disque sur l'ordinateur. Qui dit "monter" rappelle le point de montage Linux (unix...). Google a annoncé une version de Google Drive Linux pour bientôt mais en attendant vous pouvez encore utiliser le projet http://code.google.com/p/google-docs-fs/

Ce projet était à la base un système de montage simple utilisant fuse pour afficher les google-docs sur un disque monté localement. Mais comme Drive utilise le même point d'accès, ce (vieux) projet fonctionne très bien. Sous Fedora, il suffit de faire:

su -c "yum install fuse-python -y"


cd /tmp
hg clone https://code.google.com/p/google-docs-fs/
cd google-docs-fs
su -c "python setup.py install"

Reste alors à monter le dossier:

mkdir ~/GoogleDrive
gmount ~/GoogleDrive votre_user@gmail.com

On vous demande alors le mot de passe google, et hop le point de montage est créé:

mount
gmount.py on /home/patachou/GoogleDrive type fuse.gmount.py (rw,nosuid,nodev,relatime,user_id=1000,group_id=1000)

Vous pouvez dés lors visiter le dossier, créer des répertoires, copier des données, ouvrir vos documents... et y accéder depuis votre mobile, le net... Reste à voir ce que l'application Google offrira de mieux que ce petit projet python, parce que pour le moment cela me convient tellement bien...

PS: vous pouvez ajouter ce point de montage dans /etc/fstab pour l'avoir actif tout le temps, mais comme je ne sais pas comment placer le mot de passe. Je vous tiens au courant si je trouve :)" class="smiley

Une petite interface en ligne de commande pour Revelation.

French version (English version)

Revelation est un logiciel qui vous permet de gérer vos mot de passe comme vous le souhaitez. Vous pouvez les organiser en list ou par catégorie avec des dossiers, et le tout est sauvegarder dans un fichier chiffré.

Je l'utilise depuis quelques temps mais bon, je ne souhaite pas me promener tous les jours avec le dit fichier sur une clé USB (même si celle-ci est chiffrée elle-même).

Du coup j'ai écrit une petite interface en ligne de commande qui permet d'interroger une base de donnée de Revelation par ssh.

Voir le contenu du fichier:

$ ./revelationcli.py revelation.db --showtree
Password: 
Database:
  | \_ test1
  | \_ test2
  | \_ folder1
  |   | \_ folder2
  |   |   | \_ test4
  |   |   | \_ test2
  |   | \_ test3

Voir les information à propos d'un mot de passe:

$ ./revelationcli.py revelation.db test4
Password: 
  Name : test4
  Database : test

Voir toutes les informations à propos d'un mot de passe (y compris le mot de passe lui même):

$ ./revelationcli.py revelation.db test4 --show
Password: 
  Name : test4
  Password : HYoJx7W8
  Database : test

Le projet est pour le moment disponible à : http://project.pingoured.fr/revelationcli/

Voyons si ça vaut le coup de le développer plus que ça ;-)

Il est évident que nous ne sommes pas tous accrocs aux outils en mode texte (dans un terminal) mais personnellement j'y trouve mon compte: vitesse, exécution claire, lisibilité... et modularité. Je suis un Google Fan (houuu je vais m'en prendre plein la poire moi) et j'ai beaucoup de mes données sur Google: mail, documents, agenda... Voici donc comment pouvoir envoyer des mails et lire ces derniers convenablement avec Mutt, y compris l'autocompletion des contacts Gmail

La configuration ne sera pas compliqué. Il faudra juste se farcir 3 fichiers de configurations:

• un pour mutt lui même, configuration du compte
• un pour permettre les macros de lecture de mail en HTML
• un fichier netrc pour permettre à goobook de fonctionner

Bref, passons en premier lieu à l'installation proprement dite des logiciels:

su -c "yum install mutt python-setuptools links"
easy_install goobook

Le première commande installe mutt et les utilitaires pytyon pour installer un paquet python, puis links, le lecteur html en console. L'autre installe goobook, un outil qui permet de récupérer un carnet d'adresse google.

Goobook est un outil python que j'ai testé après en avoir essayé plusieurs, c'est de loin le plus pratique et le plus abouti que je connaisse. Vous pouvez voir la page du projet ici: http://pypi.python.org/pypi/goobook...

Maintenant, passons à la configuration de Mutt

#fichier ~/.muttrc

#enregistre les messages envoyés et brouillons dans Gmail
set record="+[Gmail]/Messages envoyés"
set postponed="+[Gmail]/Brouillons"

#configuration du serveur
set hostname=gmail.com
my_hdr From: PRENOM NOM <USER@gmail.com>
set use_envelope_from
set envelope_from_address="USER@gmail.com"

unignore Date Message-ID In-Reply-To

set move=no
set spoolfile=imaps://imap.gmail.com:993/INBOX
set imap_user = "USER@gmail.com"
set imap_pass= "VOTRE MOT DE PASSE"
set imap_authenticators="login"
set imap_passive="no"
set folder="imaps://imap.gmail.com:993"
set imap_check_subscribed="yes"
set imap_list_subscribed="yes"

set smtp_url="smtps://USER:VOTRE MOT DE PASSE@smtp.gmail.com:465"
set ssl_starttls="yes"

set locale="fr_FR"
set date_format="%A %d %b %Y à %H:%M:%S (%Z)"
set attribution="Le %d, %n à écrit:"
set forward_format="[Fwd: %s]"
set forward_quote

mailboxes !

set pager_index_lines="7"
set pager_stop

#gérer un cache
set message_cachedir="~/.mutt_msg_cache"
set header_cache="~/.mutt_header_cache"

#force l'utilisation d'un programme exterieur pour les mails en HTML
auto_view text/html

#et ici la config pour les contacts
set query_command="goobook query '%s'"
bind editor <Tab> complete-query
macro index,pager a "<pipe-message>goobook add<return>" "add the sender address to Google contacts"

Et enfin il faut configurer les commandes pour lire les mails HTML:

#fichier ~/.mailcap
text/html;  links %s; nametemplate=%s.html
text/html;  links -dump %s; nametemplate=%s.html; copiousoutput

Bien. Reste à gérer goobook, on commence par créer un fichier:

#~/.netrc
machine google.com
    login USER@gmail.com
    password Votre Mot de passe

Voilà, testez rapidement que ça passe en tapant:

goobook reload
goobook query un_nom_au_choix

Et bien voilà, lancez maintenant la commande mutt et appréciez un peu la lecture de mail dans un terminal.

Souvenez vous de quelques racourcis:

• Maj+D pour supprimer un ensemble de mail correspondant à un motif que vous tapez (par exemple si vous tapez microsoft, tout les mails correspondants seront marqué comme "à supprimer")
• d pour supprimer le message sélectionné
• m pour envoyer un message (les contacts sont auto complétés via la touche tabulation)
• r pour répondre
• c por changer de dossier de mail
• / pour chercher un mail, selon le nom, le sujet...
• $ pour valider les changements (suppressions)

Voilà, personnellement j'ai adopté mutt et j'en suis très content. Je classe et nettoie ma boite mail en 4 fois moins de temps qu'avant.

Notez que nous pourrons ensuite utiliser mcabber pour tchater avec nos contacts google :)" class="smiley on en reparlera

EDIT: j'ai supprimé la phase de création de goobookrc qui est inutile en fait...

Cython permet de coder des extensions python compilées via un mécanisme de traduction en C. Mais il permet aussi de créer un exécutable de votre programme python. Les performances sont spectaculaires et nous allons le voir dans ce billet

Python est l'un des langages les plus aboutis de notre génération. Tant au point de vue sémantique que la souplesse qu'il permet en terme d'environnement et de possibilités. Outre les outils et modules qui permettent de travailler efficacement, des projets existent pour rendre python encore plus optimal. Beaucoup savent déjà que, comme dans pas mal de langages, il est possible de développer des extension en C pour augmenter la vitesse d'exécution d'un programme python. Mais l'écriture est un peu complexe et il souvent on préfère laisser de coté la performance en faveur de la vitesse de développement.

Python étant interprété, le programme que vous aurez créé sera alors soumi à une dépendance forte: Python lui même. Car pour exécuter un programme python, il faut python. Or comme je vous l'ai dit Python a un univers autour de lui qui permet de faire des miracles. Nous allons donc voir l'un des ses astres qui gravite autour de Python: Cython. Avec lui, vous allez pouvoir développer simplement des extension plus optimisées, et en plus pouvoir compiler un programme python en un exécutable binaire natif.

La seule dépendance sera alors la librairie python.

Voici, sous Fedora, ce que vous allez faire:

yum install Cython

Cela installe les librairies Cython + un outil de compilation qui porte le même nom. C'est parti pour l'explication.

Cython est un outil qui va permettre la traduction de votre code python en C. Un peu comme le fait shedskin. La différence est que Cython permet de générer un code en C qui sera exploitable par python. En d'autres termes, et pour être plus exact, Cython crée du code C pour générer une extenion python valide.

Prenon un simple exemple:

#file: hello.py
def printHello:
        print "Hello you !"

Ce code est simple, c'est une fonction qui, lorsqu'on l'appelle, affiche un message "Hello you !". Pour générer l'extension il existe plusieurs méthodes. La plus simple étant de faire un fichier "setup.py" (un standard python qui utilise distutils) ou utiliser Cython.

Comme je péfère expliquer les choses complexe pour les rendre simples après coup, on commence par la méthode Cython.

cython hello.py

Cela génère un fichier hello.c. Oui il est énorme, près de 1000 lignes. Le but n'est pas de faire léger mais rapide :)" class="smiley

Bon, on va compiler le fichier pour en faire une librairie partagée pour Python:

gcc hello.c -shared -pthread -fPIC -fwrapv -O2 -Wall -fno-strict-aliasing $(pkg-config python --cflags) -o hello.so

voilà donc un fichier hello.so qui est une extension python que nous pouvons utiliser:

#fichier: test.py
import hello

printHello()

Pour le moment, c'est pas super utile car nous ne faisons qu'une opération très simple. Mais Cython ne s'arrête pas à ça. Il permet d'utiliser des type C et même des librairies C. De plus, nous allons voir que nous pouvons faire un exécutable de notre programme. Procédons par étapes.

Passons à l'utilisation de type C, ce qui va rendre un programme plus rapide. Vous connaissez fibonacci ? voici le code qui permet de trouver le résultat de la suite à un rang donné:

#fichier fibo.py
def fibo(n):
        if n == 0 or n == 1: 
                return n
        return fibo(n-2) + fibo(n-1)

Cette fonction est particulièrement lente, d'abord parcce que nous n'avons pas optimisé le code pour garder en mémoire les suite déjà calculées, mais en plus parce que nous allons passer par Python...

Testons:

#fichier test_fibo.py
from fibo import fibo
fibo(32)

et lançons le test avec la commande "time" qui nous donnera le temps d'éxécution:

time python test_fibo.py
3524578

real    0m1.574s
user    0m1.561s
sys     0m0.008s

1,6 seconde environ... autant dire que c'est pas fameux... Voyons avec cython.

cython fibo.py
gcc fibo.c -o fibo.so -shared -pthread -fPIC -fwrapv -O2 -Wall -fno-strict-aliasing $(pkg-config python --cflags)

time python test_fibo.py 
3524578

real    0m1.229s
user    0m1.137s
sys     0m0.089s

Ha y'a du mieux ! 1,2 secondes, on dirait pas mais là on a gangé 30% de temps d'éxécution...

Encore mieux ? possible oui et vous allez voir, pas des moindres !

Entrons dans le vif du sujet, Cython n'est pas python mais un language à part entière. Il permet de créer des types C, je vous l'ai dit. Cela se fait avec le mot clef "cdef". Avec ce mot clef, on peut donc créer une fonction ou variable C, donc en typant et en jouant avec les retours de fonctions. Fibonacci n'utilise que des entiers. Voyons comment redéfinir notre fonction pour la rendre pure C.

En premier lieu, vous renommez fibo.py en fibo.pyx. Pourquoi ? parce que Cython a besoin de savoir que cette fois-ci nous allons utiliser un fichier prévu pour le développement C. Notre fonction va donc ressembler à cela:

#fichier fibo.pyx
cdef int fibo(int n):
        if n == 0 or n == 1: 
                return n
        return fibo(n-2) + fibo(n-1)

Souci , cette fonction ne sera pas vu par des appels externes... en d'autres termes si vous voulez appeler la fonction "fibo" depuis test_fibo.py, ça ne marchera pas. Il faut donc utiliser une des deux méthodes:

• soit vous définissez en plus une méthode avec "def" qui apelle "fibo"
• soit vous n'utilisez pas cdef, mais cpdef qui fera l'alias tout seul (pratique hein)

Alors la méthode 2 me parraissant plus sympa:

#fichier fibo.pyx
cpdef int fibo(int n):
        if n == 0 or n == 1: 
                return n
        return fibo(n-2) + fibo(n-1)

Allez on lance la compilation, pensez bien qu'on utilise le fichier .pyx maintenant, pas le .py:

cython fibo.pyx
gcc fibo.c -o fibo.so -shared -pthread -fPIC -fwrapv -O2 -Wall -fno-strict-aliasing $(pkg-config python --cflags

Et le miracle:

time python test_fibo.py 
3524578

real    0m0.070s
user    0m0.058s
sys     0m0.012s

Et oui, 70 millisecondes ! Incroyable non ?

Et si maintenant on créait un exécutable ? Soyons fou ! On va utiliser une option de Cython qui permet d'intégrer l'exécutable python dans la fonction "main", cette option s'appelle "--embed" pour "embarquer":

cython --embed test_fibo.py -o test.c

Ici j'ai demandé à sortir un fichier nommé test.c, sinon on aurait test_fibo.c et j'aime pas les underscores :)" class="smiley

Compilons ce source:

gcc test.c -o test $(pkg-config python --cflags) -lpython2.7

l'option "-lpython2.7" est celle qui est valable pour Fedora 14 (qui utilise python 2.7) sinon on adaptez le numéro de version à celle de votre installation. Et nous avons maintenant un fichier "test" exécutable:

./test
3524578

Il marche :)" class="smiley par contre on ne gagne pas grand chose en temps d'éxécution par rapport à test_fibo.py. Mais le but ici était d'avoir un exécutable qui ne demande plus que la librairie python (dans le paquet python-libs de Fedora) et non plus Python lui même.

Voyons ce que demande notre exécutable en dépendance:

ldd test
        linux-vdso.so.1 =>  (0x00007fffba369000)
        libpython2.7.so.1.0 => /usr/lib64/libpython2.7.so.1.0 (0x00007f180b44a000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f180b0ae000)
        libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f180ae92000)
        libdl.so.2 => /lib64/libdl.so.2 (0x00007f180ac8e000)
        libutil.so.1 => /lib64/libutil.so.1 (0x00007f180aa8b000)
        libm.so.6 => /lib64/libm.so.6 (0x00007f180a806000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f180b81c000)

Effectivement il demande libpython et, évidamment, fibo.so est appelé lors de l'exécution, donc pensez à avoir ce fichier dans le même répertoire ou bien placé dans le répertoire de librairies (LD_LIBRARY_PATH, ou dans les lib de python)

Voilà, c'est une "courte" introduction car en fait Cython est bien plus puissant que cela, vous aurez à loisirs d'utiliser les librairies C existante (stdlib, math...) et de rendre vos développement extrêmement puissant et rapide... Voilà encore un point qui me rend de plus en plus fan de Python.

Je vous conseille vivement d'aller voir le site de documentation de cython et notamment la page qui traite de distutils dans le tutoriel cython

Voilà voilà

Je l'avoue, j'utilise Adobe flashplayer. Oui je sais j'ai honte, je devrais utiliser swfdec ou gnash mais depuis que la version alpha du plugin 64bits fonctionne plutôt bien, j'ai succombé à la tentation de profiter des sites avec du contenu flash 10 :)" class="smiley

Comme tout geek qui se respecte, j'ai mon côté fainéant qui me pousse à par exemple, faire confiance à un gestionnaire de paquets pour la mise à jour des logiciels installés sur mon ordinateur, sauf que cette version alpha n'est pas empaquetée :(" class="smiley Alors plutôt que de passer voir régulièrement sur le site d'Adobe pour voir si une nouvelle version est sortie, la télécharger, installer manuellement le tout après avoir supprimé l'ancien plugin j'ai ouvert mon terminal, lancé Vim et Firefox pointé sur la doc officielle Python et codé un petit programme qui s'occupe des taches suivantes :

• Vérifie si le plugin est déjà installé et le supprime (ou vous demande de supprimer le rpm)
• Détermine automatiquement depuis la page d'Adobe le lien de téléchargement de la dernière version du plugin
• Télécharge l'archive
• L'extrait
• Installe le nouveau plugin pour Mozilla Firefox

Par contre il n'est pas capable de vous dire si vous avez déjà la dernière version, le but étant juste de le lancer une fois tous les deux mois pour mettre à jour le truc :D

Par ailleurs : pensez à désinstaller le plugin swfdec ou gnash avant de tester Flashplayer 64bits ils risqueraient d'entrer en conflit.

Télécharger le script

Dépendances : Rien qui ne soit pas dans la lib standart de Python ou sur un système Fedora normal.