Boîte à Outils 3

Extraction des patrons morphosyntaxiques
et relations de dépendances

#!/usr/bin/perl
#-----------------------------------------------------------
# Ligne de commande : perl BAO3-patrons.pl fichier_treetagger.xml patron(s)_separateur_tiret
# Attention au chemin ! Le fichier résultat de treetagger fichier_treetagger.xml se trouve dans le dossier BAO2
#---------------------------------------------------------
# On précise l'encodage de sortie en UTF-8
use utf8;
binmode STDOUT,":utf8";
#---------------------------------------------------------
# On prend le premier argument en tant que fichier à traiter
# Le reste des arguments (correspondant au patron) est stocké dans une liste
my $fichieratraiter=shift @ARGV;
my @PATRON=@ARGV;
#---------------------------------------------------------
my @PATRON_TT = ("ABR", "ADJ", "ADV", "DET", "DET:ART", "DET:POS", "INT", "KON", "NAM", "NOM", "NUM", 
"PRO", "PRO:DEM", "PRO:IND", "PRO:PER", "PRO:POS", "PRO:REL", "PRP", "PRP:det", "PUN", "PUN:cit", "SENT", 
"SYM", "VER", "VER:cond", "VER:futu", "VER:impe", "VER:impf", "VER:infi", "VER:pper", "VER:ppre", "VER:pres", 
"VER:simp", "VER:subi", "VER:subp");
# On s'assure que les patrons font bien partis de la liste
# Et on affiche la liste si besoin
for $pos (@PATRON) {
	if ( !grep( /^$pos$/, @PATRON_TT ) ) {
		print "Le ou les patrons n'ont pas été reconnu(s)\n";
		print "Voir la liste des POS possibles ? \nTapez 'oui', ou n'importe quelle touche pour sortir ";
		# <STDIN> permet de récupérer la réponse de l'utilisateur dans le terminal
		my $voir_liste = <STDIN>;
		# chomp permet d'enlever la ligne de réponse de l'utilisateur
		chomp $voir_liste;
		if ($voir_liste eq "oui") {
			print "@PATRON_TT\n";
			exit;
		}
		exit;	
	}
}
#---------------------------------------------------------
# On récupère la rubrique et le patron complet qui nous servira aux noms des fichiers de sortie
# Rq : la longueur du patron '$#PATRON' n'est pas égal à longueur du patron donnée par 'scalar @PATRON' 
# En réalité, $#PATRON = scalar @PATRON -1, ici $#PATRON est utilisé car notre indice pour le foreach commence à 0
my $rubrique = "";
if ($fichier=~/.*?-(\d+)\.xml/){
	$rubrique = $1;
}
$patron="";
$i=0;
foreach (@PATRON) {
	if ($i != $#PATRON){
		$patron.="$PATRON[$i]-";
	}
	else {
		$patron.="$PATRON[$i]";
	}
	$i++;
}
#print $patron;

# On ouvre le fichier à traiter et on stocke le contenu dans une liste
open my $input, "<:encoding(utf-8)", $fichieratraiter;
my @CONTENU=<$input>;
close($input);
# On lit la liste @CONTENU en la vidant : tant qu'il y a encore du contenu, on continue la lecture
# une fois que la liste sera vide, cela signifiera que tout le contenu aura été lu

while (my $ligne=shift @CONTENU){
	my $chaine="";
	my $indice=1;
	# si le premier élément/POS du patron ($PATRON[0]) a été matché
	if ($ligne=~/<element><data type="type">$PATRON[0]<\/data><data type="lemma">[^<]+?<\/data><data type="string">([^<]+?)<\/data><\/element>/) {
		# On incrémente la chaine avec la forme que l'on a trouvé et on utilise une variable pour voir la longueur du patron qu'on va pouvoir atteindre
		$chaine.=$1;
		my $longueur=1;
		# et il faut que je continue la lecture pour voir si la suite matche également avec le reste du patron
		while ($CONTENU[$indice-1]=~/<element><data type="type">$PATRON[$indice]<\/data><data type="lemma">[^<]+?<\/data><data type="string">([^<]+?)<\/data><\/element>/){
			$indice++;
			$longueur++;
			$chaine.=" ".$1;
		}
		# Si tout le patron complet a été matché, alors on garde la chaine
		if (scalar @PATRON == $longueur) {
			#print "$chaine\n";
			$dic_Patron{$chaine}++;
			$nbTerme++;
		}
	}
}

