vendredi 18 septembre 2015

Inspection des propriétés - petite technique pratique

Voici une petite technique intéressante que vous pouvez utiliser dans un python Interactif (comme IEP par exemple).

Cela fonctionne avec tous les objets... mais dans mon cas, c'est avec un module que j'ai utilisé cette technique. Dans l'article précédent, je voulais recharger le module model.py ... mais je voulais aussi m'assurer que mes objets user_table, group_table, permission_table, etc étaient maintenant disponible!

Les petits trucs à retenir de cet article seront
  [ attr for attr in dir(m) if '_table' in attr]
  [ '%s : %s' % (attr.ljust(25), getattr(m,attr)) for attr in dir(m) if '_table' in attr ]

Mais pour les plus curieux, je vous propose de lire les différentes étapes.

1) Récupérer la référence vers module
import sys
m = sys.modules['model']

2) Faire un dir() --> inefficace
Faire un dir() sur un module (ou un objet) peut retourner un contenu fastidieux à parcourir suivant la taille de l'objet. Dans le cas ci-présent, il n'y a pas moins de 193 entrées! Gloups!

dir( m )
Out[67]: 
['AliasOption',
 'AttributeExtension',
 'BIGINT',
 'BINARY',
 'BLOB',
 ...
 'with_parent',
 'with_polymorphic']

In [68]: len( dir(m) )
Out[68]: 193

3) Utilisons une compréhension list
Avec une simple compréhension liste basé sur dir(), nous allons pouvoir filtrer le contenu retourné à l'aide de l'instruction if.
Comme dir() liste les attribut, il suffit de tester si la chaine de caractère '_table' apparaît dans le nom de l'attribut.
C'est magique :-)

[ attr for attr in dir(m) if '_table' in attr]
Out[69]: 
['group_permission_table',
 'group_table',
 'permission_table',
 'user_group_table',
 'user_table']

4) Avec les valeurs svp
Avoir les noms des attributs c'est bien, avec leur valeur c'est encore mieux!
Cette fois-ci, nous utilisons getattr() pour obtenir la valeur et nous justifions avec ljust() pour le confort de lecture.

In [72]: [ '%s : %s' % (attr.ljust(25), getattr(m,attr)) for attr in dir(m) if '_table' in attr ]
Out[72]: 
['group_permission_table    : tf_group_permission',
 'group_table               : tf_group',
 'permission_table          : tf_permission',
 'user_group_table          : tf_user_group',
 'user_table                : tf_user']

Attention, c'est uniquement pour faire de l'investigation en live!!!

5) Avec le représentation des valeurs
Si vous jouez avec python depuis un moment, vous avez certainement déjà rencontré la fonction __repr()__. Cette dernière est utilisée par l'interpréteur pour afficher plus de détails  sur les objets (et pas uniquement leur adresse).
Si cela est pratique, cela peut aussi fournir du contenu très... touffu selon les circonstances.

Cette version du script remplace uniquement un des %s par %r (pour demander l'affichage de la "représentation").

In [73]: [ '%s : %r' % (attr.ljust(25), getattr(m,attr)) for attr in dir(m) if '_table' in attr ]
Out[73]: 
["group_permission_table    : Table('tf_group_permission', MetaData(bind=Engine(postgresql://dom:***@hp-minty/dom)), Column('id_permission', Integer(), ForeignKey('tf_permission.id'), table=), Column('id_group', Integer(), ForeignKey('tf_group.id'), table=), schema=None)",
 "group_table               : Table('tf_group', MetaData(bind=Engine(postgresql://dom:***@hp-minty/dom)), Column('id', Integer(), table=, primary_key=True, nullable=False), Column('group_name', Unicode(length=16), table=, nullable=False), schema=None)",
 "permission_table          : Table('tf_permission', MetaData(bind=Engine(postgresql://dom:***@hp-minty/dom)), Column('id', Integer(), table=, primary_key=True, nullable=False), Column('permission_name', Unicode(length=16), table=, nullable=False), schema=None)",
 "user_group_table          : Table('tf_user_group', MetaData(bind=Engine(postgresql://dom:***@hp-minty/dom)), Column('user_id', Integer(), ForeignKey('tf_user.id'), table=, primary_key=True, nullable=False), Column('group_id', Integer(), ForeignKey('tf_group.id'), table=, primary_key=True, nullable=False), schema=None)",
 "user_table                : Table('tf_user', MetaData(bind=Engine(postgresql://dom:***@hp-minty/dom)), Column('id', Integer(), table=, primary_key=True, nullable=False), Column('user_name', Unicode(length=16), table=, nullable=False), Column('password', Unicode(length=40), table=, nullable=False), Column('display_name', Unicode(length=255), table=, default=ColumnDefault('')), Column('created', DateTime(), table=, default=ColumnDefault(. at 0x04560B70>)), schema=None)"]
Comme vous pouvez le constaté, c'est nettement plus chargé... et avec le retour à la ligne, c'est franchement illisible)
Comme quoi "le mieux est parfois l'ennemi du bien".

