Donc, j'ai un fichier contenant plein de liens, et maintenant, je veux exploiter ces informations. Comment faire ? Comme indiqué dans le billet du blog de Nicolas Cynober, nous pouvons utiliser un outil comme SPARQLer pour manipuler les informations. Dans SPARQLer, vous pourrez soumettre votre requête écrite en SPARQL, et obtenir une réponse sous différent format :

• en XML, avec la possibilité de renseigner un script XSLT permettant de transformer le document (par exemple en XHTML) ;
• en JSON ;
• ou encore simplement en texte.

Donc, c'est un outil très intéressant, mais il faut être en ligne, et personnellement, j'aime bien avoir mes outils directement disponibles, quelque soit mes accès au web. Et donc, se pose la question de savoir ce que je peux avoir directement sur ma machine. Un petit tour par le CPAN, et hop, voici quelques modules prometteurs :

• RDF::Redland ;
• RDF::Trine ;
• et celui qu'il me faut pour interroger le fichier via la SPARQL : RDF::Query.

Un petit cpan RDF::Query plus tard, je me retrouve donc avec un module permettant d'interroger en SPARQL un store RDF.

Mais comment faire passer mon fichier pearltrees_export.rdf dans un store RDF ? Relativement simplement, RDF::Trine propose dans son répertoire bin quelques exemples de scripts qui vont nous aider :

• rdf_init_store.pl qui, comme son nom l'indique, permet d'initialiser un magasin RDF ; j'ai donc lancé la commande suivante pour initialiser ma base de données : ./rdf_init_store.pl sqlite ./pearltrees.db '' '' pearltrees ce qui signifie donc :
  1. initialise une base de données en utilisant SQLite ;
  2. le nom de cette base de données est ./pearltrees.db ¹;
  3. le premier '' permet de spécifier le nom d'utilisateur pour la base de données, et il n'y en a pas dans le cas présent ;
  4. le second '' permet de spécifier le mot de passe, idem que précédemment²
  5. et finalement, pearltrees est le nom du modèle de données RDF, ici j'ai arbitrairement donné le nom de pearltrees ;
  6. la commande une fois lancée me donne un message d'avertissement : Log4perl: Seems like no initialization happened. Forgot to call init()?, mais quand je vérifie via un sqlite3 pearltrees.db, je constate que les tables (Bnodes, Literals, Models, Resources et Statement2742456113224982524) ont bien été créées, donc, pas de soucis !
• rdf_store_add_file.pl qui permet d'ajouter un fichier dans la base de données de triplets ; ce script s'utilise de la manière suivante ./rdf_store_add_file.pl sqlite ./pearltrees.db '' '' pearltrees sebdeclercq.rdf, ce qui suit la logique du script précédent (utilisation de SQLite, le nom de la base de données, le nom d'utilisateur, le mot de passe et le nom du modèle de données RDF.

Sur mon EeePC 1005HA, voici quelques statistiques :

• pour un fichier RDF de 421515 octets, j'obtiens une base de données de 1872896 octets ;
• le traitement du fichier prend un peu de temps, voici le résultat de time :

real    16m52.234s
user    3m33.573s
sys     0m17.757s

Après l'exécution de rdf_store_add_file.pl, nous nous retrouvons donc avec une base de données qui pourra servir de base à RDF::Query.

Voici un petit script illustrant l'utilisation de RDF::Query :

#!/usr/bin/env perl

use strict;
use warnings;

use RDF::Trine;
use RDF::Trine::Store::DBI;
use RDF::Query;
use Data::Dump;

my $sparql = <<'SPARQL';
PREFIX pt: <http://www.pearltrees.com/rdf/0.1/>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX dc: <http://purl.org/dc/elements/1.1/>

SELECT ?title ?url
WHERE {
   ?pearl rdf:type pt:pearl;
          dc:title ?title;
          owl:sameAs ?url;
          pt:parentTree ?tree
}
ORDER BY DESC (?tree)
SPARQL

my $store =
  RDF::Trine::Store::DBI->new( 'pearltrees', 'DBI:SQLite:dbname=./pearltrees.db', '', '' );
my $model = RDF::Trine::Model->new($store);

my $querier = RDF::Query->new($sparql);

my $iterator = $querier->execute($model);
while ( my $row = $iterator->next ) {
    print $row->{title} . ' ' . $row->{url} . "\n";
}

Voilà pour aujourd'hui. Je suis en train de travailler sur un script s'appuyant sur HTTP::Server::Simple et Template::Declare afin d'avoir une interface plus agréable pour tester mes requêtes SPARQL.

Keep in touch…

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.

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

M'appuyant souvent sur le CPAN, j'en suis venu à me faire une copie sur mon disque dur que je garde synchronisé aussi régulièrement que possible. Ce travail est réalisé par l'excellent minicpan (CPAN::Mini). Me voici donc dans la situation agréable d'avoir toujours à porter de main une archive du CPAN, que je sois connecté à Internet ou non. Mais le CPAN ne se limite pas à cela, c'est également l'outil que je consulte pour lire la documentation (oui, je sais perldoc est là pour cela), mais que faire quand je suis sur la route ? C'est simple, utiliser minicpan_webserver (CPAN::Mini::Webserver). Ce dernier s'appuie sur le fichier de configuration de minicpan, et met à disposition le tout via un serveur web. Je peux maintenant faire des recherches, lire la documentation, les tests, et je peux même lancer l'installation à partir de cette interface. Bref, un CPAN survitaminé ! A essayer !