Un Electron Libre...

Je viens de terminer la lecture du livre "The Definitive Guide to Django: Web Development Done Right",écrit par les développeurs principaux du framework python Django, à savoir Jacob Kaplan-Moss et Adrian Holovaty.

Le livre est décomposé en trois grandes parties :

• Partie 1 : Présentation de l'outil
• Partie 2 : Dans les entrailles de Django : présentation des modules et "sous-frameworks"
• Partie 3 : Annexes avec des témoignages et de la documentation

On peut dire qu'à l'issue de la partie 1, vous êtes en mesure de jouer avec Django pour construire une application de démo, simple et sans prétention. A l'issue de la partie 2, vous l'avez bien enrichit et même déployer en production. Si vous avez réussi à intégrer/mémoriser la partie 3, vous êtes un expert Django

Ce que j'ai bien aimé :

• Le livre se veut plus un guide qu'une documentation : le livre ne va pas présenter dans le détail tous les aspects de Django. Il va en présenter suffisamment pour s'en faire une idée, voir l'intérêt de tel ou tel module mais pas détailler l'option X du module Y. La documentation de référence reste celle en ligne et du coup, ils sont à voir comme étant complémentaires et non comme une version papier de la documentation officielle.
• De nombreuses "bonnes pratiques" tant au niveau de Django que du développement web en général sont données au fur et à mesure du livre. J'ai plié un gros nombre de pages pour me rappeler d'intégrer plein de petits trucs dans mes projets actuels.
• Si on connait rien en python, les auteurs fournissent suffisamment d'information pour comprendre la logique de l'ensemble. Globalement je trouve le livre très pédagogique.
• J'ai appris plein de choses que je n'avais pas vu en parcourant la documentation officielle.

Ce que j'ai moins aimé :

• La partie déploiement est un peu légère à mon goût, je m'attendais à un truc un peu plus solide - pour le coup, c'est pas top évident de déployer une appli django la première fois - surtout quand on vient des applis PHP qui sont "upload & play".

Même si certains choses du livre ont un peu bougé, je pense que ça vaut le coup de l'acheter si on veut se familiariser avec Django. Le livre est également lisible en ligne sur le site djangobook.com. Il paraitrait même que des gens ont proposé de le traduire en français

Utilisant la version de développement (svn) de Django, j'ai farfouillé dans le contenu du répertoire extras de django et on y trouve un symathique fichier django_bash_completion.

Il vous suffit de placer ce fichier dans /etc/bash_completion.d/ (ou de faire un lien symbolique, ce qui peut être pratique si le fichier est mis à jour et si vous suivez régulièrement la version de développement).

Pour profiter de cette complétion suivant votre distribution GNU/Linux et où l'autocomplétion est définie :

source /etc/profile
 
et/ou :
 
source ~/.bashrc

Ensuite, à la racine de votre projet django, faites :

python manage.py [Tab] [Tab]

et toutes les options possibles vont apparaître :

$ python manage.py
adminindex        loaddata          sqlclear          startproject
createcachetable  reset             sqlcustom         syncdb
dbshell           runfcgi           sqlflush          test
diffsettings      runserver         sqlindexes        validate
dumpdata          shell             sqlreset
flush             sql               sqlsequencereset
inspectdb         sqlall            startapp

Toujours ça de pris

Dans le monde python, il y a :

• Une syntaxe de documentation puissante mais pas aisée à prendre en main : ReST, pour ReStructured Text, fourni via docutils. Voir la QuickRef de ReST.
• Pygments, un système de coloration syntaxique, un peu comme GeSHi en PHP.

Dans vos documents rédigés en ReST, il est possible d'inclure Pygments pour enrichir le rendu de vos documents.

Il vous faut pour cela :

• docutils installé sur votre ordinateur,
• pygments aussi
• récupéré le fichier external/rst-directive.py présent dans le fichier source de pygments 0.9 et le copier dans /usr/lib/python2.5/site-packages/docutils/parsers/rst/directives/

Ensuite, et c'est là où le système manque un peu de flexibilité, il faut déclarer cette directive :

• Editer /usr/lib/python2.5/site-packages/docutils/parsers/rst/directives/init.py (il y a deux "_" de chaque coté du init - bug de DC2 apparemment) pour ajouter une ligne :

_directive_registry = {
      'sourcecode': ('rst-directive', 'pygments_directive'),
      'attention': ('admonitions', 'Attention'),
      ...
      }

Cette déclaration dit que quand j'utiliserais la directive sourcecode dans mon document ReST, alors il doit aller utiliser la classe pygments_directive présente dans le fichier rst-directive.py.

