Archives février 2010

Récemment, au détour de GitHub, j'ai vu un projet intéressant : growlme. Pour ceux qui ne connaissent pas Growl, il s'agit d'un système de notification non intrusif. Imaginez que vous lancez la gravure d'un DVD, et pendant ce temps-là vous en profitez pour travailler sur un article ou un billet de blog. Traditionnellement, les logiciels de gravure vous afficheront une petite fenêtre à la fin de la grave, interrompant ainsi ce que vous étiez en train de faire. Avec les systèmes de notification comme Growl, une fenêtre volante apparaîtra en haut à droite de l'écran signalant la fin de la gravure. Growl est uniquement disponible sur Mac¹, mais il existe des systèmes équivalent sur Linux (libnotify entre autres).

growlme permet de lancer un programme en ligne de commande et d'être tenu au courant du résultat de son exécution via Growl. Comme il m'arrive souvent de lancer un processus assez long via la ligne de commande, et de m'atteler à d'autres tâches entre-temps, j'aimerais bien avoir l'équivalent sur mon Linux.

Le résultat n'est pas bien long et exploite Desktop::Notify, c'est-à-dire l'interface Perl à libnotify, IPC::Run pour lancer la commande, Getopt::Long pour traiter les paramètres en ligne de commande (notez l'usage de Getopt::Long::Configure('pass_through') pour conserver un @ARGV, ainsi que Sys::Hostname pour avoir le titre de la notification. Pour le reste, j'ai singé le programme originel.

#!/usr/bin/env perl

use strict;
use warnings;

use Desktop::Notify;
use IPC::Run qw( run );
use Getopt::Long;
use Sys::Hostname;

my $config = {
    message => 'Succeed!',
    fail    => 'FAILED',
    title   => hostname(),
};

Getopt::Long::Configure('pass_through');
GetOptions( $config, 'message=s', 'fail=s', 'title=s' );

if ( scalar(@ARGV) == 0 ) {
    die "$0: must provide a command to execute\n";
}
else {
    my $notify = Desktop::Notify->new();
    my $notification;

    eval { run \@ARGV };
    my $exitcode = $? >> 8;
    if ( $exitcode == 0 ) {
        $notification = $notify->create(
            summary => $config->{title},
            body    => $config->{message},
            timeout => 5000,
        );
    }
    else {
        $notification = $notify->create(
            summary => $config->{title},
            body    => $config->{fail},
            timeout => 5000,
        );
    }

    $notification->show();
    $notification->close();
}

J'ai créé un gist sur GitHub de cet outil.

Dans le cadre d'un cours d'un cours de Gestion numérique des connaissances, je parle un peu d'information retrieval. Juste les bases, mais bon, cela me paraît important de savoir comment fonctionne un moteur de recherche, surtout pour de futurs spécialistes de l'information et de la documentation. Parmi ces bases, nous avons la manière dont un moteur de recherche perçoit le texte qu'il doit indexer. Si la théorie est facile à appréhender, cela ne m'empêche pas de rajouter une couche visuelle, et c'est pour cette raison que j'ai écrit un petit permettant d'illustrer cette phase de l'indexation.

Le script a été développé sur un temps de midi, un peu avant de donner le cours, et donc, je n'ai pas travaillé l'ergonomie et la mise en page de l'outil. Pour réaliser rapidement l'outil, j'ai utilisé les outils suivants :

• HTTP::Server::Simple + Template::Declare pour créer un petit site web à partir duquel l'utilisateur pourra copier/coller un texte ;
• Text::ExtractWords permettant d'extraire les mots.

Pour le reste, le code est assez simple :

#!/usr/bin/env perl

use strict;
use warnings;

package MyView::Templates;
use Template::Declare::Tags;
use base 'Template::Declare';

private template form => sub {
    my $self  = shift;
    my $title = shift;

    div {
        attr { style => 'margin: auto; size: 15%;', };
        form {
            attr {
                action => '/submit',
                method => 'POST',
            };
            textarea {
                attr {
                    cols  => '100',
                    rows  => '25',
                    name  => 'title',
                    style => 'float: left;',
                };
                $title;
            };
            input {
                attr {
                    name  => 'submit',
                    type  => 'submit',
                    value => 'Soumettre',
                    style => 'float: left;',
                };
            };
            input {
                attr {
                    name  => 'reset',
                    type  => 'reset',
                    value => 'Réinitialiser',
                    style => 'float: left;',
                };
            };
            div { attr { style => 'clear: both;' } };
        };
    };

};

template main => sub {
    my $self  = shift;
    my $title = shift;

    html {
        head {};
        body {
            show( 'form', $title );
        };
    };
};

