Vous êtes sur la page 1sur 7

#/usr/bin/perl

use HTML::Entities ();


<<DOC;
Axel COURT & Marjorie SEIZOU
FEVRIER 2010

usage : perl Parcours-fils-Grep.pl chemin-du-repertoire-a-parcourir

Le programme prend en entrée le nom du répertoire contenant les fichiers à traiter et


demande à l'utilisateur quelle est la rubrique à traiter.

Le programme construit en sortie plusieurs fichiers contenant de résultat du filtrage selon


l'usage qui en sera fait :
- un fichier structuré au format XML :
<PARCOURS>
<DESC>du fichier</DESC>
<FILTRAGE rubrique="">
<FICHIER num="" date="">
<ARTICLE num="">
<TITRE>titre de l'article<\/TITRE>
<RESUME>résumé de l'article</RESUME>
</ARTICLE>
</FICHIER>
</FILTRAGE>
</PARCOURS>

- un fichier texte structuré au format de balisage Lexico3 :


<filrss_rubrique=num>
<num_article=num>
<titre_num_article=num>
titre de l'article
<resume_num_article=num>
résumé de l'article

- un fichier non structuré au format texte ;

- un fichier contenant des balises comme <nom_du_fichier> pour la structuration du tableau


des résultats des étiquetages de TTagger (feuille de style xsl).

- même chose pour Cordial, mais les repérages ne sont pas sous la forme de balises mais
plutôt de mots-clés (type "BLOCDEPHRASE"), puisque Cordial s'entête à vouloir
étiqueter chaque élément contenu à l'intérieur d'une balise (contrairement à TT qui
n'étiquette pas les balises si l'option -sgml est spécifiée)

Remarque : la construction de ce programme s'appuie sur les scripts donnés en cours :


parcours-arborescence-fichiers.pl, filtreur.pl & nettoyeur.pl

DOC
#-----------------------------------------------------------
########################
# Opérations initiales #
########################

# test des paramètres


if ($ARGV[0] eq "") {
print " syntaxe : perl parcours-arborescence-fichiers-Grep.pl
chemin_du_repertoire_a_parcourir \n" ;
exit(-1);
}

# Récupération du chemin du répertoire à parcourir


my $rep="$ARGV[0]";
# on s'assure que le nom du répertoire ne se termine pas par un "/"
$rep=~ s/[\/]$//;

# Initialisation des différentes variables


# numéro & nom de la rubrique, date de l'article traité
my $num="";
my $rubrique="";
my $date="";
# variables contenant le flux de sortie
my $DUMPXML="";
my $DUMPTXT="";
my $DUMPLEXICO="";
my $DUMPTMP=""; # afin d'utiliser des balises '<fichier>' et de structurer le tableau des
résultats
my $DUMPTMP2=""; # idem, mais pour Cordial (on insère des anotations de début de fichier)

# dialogue avec l'utilisateur


print "\nBienvenue sur le filtreur-nettoyeur de fils RSS \"Le Monde\" !\n\n";
print "Entrez l'identifiant de la rubrique a traiter : \n";
print "0 : A la une\t\t\t\t6 : Medias\n
1 : International\t\t\t7 : Rendez-vous\n
2 : Europe\t\t\t\t8 : Sports\n
3 : Livres\t\t\t\t9 : Opinions\n
4 : Cinema\t\t\t\t10 : Planete\n
5 : Technologies\t\t\t11 : Voyages\n";

# Récupération de l'identifiant de la rubrique tapé par l'utilisateur


$id = <STDIN>;
# Suppression du dernier caractère de retour à la ligne s'il y en a un
chomp($id);

# Choix de la rubrique
if ($id eq 0) {$num="3208";}
elsif ($id eq 1) {$num="3210";}
elsif ($id eq 2) {$num="3214";}
elsif ($id eq 3) {$num="3260";}
elsif ($id eq 4) {$num="3476";}
elsif ($id eq 5) {$num="651865";}
elsif ($id eq 6) {$num="3236";}
elsif ($id eq 7) {$num="3238";}
elsif ($id eq 8) {$num="3242";}
elsif ($id eq 9) {$num="3232";}
elsif ($id eq 10) {$num="3244";}
elsif ($id eq 11) {$num="3546";}
else { print "Hum... Je n'ai pas compris : je traiterai donc la rubrique 'A la Une'\n"; $num=
"3208"; }

