Styles

samedi 22 décembre 2012

Emacs et Python : flymake pour vérifier le votre code en arrière plan avec pylint, pep8 et pyflakes

Cet article fait suite au premier article sur le sujet Emacs et Python : mon environnement de développement avec virtualenv.

Flymake va permettre de vérifier en arrière plan la validité de votre code ainsi que le respect de bonne pratiques. Les outils réalisant cette analyse sont pylint, pep8 et pyflakes. Flymake fait partie de la distribution standard de emacs et va appeler ces outils pour mettre en exergue les éventuelles erreurs dans votre code.


Tout d'abord, installez pylint, pep8 et pyflakes en utilisant l'outil d'installation pip (cet outil est installé par défaut à la création de votre environnement virtuel virtualenv) : dans une fenêtre shell (ou DOS) activez votre environnement virtuel python si ce n'est pas déjà fait et faites:
pip install pylint
pip install pep8
pip install pyflakes
Ces trois outils vont être appelés par un script shell (ou batch sous windows) unique : pycheckers (ou pycheckers.bat sous windows). C'est celui-ci qui sera appelé par flymakes.

Sous linux, créez un script pycheckers avec les droits d'exécution :
#!/bin/sh
cd /
filename=`readlink -f $*`
pylint -f parseable -r n $filename
pep8 $filename
pyflakes $filename
Sous windows, créez un batch pycheckers.bat :
@@echo off
pylint -f parseable -r n -i y %* | sed -r "s/\\/\//g"
pep8 %*
pyflakes %* | sed -r "s/\\/\//g"
exit /b 0
L'appel à l'outil sed permet de remettre d'aplomb les / du chemin complet des fichiers analysés pour que Flymake n'est pas de problème pour faire correspondre les erreurs aux fichiers ouverts dans Emacs. Sous linux, copiez pycheckers sous monenv/bin , sous windows copiez pycheckers.bat dans monenv\Scripts. Dans votre .emacs, mettre la configuration flymake suivante:
(when (load "flymake" t)
  (defun flymake-pyflakes-init ()
    (let* ((temp-file (flymake-init-create-temp-buffer-copy
                       'flymake-create-temp-with-folder-structure))
           (local-file (file-relative-name
                        temp-file
                        (file-name-directory buffer-file-name))))
      (list "pycheckers"  (list local-file))))
  (add-to-list 'flymake-allowed-file-name-masks
               '("\\.py\\'" flymake-pyflakes-init flymake-simple-cleanup)))

(add-hook 'python-mode-hook 'flymake-mode)
Relancez votre Emacs à partir d'un shell où votre environnement python a été activé : sous linux : nohup emacs > /dev/null 2>&1 et sous windows: start /B emacs

Et voilà, lors de l'édition de programme python (.py) flymake-mode sera automatiquement démarré et fera appel à pycheckers à chaque fois que vous aurez modifié votre code source. Flymake surlignera les lignes où des erreurs ont été reportées par les outils pylint, pep8 et pyflakes. Lisez la documentation flymake pour connaitre l'ensemble de ce qui peut être fait avec cet outil.

mercredi 5 décembre 2012

Emacs et Python : mon environnement de développement sous Windows et Linux avec virtualenv

J'ai passé du temps à peaufiner mon environnement de développement Python sous Emacs, histoire d'être le plus productif possible. Je vais essayer de résumer dans ce billet et les suivants l'ensemble des actions à mener pour configurer Emacs et avoir à disposition l'ensemble des fonctionnalités qu'on est en droit d'attendre d'un IDE moderne. J'ai testé cette configuration sous linux et windows ce qui n'est pas rien car, parfois, la configuration est bien différente. Tout d'abord, voici en gros l'architecture logicielle de cette solution de développement :

- Emacs 23 ou 24 : votre éditeur de texte préféré
- Python 2.6 ou 2.7 mais pas python 3 (et oui, je n'ai pas eu encore le temps de comparer les différentes opérations à mener pour être aussi compatible python 3)
- virtualenv : un outil pour définir des environnements python séparés, très pratique pour avoir des configurations différentes entre les projets
- pylint, pep8 et pyflakes : outils python que nous utiliserons pour faire de l'analyse statique du code en arrière plan dans Emacs via flymake.
- rope, ropemode, ropemacs et pymacs : outils python de refactoring, utilisés aussi pour faire de la "completion" (compléter automatiquement lors de la frappe)
- gnuwin32 : c'est la majorité des outils GNU compilés nativement pour windows. Ils serviront sous windows à corriger certains petits problèmes.
- auto-complete : mode emacs pour compléter les termes lors de la frappe,
- flymake : pour faire de l'analyse statique en arrière plan du code en cours de frappe,
- eldoc : mode emacs pour avoir dans le minibuffer, la signature de la fonction en cours de frappe.


Installation d'emacs

Télécharger la dernière version de Emacs 24 ou 23 et dézipper la : sous windows, prendre la version binaire; sous linux : prendre les sources et recompiler.

Pour information, sous debian, il y a une version emacs 23 qui marche très bien, installez là directement via le "gestionnaire de paquet Synaptic".

S'assurer que l'exécutable "emacs" est dans le PATH et que vous pouvez l'appeler directement à partir de votre invite shell.


Installation de python

Téléchargez python 2.6 ou 2.7 et installez le.

Sous windows, pas la peine de mettre ensuite le répertoire python dans le PATH (on utilisera virtualenv pour "activer" une certaine version de python)


Sous windows : installation de gnuwin32

Gnuwin32 est un ensemble d'outils GNU compilés nativement pour Windows. Ces outils vont nous rendre la vie plus facile sous Windows, car de part sa nature, Emacs s'intègre bien mieux à son environnement quand quelques outils GNU de base sont disponibles.

Téléchargez l'outil de téléchargement des outils gnuwin32 puis avec cet outil, installez tous les outils gnuwin32, puis mettre le répertoire /bin dans la variable PATH.


Installation d'un environnement virtualenv

Télécharger la dernière version de virtualenv.py puis créez votre nouvel environnement virtualenv avec l'instruction suivante :

python ./virtualenv.py monenv

Cela crée un répertoire monenv correspondant à votre environnement virtuel python. A l'intérieur ont été recopié les exécutables python (le même python qui a été utilisé dans la commande précédente) ainsi qu'un sous ensemble de la bibliothèque standard nécessaire pour initier l'environnement virtuel. Il faut ensuite "activer" votre environnement virtuel en invoquant la commande suivante: sous linux :

. ./monenv/bin/activate

sous windows :

.\monenv\Scripts\activate

Vous pouvez voir que votre environnement virtuel est activé sur votre invite de commande qui a du changer d'aspect et doit maintenant indiquer entre parenthèse le nom de l'environnement virtuel actif.

Faites un which python (même sous windows, grâce à gnuwin32 !) pour voir que vous utilisez bien le python (ou python.exe) de votre environnement virtuel et pas le python global. Il est à noter qu'on ne retrouve pas toutes les libraries standard python dans monenv/lib (monenv\Lib sous windows), et lors de l'exécution de python, le répertoire des librairies standards de l'installation globale se retrouve aussi dans le sys.path python, comme le prouve ces quelques lignes :

(monenv) F:\jrx\src\jrxemacs>python
Python 2.7.3 (default, Apr 10 2012, 23:31:26) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.path
['', 'F:\\jrx\\src\\virtualenvs\\monenv\\lib\\site-packages\\setuptools-0.6c11-py2.7.egg', 'F:\\jrx\\src\\virtualenvs\\monenv\\lib\\site-packages\\pip-1.2.1-py2.7.egg', 'C:\\WINDOWS\\system32\\python27.zip', 'F:\\jrx\\src\\virtualenvs\\monenv\\DLLs', 'F:\\jrx\\src\\virtualenvs\\monenv\\lib', 'F:\\jrx\\src\\virtualenvs\\monenv\\lib\\plat-win', 'F:\\jrx\\src\\virtualenvs\\monenv\\lib\\lib-tk', 'F:\\jrx\\src\\virtualenvs\\monenv\\Scripts', 'c:\\soft\\python-2.7\\Lib', 'c:\\soft\\python-2.7\\DLLs', 'c:\\soft\\python-2.7\\Lib\\lib-tk', 'F:\\jrx\\src\\virtualenvs\\monenv', 'F:\\jrx\\src\\virtualenvs\\monenv\\lib\\site-packages']
>>>

L'intérêt de virtualenv vient aussi du fait que les outils pip et easy_install sont installés automatiquement dès la création de l'environnement virtuel.

Voilà, nous avons ici les bases de l'installation Emacs et Python pour développer. Reste à configurer Emacs pour fonctionner avec Python. Dans un prochain billet, nous verrons comment outiller cet environnement pour faire fonctionner la superbe librairie flymake de Emacs et avoir de l'analyse statique de votre code en temps réel!