1. <<DOC;
  2. Uyên-To DOAN-RABIER
  3. Ruixin HE
  4. Mohamed Sofiane KERROUA
  5.  
  6. BàO 2 - Expression régulière
  7.  
  8. En utilisant uniquement des expressions régulières, produit en sortie des fichiers contenant les résumés de fils rss
  9. contenus dans des fichiers xml dans une arborescence donnée. Produit en plus des fichiers étiquetés par tree-tagger et
  10. des fichiers exploitables par Cordial (>2Mo et en iso-8859-1).
  11.  
  12. usage : bao2_regexp.pl nom_du_répertoire
  13.  
  14. DOC
  15.  
  16. #/usr/bin/perl
  17. #use strict;
  18. #use warnings;
  19. use Unicode::String qw(utf8);
  20.  
  21. #-----------------------------------------------------------
  22. # Procédure principale
  23. #-----------------------------------------------------------
  24. #Les fichiers sont créés dans un répertoire "resultat"
  25. mkdir(resultat);
  26. #Les fichiers pour cordial sont créés dans un répertoire "cordial"
  27. mkdir(cordial);
  28. mkdir("./cordial/fichiers");
  29.  
  30. #-----------------------------------------------------------
  31. # on initialise une variable $rep contenant le flux de sortie
  32. my $rep="$ARGV[0]";
  33. # on s'assure que le nom du répertoire ne se termine pas par un "/"
  34. $rep=~ s/[\/]$//;
  35.  
  36. #-----------------------------------------------------------
  37. # Initialisation d'un tableau de hash évitant la répétition du contenu des fils rss
  38. my %tabcontenu = ();
  39. &parcoursarborescencefichiers($rep);    #recurse!
  40.  
  41. #-----------------------------------------------------------
  42. $cheminrep ="./resultat";
  43. # On ouvre le répertoire "résultat" contenant les fichiers de sortie xml et txt
  44. # On ajoute à chaque fichier xml la balise fermante </file>
  45. # On convertit chaque fichier txt en iso-8859-1 et on le place dans le dossier cordial
  46. opendir(DIRS,$cheminrep) or die "can't open $cheminrep: $!\n";
  47. my @files = readdir(DIRS);
  48. closedir(DIRS);
  49. foreach my $fichier(@files){
  50.     next if $fichier =~ /^\.\.?$/;
  51.             # A chaque fichier xml crée en sortie on ajoute la balise fermante </file>
  52.             if($fichier =~/\.xml$/){
  53.                 open(OUT,">>:encoding(utf-8)","./resultat/$fichier");
  54.                 print OUT "</file>\n";
  55.                 close(OUT);
  56.             }
  57.             # Chaque fichier txt est converti en iso-8859-1 pour un traitement avec Cordial
  58.         if($fichier=~/\.txt$/){
  59.     open(IN,"<:encoding(utf8)","./resultat/$fichier");
  60.     open (OUT4, ">:encoding(iso-8859-1)","./cordial/iso_$fichier");
  61.     while(<IN>){
  62.          print OUT4 $_;
  63.     }
  64.         close (OUT4);
  65.         close (IN);
  66.     }
  67. }
  68.  
  69. #-----------------------------------------------------------
  70. # Ouverture du répertoire cordial afin de découper les fichiers de plus de 2Mo pour les traiter avec Cordial
  71. $cordial="./cordial";
  72. opendir(COR, $cordial) or die "can't open $path: $!\n";
  73. my @fics = readdir(COR);
  74. closedir(COR);
  75. foreach my $fich(@fics){
  76.     next if $fich =~ /^\.\.?$/;
  77.     &decoupe($fich); # Procédure qui permet de couper un fichier de plus de 2Mo en plusieurs fichiers de 2Mo maximum
  78. }
  79.  
  80. exit; # Fin du programme
  81.  
  82. #-----------------------------------------------------------
  83. # Procédure "parcoursarborescencefichiers"
  84. # Parcours une arborescence et traite chaque fichier xml contenant des fils rss
  85. # Donnée : un répértoire passé en paramètre par valeur
  86. # Résultats : - le résultat du traitement au format txt
  87. #             - le résultat du traitement au format xml
  88. #             - le résultat du traitement au format xml avec un étiquetage réalisé tree-tagger
  89. sub parcoursarborescencefichiers {
  90. #-----------------------------------------------------------
  91. # Récupération du répertoire et ouverture du répertoire
  92.     my $path = shift(@_);
  93.     opendir(DIR, $path) or die "can't open $path: $!\n";
  94.     my @files = readdir(DIR);
  95.     closedir(DIR);
  96.  
  97. #-----------------------------------------------------------
  98. # Traitement de chaques fichiers contenu dans le répertoire
  99.     foreach my $file (@files) {
  100.         next if $file =~ /^\.\.?$/;
  101.         $file = $path."/".$file;
  102. # Si on tombe sur un répertoire on relance la procédure
  103.         if (-d $file) {
  104.             &parcoursarborescencefichiers($file);   #recurse!
  105.         }
  106.        
  107. #-----------------------------------------------------------       
  108. # Traitement du fichier    
  109.         if (-f $file) {
  110. # Si le fichier est un fichier xml et si ce fichier xml n'est pas un fichier ne contenant pas fils rss on le traite
  111.             if(($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/) && ($file !~/0,2-3404,1-0,0\.xml$/)) {
  112.  
  113. # Initialisation des différentes variables         
  114.             my $rubrique="";
  115.             my $encodage = "";
  116.             my $encodagesortie="utf-8";
  117.             my $texte="";
  118.  
  119. #-----------------------------------------------------------
  120. # Si le fichier est vide pas de traitement
  121.             if (-z $file) {
  122.                 print "$file est vide: pas de traitement\n";
  123.             }else{
  124.  
  125. #-----------------------------------------------------------
  126. # Détection de l'encodage du fichier
  127.                     open(FIC,$file);
  128.                     while (my $ligne=<FIC>) {
  129.                     $ligne =~ s/\n//g;
  130.                     if($ligne =~/(iso-8859-1|utf-8)/ig){
  131.                         $encodage = $1;
  132.                     }
  133.                     }          
  134.                     close(FIC);
  135.  
  136. #-----------------------------------------------------------
  137. # Détection de la rubrique en mettant le texte sur une ligne, dans le cas ou il n'y a pas de rubrique ou classe le fichier dans les non-classés            
  138.                     open(FILE,"<:encoding($encodage)",$file);
  139.                     while (my $ligne=<FILE>){
  140.                     $ligne =~ s/\n//g;
  141.                     $texte .= $ligne;
  142.                     }
  143.                     close(FILE);
  144.                    
  145.                     if ($texte=~/<channel><title>([^<]+)<\/title>/){
  146.                         $rubrique = $1;  
  147.                         $rubrique=~s/é/e/gi;
  148.                         $rubrique=~s/è/e/gi;
  149.                         $rubrique=~s/ê/e/gi;
  150.                         $rubrique=~s/à/a/gi;
  151.                         $rubrique=~s/es /e/i;
  152.                         $rubrique=~ s/Le ?Monde.fr ?://;
  153.                         $rubrique=~ s/ ?- ?Le ?Monde.fr//;
  154.                         $rubrique=~ s/es$/e/i;
  155.                         $rubrique=~ s/ //g;
  156.                         $rubrique=uc($rubrique);
  157.                     }
  158.                                        
  159.                     if($rubrique eq ""){
  160.                     $rubrique = "non-classe";
  161.                     }  
  162.  
  163. #-----------------------------------------------------------
  164. # Création des fichiers de sortie                  
  165.                     open(OUT1,">>:encoding(utf-8)","./resultat/$rubrique.txt");
  166.                     open(OUT2,">>:encoding(utf-8)","./resultat/$rubrique.xml");
  167.                     open(OUT3,">>:encoding(utf-8)","./resultat/$rubrique-treetagger.xml");
  168.  
  169. #-----------------------------------------------------------
  170. # Ajout des entêtes dans les fichiers de sortie xml
  171.                     if(-z OUT2){   
  172.                         print OUT2 "<?xml version=\"1.0\" encoding=\"$encodagesortie\" ?>\n";
  173.                         print OUT2 "<file>\n";
  174.                         print OUT2 "<name>$ARGV[0]</name>\n";
  175.                     }
  176.                
  177.                     if(-z OUT3){   
  178.                         print OUT3 "<?xml version=\"1.0\" encoding=\"$encodagesortie\" ?>\n";
  179.                         print OUT3 "<file>\n";
  180.                         print OUT3 "<name>$ARGV[0]</name>\n";
  181.                     }
  182.  
  183. #-----------------------------------------------------------
  184. # Suppression des espaces inutiles, détection de la date du fichier                    
  185.                     $texte =~ s/> *</></g;
  186.                     $texte=~/<pubDate>([^<]+)<\/pubDate>/;
  187.                     my $date=$1;
  188.  
  189. #-----------------------------------------------------------
  190. # Conversion de la date en utf-8 si l'encodage du fichier en entrée ne l'est pas
  191.                     if (uc($encodage) ne "UTF-8") {utf8($date);}
  192.                    
  193. #-----------------------------------------------------------
  194. # Ajout de la date et de la balise ouvrante items dans les fichier de sortie xml
  195.                     print OUT2 "<date>".$date."</date>\n";
  196.                     print OUT2 "<items>\n";
  197.                     print OUT3 "<date>".$date."</date>\n";
  198.                     print OUT3 "<items>\n";
  199.                    
  200. #-----------------------------------------------------------
  201. # Détection du titre et du résumé du fils rss
  202.                     while ($texte =~ /<item><title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g) {
  203.                     my $titre=$1;
  204.                     my $resume=$2;
  205.  
  206. #-----------------------------------------------------------
  207. # Test sur le titre du fil rss, si il est déjà contenu dans le tableau de hash on ne le traite pas
  208.                     my $test = $titre;
  209.                     if(!exists $tabcontenu{$test}){
  210.    
  211. #-----------------------------------------------------------
  212. # Conversion du titre et du résumé en utf-8 si l'encodage du fichier en entrée ne l'est pas
  213.                         if (uc($encodage) ne "UTF-8") {utf8($titre);utf8($resume);}
  214.  
  215. #-----------------------------------------------------------
  216. # Appel de la fonction "nettoietexte" avec comme paramétres le titre et le résumé
  217.                             $titre = &nettoietexte($titre);
  218.                             $resume = &nettoietexte($resume);
  219.  
  220. #-----------------------------------------------------------
  221. # Appel de la fonction "etiquetage" avec comme paramétres le titre et le résumé
  222.                             my ($titreetiquete, $resumeetiquete) = &etiquetage ($titre, $resume);
  223.  
  224. #-----------------------------------------------------------
  225. # On ajoute dans les différents fichiers le titre et le résumé
  226.                             print OUT1 "Titre : $titre \n";
  227.                             print OUT1 "Resume : $resume \n";
  228.                             print OUT2 "<item><title>$titre</title><abstract>$resume</abstract></item>\n";
  229.                             print OUT3 "<item>\n<title>\n$titreetiquete</title>\n<abstract>\n$resumeetiquete</abstract>\n</item>\n";
  230.                            
  231. #-----------------------------------------------------------
  232. # On ajoute dans le tableau de hash le titre du fil rss
  233.                             $tabcontenu{$test}++;
  234.                         }
  235.                     }
  236.  
  237. #-----------------------------------------------------------
  238. # Fermeture de la balise items dans les fichiers xml, fermeture des fichiers
  239.                     print OUT2 "</items>\n";
  240.                     print OUT3 "</items>\n";
  241.                     close(OUT1);
  242.                     close(OUT2);
  243.                     close(OUT3);
  244.                 }
  245.             }
  246.         }
  247.     }
  248. } # Fin "parcoursarborescencefichiers"
  249.  
  250.  
  251. #-----------------------------------------------------------
  252. # Fonction "etiquetage"
  253. # Permet d'etiqueter un texte avec le programme extérieur tree-tagger
  254. # Données : - $titre : une variable contenant des chaînes de caractères en utf-8
  255. #           - $resume : : une variable contenant des chaînes de caractères en utf-8
  256. # Résultats : 2 variables contenant le texte étiqueté par tree-tagger  
  257. sub etiquetage {
  258.     my ($titre,$texte)=@_;
  259.     #----- le titre
  260.     my $codage="utf-8";
  261.     my $tmptag="texteaetiqueter.txt";
  262.     open (TMPFILE,">:encoding(utf-8)", $tmptag);
  263.     print TMPFILE $titre,"\n";
  264.     close(TMPFILE);
  265.     system("perl ./treetagger-win32/cmd/tokenise-fr.pl $tmptag | tree-tagger.exe ./treetagger-win32/lib/french-utf8.par -lemma -token -no-unknown -sgml > treetagger.txt");
  266.    
  267.     system("perl ./treetagger-win32/cmd/treetagger2xml-utf8.pl treetagger.txt $codage ");
  268.     # lecture du resultat tagge en xml :
  269.     open(OUT,"<:encoding(utf-8)","treetagger.txt.xml");
  270.     my $fistline=<OUT>;
  271.     my $titreetiquete="";
  272.     while (my $l=<OUT>) {
  273.     $titreetiquete.=$l;
  274.     }
  275.     close(OUT);
  276.     #----- le resume
  277.     open (TMPFILE,">:encoding(utf-8)", $tmptag);
  278.     print TMPFILE $texte,"\n";
  279.     close(TMPFILE);
  280.     system("perl ./treetagger-win32/cmd/tokenise-fr.pl $tmptag | tree-tagger.exe ./treetagger-win32/lib/french-utf8.par -lemma -token -no-unknown -sgml > treetagger.txt");
  281.     system("perl ./treetagger-win32/cmd/treetagger2xml-utf8.pl treetagger.txt $codage");
  282.     # lecture du resultat tagge en xml :
  283.     open(OUT,"<:encoding(utf-8)","treetagger.txt.xml");
  284.     my $fistline=<OUT>;
  285.     my $texteetiquete="";
  286.     while (my $l=<OUT>) {
  287.     $texteetiquete.=$l;
  288.     }
  289.     close(OUT);
  290.     # on renvoie les resultats :
  291.     return ($titreetiquete,$texteetiquete);
  292. } # Fin "etiquetage"
  293.  
  294.  
  295. #-----------------------------------------------------------
  296. # Fonction "nettoietexte"
  297. # Nettoie un texte de ses entités xml
  298. # Donnée : une chaîne de caractère contenant des entités xml
  299. # Résultat : la chaîne de caractères nettoyée de ses entités xml
  300. sub nettoietexte {
  301.     my $texte=shift;
  302.     $texte =~ s/&lt;/</g;
  303.     $texte =~ s/&gt;/>/g;
  304.     $texte =~ s/<a href[^>]+>//g;
  305.     $texte =~ s/<img[^>]+>//g;
  306.     $texte =~ s/<\/a>//g;
  307.     $texte =~ s/&#38;#39;/'/g;
  308.     $texte =~ s/&#38;#34;/"/g;
  309.     $texte =~ s/&#233;/é/g;
  310.     $texte =~ s/&#234;/ê/g;
  311.     $texte =~ s/<[^>]+>//g;
  312.     $texte =~ s/&nbsp;/ /g;
  313.     $texte=~s/&#39;/'/g;
  314.     $texte=~s/&#34;/"/g;
  315.     $texte=~s/&amp;#39;/'/g;
  316.     $texte=~s/&amp;#34;/"/g;
  317.     return $texte;
  318. } # Fin "nettoietexte"
  319.  
  320.  
  321. #-----------------------------------------------------------
  322. # Procédure "decoupe"
  323. # Decoupe des fichiers de plus de 2Mo en plusieurs fichiers de 2Mo
  324. # Donnée : une variable contenant le nom d'un fichier à couper
  325. # Résultat : les fichiers découpés crées dans un répertoire "fichiers" contenu dans le répertoire "cordial"
  326. sub decoupe{
  327. my $fichier = shift(@_);
  328. open(F,"./cordial/$fichier");
  329. my $num = 1;
  330. my $taille = 0;
  331. while($ligne = <F>) {
  332.     if($taille < 2000000){ # On veut des fichiers de 2Mo = 2000000 octets
  333.     open (OUT,">>./cordial/fichiers/$fichier".$num.".txt");
  334.     print OUT $ligne;
  335.     $taille = -s OUT;
  336.     close(OUT);
  337.     }else{
  338.      $num++;
  339.      $taille = 0;
  340.     }
  341. }
  342. close (F);
  343. } # Fin "decoupage"
  344.