Un épisode sur le minigrep

Un épisode sur le minigrep

Nous avons rencontré un problème lors de l'installation du minigrep sur la distribution Ubuntu 16.04.

Nous allons présenter notre solution dans ce blog. Nous avons également écrit un script pour ceux ou celles qui ont besoin de faciliter l'installation sur Linux.

PLAN

I OBSERVATION

II HYPOTHESE

III SOLUTION

IV SCRIPT

I OBSERVATION

Lors de l'installation du module Unicode-String-2.09, nous avions rencontré tout d'abord des erreurs qui concernaient la permission d'accès à certains répertoires, nous avons donc utiliser sudo ; mais les nouvelles erreurs sont survenues :

###############2.09 error log
Test Summary Report
-------------------
t/charname.t (Wstat: 65280 Tests: 0 Failed: 0)
  Non-zero exit status: 255
  Parse errors: No plan found in TAP output
Files=6, Tests=99,  1 wallclock secs ( 0.05 usr  0.01 sys +  0.10 cusr  0.02 csys =  0.18 CPU)
Result: FAIL
Failed 1/6 test programs. 0/99 subtests failed.
Makefile:980: recipe for target 'test_dynamic' failed
make: *** [test_dynamic] Error 255

II Hypothèse

La version 2.09 est distribuée en 2005. Elle n'est pas compatible avec notre perl (v5.22.1). Il nous faudra une alternative.

III Solution

   

Nous avons donc trouvé la version 2.10 (distribuée le 8 sept 2016)pour la remplacer. (disponible sur http://search.cpan.org/~gaas/Unicode-String-2.10/).

Pour installer un module perl, il existe en générale deux moyens :

1) on télécharge le module via CPAN  (Comprehensive Perl Archive Network), et on compile et installe manuellement ;

2) on utilise un module (cpanm) de CPAN, qui va automatiquement télécharger, compiler et installer les modules dont on a besoin.

   

   

    3.1 Installation manuelle

   

1) Télécharger la version 2.10 dans le répertoire minugrepemultilingue-v2.2-regexp

2) Déplacer dans le répertoire supra

3) Copier notre script install.sh dans ce répertoire (cf la partie IV)

4) Lancer ce script qui permet d'installer et de compiler le module Unicode-String-2.10 dans une seule étape.

    3.2 Installation automatique via CPAN

Nous avons également testé l'alternative via CPAN dans un autre ordinateur.

   

1) Installer avant tout le module cpanminus pour faciliter l'installation d'autres modules. cpanm n'a pas besoin de configuration.

sudo apt install cpanminus

2) Lancer la commande supra pour chercher le module Unicode::String à l'aide de cpanm. Le téléchargement, la compilation et l'installation sont réalisés automatiquement.

sudo cpanm Unicode::String

sudo cpanm Unicode::String--> Working on Unicode::String
Fetching http://www.cpan.org/authors/id/G/GA/GAAS/GAAS/Unicode-String-2.10.tar.gz ... OK
Configuring Unicode-String-2.10 ... OK
Building and testing Unicode-String-2.10 ... OK
Successfully installed Unicode-String-2.10 (upgraded from 2.09)
1 distribution installed

IV SCRIPT

install.sh

#!usr/bin/bash
#install.sh
#Ce script permet de compiler et d'installer le module Unicode-String-2.10
#PATH : /.../minigrepmultilingue-v2.2-regexp
#EXCUTION : sudo bash ./install.sh

pack=./Unicode-String-2.10
tar -zxvf $pack.tar.gz
cd $pack
perl ./Makefile.PL
make
make test
make install

REFERENCES

https://www.cpan.org/modules/INSTALL.html

https://metacpan.org/pod/Unicode::String

    

Création d’une page html contenant 3 tableaux de 13 colonnes avec script bash

Création d’une page html contenant 3 tableaux de 13 colonnes avec script bash

PLAN

I MISE A JOUR

II SCRIPT

III RESULTAT

I MISE A JOUR

