Actualités pour la catégorie : Développement

La face cachée du Sudoku

fantomas42@gmail.com (fantomas) — Tue, 11 Oct 2011 16:49:56 +0200

Introduction

Tout commence un soir entre amis, où une envie démente de coder un petit projet nous surprend entre 2 bières. :D

Lui vient du monde Java, moi du Python, mais ayant subi la même formation, le moment fût propice pour comparer nos progrès et évolutions et aussi lancer un troll ou deux.

Ensuite nous vient l'idée de programmer un résolveur universel de Sudoku, ayant quelques connaissances de base à propos de ce jeu, j'imagine dans les grandes lignes un algorithme pour résoudre ce genre de puzzles...

L'idée générale du programme est d'appliquer de manière séquentielle les 2 ou 3 stratégies de résolutions que j'utilise moi même quand je fais un Sudoku tiré d'un magazine...

Passage à l'acte

Rapidement j'obtiens un résultat, mais se pose le problème de la difficulté. En effet, les grilles disponibles dans les magazines sont classées par difficulté croissante, or cette difficulté est toute relative.

En effet seul le nombre de techniques de résolutions nécessaires (en général 3 ou 4) à un puzzle conditionne le niveau de difficulté. A savoir qu'il existe de techniques très complexes pour résoudre certaines grilles de Sudoku, mais il ne sera jamais nécessaire même à un niveau dit "Diabolique" de les maîtriser. Seules les techniques élémentaires seront nécessaire pour 95% des grilles publiées.

Mais concernant les 5% restant, là cela devient beaucoup plus complexe, car après plusieurs heures de recherches et de compréhension de ces techniques, je décide d'en implémenter certaines dans le résolveur pour augmenter ses chances de résolution.

Mais le problème reste entier, même si j'augmente le nombre d'algorithmes de résolution, si je tombe sur un cas que je n'ai pas prévu, je ne peux pas résoudre complètement la grille. En effet, le programme n'est pas capable d'improviser une solution ou d'échafauder une hypothèse qui lui permettrait de se sortir de ce cas imprévu.

A la suite de cette série d'échecs, je décide d'implémenter un algorithme de résolution basé sur le backtracking, solution qui me convient beaucoup mieux car le taux de résolution des puzzles est de 100%, mais insatisfaisante car elle ne permet pas d'expliquer la solution et le temps de résolution d'un puzzle est peu prédicable et très fluctuant.

Réflexions

En guise de conclusion à cette immersion dans le monde du Sudoku qui s'est révélée au final bien plus riche qu'il ne le semblait aux premiers abords, j'ai appris une belle leçon en matière de programmation et surtout d'algorithmique.

En effet mimer la façon de penser d'un homme pour résoudre certains problèmes de programmation peut parfois se révéler intéressant et source de solutions, mais il ne faut pas oublier que l'on traite avec une machine.
Une machine n'a pas la capacité d'innovation ou d'évolution face à un problème non identifié, par contre elle est capable de retenir des millions d'informations et de les traiter beaucoup plus rapidement que n'importe quel humain et ça, c'est un avantage indéniable.

Même si un humain peut utiliser la technique du Backtracking (appelé aussi Nishio) pour résoudre sa grille, il mettra un temps phénoménal mais il n'y arrivera que s'il est très rigoureux et ce n'est pas du tout ludique.

Par contre pour une machine, la donne s'inverse, la machine est rigoureusement rigoureuse et peut faire tous ces calculs très rapidement.

Pour conclure, même si un humain et une machine peuvent plus ou moins faire la même chose, il ne faut jamais oublier de prendre en compte les points forts et points faibles de l'un et de l'autre dans la conception d'un algorithme.

Résultats

Le résultat de toute ces expériences est disponible sur PyPI sous le nom de sudoku-solver.

$ easy_install sudoku-solver
$ sudoku_solver votre_grille.txt

Vous pouvez éventuellement contribuer sur la page Github du projet à l'adresse suivante : https://github.com/Fantomas42/sudoku-solver

Et pour terminer, je n'ai pas pu m'empêcher de réaliser une démo web de ma librairie sous le framework Django. Donc si vous voulez résoudre ou vérifier vos grilles de Sudoku, allez à cette adresse : http://sudoku.willbreak.it/

Bon puzzles !

Ô middleware, mon beau middleware : Request Template Loader

fantomas42@gmail.com (fantomas) — Tue, 08 Mar 2011 14:38:28 +0100

Dans le monde du web, là où tout est anarchie (ou presque), je me retrouve confronté assez souvent à cette problématique :

Comment afficher le contenu d'un site réalisé avec Django sur un autre site déjà existant ?

Là où je bosse, on aime bien les iframes HTML (no comments please :)), mais le contenu ou le style de la frame incluse ne correspondent pas forcément au site recevant la frame. L'idée, vu qu'on se trouve à la base dans un environnement Django, serait de déployer un nouveau site, avec son propre jeu de templates prévues pour le site incluant les frames.

