Actions effectuées sur la plateforme 17/11/2025
Pour fabriquer l’archive de l’ensemble des fichiers à extraire on utilise le script suivant :
import pymongo
import re
import os
import sys,getopt
import json
# -----------------------------------------
# Connexion a la base de données
# -----------------------------------------
myclient = pymongo.MongoClient("mongodb://localhost:27087/",username="ystroppa",password="blblabla",authSource="bddictionnairique",authMechanism='SCRAM-SHA-1')
mydb = myclient["ilfo"]
mycol = mydb["eslo2"]
liste_mots=["création","créations","heureusement","ingénieur","ingénieurs","évidemment","difficulté","difficultés","technique","techniques"]
for mot in liste_mots:
myquery = {"texte":{"$regex":mot}}
myproject = { "_id":0, "enreg":1,"locuteur":2,"debut":3,"fin":4}
mydoc = mycol.find(myquery,myproject)
liste={}
for x in mydoc:
# on append dans le fichier tar
nom_file="tar -rvf archives.tar "+" "+x["enreg"][0:-2]+"/"+x["enreg"][0:-2]+"-"+x["locuteur"]+"-"+x["debut"]+"-"+x["fin"]+".mp3"
print(nom_file)à Utiliser avec une redirection vers un fichier avec l’extension bash et à exécuter sur la machine cible pour construire l’archive tar que l’on, pourra ensuite déployer sur le serveur cible.
Réalisation de la scission des enregistrements en segments/groupe de souffle on utilise le script suivant qui consulte la collection eslo2 pour extraire tous les groupes de souffles recensés pour un enregistrements et produit la commande à l’aide de ffmpeg pour lors d’une exécution produire le fichier unitaire associé à ce groupe de souffle.
Ce script permet
# -------------------------------------------------------------------------------------------------
# Fichier de traitement des fichiers sonores pour les découper en plusieurs fragments de fichiers
# par groupe de souffle
# Y. Stroppa SPGoO -- pour passy
# -------------------------------------------------------------------------------------------------
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Script d'extraction des donnees dans le cadre de la plateforme Passy
fichiers trs issus de transcriber
@author: ystroppa spgoo/CNRS
"""
import sys,getopt
import json
import pymongo
import re
# -----------------------------------------
# Connexion a la base de donnees
# -----------------------------------------
myclient = pymongo.MongoClient("mongodb://192.168.1.38:27087/",username="ystroppa",password="blablabla",authSource="bddictionnairique",authMechanism='SCRAM-SHA-1')
mydb = myclient["ilfo"]
mycol = mydb["eslo2"]
def genere_file_script(enregistrement):
# il faut recuperer enreg, locuteur, debut et fin
# nom_file=enreg+"_"+locuteur+"_"+"debut"+"_"+fin+".mp3"
critere=enregistrement+"_C"
myquery = {"enreg":critere}
myproject = { "_id":0, "enreg":1,"locuteur":2,"debut":3,"fin":4}
Noutput="script_"+enregistrement+".bash"
output = open(Noutput,"w")
output.write("#!/bin/bash \n")
mydoc = mycol.find(myquery,myproject)
for x in mydoc:
enreg=x["enreg"][0:-2]
enregfile=x["enreg"][0:-2]+".mp3"
locuteur=x["locuteur"]
debut=x["debut"]
fin=x["fin"]
nom_file=enreg+"-"+locuteur+"-"+debut+"-"+fin+".mp3"
commande="ffmpeg -i "+enregfile+" -vn -ss "+debut+" -to "+fin +" "+nom_file;
output.write(commande+"\n")
output.close()
# lecture du fichier contenant les noms des fichiers à traiter
file = open("liste_fic.txt", encoding='utf-8')
data=file.read()
file.close()
DATA=data.splitlines()
for x in DATA:
print(x)
genere_file_script(x)
Importation des locuteurs d’ESLO dans la plateforme
Constitution d’un fichier csv de l(‘ensemble de la table locuteurs de la base de données
Et importation de ce fichier dans une collection de Mongodb via le script import_locuteur_mongo.py
import json, pymongo
import re
import csv
myclient = pymongo.MongoClient("mongodb://localhost:27087/", username='ystroppa',password='blablabla',authSource='ilfo', authMechanism='SCRAM-SHA-256')
mydb = myclient["ilfo"]
mycol = mydb["locuteurs"]
# lecture du fichier csv et chargement des structures pour les sauvegarder dans la base
# reference;sexe;etude;nomsituation;profession;anneenaissance;lieunaissance;tranche
with open('resultats_locuteurs.csv',encoding='utf-8') as csvfile:
spamreader = csv.reader(csvfile, delimiter=';')
for row in spamreader:
locuteur={}
locuteur["ref"]=row[0]
locuteur["sexe"]=row[1]
locuteur["etude"]=row[2]
locuteur["nomsituation"]=row[3]
locuteur["profession"]=row[4]
locuteur["anneenaissance"]=row[5]
locuteur["lieunaissance"]=row[6]
locuteur["tranche"]=row[7]
print(locuteur)
# il faut insérer l'enregistrement dans la collection
mycol.insert_one(locuteur)
Création de la base de données à partir des fichiers trs
Script de constitution de la base de données MongoDB à partir des fichiers de transcription. traitement.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Script d'extraction des donnees dans le cadre de la plateforme Passy
fichiers trs issus de transcriber
@author: ystroppa spgoo/CNRS
https://maelfabien.github.io/machinelearning/NLPfr/#a
https://github.com/ClaudeCoulombe/FrenchLefffLemmatizer
pip install git+https://github.com/ClaudeCoulombe/FrenchLeffLemmatizer.git
Installation de pip3 install space nklp nltk
python -m space download fr_core_news_sm
Attention a la partie getChildren de xml.etree.ElementTree n'existe plus dans cette version
il faut directement utiliser l'instruction list(root) qui retourne les enfants
"""
import numpy as np
import sys,getopt
import spacy
nlp = spacy.load("fr_core_news_sm")
# pour le lemmatiseur
from french_lefff_lemmatizer.french_lefff_lemmatizer import FrenchLefffLemmatizer
from nltk.stem.snowball import SnowballStemmer
stemmer = SnowballStemmer(language='french')
# -----------------------------------------------------------
# importation des donnes XML des dico pour conversion json
# et stockage dans une base de donnees mongodb
# -----------------------------------------------------------
import json
import xml.etree.ElementTree as ET
import itertools
import pymongo
import re
# Connexion a la base de donnees
# -----------------------------------------
myclient = pymongo.MongoClient("mongodb://ntms:27087/",username="ystroppa",password="blablabla",authSource="ilfo",authMechanism='SCRAM-SHA-1')
#myclient = pymongo.MongoClient("mongodb://ntms:27087/")
mydb = myclient["ilfo"]
# chargement des 190 054 entrées possibles pour 5HT7
mycol = mydb["eslo2"]
lexique_eslo2 = mydb["lexique_eslo2"]
# on le lit ligne par ligne et on interprete
lemmatizer = FrenchLefffLemmatizer()
nb_speakers_multiple=0
liste_mots={}
# fonctions de traitement de TAL pour les expressions
def return_token(sentence):
# Tokeniser la phrase
doc = nlp(sentence)
# Retourner le texte de chaque token
return [X.text for X in doc]
def return_token_sent(sentence):
# Tokeniser la phrase
doc = nlp(sentence)
# Retourner le texte de chaque phrase
return [X.text for X in doc.sents]
def return_word_embedding(sentence):
# Tokeniser la phrase
doc = nlp(sentence)
# Retourner le vecteur lié à chaque token
return [(X.vector) for X in doc]
def return_POS(sentence):
# Tokeniser la phrase
doc = nlp(sentence)
# Retourner les étiquettes de chaque token
return [(X.text, X.pos_) for X in doc]
def return_NER(sentence):
# Tokeniser la phrase
doc = nlp(sentence)
# Retourner le texte et le label pour chaque entité
return [(X.text, X.label_) for X in doc.ents]
def return_stem(sentence):
doc = nlp(sentence)
return [stemmer.stem(X.text) for X in doc]
def traite_bloc(bb,speakers,fichier):
"""
Traitement du bloc Turn pour en extraire les éléments
"""
global nb_speakers_multiple, liste_mots
#print(bb)
tree = ET.ElementTree(ET.fromstring(bb))
root=tree.getroot()
Turn=root.attrib
# on saute les multi-speakers pour le moment
# on regarde si plusieurs speakers
if "speaker" not in Turn:
print("pas de speaker dans le bloc")
return
tab_speakers=Turn["speaker"].split(" ")
D_bloc_recompose={}
if len(tab_speakers)<2 :
# exploitation des sync
#on parcourt les deux listes en même temps
txt_complet=""
textes=[]
debut=Turn["startTime"]
ref_end=Turn["endTime"]
for indice,txt in zip(list(root), root.itertext()):
if "time" in indice.attrib :
#print(debut + ":" + txt)
ref_debut= indice.attrib['time']
if debut!=ref_debut:
textes.append({"debut":debut, "fin":ref_debut,"texte":txt_complet.strip()})
debut=ref_debut
txt_complet=txt
#pour le dernier
textes.append({"debut":debut, "fin":ref_end,"texte":txt_complet.strip()})
#print(textes)
#on verifie si le texte est vide on n'enregistre pas
for texte in textes:
D_bloc_recompose={}
if texte["texte"]!="" and texte["texte"]!="YS" :
mot_propre=texte["texte"].replace("'"," ").replace("?"," ")
tab_res = re.split('\s+', mot_propre)
for mot in tab_res:
if mot in liste_mots:
liste_mots[mot]+=1
else:
liste_mots[mot]=1
D_bloc_recompose["enreg"]=fichier
D_bloc_recompose["locuteur"]=speakers[Turn["speaker"]]["name"]
D_bloc_recompose["texte"]=texte["texte"]
D_bloc_recompose["morpho"]=[{y:x} for x,y in return_POS(texte["texte"])]
D_bloc_recompose["debut"]=texte["debut"]
D_bloc_recompose["fin"]=texte["fin"]
#print(D_bloc_recompose)
mycol.insert_one(D_bloc_recompose)
else :
nb_speakers_multiple+=1
def lance(_file):
"""
Traitement des fichiers de transcription
on lit le xml comme un fichier texte que l'on parse a la volee
"""
global file_object
tab=_file.split('.')
file = open(_file, encoding = "ISO-8859-1") #utf8")
data=file.read()
file.close()
Data_lignes=data.splitlines()
speakers={}
B_tt_speakers=False
B_blocTurn=False
bloc=""
# lecture de chaque enregistrement et on recompose le bloc de données
for ligne in Data_lignes:
# chaque est une structure json
#recuperation des speakers
if "<Speakers>" in ligne:
# traitement et memorisation des speakers
B_tt_speakers=True
#print(ligne)
elif "</Speakers>" in ligne:
# fin de traitement des speakers
B_tt_speakers=False
#print("fin de traitrement speakers")
elif B_tt_speakers:
#<Speaker id="spk1" name="BD343FEM" check="no" dialect="native" accent="" scope="local"/>
# on charge les speakers dans la liste
tree = ET.ElementTree(ET.fromstring(ligne))
root=tree.getroot()
speakers[root.attrib["id"]]=root.attrib
#print(ligne)
# traitement des grupes de soufle
if not B_tt_speakers:
# reperer les attrib Turn
#<Turn startTime="0" endTime="5.505" speaker="spk1">
#<Sync time="0"/>
#et j'ai mis euh deux piles à charger pendant deux jours
#<Sync time="2.36"/>
#<Sync time="3.084"/>
#et là je les ai remises aujourd'hui
#<Sync time="4.424"/>
#et y a qu'une seule barre
#</Turn>
# on charge le bloc Turn à /Turn et on le traite
#print(ligne)
if "<Turn" in ligne:
bloc=ligne
B_blocTurn=True
elif "</Turn>" in ligne :
bloc+=ligne
traite_bloc(bloc,speakers,tab[0])
B_blocTurn=False
bloc=""
elif B_blocTurn:
#print(ligne)
if ligne.strip()=="":
ligne="YS"
bloc+=ligne
file_object = open('split_fichiers'+'.sh', 'w')
file_json = open('resultats.json', 'w')
file_anomalie = open('anomalie.txt', 'w')
def main(argv):
inputfile = ''
outputfile = ''
try:
opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="])
except getopt.GetoptError:
print('test.py -i <inputfile> -o <outputfile>')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print('test.py -i <inputfile> -o <outputfile>')
sys.exit()
elif opt in ("-i", "--ifile"):
inputfile = arg
elif opt in ("-o", "--ofile"):
outputfile = arg
# fournir le fichier liste_fichiers.txt contenant l'ensemble des ficheirs à analyser et à extraire
with open(inputfile, 'r',encoding='utf-8') as myfile:
files = myfile.read().split("\n")
# on balaye l'ensemble des noms de ficheirs un à un pour les soumettre au traitement
for file in files:
if file!="":
print(file)
lance(file)
file_object.close()
print("Nb de bloc multiple : " + str(nb_speakers_multiple))
# il faut enregistrer liste_mots dans la base
for mot in liste_mots:
if mot.strip()!="":
MOT={"mot":mot,"count":liste_mots[mot]}
lemmes=lemmatizer.lemmatize(mot,'all')
#print(lemmes)
#[('définitif', 'adj'), ('définitive', 'nc')]
MOT["lemmes"]={}
for lemme in lemmes :
MOT["lemmes"][lemme[1]]=lemme[0]
#print(MOT)
lexique_eslo2.insert_one(MOT)
if __name__ == "__main__":
main(sys.argv[1:])