Nous avons ajouté 5 colonnes par rapport au blog précédent.

    1.1 Contexte

   

Le texte dump d'une page html est assez gros. Il est donc necessaire d'"abréger" le texte selon notre besoin pour avoir un résultat d'analyses beaucoup plus pertinent. Dans cette version du script, nous avons envisagé d'extraire 2 lignes avant et 2 lignes après du motif pour composer notre "contexte". Nous allons modifier cette option après.

   

Méthode :

   

egrep [OPTIONS] MOTIF [FICHIER...]

OPTION -i : ignorant les casses du motif et du fichier d'entrée

OPTIONS -A NUM, -B NUM, -C NUM : NUM lignes après(After), NUM lignes avant(Before), ou NUM lignes avant et après (Contexte)

   

egrep -i -C 2 "$motif" < $dump-utf8 >> $contexte;

   

$motif est une variable définie dans le fichier paramètre

$dump-utf8 désigne le fichier d'entrée (un texte dump) de cette commande

$contexte désigne le fichier de sortie où stockent les contextes d'un texte dump

   

    1.2 Contexte html (minigrep)

   

Minigrep est un script perl qui permet de représenter les contextes recueillis dans une page html.

Pour nous en servir, il faut une installation (Nous avons écrit un script pour faciliter cette étape, cf notre prochain blog).

   

Méthode :

   

perl $minigrep "UTF-8" $dump-utf8 $motif_mini_grep;
mv $minigrep_out $contexte_html;

   

Le fichier de sortie est placé par défaut dans le répertoire courant (où l'on exécute le script, i.e. PROJET_MOT_SUR_LE_WEB). Il faut le déplacer (et renommer) dès qu'il est créé. Sinon on risque de l'écraser dans l'éxécution suivante de la boucle.

   

    1.3 Fréquence du motif

   

La fréquence du motif, c'est-à-dire le nombre d'occurences du(des) mot(s) à chercher, nous fournit une vision globale de l'importance du motif dans le texte.

Méthode :

fq=`egrep -i "$motif" $dump-utf8 |wc -l`;

1) Trouver toutes les lignes contenant le motif dans le fichier d'entrée ;

2) Compter le nombre de lignes.

   

    1.4 Liste des mots (index)

   

La liste des mots ( cf term frequency ) permet d'évaluer l'importance d'un terme contenu dans un fichier.

Méthode :

sed -r "s/[-\w\']+/ /g" $dump-utf8 |tr '\n' ' '|tr ' ' '\n'|tr -s '\n'|tr '[A-Z]' '[a-z]' > $dump-tmp1;
sort -bdf $dump-tmp1 |uniq -ci|sort -gr -o $list_freq;

Créer un fichier temp qui

1) n'a pas de ponctuations, sauf le trait d'union d'un mot composé (ex. prêt-à-porter);

2) a un seul token par ligne ;

3) est transformé en minuscule ;

4) A partir du fichier temporaire, établir un index classé par fréquence décroissante.

               

   

   

    1.5 Bigramme (ou Digramme)

Dans cette colonne, nous avons créé pour chaque texte dump une liste de bigramme classé par fréquence décroissante.

   

Méthode :

tail -n +2 $dump-tmp1 > $dump-tmp2
paste $dump-tmp1 $dump-tmp2 | sort | uniq -ci | sort -gr -o $di_grams;

               

A partir du fichier de liste temporaire créé dans l'étape supra,

1) la commande tail -n +2 permet d'afficher le fichier à partir de la deuxième ligne sur la stdOUT, on le dirige comme un second fichier temporaire

2) la commande paste ensuite colle ces deux fichiers en un seul dont chaque ligne contient 2 tokens,

3) la suite du pipeline sert à classer les bigrammes par fréquence décroissante et à diriger le résultat dans un nouveau fichier.

II Script