Mais ce genre de technique nécessite de mettre en place un nouveau domaine, de déployer et de maintenir 2 sites. Bon vous me direz que ce n'est pas forcément ce qu'il y a de plus dur, mais il y a moyen de faire mieux. Et surtout que ce passe-t-il si vous devez faire ce genre d'opération non pas sur 1 site, mais sur plusieurs. Tout de suite cela devient plus ennuyeux. :(

C'est là où intervient la solution du middleware. L'idée est de pouvoir passer en GET un paramètre qui conditionnera le chargement des templates dans le site source. Comme cela peu importe combien de frames au look différent on devra gérer, la mise en forme et la personnalisation du contenu se fera très facilement.

Maintenant place au code, les explications sur le fonctionnement viennent directement après.

import os
from urllib import urlencode
from urlparse import urlparse
from urlparse import urlunparse
try:  # For Python < 2.6
    from urlparse import parse_qs
except ImportError:
    from cgi import parse_qs

from django.conf import settings
from django.utils.encoding import smart_str

from BeautifulSoup import BeautifulSoup


GET_VAR_NAME = getattr(settings, 'TEMPLATE_GET_VAR_NAME', 'from_source')


class RequestTemplateMiddleware(object):
    """Middleware to modify on the fly
    the loading of the templates"""

    def __init__(self):
        self.original_template_dirs = settings.TEMPLATE_DIRS

    def process_request(self, request):
        source = request.GET.get(GET_VAR_NAME)

        if source:
            settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__),
                                                   'templates', source),) + \
                                                   settings.TEMPLATE_DIRS
        return None

    def process_response(self, request, response):
        settings.TEMPLATE_DIRS = self.original_template_dirs

        source = request.GET.get(GET_VAR_NAME)

        if source and '<html' in response.content:
            soup = BeautifulSoup(smart_str(response.content))
            for link in soup.findAll('a'):
                link['href'] = self.update_link(link['href'], source)
            for form in soup.findAll('form'):
                form['action'] = self.update_link(form['action'], source)
                form.insert(0, '<div><input type="hidden" name="%s" ' \
                            'value="%s" /></div>' % (GET_VAR_NAME, source))
            response.content = str(soup)

        return response

    def update_link(self, link, source):
        """Update the links with the good GET parameter"""
        url_parts = urlparse(link)
        query_dict = parse_qs(url_parts.query)
        query_dict.update({GET_VAR_NAME: source})
        return urlunparse((url_parts.scheme, url_parts.netloc,
                           url_parts.path, url_parts.params,
                           urlencode(query_dict), url_parts.fragment))

Comme on peut le voir, ce middleware va court-circuiter l'ordre de chargement des templates en modifiant la variable TEMPLATE_DIRS utilisée par django.template.loaders.filesystem.Loader, grâce à la variable from_source passée dans l'url en GET.

Ensuite il ne reste plus qu'à créer le dossier de templates correspondant à la variable from_source et d'y placer les templates personnalisés. A savoir que le nom de la variable passée en GET est configurable pour plus de souplesse.

La seule dépendance requise est BeautifulSoup qui va modifier le contenu HTML afin de pouvoir continuer à utiliser le middleware quand on clique sur un lien ou on valide un formulaire.

Au delà de l'utilité de ce bout de code, j'espère que cela va vous motiver à programmer et utiliser vos propres middlewares, car cela s'avère souvent la meilleure solution à un problème complexe lors du développement d'un site internet avec Django.

Le temps des releases : django-blog-zinnia

fantomas42@gmail.com (fantomas) — Thu, 16 Sep 2010 18:51:12 +0200

Incroyable, après presque 2 ans d'attente, Zinnia l'application Django propulsant ce blog est enfin publiée sur un dépôt public.

Le premier article faisant référence à Zinnia date en effet du 16 Novembre 2008.

Beaucoup d'évolutions ont été apportées entre cette première version réalisée à titre personnel et celle qui gère le site actuellement. Ceci explique en partie mon manque d'activité sur le site.

Au final, j'en ai profité pour mettre à jour le code du site en utilisant la version de développement et refondre le skin du site, un peu trop sombre et vieillissant à mon goût.

Maintenant, concentrons nous sur notre sujet. Tout d'abord le code source de Zinnia est disponible sur GitHub, ce qui facilite le travail communautaire, donc si vous voulez participer, forker ou télécharger, aucun problème, vous y êtes même encouragé.

Lors de la publication du code source, je me suis efforcé de documenter un maximum les fonctionnalités ainsi que l'installation, donc pour présenter le projet je vais me baser sur ces documents.

Tout d'abord, qu'est-ce-que Zinnia ou django-blog-zinnia exactement ?