# On ouvre et écrit dans notre fichier de résultat

open my $resultat,">:encoding(UTF-8)","perl-extract_patron-$rubrique-$patron.txt";

# On écrit le nombre de chaines trouvés selon le patron demandé
print $resultat "$nbTerme éléments trouvés\n";

# On trie notre dictionnaire selon les fréquences
# Pour chaque chaine du dictionnaire, on écrire la clé suivie de son nombre d'occurrences dans le texte
foreach my $patron (sort {$dic_Patron{$b} <=> $dic_Patron{$a} } keys %dic_Patron) {
	print $resultat "$dic_Patron{$patron}\t$patron\n";
}
close($resultat);
move("perl-extract_patron-$rubrique-$patron.txt", "BAO3") or die "Erreur $!";
#---------------------------------------------------------

#!/usr/bin/python3
#-----------------------------------------------------------
# Ligne de commande : python3 BAO3-patrons.py fichier_treetagger.xml patron(s)_separateur_tiret
# Attention au chemin ! Le fichier résultat de treetagger fichier_treetagger.xml se trouve dans le dossier BAO2
###################################################################################
# Importation des bibliothèques dont on a besoin
from typing import List
import re
import sys
from pathlib import Path
import shutil, os
from os.path import exists
import time
start_time = time.time()   
....
# Comme en perl, on teste si le patron est valide
patron_TT = ["ABR", "ADJ", "ADV", "DET", "DET:ART", "DET:POS", "INT", "KON", "NAM", "NOM", "NUM", "PRO", "PRO:DEM", "PRO:IND", 
"PRO:PER", "PRO:POS", "PRO:REL", "PRP", "PRP:det", "PUN", "PUN:cit", "SENT", "SYM", "VER", "VER:cond", "VER:futu", "VER:impe", 
"VER:impf", "VER:infi", "VER:pper", "VER:ppre", "VER:pres", "VER:simp", "VER:subi", "VER:subp"];
def TestPatron(patron): 
    for tag in patron:
        if tag not in patron_TT:
            return False
    return True
#---------------------------------------------------------
# Et on récupère un patron avec des tags séparés de tirets pour le fichier de sortie
def Patron_avec_tirets(patron):
    chaine = ""
    # Si le patron est valide
    if TestPatron(patron):
        # On incrémente la chaine avec les tags du patron jusqu'au dernier
        for i in range(len(patron)-1):
            chaine += patron[i] + "-"
        # Le dernier est ajouté sans tiret    
        chaine += patron[-1]
        return chaine
    return "erreur"

# 3ème méthode on s'appuie sur la méthode du buffer de la méthode précédente
def extract3(corpus_file: str, patron: List[str]) :
#chemin du fichier corpus_file
    # Comme la 2ème méthode, on initialise notre buffer
    # Mais cette fois-ci avec deux emplacements "---" pour chaque tag du patron
    buf = [("---", "---")] * len(patron)
    # On ouvre notre corpus
    with open(corpus_file) as corpus : 
        # Pour chaque ligne du corpus
        for line in corpus :
            # On enlève le premier couple de notre liste
            buf.pop(0)
            # On crée notre match qui va capturer le tag et la forme présents dans la ligne
            match = re.match(f'<element><data type="type">([^<]+?)</data><data type="lemma">[^<]+?</data><data type="string">([^<]+?)</data></element>', line)
            # Si on a bien matché la ligne contenant le tag et la forme
            # On ajoute le couple dans le buffer et on incrémente la chaine avec la forme
            if match :
                tag = match.group(1)
                forme = match.group(2)
                buf.append((tag,forme))
            # Si on a pas pu matcher la ligne
            # Cela signifie que l'on est soit en début soit en fin de corpus, soit que l'on change de phrase
            # Dans ces cas là, il faut réinitialiser le buffer à zéro (avant d'entamer la prochaine phrase notamment)
            else :
                buf = [("---", "---")] * len(patron)
                 # break
            # On se base sur le même modèle que précédemment avec une légère variation
            chaine = ""
            ok = True
            for i, gat in enumerate(patron) :
                # Ici, si le premier élément du couple (tag, forme) est égal au tag correspondant du patron demandé
                # Attention, on veut également matcher les tags comme VER qui se trouvent sous la forme VER:cond
                # d'où le match et non le "=" strict
                if re.match(gat, buf[i][0]):
                    chaine += buf[i][1] + " "
                else:
                    ok = False
            if ok :
                global f
                f.write(chaine + "\n")    