private template data => sub {
    my $self   = shift;
    my $result = shift;

    div {
        attr { style => 'margin: auto; width: 40%' };
        h1 {
            "Résultat de l'analyse";
        };
    }
    div {
        ol {
            foreach my $word ( sort keys %$result ) {
                li { $word . " : " . $result->{$word} };
            }
        };
    };
};

template result => sub {
    my $self   = shift;
    my $title  = shift;
    my $result = shift;

    html {
        head {};
        body {
            show( 'form', $title );
            hr {};
            show( 'data', $result );
        };
    }
};

package MyWebServer;

use HTTP::Server::Simple::CGI;
use base qw(HTTP::Server::Simple::CGI);
use Text::ExtractWords qw(words_count);

use Template::Declare;
Template::Declare->init( dispatch_to => ['MyView::Templates'] );

my %dispatch = (
    '/'       => \&resp_homepage,
    '/submit' => \&resp_submit,
);

sub handle_request {
    my $self = shift;
    my $cgi  = shift;

    my $path    = $cgi->path_info();
    my $handler = $dispatch{$path};

    if ( ref($handler) eq "CODE" ) {
        print "HTTP/1.0 200 OK\r\n";
        $handler->($cgi);

    }
    else {
        print "HTTP/1.0 404 Not found\r\n";
        print $cgi->header( -charset => 'UTF-8' ),
          $cgi->start_html('Not found'),
          $cgi->h1('Not found'),
          $cgi->end_html;
    }
}

sub resp_homepage {
    my $cgi = shift;
    return if !ref $cgi;

    print $cgi->header( -charset => 'UTF-8' ), Template::Declare->show('main');
}

sub resp_submit {
    my $cgi = shift;
    return if !ref $cgi;

    my $title  = $cgi->param('title');
    my $result = {};
    words_count( $result, $title, {} );

    print $cgi->header( -charset => 'UTF-8' ),
      Template::Declare->show( 'result', $title, $result );
}

package main;

my $server = MyWebServer->new(9999);
$server->run();

J'ai créé un gist de cet outil sur Github, et je compte l'améliorer quand j'aurai un peu de temps.

Dernièrement sur la liste de diffusion perl4lib, une question a été posée concernant l'existence d'une solution permettant de diviser un fichier MARC trop gros en plusieurs fichiers plus petits.

Comme beaucoup d'utilisateurs de fichiers MARC, et de programmeurs manipulant des fichiers MARC, j'ai été confronté à ce problème et j'avais développé une petite solution rapide :

#!/usr/bin/env perl

use strict;
use warnings;

use MARC::File::USMARC;
use MARC::Record;

use Getopt::Long;

my $config = { output => 'input' };

GetOptions($config, 'input=s', 'chunk=s', 'output=s', 'max=s');

if (not exists $config->{input} and not exists $config->{chunk}) {
    die "Usage: $0 --input file --chunk size [--output file]\n";
} else {
    run($config->{input}, $config->{output}, $config->{chunk}, $config->{max});
    
}

sub run {
    my ($input, $output, $chunk, $max) = @_;

    my $marcfile = MARC::File::USMARC->in($input);
    
    my $fh = $output eq 'input' ? create_file($input) : create_file($output);
    my $cpt = 1;
        my $total = 0;
    while (my $record = $marcfile->next) {
        $total++;
        
        if (defined $max) {
            last if $total > $max;
        }
        if ($cpt++ > $chunk) {
            close $fh;
            $fh = $output eq 'input' ? create_file($input) : create_file($output);
            $cpt = 1;
        } 

        print $fh $record->as_usmarc;
    }   
    close $fh;
}

sub create_file {
    my ($output) = @_;
    my $cpt = 0;
    
    my $filename = sprintf('%s.%03d', $output, $cpt++);
    while (-e $filename) {
        $filename = sprintf('%s.%03d', $output, $cpt++);
    }

    open my $fh, '>', $filename;
    return $fh;
}

Cet outil est l'exemple même de solution qu'un bibliothécaire - documentaliste devrait être à même de programmer (pour autant qu'il souhaite programmer, bien entendu). L'algorithme employé est loin d'être compliqué (même si cela reste un bon exercice), et il s'agit d'une exploitation de modules existants (vive le CPAN !) pour lesquels il existe de la documentation. Bref, un bel exemple de paresse et de spécicialisation.

Néanmoins, une meilleure solution que ce marc_split.pl est sans aucun doute l'utilisation de l'utilitaire yaz-marcdump comme l'indique Sébastien Hinderer. Voici quelques exemples :

• yaz-marcdump -C 5000 export.mrc : cela créera des fichiers de 5000 notices dont le nom sera de la forme suivante : 0000001, 0000002, etc
• yaz-marcdump -C 5000 -s export_by_5000- export.mrc : permettra de spécifier un préfixe aux fichiers créés, dans l'exemple, cela nous donnera des fichiers de la forme suivante : export_by_5000-0000001, export_by_5000-0000002, etc