Zinnia est une application générique pour gérer un blog à travers un site en Django. Elle a été conçue pour publier des articles et le faire efficacement ! De manière générale toutes les fonctionnalités qui peuvent être fournies par une autre application réutilisable écrite en Django ont été mises de coté. Pourquoi réécrire ce qui a déjà été testé et approuvé par les autres ?

Mais plutôt qu'un long discours, je vais dresser la liste actuelle des fonctionnalités disponibles.

Commentaires
Flux RSS ou Atom
Vues par archives
Vues par catégories et tags
Détection des articles relatifs
Moteur de recherche avancé
Prépublication et expiration
Widgets
Sitemaps
Protection anti-spam avec Akismet
API MetaWeblog
Ping dans les annuaires
Ping des ressources externes
Support de Bit.ly, Twitter
Gestion de Gravatar
Plugin pour Django-CMS
Travail collaboratif
Autocomplétion des tags
Support des Pingbacks et Trackbacks
WYMeditor ou TinyMCE pour éditer
Templates génériques prêts l'emploi
Utilitaire de conversion depuis WordPress

Je dois certainement oublier des petites choses, mais ça commence déjà à faire pas mal. D'ailleurs, si vous avez une idée de ce qui pourrait manquer n'hésitez pas à m'en faire part.

Une documentation complète et mise à jour se trouve à cette adresse : http://django-blog-zinnia.com/docs/
Vous trouverez dans cette documentation un lien vers une documentation de l'API, ainsi que le code coverage des tests effectués sur l'application. Car bien sûr l'application est testée. Ouf !

J'ai failli oublier de dire qu'une version de démonstration de l'application se trouvait ici : http://django-blog-zinnia.com/blog/

Bon il ne reste plus qu'à écrire des articles ! :)

Le temps des releases : easy_extract

fantomas42@gmail.com (fantomas) — Tue, 19 Jan 2010 10:47:56 +0100

Imaginons que j'ai sur un serveur de donnée une grosse quantité d'archives sous différents formats, tel que RAR, ZIP, XTM...