# Fonction afin d'automatiser les patrons demandés
# On va créer une grande liste de patrons contenant des patrons (qui sont eux-mêmes des listes contenant les tags)
def DecoupPatrons(liste_patrons: List[str]):
    grande_liste=[]
    petite_liste=[]
    for e in liste_patrons:
        # On ajoute la petite liste dès qu'on trouve un séparateur et on la vide
        if e == "-":
            grande_liste.append(petite_liste)
            petite_liste=[]
            continue
        else :
           petite_liste.append(e)
    # On n'oublie pas le dernier patron qui lui n'a pas de séparateur à la fin
    # avant de return la liste de liste (grande_liste) crée 
    grande_liste.append(petite_liste)
    return grande_liste
#---------------------------------------------------------
# Programme principal                
if __name__== "__main__":
    # On stocke les arguments passés au programme comme suit :
    # Le premier argument sera notre corpus, d'où on récupère la rubrique comme pour perl
    # Tout le reste des arguments sera notre patron
    corpus_file = sys.argv[1]
    p_rubrique = re.search("-(\d+).xml", corpus_file)
    rubrique = p_rubrique.group(1)
    patrons = sys.argv[2:]
	###################################
    # Zone de test, à commenter/décommenter pour tester les différentes méthodes pour comparer le temps d'exécution
	...
	###################################
    for patron in DecoupPatrons(patrons):
        if Patron_avec_tirets(patron) != "erreur" :
            fichier = f"python-extract_patron-{rubrique}-{Patron_avec_tirets(patron)}.txt"
            # Si le fichier a déjà été créé, on le supprime afin de laisser place au nouveau
            if os.path.exists(f"./BAO3/{fichier}"):
                os.remove(f"./BAO3/{fichier}")
            with open(fichier, "w", encoding="utf-8") as f:
                extract3(corpus_file, patron)
            shutil.move(fichier, "BAO3")
        else : 
            print("Attention, il y a eu au moins une erreur dans les patrons donnés. Seuls les patrons corrects ont été réalisés.")

#!/usr/bin/perl
#----------------------------------------------------------------------------------
# Ligne de commande : perl BAO3-relations.pl fichier_udpipe.xml relation
# Attention au chemin ! Le fichier résultat de udpipe fichier_udpipe.xml se trouve dans le dossier BAO2
# En entrée : sortie UDPIPE formatée en XML + une relation syntaxique
# En sortie la liste triée des couples (gouverneur, dépendant) en relation
#----------------------------------------------------------------------------------
use strict;
use utf8;
binmode STDOUT, ':utf8';
#-------------------------------------------------------------------------------------
my $fichier="$ARGV[0]";
my $rubrique = "";
if ($fichier=~/.*?-(\d+)\.udpipe\.xml$/){
	$rubrique = $1;
}
my $relation="$ARGV[1]";
my %dicoRelation=();
# on découpe le texte par phrase (liste d'items annotés et potentiellement dépendants)
$/="</p>"; 	

open my $IN ,"<:encoding(utf8)",$fichier;
while (my $phrase=<$IN>) {
	# on traite chaque "paragraphe" (balises <p>) en le découpant par "items"
	my @LIGNES=split(/\n/,$phrase);
	for (my $i=0;$i<=$#LIGNES;$i++) {
		# si la ligne lue contient la relation, on ira chercher le dépendant puis le gouverneur
		if ($LIGNES[$i]=~/<item><a>([^<]+)<\/a><a>([^<]+)<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>([^<]+)<\/a><a>[^<]*$relation[^<]*<\/a><a>[^<]+<\/a><a>[^<]+<\/a><\/item>/i) {
			my $posDep=$1;
			my $posGouv=$3;
			my $formeDep=$2;
			# soit le gouverneur est avant le dépendant, soit après
			# on fait donc les deux cas de figure :
			# si le gouverneur est avant le dépendant, on parcourt les lignes de 0 à l'endroit où on a trouvé le dépendant (exclu)
			if ($posGouv < $posDep) {
				for (my $k=0;$k<$i;$k++) {
					# On cherche la ligne du gouverneur selon son identifiant et on capture sa forme
					if ($LIGNES[$k]=~/<item><a>$posGouv<\/a><a>([^<]+)<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><\/item>/) {
						my $formeGouv=$1;
						# On rajoute dans notre dictionnaire le couple gouverneur et dépendant trouvé
						$dicoRelation{"$formeGouv $formeDep"}++;
					}
				}
			}
			# si le gouverneur est après le dépendant alors on commence à la ligne suivante jusqu'à la dernière ligne de la phrase
			else {
				for (my $k=$i+1;$k<=$#LIGNES;$k++) {
					if ($LIGNES[$k]=~/<item><a>$posGouv<\/a><a>([^<]+)<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><\/item>/) {
						my $formeGouv=$1;
						# On rajoute dans notre dictionnaire le couple gouverneur et dépendant trouvé
						$dicoRelation{"$formeGouv $formeDep"}++;
					}
				}
			}
		}
	}
}
close ($IN);

