def decomposer(self, new_relation):
if new_relation.sous_relation != None:
if(new_relation.objet_g in self.decomposition.keys()):
#print("il est dans les keys")
relation_pere, pere, objet_frere = self.pere_de(new_relation.objet_g)
#print("pere "+str(pere)+"\n"+str(relation_pere))
#print("frere "+str(objet_frere)+"\n")
if pere != None:
if(objet_frere in self.decomposition.keys()):
sous1 = new_relation.sous_relation
sous2, relation_frere = self.decomposition[objet_frere]
#print (sous2.lien)
#print(sous1.lien)
newobjet = self.concatene_objets([sous1.objet_g, sous1.objet_d, sous2.objet_g, sous2.objet_d])
self.liste_objets.append(newobjet)
ind = newobjet.is_relation()
objg, objd, lien1, new1, new2 = newobjet.get_relation(ind, self.liste_objets)
if new1:
self.liste_objets.append(objg)
if new2:
self.liste_objets.append(objd)
sous_relation = Relation(objg, objd, lien1, None , "conj de coordination", None)
r = Relation(pere, newobjet, new_relation.lien, new_relation.ponctuation, "verbe",
sous_relation)
#print("ooooooooooooooooooo "+str(relation_pere)+"\n aaaaaaaaaaaaa "+ str(relation_frere) +
#"\n bbbbbbbbbbbbb "+str(new_relation))
r.origine.extend([relation_pere, relation_frere, new_relation])
return r
return None
def nouvelle_decomposition (self, new_relation):
relation_pere, pere, objet_frere = self.pere_de(new_relation.objet_g)
if pere!= None:
for relation in self.liste_relations:
if (relation.lien.label in LISTE_ETRE) and (relation.objet_g == objet_frere) and (relation.sous_relation == None):
new_obj = self.concatene_objets([relation.objet_d, new_relation.objet_d])
self.liste_objets.append(new_obj)
lien1 = Mot("ou", "CC", "O")
sous_relation = Relation(relation.objet_d, new_relation.objet_d, lien1, None , "conj de coordination", None)
r = Relation(pere, new_obj, relation.lien, relation.ponctuation, "verbe", sous_relation)
r.origine.extend([relation_pere, relation, new_relation])
return r
return None
def inverser_objet_relation(self, relation, conclusion):
ponct = Mot(".", "PUNC", "O")
origine = relation
if conclusion.label in ["ont", "a"] :
r = Relation(relation.objet_d.objet_dTo_g1(), relation.objet_g, conclusion, ponct, conclusion.label, None)
else:
r = Relation(relation.objet_d, relation.objet_g, conclusion, ponct, conclusion.label, None)
r.origine.append(origine)
self.ajout_relation_concept(r)
self.conclusions.append(r)
self.liste_relations.append(r)
return r
def complex_hypothese(self, relation):
sous_relation, r = self.decomposition[relation.objet_g]
relation_pere_d, pere_d, objet_frere_d = self.pere_de(sous_relation.objet_d)
if (pere_d != None) and not(pere_d == relation.objet_g):
lien = Mot("est probablement", "V", "O")
res = Relation(relation.objet_g, pere_d, lien, relation.ponctuation, "verbe", None)
res.origine.extend([relation_pere_d, relation])
return res
relation_pere_g, pere_g, objet_frere_g = self.pere_de(sous_relation.objet_g)
if (pere_g != None) and not(pere_g == relation.objet_g):
lien = Mot("est probablement", "V", "O")
res = Relation(relation.objet_g, pere_g, lien, relation.ponctuation, "verbe", None)
res.origine.extend([relation_pere_g, relation])
return res
return None
def getRelation_verbe(self, label, mots, roles, ners):
#lesmots represente la liste des mots sous format d'objets de la classe Mot
lesmots = []
for i in range(len(mots)):
lesmots.append(Mot(mots[i], roles[i], ners[i]))
#print("iiiiiiiiiiiiiiii",len(lesmots))
is_conc, conc = isconcept(lesmots)
objet = Objets(label, lesmots, False, conc)
try:
indice = roles.index("V")
#print("indice", indice)
objet_g, conc_g = self.ajout_objet(0, indice, objet)
#print("ajout g ok")
try:
indice_ponc = roles.index("PUNC")
except:
indice_ponc = len(roles)-1
#print("indice_ponc", indice_ponc)
objet_d, conc_d = self.ajout_objet(indice+1, indice_ponc, objet)
#print("ajout d ok")
lien = lesmots[indice]
##print("oooooooooooooooooooooooooooo", indice_ponc, "len len", len(lesmots))
ponctuation = lesmots [indice_ponc]
ind = objet_d.is_relation()
if ind != -1 :
objg, objd, lien1, new1, new2 = objet_d.get_relation(ind, self.liste_objets)
obj_g, c_g = self.ajout_obj_sousrelation(objg, new1)
obj_d, c_d = self.ajout_obj_sousrelation(objd, new2)
sous_relation = Relation(obj_g, obj_d, lien1, None , "conj de coordination", None)
else:
sous_relation = None
r = Relation(objet_g, objet_d, lien, ponctuation, "verbe", sous_relation)
if ind != -1 :
if(lien1.lemma == "ou"):
self.decomposition[objet_g] = [sous_relation, r]
if objet_g.is_conc :
self.traitement_relation_concept(objet_g, r,"relation_g", conc_g)
if objet_d.is_conc :
self.traitement_relation_concept(objet_d, r, "relation_d", conc_d)
return r
except Exception as e:
raise ValueError("il n'y a pas de verbe!!! ", str(e))
return
def chercher_ascendant(self, new_relation):
#print("dkhal lahna"+ new_relation.relationToligne())
for relation in self.liste_relations:
if relation.lien.label in LISTE_ETRE:
#print("rd", relation.objet_d, "nrd", new_relation.objet_d, "rg", relation.objet_g,"nrg", new_relation.objet_g)
if relation.objet_d == new_relation.objet_g:
r = Relation(relation.objet_g, new_relation.objet_d, relation.lien, relation.ponctuation, "verbe",
new_relation.sous_relation)
r.origine.extend([relation,new_relation])
return r
if relation.objet_g == new_relation.objet_d:
#print("dkhal lahna")
r = Relation(new_relation.objet_g, relation.objet_d, relation.lien, relation.ponctuation, "verbe",
None)
r.origine.extend([relation,new_relation])
return r
return None
def simple_hypothese(self, relation):
relation_pere, pere, objet_frere = self.pere_de(relation.objet_d)
##print("ooooooooooooooooooooooo",str(pere))
if pere != None:
lien = Mot("est probablement", "V", "O")
r = Relation(relation.objet_g, pere, lien, relation.ponctuation, "verbe", None)
r.origine.extend([relation_pere, relation])
return r
else:
return None
def sous_hypotheses(self, new_relation):
relation_pere, pere, objet_frere = self.pere_de(new_relation.objet_g)
if pere != None:
lien = Mot("est probablement", "V", "O")
if not self.contient(pere, new_relation.objet_d, lien):
r = Relation(pere, new_relation.objet_d, lien, new_relation.ponctuation, "verbe", None)
r.origine.extend([relation_pere, new_relation])
##print(str(r.relationToligne()))
self.hypotheses.append(r)
return r
else:
return None
else:
return None
def union(self, new_relation):
for relation in self.liste_relations:
if relation.lien.label in ['est']:
if(relation != new_relation):
if relation.objet_d == new_relation.objet_d:
newobj = relation.objet_g.union_objets(new_relation.objet_g)
newlien = Mot("sont", "V", "O")
r = Relation(newobj, new_relation.objet_d, newlien, relation.ponctuation, "verbe",
new_relation.sous_relation)
r.origine.extend([relation,new_relation])
return r
else:
return None
return None
def transfert_relation_concept_objet(self, objet):
conclusion_heritage = []
for relation in objet.relations_g:
conclusion_heritage.append(Relation(objet, relation.objet_d, relation.lien, relation.ponctuation, relation.label,
relation.sous_relation))
return conclusion_heritage