Si je souhaite extraire toutes ces archives, je devrais aller trouver chaque archives dans son répertoire, taper la bonne commande pour pouvoir les extraire, les réparer au besoin et ainsi de suite... Plutôt fastidieux non ? :(

Sur ce constat m'est venu l'idée de easy_extract, un script écrit en Python qui va analyser récursivement les répertoires à la recherche d'archives ou de collections d'archives pour les extraire et les réparer automatiquement si elles sont corrompues.

Pour cela, il suffit de lancer le script de la manière suivante par exemple :

$ easy_extract -r mes_archives/

Pratique et le gain de temps est évident, car une fois le script lancé, vous n'avez plus à vérifier que l'extraction s'est bien déroulée pour ensuite passer à la suivante, donc a scotcher devant votre terminal. Victoire une tâche fastidieuse de plus automatisée. :D

Pour l'installation, il est nécessaire d'installer les paquets suivant avant :

par2
unrar-free
7zip-full

Ensuite l'installation du script se fait grâce à easy_install :

$ easy_install easy_extract

Bien sûr le code est open-source, donc si vous voulez contribuer, forker ou juste critiquer, le code se trouve à l'adresse suivante : http://github.com/Fantomas42/easy-extract

Bonne décompression et bon leech.

Le temps des releases : Vélib'erator

fantomas42@gmail.com (fantomas) — Thu, 24 Sep 2009 14:16:23 +0200

Suite à mon abonnement à Vélib', habitant près d'une station récemment construite, j'ai vite remarqué que de trouver un vélo en bon état ou une place de parking à proximité avant les 30 minutes fatidiques et payantes pouvait vite devenir un calvaire.

Sur ce, après quelques recherches, j'ai pu constater que les informations sur l'état des stations du réseau Vélib' étaient librement accessibles. D'où l'idée de créer un paquet python nommé Veliberator, me permettant depuis mon shell de consulter l'état de mes stations favorites.

Pour les fans de la ligne de commande, essayez ceci :

$ sudo easy_install veliberator
$ sudo synchronize.py
$ find_place.py 42008

Partant de là, je me dis qu'il serait dommage de m'arrêter à ce stade du développement, d'autant plus que mon problème pour trouver une place libre rapidement ne se résous que depuis mon ordinateur, il faudrait donc que ce service soit accessible partout et pour tout le monde.

Un site web semble être la solution idéale, d'autant plus si on est capable d'optimiser l'affichage des pages au type de support, par exemple un mobile.

Equipé de mon module python et de Django, j'ai donc réalisé le site http://veliberator.com.

Au programme du site :

Consultation des statuts des stations Vélib'.
Affichage des stations aux alentours.
Affichage des lieux importants près des stations.
Flux RSS pour monitorer le statut des stations.
Vues par ville, départements, statut, adresse.
Statistiques du réseau Vélib'.
Recherche par : adresse, métro, monument, code postal, coordonnées GPS.
Calcul des distances.
Traçage d'itinéraires entre stations Vélib'.
Gestion de favoris.
Interfaces claires et unifiées.
Cartes détaillées et en plein écran.
Géo-localisation automatique.
Internationalisation
Support pour les téléphones mobiles et iPhone.
Support pour les Télésites Freebox.

En effet le site tourne sous plusieurs versions, chacune adaptées à son environnement d'affichage, et à tout moment je peux consulter ces informations.

Dans mon cas, quand je rentre du travail en Vélib' et qu'il n'y a plus de place en bas de chez moi, je sais directement où aller pour trouver une place libre, sur mon téléphone. Adieu les rondes au hasard à la recherche d'une place libre... Merci Vélib'erator ! :D

Si vous avez des suggestions, je suis ouvert à toutes propositions d'amélioration.

http://veliberator.com

http://m.veliberator.com

Edit 30 septembre 2009 : Suite à un email provenant de la société JCDecaux, je me vois dans l'obligation de ne plus utiliser leurs données sur les stations vélib selon les articles L. 112-3 al 2 et L.341-1 du code de la propriété intellectuelle. Données qui sont pourtant accessible publiquement... A priori, avec Vélib, il vaut mieux éviter les initiatives personnelles.

Le temps des releases : Django-sekh

fantomas42@gmail.com (fantomas) — Mon, 31 Aug 2009 18:17:51 +0200

Vous avez certainement déjà vu dans Google quand vous consultez une page depuis son cache, les termes de la recherche sont coloriés dans le contenu de la page pour permettre de les discerner rapidement.

De ce principe certains sites ont adapté la même technique en coloriant certains mots de la page correspondant à la recherche de l'utilisateur si il provient d'un moteur de recherche.

C'est ce que django-Search Engine Keywords Highlighter fait !

Une fois installé avec BeautifulSoup, il suffit juste d'ajouter ce middleware à la fin de la liste dans votre fichier settings.

MIDDLEWARE_CLASSES = (
  ...
  'sekh.middleware.KeywordsHighlightingMiddleware',
)

Moi quand c'est facile à installer, j'aime ! :D

Ce middleware va rajouter une balise span autour des mots de la recherche, le tout avec des classes qui vont bien permettant la décoration en CSS.

L'inconvénient est que si votre HTML est mal formatté, le middleware risque de faire planter la page.

Pour voir un exemple cliquez ici.

Pour plus d'informations et pour télécharger le code :

http://github.com/Fantomas42/django-sekh/tree/master

Le temps des releases : Django-smileys

fantomas42@gmail.com (fantomas) — Sun, 19 Jul 2009 13:25:48 +0200

Parfois il est temps de se sortir les doigts du code, et d'en parler !
Mais pour en parler, il faut documenter, ce qui prend un peu de temps, mais j'y travaille.

Pour commencer je vais vous présenter une de mes applications favorites, par sa simplicité et son utilité incroyable. :D

Django-smileys est une application Django comme son nom l'indique, permettant d'inclure facilement dans ses templates des smileys, de ce genre :) :p.

Pour cela, une fois l'application téléchargée et installée dans votre projet django, il vous suffit dans vos templates d'utiliser le filtre qui va convertir tout les code smileys définis dans SMILEYS_LIST.

{% load smiley_tags %}

{{ object.content|smileys }}

Plutôt facile non ? Surtout que l'on peut maintenant convertir tout type de contenu texte.

La liste des smileys est configurable, ainsi que l'url de dépot et la classe d'habillage CSS.

Pour télécharger ce projet hallucinant : http://github.com/Fantomas42/django-smileys/tree/master

Bientôt d'autres releases.

Paye ta Fabric !

fantomas42@gmail.com (fantomas) — Fri, 01 May 2009 14:53:09 +0200

Le déploiement d'applications, c'est pas toujours facile et rébarbatif surtout quand on travaille sur un parc de machines.

Imaginons que j'utilise un serveur de version, du genre Subversion ou Mercurial et que j'utilise un ou deux serveurs (test, production 1, production 2, ...) pour héberger mon ou mes applications.

Le déroulement est le suivant :

Développement en local.
Propagation des modifications.
Connection SSH sur les serveurs.
Rapatriement les dernières modifications
On redémarre le soft.

Vous me direz que cela n'est pas forcément très long, mais quand vous devez le faire souvent et plusieurs fois par jour, on en a vite pleins le dos et cela est source d'erreur.

Heureusement l'informatique étant un sport où celui qui est le plus fainéant gagne, il existe un solution pour se simplifier ces tâches de déploiements à distance.

Son nom ? Fabric

En quelques lignes de Python, définissant des règles, un peu à la manière d'un Makefile, il est possible d'automatiser ce genre d'opération.

Voici un exemple basique pour le déployement d'un projet Django avec Mercurial :