Voila, Happy Python Hacking ;-)

Recharger un module Python à la volée

Il y a peu, je vous parlais d'IEP dans ce billet "IEP: un éditeur Python interactif convivial (Windows, Mac, Linux)".

Environnement bien pratique pour faire des tests et je découvre justement SqlAlchemy.
J'étais justement entrain de coder un petit module de test model.py lorsque je me suis demandé comment recharger mon module!
IEP - édition d'un module "model.py"

J'avais déjà fait un import model ... mais ayant modifié le code, je voulais savoir comment le recharger.
Voici donc comment faire...

Option 1 - à la dure
import sys
del( sys.modules['model'] ) # virer le module "model.py"
from model import *         # ré-importer le module "model.py"

Option 2 - importlib.reload()
import importlib
import sys
a = sys.modules['model'] # Référence vers le module
importlib.reload( a )    # Demander à Python de recharge le module

jeudi 17 septembre 2015

Entête pour fichier Python

Voici une proposition d'entête de fichier Python à partir d'information collectées ici et là.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""Foobar.py: Description of what foobar does."""

__author__ = "Rob xxxx, Gavin xxxx, and Peter xxxx"
__copyright__ = "Copyright 2007, The xxxx Project"
__credits__ = ["Rob xxx", "Peter xxx", "Gavin xxxx",
                    "Matthew xxxx"]
__license__ = "GPL"
__version__ = "1.0.1"
__maintainer__ = "Rob xxx"
__email__ = "rob@spot.xxx.edu"
__status__ = "Production"


from sqlalchemy import *
from sqlalchemy.orm import *
from datetime import datetime
....

vendredi 4 septembre 2015

IEP: un éditeur Python interactif convivial (Windows, Mac, Linux)

IEP est un outil vraiment très pratique et agréable permettant de faire du prototypage en Python dans un milieu ergonomique.
Nous ne parlons pas de développement (qui est un autre domaine) mais de Python Interactif (et même IPython).
IEP - Un python interactif vraiment convivial.
J'aime employer Python en mode interactif... c'est vraiment pratique pour faire du prototypage ou essayer des nouvelles fonctions. Il y a aussi son grand frère IPython que je ne connais pas encore très bien.

Limite de Python Interactif en mode console
Par contre, si ces environnements consoles sont plus que pratique du fait de leur mode console, ils deviennent également pénibles lorsqu'il faut faire un "fix" dans une fonction mal définie.
Il faut recommencer la saisie ligne a ligne... ce n'est pas gênant si c'est une fois mais autrement plus ennuyant en usage intensif.

Je voulais charger dynamiquement le contenu d'une table postgresql dans un objet SqlAlchemy (via l'ORM)... puis sauver les objets dans un fichier JSON. Le but est d'exporter les données sur un serveur FTP pour rechargement dans une DB en ligne. Alors oui, vu le nombre de manipulation, j'étais un peu à l'étroit dans la version console.

IEP... KASEKO?!?

J'ai donc cherché un environnement Python Interactif plus convivial - aussi sous Windows - et je suis tombé sur Interactive Editor for Python (IEP)

C'est toujours un Python interactif (IPython) auquel est associé une gestion de fichier, quelques outils, un logger et des fonctionnalités vraiment efficaces.
Une combinaison idéale pour une utilisation en mode Interactif:
  • Exécution du texte sélectionné à la volée (dans l'interpréteur)
  • Exécution du script ou du contenu du fichier
  • Explorateur de fichier
  • Explorateur de classe
  • Auto complétion
  • Python Interactif fonctionnant dans un thread séparé
    Autorise donc la poursuite du coding pendant une phase d'éxécution.
  • Excellent support de raccourcis clavier!
    Capital pour allez vite.
  • etc
L'installer Windows ne fait que 10Mb... tout à fait raisonnable pour les services rendus.

Ressources

samedi 29 août 2015

Pillow - le fork de PIL

PIL Python Image Library est une puissante bibliothèque de traitement d'image.

PIL est mondialement reconnu pour sa puissance... mais aussi tristement connu pour être parfois vraiment pénible à installer.

En travaillant sur la documentation du Sense Hat pour Raspberry-Pi, j'ai découvert que la fondation Pi proposait d'installation Pillow en même temps que la bibliothèque du Sense-Hat.
Piqué à vif, j'ai jeté un petit coup d'oeil sur Pillow.

Pillow? Kaseko?!?!
Pillow est un Fork de PIL, créé par Alex Clark and Contributeurs. PIL est la bibliothèque Python Imaging Library par Fredrik Lundh et Contributeurs.


Pillow Logo
source: python-pillow.github.io

Si la fondation Pi propose d'installer Pillow plutôt de Pil c'est probablement parce que Pillow peut s'installer via l'utilitaire pip et que la bibliotèque est suffisamment légère que pour pouvoir tourner sur un Pi.
Cela n'enlève pourtant rien à l'intérêt de Pillow (cfr la doc).

De la doc
Autre point crucial, c'est la documentation... une belle doc comme je les aiment bien.
Installer Pillow

sudo pip-3.2 install pillow

Plus d'information

mercredi 26 août 2015

Bibliothèque & outils pour Python

Python-Editor
En m'intéressant à Alembic et SqlAlchemy, je suis tombé sur un Package portant le nom de Pyhton-Editor.

Et bien, que voila un petit outil intéressant... Python-Editor ouvre un éditeur (par programmation) et se débrouille pour capturer le résultat.
Outil simple mais efficace, il permet surtout de s'affranchir des problèmes liée à la plateforme utilisée (Windows, Mac, Linux) :-)

https://pypi.python.org/pypi/python-editor/0.3

jeudi 6 août 2015

Faire le backup d'une seule table en PostgreSql

Préambule
je sais... il est toujours mieux de faire un backup de la DB dans son entièreté. C'est d'ailleurs ce que je recommande en général, cependant, il y a toujours des cas particulier.

Introduction
Voila, j'ai fait plusieurs update foireux dans la table des  fournisseurs sur mon environnement de développement. J'aurais bien besoin de restaurer les données de cette table depuis le serveur de production... mais je ne voudrais pas restaurer toute la DB maintenant.

La solution
  • Faire un backup de la table depuis le serveur avec pg_dump --> fichier de backup sql
  • Renommer la table sur le serveur local (vaut mieux pas l'effacer trop vite)
  • Restaurer le fichier de backup sur la db locale avec l'outil psql
Backup de la table

pg_dump.exe --host adresse_du_serveur --port 5432 --username nom_utilisateur --format plain --ignore-version --verbose --file "nom_du_fichier_de_backup_sql" --table public._nom_de_la_table base_de_donnee

Exemple pratique 
pg_dump.exe --host 192.168.1.205 --port 5432 --username postgres --format plain --ignore-version --verbose --file "C:\temp\supplier.backup" --table public.file0020 stockprod

Restaurer les  données
N'oubliez pas renommer la table (vous pouvez le faire avec pgAdmin III , via les propriétés de la table)

psql -h adresse_serveur_local -p 5432 -U nom_utilisateur -d base_de_donnée -a -f nom_du_fichier_de_backup_sql

Exemple pratique

cd c:\temp\
psql -h localhost -p 5432 -U postgres -d stockdev -a -f suppliers.bakup