def ProjetEncadre2(

nom="Extraction de patrons morphosyntaxiques et relations de dépendance"

def bao3():

Extraction de données morphosyntaxiques.

Je vais réaliser une extraction de patrons morphosyntaxiques à partir des corpus annoté avec TreeTagger et UDpipe puis ensuite extraire une relation de dépendance syntaxique depuis le corpus annoté avec UDpipe.

#---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#

def python():

Patrons

#Fonction renvoyant une liste de patrons (eux aussi sous forme de liste), lorsqu'elle reçoit en entrée des patrons séparés par un "/"
def patrons_maker(liste) :
		patron=""
		
		patrons={}
		
		
		for pos in liste:
			if pos!="/":
				patron+=f'{pos} '
			else:
				patron=patron[:-1]
				patrons[patron]=[x for x in patron.split(' ')]
				patron=""
				
		patron=patron[:-1]
		
		patrons[patron]=[x for x in patron.split(' ')]
		
		return patrons

#Fonction parcourant un document et renvoyant un dictionnaire de patrons, en entrée elle prend un fichier et une liste de patrons. En sortie elle donne un dictionnaire.
def patrons_finder(fichier,liste,parser):
		patrons=patrons_maker(liste)
		#dictionnaire des longueurs de patrons, nécessaire pour faire des buffers pour les patrons en même temps
		len_patrons={p: len(patrons[p]) for p in patrons.keys()}
		dico_patrons={}
		#initialisations selon les deux parsers
		if parser=="ud":
			#Cette regex permet de séparer sur une ligne les différents niveaux d'annotation par UDpipe
			reg=re.compile("(.*?)(\t|\n)")
			pos_p=2
			forme_p=0
		elif parser == "tt":
			#Cette regex permet de séparer sur une ligne les différents niveaux d'annotation par TreeTagger
			reg=re.compile("<data.*?>(.*?)</data>")
			pos_p=0
			forme_p=2
		else:
			print('Je ne connais pas ce parser')
			return False
		
		#initialisation du dictionnaire final, qui contiendra un dictionnaire par patron
		for patron in patrons.keys():
			dico_patrons[patron]={}
			
		with open(fichier,"r",encoding="UTF-8") as f:
			l=f.readline()
			pos=[]
			forme=[]
			while l:
				matches=re.findall(reg,l)
				if matches:
					if parser=='tt':
						#le split était là pour les cas dans lesquels l'annotation pourrait être de type "DET:art"
						pos.append((matches[pos_p][0].split(":")[0]))
						forme.append(matches[forme_p])
					else:
						pos.append((matches[pos_p][0].split(":")[0]))
						forme.append(matches[forme_p][0])
				#Boucle de remplissage des dictionnaire, à chaque tour de boucle(/ligne du document), chaque buffer se produit
				for patron in patrons.keys():
					#pos est la liste des POS de tout le document qui se remplit au fur et à mesure du parcours, cette condition permet de commencer la recherche d'un patron uniquement lorsque l'on est assez avancé
					if len(pos)>=len_patrons[patron]:
						t=len_patrons[patron]
						#Création d'une liste de la taille de notre patron, regardant les t dernières pos ajoutées à la liste
						buf_pos=[pos[-n] for n in range(t,0,-1)]
						#Si ces pos sont les même que celles du patron, on ajoute les formes respectives en clé à notre dictionnaire de comptage du patron en question
						if buf_pos==patrons[patron]:
							buf_forme=" ".join([forme[-n] for n in range(t,0,-1)])
							dico_patrons[patron][buf_forme]=dico_patrons[patron].get(buf_forme,0)+1
						
				l=f.readline()
		return dico_patrons

def bao3(fichier, liste, parser):
	dic=patrons_finder(fichier,liste,parser)
	ecriture(dic, parser)
	return True

if __name__ == "__main__":
	fichier=sys.argv[1]
	parser=sys.argv[2]
	liste_patrons=sys.argv[3:]
	
	bao3(fichier, liste_patrons, parser)

python3 bao3.py analyse_BAO2.xml tt LISTE_PATRONS
python3 bao3.py analyse_BAO2.txt ud LISTE_PATRONS
LISTE_PATRONS : PATRON / PATRON / ...

***********

return script, résultat 

Dépendance

#On parcourt le document phrase par phrase, créant un buffer
sent_buf = {} 
	obj_buf = []
	#on initialise les couples comme ensemble pour ne pas les répéter
	couples = set()
	for line in Path(fic).read_text().split("\n"):
		if line.startswith("<item>"):
			#initialisation de tous les niveaux d'annotation du document
			fields = re.findall("<a>([^<]+)</a>", line)
			idx, word, lemma, tag, _, _, head, rel, _, _ = fields
			#On ajoute dans notre buffer la clé de la position d'un mot dans la phrase, on lui donne la valeur de son lemme
			sent_buf[idx] = lemma
			#On s'intéresse à la relation obj
			if rel == 'obj':
				#On ajoute à notre liste de buffer de relation un tuple comprenant le lemme de l'objet actuel et la position de son gouverneur
				obj_buf.append((lemma, head))
		if line == "</p>":
		#Une fois la phrase finie on ajoute notre couple à noter ensemble
			for obj_lemma, head in obj_buf:
				#print(sent_buf[head], "--[obj]-->", obj_lemma)
				couples.add((f"{sent_buf[head]}", f"{obj_lemma}"))
			obj_buf = []
			sent_buf = {}
	#formatage pour padagraph
	print("@V: #src, %N")
	for src, tgt in couples:
		print(f"{src},{tgt}")
python3 bao3_rel.py sortieudpipe-slurp_3208-2021.xml

***********

return script, résultat