"""Fabric Rules for MyProject"""

config.production = ['server.domain.com']
config.app_dir = '/home/dev/djangos/myproject'

def publish():
    """Publish the content by pushing it"""
    local('hg push')

def apache_reload():
    """Reload the apache process"""
    sudo('/etc/init.d/apache2 reload')

@roles('production')
def update():
    """Update the code source"""
    run('cd $(app_dir); hg pull; hg update')
    run('cd $(app_dir); python manage.py syncdb')
    run('cd $(app_dir); python manage.py loaddata my_dump.json')
    apache_reload()

@roles('production')
def debug_on():
    """Turn debug mode on for the production server."""
    run("cd $(app_dir); sed -i -e 's/DEBUG = .*/DEBUG = True/' settings.py")
    apache_reload()

@roles('production')
def debug_off():
    """Turn debug mode off for the production server."""
    run("cd $(app_dir); sed -i -e 's/DEBUG = .*/DEBUG = False/' settings.py")
    apache_reload()

@depends(publish, update)
def deploy():
    """Deploy the website."""
    pass

Un des avantages principaux de Fabric est qu'il est possible de l'utiliser sur plusieurs serveurs en même temps, avec des règles spécifiques.

On lance Fabric, et on peut aller prendre un café. :D

Pour information Fabric est basé sur Capistrano, le même principe mais en Ruby.

Un must, à tester absolument.

Edit : le site du projet Fabric

Stop aux spams sur django.contrib.comments

fantomas42@gmail.com (fantomas) — Wed, 15 Apr 2009 23:14:47 +0200

Depuis quelques jours, les formulaires de commentaires fournis par l'application django.contrib.comments dans la distribution de Django, sont devenus vulnérables aux spams.

L'application comments contient par défauts plusieurs sécurités pour éviter le spamming, comme un honeypot et la vérification du temps de saisie du commentaires.

Malgré cela les équipes de spammer sont très réactives, et coder un bot spécifique pour les sites django utilisant ce système de commentaires, rend tous ces sites vulnérables.

En parallèle de cela, dans la version 1.1b de Django, l'application comments acquiert une nouvelle fonctionnalité, qu'est la modération automatique. L'envois de mails en cas de commentaires, et aussi prise en charge.

J'en ai donc profité pour développer une protection contre le spam plus efficace basée sur Akismet à partir de cette nouvelle fonctionnalité.

"""Moderator of Entry comments
   Based on Akismet for checking spams
   Need to override the default Moderator,
   for getting request in parameters."""
from django.conf import settings
from django.utils.encoding import smart_str
from django.contrib.sites.models import Site
from django.db.models import signals
from django.contrib import comments
from django.contrib.comments.signals import comment_will_be_posted
from django.contrib.comments.moderation import Moderator
from django.contrib.comments.moderation import CommentModerator

from django.conf.settings import MAIL_COMMENT
from django.conf.settings import AKISMET_COMMENT

AKISMET_API_KEY = getattr(settings, 'AKISMET_API_KEY', '')

class EntryCommentModerator(CommentModerator):
    """Moderate the comment of Entry"""
    email_notification = MAIL_COMMENT
    enable_field = 'comment_enabled'

    def email(self, comment, content_object):
        if comment.is_public:
            super(EntryCommentModerator, self).email(comment, content_object)
            
    def moderate_akismet(self, comment, content_object, request):
        """Need to pass Akismet test"""
        if not AKISMET_COMMENT:
            return False

        from akismet import Akismet
        from akismet import APIKeyError

        akismet = Akismet(key=AKISMET_API_KEY,
                          blog_url='http://%s/' % Site.objects.get_current().domain)
        if akismet.verify_key():
            akismet_data = {'user_ip': request.META.get('REMOTE_ADDR', ''),
                            'user_agent': request.META.get('HTTP_USER_AGENT', ''),
                            'referrer': request.META.get('HTTP_REFERER', 'unknown'),
                            'permalink': content_object.get_absolute_url(),
                            'comment_type': 'comment',
                            'comment_author': comment.userinfo.get('name', ''),
                            'comment_author_email': comment.userinfo.get('email', ''),
                            'comment_author_url': comment.userinfo.get('url', '')}
            return akismet.comment_check(smart_str(comment.comment),
                                         data=akismet_data,
                                         build_data=True)
        raise APIKeyError("Your Akismet API key is invalid.")


class EntryModerator(Moderator):
    """Moderator for Entry"""

    def connect(self):
        comment_will_be_posted.connect(self.pre_save_moderation, sender=comments.get_model())
        signals.post_save.connect(self.post_save_moderation, sender=comments.get_model())
        

    def pre_save_moderation(self, sender, comment, request, **kwargs):
        """Overriding the existing method by passing request to allow"""
        super(EntryModerator, self).pre_save_moderation(sender, comment, **kwargs)

        moderation_class = self._registry[comment.content_type.model_class()]
        if moderation_class.moderate_akismet(comment, comment.content_object, request):
            comment.is_public = False



