Python
Monday, 30 January 2017
|
Écrit par
Grégory Soutadé

Capture d'écran IWLA

Une petite version d'IWLA est sortie. Les changements ne sont pas extraordinaires, mais il y a deux corrections de bug qui méritent de paraître. Au menu cette année :

  • Ajout de l'option -p qui permet de ne regénérer que l'affichage (sans la phase d'analyse)
  • Affichage de la bande passante des robots (possibilité de n'afficher que le top 10 pour gagner de la place)
  • Deux bugs corrigés concernant la compression des fichiers (dont un qui pouvait entraîner des corruptions de base de données).

À vos téléchargements !

Thursday, 29 September 2016
|
Écrit par
Grégory Soutadé

Journée de la femme : tu feras ça demain

"J'ai la fleeeeeeeeeeeeeemme" principale excuse de la question : "Est-ce que tu as fait une sauvegarde de tes données ?" Oui, mais en fait non ! Comme je l'indiquais dans cet article, il faut en faire tous les 6 mois/1 an à minima.

Car, quand la carte mère subit un choc qui provoque un court-circuit sur le disque et que le moteur fonctionne en mode très dégradé empêchant de lire correctement les secteurs, et bien c'est un, cinq, dix ans de données qui sont perdues ! Ne parlons même pas de la destruction par l'eau ou le feu qui est irrémédiable. Pire encore : le vol pur et simple !

Dans notre cas, le disque fonctionne en mode dégradé : lecture poussive mais pas impossible (par contre il refuse de se faire monter). Trois options s'offrent alors :

  • Envoyer le disque chez une entreprise spécialisée qui va réaliser une récupération parfaite (sauf destruction du disque) : dans les 800€-1000€
  • Copie du disque par dd, puis tentative de montage/récupération
  • Tentative de récupération directe par photorec

J'ai choisi d'utiliser la dernière option (le disque ne m'appartient pas). Résultat, il a fallu 10 jours pour l'analyse des quelques 500Go. Photorec fait une lecture secteur par secteur et tente de retrouver la structure des fichiers qu'il connaît (les fichiers multimédias sont bien reconnus). C'est le genre de logiciel qui sauve des vies !

Néanmoins, les méta données sauvegardées dans le système de fichier (nom, emplacement, date) ne sont pas restaurées. On se retrouve donc avec des tas de fichiers de type : recup_dir.x/fXXXXXXX.zzz qu'il faut trier et renommer à la main. Pour effectuer un pré traitement de cet amas, j'ai écrit un petit script Python Photorec stage 2, chargé de la seconde étape d'une récupération photorec. Initialement, il ne devait détecter que les fichiers MS Office et Open Office à partir d'un fichier zip, mais au final il en fait bien plus.

Fonctions principales :

  • Détection des fichiers MS Office et Open Office à partir des fichiers .zip + détection de la date de création
  • Lecture des meta données ID3 des fichiers MP3 pour y retrouver le nom
  • Lecture des meta données EXIF des fichiers JPG pour y retrouver la date de création
  • Filtre sur les extensions (par liste blanche ou liste noire)
  • Filtre sur la taille des fichiers

Voilà de quoi dégrossir le travail (particulièrement efficace pour regrouper les photos d'un même album). Le tout est disponible sur ma forge avec une licence GPL v3.

Monday, 08 August 2016
|
Écrit par
Grégory Soutadé

Après avoir ouvert le champomy pour les 6 ans du blog, je reviens rapidement sur IWLA car j'aime m'auto extasier sur ce petit outil. L'idée de base était de remplacer AWSTATS par quelque chose de plus facilement "hackable", ce qui est chose faite. Si on rajoute la concision du langage Python par dessus, on obtient un script du genre :

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

import argparse
import gzip
import pickle
import re
import operator

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Statistics extraction')

    parser.add_argument('-f', '--file', dest='file',
                        help='Comma separated IWLA databases')

    args = parser.parse_args()

    blog_re = re.compile(r'^.*blog\.soutade\.fr\/post\/.*$')

    big_stats = {}

    for filename in args.file.split(','):
        with gzip.open(filename, 'r') as f:
            print 'open %s' % (filename)
            stats = pickle.load(f)
            print 'unzipped %s' % (filename)
            top_pages = stats['month_stats']['top_pages']
            for (uri, count) in top_pages.items():
                if not blog_re.match(uri):
                    continue
                big_stats[uri] = big_stats.get(uri,0) + count
            print 'analyzed %s' % (filename)

    print '\n\nResults\n\n'

    for (uri, count) in sorted(big_stats.items(), key=operator.itemgetter(1), reverse=True)[:10]:
        print '%s => %d' % (uri, count)

Que fait-il ? Il va tout simplement appliquer un filtre sur les pages du blog qui concernent les articles pour en extraire les 10 les plus consultées. Ce qui me fait gagner du temps pour mon bilan annuel !

Bien sûr, on peut créer des tas d'outil indépendants qui vont extraire et manipuler les données pour les mettre en forme, le tout avec une facilité déconcertante. Mieux encore, créer un plugin pour l'intégrer directement dans la sortie HTML quand ceci est nécessaire !

Monday, 04 July 2016
|
Écrit par
Grégory Soutadé

This was my problem for Dynastie (a static blog generator). I have a main super class Post and a derived class Draft that directly inherit from the first one.

class Post(models.Model):
    title = models.CharField(max_length=255)
    category = models.ForeignKey(Category, blank=True, null=True, on_delete=models.SET_NULL)
    creation_date = models.DateTimeField()
    modification_date = models.DateTimeField()
    author = models.ForeignKey(User, null=True, on_delete=models.SET_NULL)
    description = models.TextField(max_length=255, blank=True)
    ...

class Draft(Post):
    pass

A draft is a note that will not be published soon. When it's published, the creation date is reset. Using POO and inheritance, it's quick and easy to model this behavior. Nevertheless, there is one problem. When I do Post.objects.all() I get all Post objects + all Draft objects, which is not what I want !!

The trick to obtain only Post is a mix with Python and Django mechanisms called Managers. Managers are at the top level of QuerySet construction. To solve our problem, we'll override the models.Model attribute objects (which is a models.Manager).

Inside inheritance

To find a solution, we need to know what exactly happens when we do inheritance. The best thing to do, is to inspect the database.

CREATE TABLE "dynastie_post" (
    "id" integer NOT NULL PRIMARY KEY,
    "title" varchar(255) NOT NULL,
    "category_id" integer REFERENCES "dynastie_category" ("id"),
    "creation_date" datetime NOT NULL,
    "modification_date" datetime NOT NULL,
    "author_id" integer REFERENCES "auth_user" ("id"),
    "description" text NOT NULL);

CREATE TABLE "dynastie_draft" (
    "post_ptr_id" integer NOT NULL PRIMARY KEY REFERENCES "dynastie_post" ("id")
);

We can see that dynastie_draft has a reference to the dynastie_post table. So, doing Post.objects.all() is like writing "SELECT * from dynastie_post" that includes Post part of drafts.

Solution 1 : Without altering base class

The first solution is to create a Manager that will exclude draft id from the request. It has the advantage to keep base class as is, but it's not efficient (especially if there is a lot of child objects).

class PostOnlyManager(models.Manager):
    def get_queryset(self):
        query_set = super(PostOnlyManager, self).get_queryset()
        drafts = Draft.objects.all().only("id")
        return query_set.exclude(id__in=[draft.id for draft in drafts])

class Post(models.Model):
    objects = PostOnlyManager()

class Draft(Post):
    objects = models.Manager()

With this solution, we do two requests at each access. Plus, it's necessary to know every sub class we want to exclude. We have to keep the BaseManager for all subclasses. You can note the use of only method to limit the query and de serialization to minimum required.

Solution 2 : With altering base class

The solution here is to add a field called type that will be filtered in the query set. It's the recommended one in the Django documentation.

class PostOnlyManager(models.Manager):
    def get_query_set(self):
        return super(PostOnlyManager, self).get_queryset().filter(post_type='P')

class Post(models.Model):
    objects = PostOnlyManager()
    post_type = models.CharField(max_length=1, default='P')

class Draft(Post):
    objects = models.Manager()

@receiver(pre_save, sender=Draft)
def pre_save_draft_signal(sender, **kwargs):
    kwargs['instance'].post_type = 'D'

The problem here is the add of one field which increase database size, but filtering is easier and is done in the initial query. Plus, it's more flexible with many classes. I used a signal to setup post_type value, didn't found a better solution for now.

Conclusion

Depending on your constraints you can use the solution 1 or 2. These solutions can also be extended to a more complex filtering mechanism by dividing your class tree in different families.

Thursday, 14 April 2016
|
Écrit par
Grégory Soutadé

Capture d'écran IWLA

Bientôt un an depuis la version précédente d'IWLA (mon analyseurs de statistiques web écrit en Python) et, sans m'en rendre compte, il y a des tas de nouveautés ! Au menu:

  • Mise en lumière des différences (par rapport à la dernière analyse) pour les mots clés ainsi que les fichiers téléchargés
  • Rappel du résumé annuel dans les statistiques mensuelles
  • Ajout de la durée de l'analyse
  • Détection des navigateurs
  • Détection des systèmes d'exploitations
  • Détection des pays (grâce à iptogeo)
  • Détection des clientS RSS
  • Statistiques détaillées pour un/des visiteur(s) particuliers
  • Possibilité de mettre à jour des configurationS par rapport à celles par défauts (sans écrasement) avec le suffixe "_append"
  • Statistiques par heures
  • Possibilité de spécifier plusieurs fichiers à analyser
  • Support des fichiers compressés (.gz)
  • Possibilité de ne pas compresser la base de données (option -z)
  • Possibilité de spécifier ses propres moteurs de recherche
  • Requêtes DNS inversés pour les clientS RSS

Quelques bugs ont été corrigés :

  • Le dernier jour du mois n'était pas analysé
  • Les pages accédées à la même seconde n'étaient pas analysées

Comme quoi, un logiciel "stable" n'existe pas. Je suis plutôt content de cette version qui est vraiment complète et avec des fonctionnalités non présentes dans AWStats ! Cela tient surtout en la modularité de l'architecture qui, certes, réduit un peu les performances, mais offre une grande souplesse dans l'écriture de modules (filtres).