#!bin/bash
#PATH=$PATH:~/home/.../PROJET_MOT_SUR_LE_WEB
#./PROGRAMMES/20171129_CreationTableau_13cols.sh
#parametre :  ./PROGRAMMES/20171129_parametres
#EXECUTION
#bash ./PROGRAMMES/20171129_CreationTableau_13cols.sh < ./PROGRAMMES/20171129_parametres
#VERSION 20171129
################################################################################
#MISE A JOURS 
# Ajouter un paramètre motif (pour récupérer son contexte et calculer sa fréquence)
# Ajouter un paramètre qui est le chemin du fichier motif (seulement pour le script minigrep)
# Ajouter une colonne contexe, (commandes : egrep, wc)
# Ajouter une colonne contexte_html,(script minigrep) 
# Ajouter une colonne pour la fréquence du motif, (commandes : egrep, wc)
# Ajouter une colonne pour la liste des mots, (commandes : sort, uniq)
# Ajouter une colonne pour le bigramme (commandes : tail, paste, sort, uniq)
################################################################################

echo "Création d'une page html contenant trois tableaux ";
read rep; 
read table;
read rep_page_aspiree;
read rep_dump_text;
read rep_contexte;
read motif;
read motif_mini_grep;

echo "INPUT : nom du répertoire contenant des fichiers d'URLs : $rep"; 
echo "OUTPUT : nom du fichier html contenant des tableaux : $table";
echo "OUTPUT : nom du répertoire stockant les pages aspirées : $rep_page_aspiree";
echo "OUTPUT : nom du répertoire stockant les texts dump : $rep_dump_text";
echo -e "Motifs de recherche :\n\t\t$motif\n";
echo "OUTPUT : nom du répertoire stockant les fichiers contextes : $rep_contexte";
echo "OUTPUT : nom du répertoire stockant les fichiers index : $rep_contexte";
echo "OUTPUT : nom du répertoire stockant les fichiers ngram : $rep_contexte";

echo -e "\n\n\n\n\nVeuillez patienter quelques instants.\n\n\nTravail en mode silence...\n\n\n";

################################################################################

echo -e "<!DOCTYPE html>\n<html>\n\t<head>\n\t\t<title>Tableau URLs</title>\n\t\t<meta charset=\"utf-8\">\n\t</head>\n" > $table;
echo -e "\t<body>\n\t\t<h2 align=\"center\">Tableaux des URLs de teste</h2>" >> $table;


creer_tableau(){
    echo -e "\t\t\t\t<th width = \"$2\" align = \"center\">$3</th>" >> $table;
}