# On ouvre et écrit dans notre fichier de résultat avant de le déplacer
open my $resultat,">:encoding(UTF-8)","perl-extract_relation-$rubrique-$relation.txt";
# On imprime la liste des couples gouverneurs et dépendants et selon leur fréquence, triée par ordre décroissant
foreach my $relation (sort {$dicoRelation{$b}<=>$dicoRelation{$a}} (keys %dicoRelation)) {
	print $resultat "$relation\t$dicoRelation{$relation}\n";
}
close($resultat);
move("perl-extract_relation-$rubrique-$relation.txt", "BAO3") or die "Erreur $!";
#---------------------------------------------------------

# Fonction de nettoyage
def clean(s: str) :
    s=re.sub("[^\w]", "", s)
    s=re.sub("’","'", s)
    s=re.sub(",","",s)
    s=re.sub("@","", s)
    s=re.sub("ᵉ","", s)
    s=re.sub("°","", s)
    return s

def Couple(f, relation):
    # On initialise les variables dont on va avoir besoin
    # Un buffer sous forme de dictionnaire pour stocker les identifiants et lemme de chaque token (réinitialisé à chaque phrase)
    sent_buf = {} 
    # Un buffer sous forme de liste pour stocker des tuples contenant le lemme du dépendant et l'identifiant de son gouverneur
    obj_buf = []
    # Trois sets pour avoir une liste sans doublons des couples, gouverneurs et dépendants
    couples = set()
    gouvernors = set()
    deps = set()
    # Pour chaque ligne
    for line in Path(f).read_text().split("\n"):
        # Lorsqu'on tombe sur un item, on cherche tous les éléments avec balises <a>
        # On en trouve normalement 8 qu'on met dans les différentes variables
        # Ceux qui ne nous sont pas utiles sont stockés dans la variable "_"
        if line.startswith("<item>"):
            fields = re.findall("<a>([^<]+)</a>", line)
            idx, word, lemma, tag, _, _, head, rel, _, _ = fields
            lemma = clean(lemma)
            # On stocke chaque lemme dans le dictionnaire sent_buf avec comme clé son identifiant
            sent_buf[idx] = lemma
            # Si la relation est obj, on ajoute le lemme et le gouverneur sous forme de tuple dans la liste obj_buf
            if rel == relation:
                obj_buf.append((lemma, head))
        # Si on arrive à la fin d'une phrase (signalé avec la balise fermante "</p>")
        if line == "</p>":
            # Pour chaque lemme et gouverneur dans la liste obj_buf
            for dep_lemma, head in obj_buf:
                # print(f'{sent_buf[head]}, "--[{relation}]-->", {dep_lemma}')
                # On ajoute le lemme du gouverneur et du dépendant en tant que couple
                # Le lemme du gouverneur ayant été trouvé grâce au numéro "head" (identifiant du gouverneur)
                # qui sert de clé pour trouver le lemme associé dans le dictionnaire sent_buf
                couples.add((f"{sent_buf[head]}", f"{dep_lemma}"))
                # On ajoute le gouverneur dans le set des gouverneurs
                # On ajoute le dépendant dans le set des dépendants
                gouvernors.add(sent_buf[head])
                deps.add(dep_lemma)
            # On vide nos buffers pour la phrase suivante
            obj_buf = []
            sent_buf = {}
    return couples

# Programme principal                
if __name__== "__main__":
    fichier = sys.argv[1]
    relation = sys.argv[2]
    print(Couple(fichier,relation))
#-------------------------------------------------------------------------