moderator = EntryModerator()

Il suffit juste d'installer le module Akismet pour Python, et cela devrais fonctionner en définissant sa clef d'API Akismet.

Bon par contre, on remarque de suite qu'il est dommage de devoir écrire une nouvelle classe Moderator, pour pouvoir récupérer et passer le context, c'est peu pratique en effet, surtout que comments peux le gérer par défaut avec le signal comment_will_be_posted.

Mais à priori cela risque de changer si on en regarde le ticket suivant, prévu pour la version finale de Django 1.1 : Ticket 10878, projet Django

Donc une réécriture du code sera certainement nécessaire à la sortie de cette version, qui commence à se faire attendre....

Pour plus d'informations : Documentation sur la modération

Intégrer Twitter dans Django

fantomas42@gmail.com (fantomas) — Tue, 06 Jan 2009 16:19:05 +0100

Twitter, c'est le nouveau média à la mode pour lancer le buzz.
Créer en 2006, son but est simple, pouvoir résumer à tout instant, ce que l'on fait, ce que l'on pense, par des messages courts, que l'on envois par SMS. En effet les messages ne doivent pas dépasser 140 caractères.

De plus votre réseau peut suivre instantanément vos status, enfin bref voilà le Micro-Blogging d'inventé.

Twitter fournis une API pour pouvoir communiquer avec son service. Je me suis alors demandé ce que je pouvais en faire, et ait décidé d'interfacer celle ci avec Django.

A travers un exemple nous allons voir comment récupérer des informations de Twitter avec les Templatetags Django.

Première étape, installer l'excellente API python pour Twitter disponible sur GoogleCode.

Ensuite nous allons créer un module python disponible dans le PYTHON_PATH, que nous appellerons django-twitter, et y créer un templatetag qui récupèrera nos derniers status postés.

$> mkdir -p django-twitter/templatetags
$> cd django-twitter
$> touch __init__.py
$> cd templatetags
$> touch __init__.py
$> touch get_tweets.py

Ceci va nous créer la structure pour y intégrer notre code. Nous allons maintenant éditer le fichier get_tweets.py et y insérer le code suivant :

"""Templates tags for accessing to Twitter"""                                                                                                                                                                                                
from django.conf import settings                                                                                                                                                                                                             
from django.core.cache import cache                                                                                                                                                                                                          
from django.template import Library, Node                                                                                                                                                                                                    
                                                                                                                                                                                                                                             
from twitter import Api                                                                                                                                                                                                                      
                                                                                                                                                                                                                                             
register = Library()                                                                                                                                                                                                                         
                                                                                                                                                                                                                                             
class TweetStatusNode(Node):                                                                                                                                                                                                                 
    def __init__(self, num, varname):                                                                                                                                                                                                        
        self.num = int(num)                                                                                                                                                                                                                  
        self.varname = varname                                                                                                                                                                                                               
        self.key = '%s-%s' % (self.num, self.varname)                                                                                                                                                                                        
                                                                                                                                                                                                                                             
    def render(self, context):                                                                                                                                                                                                               
        tweets = cache.get(self.key)                                                                                                                                                                                                         
        if not tweets:                                                                                                                                                                                                                       
            tweets = Api().GetUserTimeline(settings.TWITTER_USER, self.num)                                                                                                                                                                  
            cache.set(self.key, tweets, settings.TWITTER_TIMEOUT)                                                                                                                                                                            
                                                                                                                                                                                                                                             
        if self.num == 1:                                                                                                                                                                                                                    
            context[self.varname] = tweets[0]                                                                                                                                                                                                
        else:                                                                                                                                                                                                                                
            context[self.varname] = tweets                                                                                                                                                                                                   
        return ''                                                                                                                                                                                                                            
                                                                                                                                                                                                                                             
@register.tag                                                                                                                                                                                                                                
def get_twitter_status(parser, token):                                                                                                                                                                                                       
    """usage : {% get_twitter_status n as tweets %}"""                                                                                                                                                                                       
    bits = token.split_contents()                                                                                                                                                                                                            
    if len(bits) != 4:                                                                                                                                                                                                                       
        raise TemplateSyntaxError, "get_twitter_status tag takes exactly three arguments"                                                                                                                                                    
    if bits[2] != 'as':                                                                                                                                                                                                                      
        raise TemplateSyntaxError, "second argument to get_twitter_status tag must be 'as'"                                                                                                                                                  
    return TweetStatusNode(bits[1], bits[3])

Explications

La fonction get_twitter_status sert de tag et va conditionner les paramètres passés à l'objet Node qui va effectuer la manipulation au sein du template et du context.
Si ce code vous semble obscur, je vous conseille d'aller faire un tour sur la documentation Django pour les templatetags.