• Editer le fichier /usr/lib/python2.5/site-packages/docutils/parsers/rst/languages/en.py (et les éventuelles traductions) :

directives = {
      # language-dependent: fixed
      'sourcecode': 'sourcecode',
      'attention': 'attention',
      ...
      }

Voilà pour l'installation de pygments et docutils.

Dans votre texte au format ReST, il vous suffit d'utiliser la directive sourcecode comme dans l'exemple suivant :

Tutoriel : partie 1
===================

settings.py
-----------

.. sourcecode:: python

    # Django settings for tutoriel project.

    DEBUG = True
    TEMPLATE_DEBUG = DEBUG

    ADMINS = (
        # ('Your Name', 'your_email@domain.com'),
    )

Si vous voulez que les numéros de lignes soient également mentionnés, il vous faut décommenter la ligne suivante (dans rst-directives.py) :

et modifier votre fichier de la façon suivante (ajout de la directive :linenos: :

Tutoriel : partie 1
===================

settings.py
-----------

.. sourcecode:: python
    :linenos:

    # Django settings for tutoriel project.

    DEBUG = True
    TEMPLATE_DEBUG = DEBUG

    ADMINS = (
        # ('Your Name', 'your_email@domain.com'),
    )

Je vous fais grâce du code html de rendu, surtout que pour le moment, je n'ai pas de coloration syntaxique (cf Pygments et ReST Partie 2)

Objectif : Utilise la balise "regroup" en filtrant sur une clé étrangère

Modèle :

Soit le modèle suivant :

"""
Technicat skills
"""
 
class DomainTechSkill(models.Model):
     name = models.CharField('Domaine de compétence technique', Maxlength=100, core=True)
 
class Techskill(models.Model):
     who = models.ForeignKey(User, verbose_name='Personne',)
     name = models.CharField('Compétences techniques', maxlength=100, core=True)
     domain = models.ForeignKey(DomainTechSkill, verbose_name='Domaine de compétences techniques',)
 
class Usertechskill(models.Model):
     who = models.ForeignKey(User, verbose_name='Personne',)
     name = models.ManyToManyField(Techskill, verbose_name='Compétence technique', filter_interface=models.HORIZONTAL, blank=True)

L'idée est de faire d'une part TechSkill <=>DomainTechSkill et d'autre part User <=> TechSkill. Ensuite au niveau de la restitution, on veut lister les compétences techniques d'un utilisateur en les regroupant par "DomainTechSkill".

Vue :

avec la vue suivante (extrait) :

def cv_detail(request, firstname, lastname):
     user = User.objects.get(first_name=firstname, last_name=lastname)
     user_techskill = user.usertechskill_set.all()
     return render_to_response('cv/cv_detail.html', {'user_techskill': user_techskill, })

Template :

et le template suivant (extrait) :

                 {# -- technical skills -- #}
                 {% if user_techskill %}
                 <p>Comp&eacute;tences techniques :</p>
                 {% for techskill in user_techskill %}
                 {% regroup techskill.name.all|dictsort:"domain" by domain as grouped %}
                 <ul>
                          {% for group in grouped %}
                                 <li> {{ group.grouper }} :
                                         {% for item in group.list %}
                                                 {{ item.name }}{% if forloop.last %}.{% else %},{% endif %}
                                         {% endfor %}
                                 </li>
                          {% endfor %}
                 </ul>
                 {% endfor %}
                 {% endif %}

Jeux de données :

Imaginons que j'ai alors rentré les couples de valeur suivants (Compétence techniques / Domaine Technique) :

• HTML / Web
• CSS / Web
• Apache / Serveur
• Portail / Système d'information
• Bind / Serveur
• CMS / Système d'information

Ce qui est souhaité :

• Serveur : Apache, Bind
• Système d'information : CMS, Portail
• Web : HTML, CSS

Ce qui est parfois obtenu (comme n'importe quelle autre combinaison de ces valeurs, ce qui nous permet d'avoir la bonne de temps à autre)

• Serveur : Apache
• Système d'information : CMS, Portail
• Serveur : Bind
• Web : HTML, CSS

Solution pour avoir la bonne combinaison de façon systématique :

La solution consiste dès lors à ajouter le nom de l'attribut (ex : domain.name) ou de filtrer par un id (ex : domain.id)

                 {% regroup techskill.name.all|dictsort:"domain.name" by domain as grouped %}

Et là, vous avez systématiquement le résultat souhaité (seul l'ordre des compétences peut varier sur une même ligne)

Merci à Samuel pour m'avoir indiqué cette capacité.