for file in `ls $rep`
{
    echo -e "\t\t<table border = \"1\" bordercolor = \"#47baae\" width = \"90%\" align = \"center\">" >> $table;
    #titre du tableau
    echo -e "\t\t\t<tr height = \"30px\" bgcolor = \"#47baae\"><th colspan = \"13\">TABLEAU-$file</th></tr>" >> $table;
    echo -e "\t\t\t<tr>" >> $table;
    #colonne1 : numéro
    creer_tableau $table %5 'N°'
    #colonne2 : lien
    creer_tableau $table %5 'LIEN'
    #colonne3 : code d'état
    creer_tableau $table %5 'CODE'
    #colonne4 : état de lien
    creer_tableau $table %15 'ETAT DE LIEN'
    #colonne5 : page aspirée
    creer_tableau $table %10 'PAGE ASPIREE'
    #colonne6 : encodage initial
    creer_tableau $table %5 'ENCODAGE INIT'
    #colonne7 : dump initial
    creer_tableau $table %10 'DUMP INIT'
    #colonne8 : dump utf-8
    creer_tableau $table %10 'DUMP UTF-8'
    #colonne9 : contexte utf-8
    creer_tableau $table %10 'CONTEXTE UTF-8'
    #colonne10 : contexte html utf-8
    creer_tableau $table %10 'CONTEXTE HTML'
    #colonne11 : fréquence de motif
    creer_tableau $table %5 'FQ MOTIF'
    #colonne12 : index (avec/sans mots vides)
    #echo -e "\t\t\t\t<th width = \"10%\" align = \"center\">CONTEXTE</th>" >> $table;
    creer_tableau $table %5 'INDEX'
    #colonne13 : ngram ==> 2grams
    creer_tableau $table %5 'NGRAM'
    echo -e "\t\t\t</tr>" >> $table;
    
    line_iterator=0;
    for line in `cat $rep/$file`
    {
        
        let line_iterator++;

        page="$rep_page_aspiree/20171129-$file-aspiree-$line_iterator.html";
        dump="$rep_dump_text/20171129-$file-dump-$line_iterator";
        contexte="$rep_contexte/20171129-$file-ctxt-$line_iterator";
        contexte_html="$rep_contexte/20171129-$file-ctxt_html-$line_iterator";
        list_freq="$rep_dump_text/20171129-$file-liste-$line_iterator";
        di_grams="$rep_dump_text/20171129-$file-2grams-$line_iterator";
        minigrep="./PROGRAMMES/minigrepmultilingue-v2.2-regexp/minigrepmultilingue.pl";
        minigrep_out="./resultat-extraction.html";
        
        lien_statut=`curl -sIL $line|egrep -i 'HTTP\/[0-9]\.[0-9]'| awk '{print $0}' | sed  's/\n/\t/g'|sed  's/\r/\t/g'`; 
        

        code_retour=`curl -sL -o $page -w "%{http_code}" $line | sed  's/\n//g'|sed  's/\r//g'`;
        echo "Etat de lien : $lien_statut"; #test, à enlever après
        echo "Code_retour : $code_retour"; #test, à enlever après

        if [[ $code_retour == 200 ]] ;then
            #Demander l'encodage
            #encodage_header_curl
            encodage=`curl -sIL $line|grep -i -Po '(?<=charset=).+(?=\b)' |awk '{print tolower($0)}'`;
            echo "encodage récupéré de l'entête : $encodage"; #test, à enlever après
            
            #condition $encodage == utf8, => dump
            if [[ $encodage == "utf-8" ]] ;then 
                #il faut désignier le jeu de caractères pour la commande lynx car quelques fois lynx ne peux pas réussir à décharger des textes sans connaissances d'encodages préalables   
                lynx -dump -nolist -assume_charset=%{charset} -display_charset=$encodage $line > $dump-utf8;
                #récupérer le contexte avec egrep, 2 lignes avant, 2 lignes après
                egrep -i -C 2 "$motif" < $dump-utf8 >> $contexte;
                #récupérer le contexte html avec minigrep, puis déplacer le fichier dans le répertoire CONTEXTES
                perl $minigrep "UTF-8" $dump-utf8 $motif_mini_grep;
                mv $minigrep_out $contexte_html;
                
                #compter la fréquence du motif
                fq=`egrep -i "$motif" $dump-utf8 |wc -l`;
                
                #créer un fichier temp qui 1)n'a pas de ponctuations, 2)a un seul token par ligne, 3)est transformé en minuscule
                sed -r "s/[-\w\']+/ /g" $dump-utf8 |tr '\n' ' '|tr ' ' '\n'|tr -s '\n'|tr '[A-Z]' '[a-z]' > $dump-tmp1;
                # à partir du fichier temp, établir une indice classée par fréquence décroissante
                sort -bdf $dump-tmp1 |uniq -ci|sort -gr -o $list_freq;
                # à partir du fichier temp, récupérer des digrams, puis enlever des fichiers temps
                tail -n +2 $dump-tmp1 > $dump-tmp2
                paste $dump-tmp1 $dump-tmp2 | sort | uniq -ci | sort -gr -o $di_grams;
                #rm $dump-tmp1 $dump-tmp2;
                
                
                echo -e "\t\t\t<tr>\n\t\t\t\t<td align = \"center\">$line_iterator</td>" >> $table; 
                echo -e "\t\t\t\t<td align = \"center\">$code_retour</td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\">$lien_statut</td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\"><a href = '$line'>20171129-$file-lien-$line_iterator</a></td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\"><a href = ".$page">20171129-$file-aspiree-$line_iterator</a></td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\">$encodage</td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\"><a href = ".$dump-utf8">20171129-$file-dump-$line_iterator-utf8</a></td>" >> $table;
                
                
                echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte">20171129-$file-contexte-$line_iterator-utf8</a></td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte_html">20171129-$file-ctxt_html-$line_iterator-utf8</a></td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\">$fq</td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\"><a href = ".$list_freq">20171129-$file-fq-$line_iterator</a></td>" >> $table;
                echo -e "\t\t\t\t<td align = \"center\"><a href = ".$di_grams">20171129-$file-2grams-$line_iterator</a></td>\n\t\t\t</tr>" >> $table;
                
                
                
                
            #condition non-utf8 && non vide => vérifier l'existence de $encodage dans la liste d'iconv
            elif [[ $encodage != "utf-8" ]] && [[ $encodage != "" ]] ;then
                #chercher l'encodage dans la liste des encodages de iconv
                verification_iconv=`iconv -l | egrep -io $encodage | sort -u`;
                
                # condition $encodage connu par iconv => dump et convertir en utf8
                if [[ $verification_iconv != "" ]] ; then
                    lynx -dump -nolist -assume_charset=%{charset} -display_charset=$encodage $line > $dump-$encodage;
                    iconv -c -f $encodage -t utf-8 $dump-$encodage > $dump-utf8;
                    #récupérer le contexte avec egrep, 2 lignes avant, 2 lignes après
                    egrep -i -C 2 "$motif" < $dump-utf8 >> $contexte;
                    #récupérer le contexte html avec minigrep, puis déplacer le fichier dans le répertoire CONTEXTES
      perl $minigrep "UTF-8" $dump-utf8 $motif_mini_grep;
      mv $minigrep_out $contexte_html;
      
      #compter la fréquence du motif
                    fq=`egrep -i "$motif" $dump-utf8 |wc -l`;
                    #créer un fichier temp qui 1)n'a pas de ponctuations, 2)a un seul token par ligne, 3)est transformé en minuscule
                    sed -r "s/[-\w\']+/ /g" $dump-utf8 |tr '\n' ' '|tr ' ' '\n'|tr -s '\n'|tr '[A-Z]' '[a-z]' > $dump-tmp1;
                    # à partir du fichier temp, établir une indice classée par fréquence décroissante
                    sort -bdf $dump-tmp1 |uniq -ci|sort -gr -o $list_freq;
                    tail -n +2 $dump-tmp1 > $dump-tmp2
                    paste $dump-tmp1 $dump-tmp2 | sort | uniq -ci | sort -gr -o $di_grams;
                    
                    
                    
                    echo -e "\t\t\t<tr>\n\t\t\t\t<td align = \"center\">$line_iterator</td>" >> $table; 
                    echo -e "\t\t\t\t<td align = \"center\">$code_retour</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$lien_statut</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = '$line'>20171129-$file-lien-$line_iterator</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$page">20171129-$file-aspiree-$line_iterator</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$encodage</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$dump-$encodage">20171129-$file-dump-$line_iterator-$encodage</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$dump-utf8">20171129-$file-dump-$line_iterator-utf8</a></td>" >> $table;
                    
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte">20171129-$file-contexte-$line_iterator-utf8</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte_html">20171129-$file-ctxt_html-$line_iterator-utf8</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$fq</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$list_freq">20171129-$file-fq-$line_iterator</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$di_grams">20171129-$file-2grams-$line_iterator</a></td>\n\t\t\t</tr>" >> $table;
                        
                    
                #condition $encodage non connu par iconv => rien à faire, seulement remplir les tableaux avec des infos necessaires
                else
                    echo "Echec : $encodage inconnu...";
                    echo -e "\t\t\t<tr>\n\t\t\t\t<td align = \"center\">$line_iterator</td>" >> $table; 
                    echo -e "\t\t\t\t<td align = \"center\">$code_retour</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$lien_statut</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = '$line'>20171129-$file-lien-$line_iterator</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$encodage</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">null</td>\n\t\t\t</tr>" >> $table;
                fi
                
            # condition pas de $encodage dans la réponse de curl -I, récupérer $encodage directement dans la balise meta de la page html (locale)
            elif [[ $encodage == "" ]] ;then
                encodage=`egrep -i 'meta.+charset' $page |awk '{print tolower($0)}'|egrep -o "charset[=\s\"a-Z0-9\-]*" |cut -d"=" -f2 | sed  's/\s//g'|sed 's/\"//g'`;
                #condition $encodage utf8 dump
                echo "encodage récupéré de page html : $encodage"; 
                
                
                if [[ $encodage == "utf-8" ]] ;then 
                    lynx -dump -nolist -assume_charset=%{charset} -display_charset=$encodage $line > $dump-utf8;
                    #récupérer le contexte avec egrep, 2 lignes avant, 2 lignes après
                    egrep -i -C 2 "$motif" < $dump-utf8 >> $contexte;
                    #récupérer le contexte html avec minigrep, puis déplacer le fichier dans le répertoire CONTEXTES
      perl $minigrep "UTF-8" $dump-utf8 $motif_mini_grep;
      mv $minigrep_out $contexte_html;
                    
                    #compter la fréquence du motif
                    fq=`egrep -i "$motif" $dump-utf8 |wc -l`;
                    #créer un fichier temp qui 1)n'a pas de ponctuations, 2)a un seul token par ligne, 3)est transformé en minuscule
                    sed -r "s/[-\w\']+/ /g" $dump-utf8 |tr '\n' ' '|tr ' ' '\n'|tr -s '\n'|tr '[A-Z]' '[a-z]' > $dump-tmp1;
                    # à partir du fichier temp, établir une indice classée par fréquence décroissante
                    sort -bdf $dump-tmp1 |uniq -ci|sort -gr -o $list_freq;
                    #récupérer le bigram de chaque texte
                    tail -n +2 $dump-tmp1 > $dump-tmp2
                    paste $dump-tmp1 $dump-tmp2 | sort | uniq -ci | sort -gr -o $di_grams;
                    #rm $dump-tmp1 $dump-tmp2;
                    
                    echo -e "\t\t\t<tr>\n\t\t\t\t<td align = \"center\">$line_iterator</td>" >> $table; 
                    echo -e "\t\t\t\t<td align = \"center\">$code_retour</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$lien_statut</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = '$line'>20171129-$file-lien-$line_iterator</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$page">20171129-$file-aspiree-$line_iterator</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$encodage</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$dump-utf8">20171129-$file-dump-$line_iterator-utf8</a></td>" >> $table;
                        
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte">20171129-$file-contexte-$line_iterator-utf8</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte_html">20171129-$file-ctxt_html-$line_iterator-utf8</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$fq</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$list_freq">20171129-$file-fq-$line_iterator</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = ".$di_grams">20171129-$file-2grams-$line_iterator</a></td>\n\t\t\t</tr>" >> $table;
                            
                        
                #condition non-utf8 && non vide => dump
                elif [[ $encodage != "utf-8" ]] && [[ $encodage != "" ]] ;then
                    
                    lynx -dump -nolist -assume_charset=%{charset} -display_charset=$encodage $line > $dump-$encodage;
#                   #condition fichier d'URLS est en chinois, utiliser enca pour convertir (enca fonctionne mieux que iconv lors de traitement de fichier chinois)
                    if [[ "$file" == "CN*" ]] ;then
   iconv -c -f $encodage -t utf-8 $dump-$encodage > $dump-utf8;
                        ##enca -L zh_CN utf-8 -x < $dump-$encodage > $dump-utf8;
                        #récupérer le contexte avec egrep, 2 lignes avant, 2 lignes après
                        egrep -i -C 2 "$motif" < $dump-utf8 >> $contexte;
                        #récupérer le contexte html avec minigrep, puis déplacer le fichier dans le répertoire CONTEXTES
   perl $minigrep "UTF-8" $dump-utf8 $motif_mini_grep;
   mv $minigrep_out $contexte_html;
   
   #compter la fréquence du motif
                        fq=`egrep -i "$motif" $dump-utf8 |wc -l`;
                        #####################################################################################
                        ##segmentation du chinois dans la prochaine version du script pour réaliser les traitements infra. 
                        #####################################################################################
                        #créer un fichier temp qui 1)n'a pas de ponctuations, 2)a un seul token par ligne, 3)est transformé en minuscule
                        #sed -r "s/[-\w\']+/ /g" $dump-utf8 |tr '\n' ' '|tr ' ' '\n'|tr -s '\n'|tr '[A-Z]' '[a-z]' > $dump-tmp1;
                        # à partir du fichier temp, établir une indice classée par fréquence décroissante
                        #sort -bdf $dump-tmp1 |uniq -ci|sort -gr -o $list_freq;
                        #récupérer le bigram de chaque texte
                        #tail -n +2 $dump-tmp1 > $dump-tmp2
                        #paste $dump-tmp1 $dump-tmp2 | sort | uniq -ci | sort -gr -o $di_grams;
                        #rm $dump-tmp1 $dump-tmp2;
                        #####################################################################################
                        
                        echo -e "\t\t\t<tr>\n\t\t\t\t<td align = \"center\">$line_iterator</td>" >> $table; 
                        echo -e "\t\t\t\t<td align = \"center\">$code_retour</td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\">$lien_statut</td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\"><a href = '$line'>20171129-$file-lien-$line_iterator</a></td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\"><a href = ".$page">20171129-$file-aspiree-$line_iterator</a></td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\">$encodage</td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\"><a href = ".$dump-$encodage">20171129-$file-dump-$line_iterator-$encodage</a></td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\"><a href = ".$dump-utf8">20171129-$file-dump-$line_iterator-utf8</a></td>" >> $table;
                                
                        echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte">20171129-$file-contexte-$line_iterator-utf8</a></td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte_html">20171129-$file-ctxt_html-$line_iterator-utf8</a></td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\">$fq</td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\"><a href = ".$list_freq">20171129-$file-fq-$line_iterator</a></td>" >> $table;
                        echo -e "\t\t\t\t<td align = \"center\"><a href = ".$di_grams">20171129-$file-2grams-$line_iterator</a></td>\n\t\t\t</tr>" >> $table;
                    
                    else
                        verification_iconv=`iconv -l | egrep -io $encodage | sort -u`;
                        
                        if [[ $verification_iconv != "" ]] ; then
                            lynx -dump -nolist -assume_charset=%{charset} -display_charset=$encodage $line > $dump-$encodage;
                            iconv -c -f $encodage -t utf-8 $dump-$encodage > $dump-utf8;
                            #récupérer le contexte avec egrep, 2 lignes avant, 2 lignes après
                            egrep -i -C 2 "$motif" < $dump-utf8 >> $contexte;
                            
                            #récupérer le contexte html avec minigrep, puis déplacer le fichier dans le répertoire CONTEXTES
       perl $minigrep "UTF-8" $dump-utf8 $motif_mini_grep;
       mv $minigrep_out $contexte_html;
    
                            #compter la fréquence du motif
                            fq=`egrep -i "$motif" $dump-utf8 |wc -l`;
                            #créer un fichier temp qui 1)n'a pas de ponctuations, 2)a un seul token par ligne, 3)est transformé en minuscule
                            sed -r "s/[-\w\']+/ /g" $dump-utf8 |tr '\n' ' '|tr ' ' '\n'|tr -s '\n'|tr '[A-Z]' '[a-z]' > $dump-tmp1;
                            # à partir du fichier temp, établir une indice classée par fréquence décroissante
                            sort -bdf $dump-tmp1 |uniq -ci|sort -gr -o $list_freq;
                            #récupérer le bigram de chaque texte
                            tail -n +2 $dump-tmp1 > $dump-tmp2
                            paste $dump-tmp1 $dump-tmp2 | sort | uniq -ci | sort -gr -o $di_grams;
                            #rm $dump-tmp1 $dump-tmp2;
                            
                            echo -e "\t\t\t<tr>\n\t\t\t\t<td align = \"center\">$line_iterator</td>" >> $table; 
                            echo -e "\t\t\t\t<td align = \"center\">$code_retour</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">$lien_statut</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\"><a href = '$line'>20171129-$file-lien-$line_iterator</a></td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\"><a href = ".$page">20171129-$file-aspiree-$line_iterator</a></td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">$encodage</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\"><a href = ".$dump-$encodage">20171129-$file-dump-$line_iterator-$encodage</a></td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\"><a href = ".$dump-utf8">20171129-$file-dump-$line_iterator-utf8</a></td>" >> $table;
                        
                            echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte">20171129-$file-contexte-$line_iterator-utf8</a></td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\"><a href = ".$contexte_html">20171129-$file-ctxt_html-$line_iterator-utf8</a></td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">$fq</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\"><a href = ".$list_freq">20171129-$file-fq-$line_iterator</a></td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\"><a href = ".$di_grams">20171129-$file-2grams-$line_iterator</a></td>\n\t\t\t</tr>" >> $table;
                        
                        else
                            echo "Echec : $encodage inconnu...";
                            echo -e "\t\t\t<tr>\n\t\t\t\t<td align = \"center\">$line_iterator</td>" >> $table; 
                            echo -e "\t\t\t\t<td align = \"center\">$code_retour</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">$lien_statut</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\"><a href = '$line'>20171129-$file-lien-$line_iterator</a></td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">$encodage</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                            echo -e "\t\t\t\t<td align = \"center\">null</td>\n\t\t\t</tr>" >> $table;
                        fi
                    fi
                    
                else 
                    echo "Echec : $encodage inconnu...";
                    echo -e "\t\t\t<tr>\n\t\t\t\t<td align = \"center\">$line_iterator</td>" >> $table; 
                    echo -e "\t\t\t\t<td align = \"center\">$code_retour</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$lien_statut</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\"><a href = '$line'>20171129-$file-lien-$line_iterator</a></td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">-</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">$encodage</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
                    echo -e "\t\t\t\t<td align = \"center\">null</td>\n\t\t\t</tr>" >> $table;
                fi                    
            fi
            
        else
            # condition état de lien autre que 200, rien à faire, seulement imprimer son numéro, son code_retour, son état et son lien.
            echo "Echec : $lien_statut";
            echo -e "\t\t\t<tr>\n\t\t\t\t<td align = \"center\">$line_iterator</td>" >> $table; 
            echo -e "\t\t\t\t<td align = \"center\">$code_retour</td>" >> $table;
            echo -e "\t\t\t\t<td align = \"center\">$lien_statut</td>" >> $table;
            echo -e "\t\t\t\t<td align = \"center\"><a href = '$line'>20171129-$file-lien-$line_iterator</a></td>" >> $table;
            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
            echo -e "\t\t\t\t<td align = \"center\">null</td>" >> $table;
            echo -e "\t\t\t\t<td align = \"center\">null</td>\n\t\t\t</tr>" >> $table;
        fi
        }
        
    echo -e "\t\t</table>\n" >> $table;
    echo -e "\t\t<br/>\n\t\t<hr width = \"90%\" color = \"#47baae\" cb 9 size = \"5\">\n\t\t<br/>" >> $table; #horizontal rule
}
##supprimer tous les fichiers temporaires
rm $rep_dump_text/*tmp1 $rep_dump_text/*tmp2;

echo -e "\t</body>\n</html>" >> $table;
echo "Fin de création des tableaux.";

III Résultat

Dans cette partie, nous propose le résultat de test. Il existe quand même des problèmes, notamment ceux qui sont liés à la "fameuse" segmentation du chinois. Nous allons les détailler dans nos prochains blogs.

3.1 la page html des tableaux

3.2 le contexte (colonne 9)

3.3 le contexte (généré par minigrep, colonne 10)

3.4 la liste des mots (index, colonne 12)

3.5 le bigramme (colonne 13)