Comme nous le voyons cette fonction retourne un objet hérité de Node, TweetStatusNode. C'est cette objet qui va contenir le code appelant l'API de Twitter.

De là j'assigne le résultat dans le context du template, et le tour est joué.

Désormais au sein de mes templates, je peux récupérer mes X derniers status sur Twitter, grâce à ces quelques lignes.

{% load get_tweets %}
{% get_twitter_status 5 as tweets %}

Simple non ?
Une dernière remarque, le système de cache de Django est utilisé, pour limiter les requêtes et le temps d'attente quand on interroge les serveurs de Twitter.

A partir de là, je pense qu'il est envisageable de faire une application Django complète, qui fournit les mêmes fonctionnalités que le site original, mais l'intérêt reste limité.

Distribuer une application Django en moins de 5 minutes

fantomas42@gmail.com (fantomas) — Mon, 29 Dec 2008 15:21:43 +0100

Vous venez de finir votre dernière application en Django, qui se veut réutilisable et distribuable. Félicitations :).

Désormais vous voulez automatiser l'installation et la distribution du paquet, et pourquoi pas le rendre installable facilement en 1 ligne de commande, sous la forme d'eggs.

Le plus simple est de réaliser un script d'installation basé sur distutils qui permettra de télécharger et d'installer le code en quelques secondes.
L'idée est de paqueter le module à distribuer avec un script nommé setup.py se chargeant de l'installation.

Mais réaliser ce script est parfois assez contraignant et long, surtout ex nihilo...

Pour cela nous allons utiliser PasteScript et un jeu de templates pour Django pour nous créer automatiquement la structure du script.

Prérequis
PasteScript : easy_install PasteScript
fez.djangoskel : easy_install fez.djangoskel

Désormais on va créer la structure du package avec cette commande :

$> paster create -t django_app mon_application

Plusieurs questions importantes vous seront posées pour créer la structure de votre distribution, répondez soigneusement.

Désormais dans ce dossier nous avons un fichier setup.py et un dossier mon_application. Le template utilisé crée automatiquement des fichiers pour réaliser une application Django. C'est là où il vous faut mettre votre code.

Maintenant éditez votre fichier setup.py pour le personnaliser un peu.

Grâce aux commandes intégrées vous pouvez distribuer votre application facilement.

Pour l'enregistrer sur Pypi et le rendre disponible via easy_install :

$> python setup.py sdist bdist_egg register upload

Pour installer votre application il suffit désormais de faire :

$> easy_install mon_application

Ou dans le cas où on a téléchargé les sources :

$> python setup.py install

Simple, rapide et efficace non ?
Je connais un RAGE2000 qui va être content !

Django unique et timed sessions

fantomas42@gmail.com (fantomas) — Wed, 24 Dec 2008 10:12:22 +0100

Comment rendre unique les comptes utilisateurs connectés sur un site en Django ?

Ce genre de problématique se retrouve souvent sur les sites internet proposant des abonnements à un service en ligne, voulant empêcher le partage d'abonnement.

Pour les besoins d'un projet spécifique en Django au sein de la société Emencia là où je travaille, j'ai du développer un moyen d'empêcher 2 utilisateurs de se connecter sur un compte utilisateur en même temps.

Mais le problème ne s'arrête pas là, comment empêcher la connection et la déconnection successive entre 2 utilisateurs ? L'idée est de donner un temps minimum de connection à chaque session ouverte pour empêcher la déconnection, par exemple 5 minutes.

Pour cela j'ai écrit un Middleware pour Django qui va se charger de rendre unique chaque sessions utilisateurs sur le site. Utiliser un middleware donne l'avantage d'être réutilisable et facile à installer.

MIDDLEWARE_CLASSES = (
    'django.middleware.common.CommonMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'utsessions.middleware.UTSessionMiddleware',
    )

Après plusieurs refactorings et tests, permettant de configurer le comportement du middleware, comme la déconnection automatique, j'ai publier le code source sur GoogleCode pour que tout le monde puisse en profiter.

Pour plus d'informations, ou pour télécharger le code, consulter le site web du projet : Django UT Sessions.

Pour installer le module depuis Pypi :

$ easy_install utsessions

Clustered Models

fantomas42@gmail.com (fantomas) — Mon, 22 Dec 2008 11:44:45 +0100

Je vous parlais récemment de l'application Django Clustered Sitemap, servant à établir la correspondance entre 2 objets sur des projets Django.

Après une review globale du code et l'ajout de certaines fonctionnalités, j'ai changé le nom du projet en Clustered models car il ne correspondait plus vraiment à la philosophie du projet.

La première modification à été d'ajouter une nouvelle version du sitemap, mais cette fois ci en nuage 2D.

Le code et les vues ont été rendu génériques pour en faciliter l'intégration et l'extensibilité.
Une feature intéressante est qu'il est possible de réutiliser la configuration des vues générique pour effectuer des groupements.