# Stockage des chemins & noms des différentes sorties


my $outputxml="SORTIE_$num.xml";
my $outputtxt="SORTIE_$num.txt";
my $outputlexico="SORTIE_formatlexico3_$num.txt";
my $outputtmp="SORTIE_txtbaliseTreeTagger_$num.txt";
my $outputtmp2="SORTIE_txtbaliseCordial_$num.txt";
# Ouverture des fichiers de sortie (précision de l'encodage : Latin-1)
if (!open (OUTPUTXML,">:encoding(iso-8859-1)", "$outputxml")) { die "Pb a l'ouverture du
fichier $outputxml"};
if (!open (OUTPUTTXT,">:encoding(iso-8859-1)", "$outputtxt")) { die "Pb a l'ouverture du
fichier $outputtxt"};
if (!open (LEXICO,">:encoding(iso-8859-1)", "$outputlexico")) { die "Pb a l'ouverture du
fichier $outputlexico"};
if (!open (TMP,">:encoding(iso-8859-1)", "$outputtmp")) { die "Pb a l'ouverture du fichier
$outputtmp"};
if (!open (TMP2,">:encoding(iso-8859-1)", "$outputtmp2")) { die "Pb a l'ouverture du fichier
$outputtmp2"};

############################################################
# Lancement de la procédure sur l'arborescence de fils RSS #
############################################################
# initialisation du compteur de fichiers et du hash qui contiendra les articles déjà extraits
my $i=1;
%DUMPARTICLES;
# le chemin du répertoire est passé en paramètre
&parcoursarborescencefichiers($rep);

########################
# Création des sorties #
########################

# Une fois que le parcours des dossiers + traitement des fichiers est terminé
# Création du fichier XML
print OUTPUTXML "<?xml version=\"1.0\" encoding=\"iso-8859-1\" standalone=\"yes\"?>\n";
#print OUTPUTXML "<?xml-stylesheet href=\"style.css\" type=\"text/css\"?>\n";
print OUTPUTXML "<PARCOURS>\n";
print OUTPUTXML "<DESC>Ce fichier contient les titres et les résumés des articles de la
rubrique ".$rubrique." des fils RSS du journal Le Monde ".$annee."</DESC>\n";
print OUTPUTXML "<FILTRAGE rubrique=\"".$rubrique."\" identifiant=\"$num\">\n".$DUMPXML.
"</FILTRAGE>\n";
print OUTPUTXML "</PARCOURS>\n";
close(OUTPUTXML);

# Création du fichier texte


print OUTPUTTXT "$DUMPTXT";
close (OUTPUTTXT);

# sortie au format lexico3 (balises/"clés" spécifiques, format texte)


print LEXICO "<filrss_rubrique=".$num.">\n\n";
print LEXICO "$DUMPLEXICO";
close(LEXICO);

# sortie temporaire pour TreeTagger


print TMP "<$rubrique>\n\n";
print TMP "$DUMPTMP";
close(TMP);

# sortie temporaire pour Cordial


print TMP2 "LIGNEDERUBRIQUE \n\n";
print TMP2 "$DUMPTMP2";
close(TMP2);

#########################################################
# Lancement de la procédure d'étiquetage par Treetagger #
#########################################################
&lancetreetagger;

# procédures d'extraction des patrons avec xslt


# &extractionxslt_NA
# &extractionxslt_NPN

######################
# Fin du programme ! #
######################
exit;

#----------------------------------------------
##############
# PROCEDURES #
##############

# Procédure parcoursarborescencefichiers
sub parcoursarborescencefichiers {

# @_ ('tableau spécial') contient l'ensemble des arguments passés en paramètre à la


procédure (ici, un seul)
# la fonction 'shift' extrait le premier élément du tableau et en renvoie sa valeur,
stockée ici sous $path
my $path = shift(@_);
# Ouverture du répertoire contenu dans variable $path
opendir(DIR, $path) or die "Problème à l'ouverture de $path: $!\n";
# lecture et stockage du contenu du répertoire dans @files
my @files = readdir(DIR);
# fermeture du répertoire
closedir(DIR);

# Note : à la premire itération, l'argument passé en paramètre est $rep, càd le chemin du
répertoire à parcourir
# @files ne contient alors que les premiers éléments de l'arborescence => ici des dossiers
avec les noms des mois
# Il faut donc au moins 4 itérations pour avoir accès aux fichiers effectifs et les stocker
sous @files : (corpus/)mois/jour/heure/filRSS.xml

# ---------------
# on trie le contenu de @files (dossiers ou fichiers) alphabétiquement/ordinalement
(ici, seulement les dossiers "mois" posent problème)
# de cette façon, l'extraction et l'écriture en sortie du contenu des fils RSS se fera
dans l'ordre mois/jour/heure
@files = sort par_num @files;

foreach my $file (@files) {


# passe au fichier suivant si jamais le nom du fichier est . ou .. (fichiers système)
next if $file =~ /^\.\.?$/;
# modification du fichier étudié pour que son nom indique clairement l'arborescence
# concaténation => nom de $file est en réalité $path + $file
$file = $path."/".$file;
# si $file contient en réalité un répertoire (-d, directory)
# on relance la procédure, avec comme argument $file pour qu'il le parcourt également
if (-d $file) {
&parcoursarborescencefichiers($file);
}
# initialisation d'un compteur pour numéroter les articles du fichier
my $j=1;
# si l'argument passé $file est de type fichier (et non pas un fichier système . ou ..)
# et que c'est un fichier RSS contenant le numéro de la rubrique à traiter
if ((-f $file) && ($file =~ /0,2-$num,1-0,0\.xml$/)) {
# on l'ouvre en précisant l'encodage en UTF-8
open(FICHIER, "<:encoding(utf-8)", "$file") or die "Le fichier de la rubrique
choisie est introuvable...\n";
# Indication pour l'utilisateur
print "Ouverture du fichier $file\n";

# On récupère le nom du fichier en vue de l'inscrire dans le tableau des résultats


et qu'il y ait une ligne par fichier taggé
# [à remplacer quand tous les dossiers normalisés : if ($file =~
/.+(Fils-\d.+0,2-$num,1-0,0\.xml)$/) {
if ($file =~ /.+(\\d.+0,2-$num,1-0,0\.xml)$/) {
$file=$1;
}
$DUMPTMP .= "<$file>\n";
$DUMPTMP2 .= "DEBUTDEFICHIER \n";

# parcours du fichier RSS ligne à ligne


while ($ligne = <FICHIER>) {
# Récupération du nom de la rubrique
if ($ligne =~ /<channel><title>(.*?Le Monde\.fr.*?)<\/title><link>/) {
$rubrique = $1;
}
# Récupération de la date de l'article
if ($ligne =~ /<lastBuildDate>(.+200.).+\ ?<\/lastBuildDate>/) {
$date = $1;
# récupération de l'année pour la balise <DESC> de la sortie xml
if ($date =~ /.*(\d+)\s(\w+)\s(20\d\d).*/) {
$jour=$1;
$mois=$2;
$annee=$3;
}
$DUMPXML.="<FICHIER num=\"$i\" date=\"$date\">\n";
$DUMPLEXICO .= "<num_fichier=$i nom_fichier=$file jour=$jour mois=$mois
annee=$annee>\n";
}
# séparation par un saut de ligne si deux balises se trouvent sur la même ligne
(supprime l'ambiguïté d'extraction du contenu des balises voulues)
$ligne =~ s/></>\n</g;
$texte .= $ligne;
}

# Formatage du texte
$texte =~ s/\n/\ /g;
$texte =~ s/\s/\ /g;
$texte =~ s/\ \ +/\ /g;
$texte =~ s/</\</g;
$texte =~ s/>/\>/g;
$texte =~ s/"/\"/g;
$texte =~ s/°/e/g;
$texteformate = HTML::Entities::decode($texte); # Remplacement des entités HTML
# Remplacement de certaines entités nécessaire pour certaines rubriques
$texteformate =~ s/&#39;/\'/g;
$texteformate =~ s/&#34;/\"/g;
# on supprime les appels à lire la suite de l'article
$texteformate =~ s/\[suite\.\.\.\]//gi;

# Récupération du titre et du résumé, contenus à l'intérieur de chaque balise


<item>
while ($texteformate =~ /<item>\
<title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g) {
$titre = $1;
$resume = $2;

# Formatage du titre
chomp($titre);
$titre = HTML::Entities::decode($titre); # Remplacement des entités HTML
$titre =~ s/&/et/g; # remplacement des caractères spéciaux
$titre =~ s/<.+>//g; # suppression des balises s'il y en a

# on ajoute des points à la fin de chaque titre afin d'éviter un étiquetage


"contextuel" entre la fin du titre et le début du résumé
if ($titre !~ /[!\?\.] *$/) {
$titre .= "\.";
}
# ponctuation : si le dernier caractère du titre est un chiffre, mettre un
espace entre le chiffre et le point
# (sinonTTagger considère que c'est une abréviation...)
$titre =~ s/(\d)\./$1 \./g;

# Formatage du résumé
chomp($resume);
$resume = HTML::Entities::decode($resume); # Remplacement des entités HTML
$resume =~ s/&/et/g; # remplacement des caractères spéciaux
$resume =~ s/<.+>//g; # suppression des balises s'il y en a

# ponctuation : si le dernier caractère du résumé est un chiffre, mettre un


espace entre le chiffre et le point
$resume =~ s/(\d)\./$1 \./g;

# Si le résumé ne contient que la phrase ci-dessous, on ne récupère rien et


on écrit une balise auto-fermante <RESUME/> (pour le fichier de sortie xml)
if ($resume =~ /Retrouvez l'ensemble des dépêches sur
http:\/\/www.lemonde.fr/) {
$resume = "<RESUME/>";
$resumetxt = "";
}
# Si le résumé est vide, on écrit une balise auto-fermante <RESUME/>
elsif ($resume =~ /^ *$/) {
$resume = "<RESUME/>";
$resumetxt = "";
}
# Dans tous les autres cas, on a un contenu potentiellement exploitable :
else {
# si le résumé ne se termine pas par un point, on en rajoute un
# (but double : pas d'étiquetage contextuel et séparation par phrase
dans le tableau des résultats)
if ($resume !~ /[!\?\.] *$/) {
$resume .= "\.";
}
$resumetxt = $resume;
$resume = "<RESUME>$resume<\/RESUME>";
}
# Filtrage des doublons d'articles
#(pas d'ajout si le titre est déjà présent dans le hash %DUMPARTICLES,
contenant les titres des contenus déjà extraits)
unless (exists $DUMPARTICLES{$titre}) {
$DUMPXML.="<ARTICLE
num=\"$j\">\n<TITRE>$titre<\/TITRE>\n$resume\n<\/ARTICLE>\n";
$DUMPTXT.="$titre $resumetxt\n";
$DUMPTMP.="<BLOC> $titre <BLOC> $resumetxt\n";
$DUMPTMP2.="BLOCDEPHRASE $titre BLOCDEPHRASE $resumetxt \n";
$DUMPLEXICO.=
"<num_article=$j>\n<titre_num_article=$j>\n$titre\n\n<resume_num_article=$j>\n$resumetxt\n\n\n
";

# Incrémentation du compteur d'articles


$j++;
# Ajout dans le hash %DUMPARTICLES du titre du résumé venant d'être
extrait, pour le filtrage
$DUMPARTICLES{$titre}++;
}
}
# Incrémentation du compteur de fichiers
$i++;
# Fermeture de la balise </FICHIER> dans le fichier XML
$DUMPXML.="<\/FICHIER>\n";
# saut de ligne pour le tableau des résultats
$DUMPTMP.="\n";
$DUMPTMP2.="\n";
# passage au fichier suivant (# recurse!)
close(FICHIER);
# ... en vidant au préalable la variable $texte
$texte = "";

}
}
}
# Procédure d'étiquetage Treetagger
sub lancetreetagger {
system("perl TreeTagger/tokenise-fr.pl $outputtmp | tree-tagger TreeTagger/french.par
-lemma -token -no-unknown -sgml > treetagger.txt");
}
# Recherche des patrons
# sub extractionxslt_NA {
# system("AltovaXML -xlst1 ss_extraction_NOM-ADJ.xml -in treetagger.txt.xml [-out
sortie-res-patrons.html]");
# }

# sub extractionxslt_NPN {
# system("AltovaXML -xlst1 ss_extraction_N-PRP-N.xml -in treetagger.txt.xml [-out
sortie-res-patrons.html]");
# }

# Procédure de tri alphabétique


sub par_num { return $a <=> $b }