Ensuite un templatetags à été ajouté pour pouvoir voir les models associés à un autre model. Le résultat est qu'il est désormais possible de voir les articles associés sur le blog. :)

Le tout étant très facile a installer, voici un exemple du code pour réaliser mes sitemaps mélant les flatpages et les articles, dans le fichier urls.py du projet.

from clustered_models import VectorBuilder
from clustered_models.clusterers import DimensionalClusterer
from clustered_models.clusterers import HierarchicalClusterer

from django.contrib.flatpages.models import FlatPage

entry_conf = {'queryset': Entry.published.all(),
'fields': ['content', 'title', 'excerpt']}

flatpage_conf = {'queryset': FlatPage.objects.all(),
'fields': ['title', 'content']}

vector = VectorBuilder(entry_conf, flatpage_conf)

urlpatterns += patterns('',
(r'^sitemap/$', 'clustered_models.views.clustered_view',
{'vector': vector, 'clusterer': HierarchicalClusterer}),
(r'^cloud-sitemap/$', 'clustered_models.views.clustered_view',
{'vector': vector, 'clusterer': DimensionalClusterer}),
)

Je ne releaserais le module que si il y a un minimum d'intérêt pour ce projet, donc à vos commentaires :).

Clustered Sitemap

fantomas42@gmail.com (fantomas) — Mon, 15 Dec 2008 21:25:48 +0100

Comme je vous en parlais dans mon précèdent article, je comptais faire quelque chose d'utile tiré de l'intelligence collective.
J'ai donc intégré une partie du code de mon projet Feed Clusterer pour en faire un module Django.

L'idée est de reprendre la configuration des vues génériques, et de spécifier les champs à inspecter pour effectuer une correspondance. Cette correspondance servira à l'établissement d'une cartographie des différentes vues d'un site en Django.

En modélisant ces données sous la forme d'un dendogramme on peut avoir un sitemap assez surprenant, que l'on peut retrouver sur la rubrique Carte en haut du site.
Les regroupements se font à la fois sur les thèmes abordés, comme la programmation, ou les restaurants, tout en mélangeant les styles d'écritures et les catégories utilisées.

Cela permet de pouvoir orienter le visiteur vers les articles connexes du site, sans avoir à établir de relations aux préalables :). Regardez la section ou je parle d'Ogame cela suit ma logique de développement et regroupe à chaque fois l'article le plus proche. Saisissant non ?

Concernant l'effet d'arbre dépliables, je tiens à en remercier l'auteur du site bassistance.de, qui a fait un travail excellent en se basant sur JQuery, un must !

Si le projet vous intéresse, je peux le releaser, il me reste que peut de travaille pour le rendre générique.

Analyse hiérarchique par le contenu

fantomas42@gmail.com (fantomas) — Sun, 14 Dec 2008 00:33:28 +0100

Je suis actuellement en train de lire un livre sur les différents types d'intelligences dîtes collectives.
C'est à dire l'analyse de données représentant les choix, ou les comportement de plusieurs personnes, et comment en extraire des vérités globales.

Une des première applications à laquelle je me suis attaqué à été de construire un Feed Clusterer en Python, servant à effectuer des regroupements par pertinences entre différents sites web.

Comment ca marche ?

Tout site web qui se respect propose un service de Flux RSS ou Atom, résumant les dernières actualités publiées sur le site. L'idée est d'en récupérer le contenu et d'en extraire une liste de mot pertinents.

En calculant le coefficient de Pearson en me basant sur les fréquences de mots comme vecteur, je peux en constituer des groupes et les classer de façon hiérarchique.

Pour visualiser cela, il suffit ensuite de tracer un dendogramme. Un dendogramme va représenter les groupes et la distance entre chaque groupes sur un ensemble de branches. Comme le montre l'image de l'article.

Ceci reste une expérience à petite échelle, mais imaginons maintenant toutes les données que récoltent les gros site web, en particulier ceux à vocations sociales, comme FaceBook, Twitter, MySpace, et n'oublions pas certains moteurs de recherches qui avec leurs dizaines de services sont capables de tracer toutes nos habitudes.

Je ne rentrerais pas dans le détails de toutes les applications inimaginables avec ces données pour tracer les gens, mais de plus avec l'internet mobile, on fournit une nouvelle donnée, c'est à dire le lieu et donc les conditions dans lesquelles on est quand on décide d'acheter un livre sur Amazon.

Marketing ciblé, ou Big Brother ? Où est la différence ?
A titre personnel, je pense que la différence se fera quand on mettra à profit les intelligences collectives au services de l'intelligence humaine, et non à son asservissement, commercial ou autre.

Donc pour finir j'ai décidé de programmer une application Django mettant à l'ouvrage cette étude, qui servira à proposer une navigation différente sur le site.
Bientôt la release. :)