275 lines
9.3 KiB
Python
275 lines
9.3 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# outils
|
|
import imports.arguments as ARG
|
|
import imports.fichiers as fichiers
|
|
import imports.dot as dot
|
|
|
|
# pattern
|
|
from pattern.fr import parse, split
|
|
|
|
'''
|
|
Intention :
|
|
En utilisant le langage dot, créé un graphe du texte donné en entrée. Le programme tente de lier entre elles les phrases en prenant le mot commun le plus signifiant d'une phrase à l'autre, de m'anière à créer un graphe. La contrainte est alors d'écrire un texte avec des mots communs d'une phrase à l'autre afin de permettre le lien graphique dans le graphe.
|
|
'''
|
|
|
|
# on regarde si on à l'option -f spécifiée : fichier à importer
|
|
fichier = ARG.obtenir( '-f' )
|
|
# si option présente mais rien de spécifié = False
|
|
if ( not isinstance( fichier, basestring) ):
|
|
fichier == False
|
|
print 'aide : python contrainte.py -f adresse/du/fichier.txt'
|
|
print 'choisir le nom d\'export : python contrainte.py -f fichier.txt -o fichier_export.txt'
|
|
export = ARG.obtenir( '-o' )
|
|
# on regarde si on à l'option -o spécifiée : fichier à exporter
|
|
export = ARG.obtenir( '-o' )
|
|
if ( not isinstance( export, basestring) ):
|
|
export == False
|
|
|
|
# si on a un nom de fichier associé à l'option -f
|
|
if ( fichier ):
|
|
fichier = fichiers.importer( fichier )
|
|
|
|
scores = {
|
|
"CC" : 10, #u"conjonction de coordination",
|
|
"CD" : 10, #u"nombre cardinal",
|
|
"DT" : 10, #u"déterminant",
|
|
"EX" : 7, #u"Existential there",
|
|
"FW" : 4, #u"mot étranger",
|
|
"IN" : 7, #u"préposition ou conjonction de subordination",
|
|
"JJ" : 5, #u"adjectif",
|
|
"JJR" : 5, #u"adjectif comparatif",
|
|
"JJS" : 5, #u"adjectif superlatif",
|
|
"LS" : 99, #u"marqueur d'élément de liste",
|
|
"MD" : 6, #u"modal",
|
|
"NN" : 2, #u"nm, singulier ou mass",
|
|
"NNS" : 3, #u"nom, pluriel",
|
|
"NNP" : 0, #u"nom propre, singulier",
|
|
"NNPS" : 1, #u"nom propre, pluriel",
|
|
"PDT" : 10, #u"predeterminer",
|
|
"POS" : 10, #u"possessive ending",
|
|
"PRP" : 2, #u"pronom personnel",
|
|
"PRP$" : 2, #u"pronom possessif",
|
|
"RB" : 4, #u"adverbe",
|
|
"RBR" : 4, #u"adverbe, comparatif",
|
|
"RBS" : 4, #u"adverbe, superlatif",
|
|
"RP" : 10, #u"particle",
|
|
"SYM" : -1, #u"symbole",
|
|
}
|
|
|
|
|
|
def traiter_ligne ( ligne ):
|
|
'''
|
|
pour chaque ligne :
|
|
on analyse avec pattern
|
|
on regarde les éléments communs avec la phrase d'avant, la phrase d'après
|
|
on prend celui avec le meilleur score
|
|
|
|
'''
|
|
print ligne
|
|
|
|
def traiter_phrase ( phrase_1, phrase_2=False, dernier_id_phrase_2=False ):
|
|
''''''
|
|
|
|
# modèle de la sortie
|
|
sortie = {
|
|
'sentence': phrase_1,
|
|
'correspondances': None,
|
|
}
|
|
|
|
# on gère les correspondances
|
|
if ( phrase_2 != False ):
|
|
sortie['correspondances'] = index_correspondances ( phrase_1, phrase_2, dernier_id_phrase_2 )
|
|
|
|
# on filtre les correspondances (ne garder que la plus importante)
|
|
sortie = filtrer_correspondances( sortie )
|
|
return sortie
|
|
|
|
def filtrer_correspondances ( data ):
|
|
''''''
|
|
# si on a des correspondances
|
|
if ( data['correspondances'] != None ):
|
|
precedent = False # false ou index
|
|
# pour chaque correspondance
|
|
for i in range( len( data['correspondances']) ):
|
|
# si on a une correspondance et qu'on en a déjà eu une
|
|
if ( data['correspondances'][i] != False and precedent != False ):
|
|
# on compare :
|
|
resultat = comparer_score ( data['sentence'], i, precedent )
|
|
# si meilleur score :
|
|
if ( resultat ):
|
|
# on supprime la précédente référence
|
|
data['correspondances'][precedent] = False
|
|
else:
|
|
# sinon on supprime cette référence
|
|
data['correspondances'][i] = False
|
|
elif ( precedent == False ):
|
|
precedent = i
|
|
return data
|
|
|
|
def obtenir_score ( type ):
|
|
''''''
|
|
try:
|
|
scores[ type ]
|
|
except Exception as erreur:
|
|
print erreur
|
|
return False
|
|
|
|
def comparer_score ( sentence, i, i_precedent=False):
|
|
''''''
|
|
try:
|
|
score = scores[ sentence.words[ i ].type ]
|
|
if ( i_precedent != False ):
|
|
score_precedent = scores[ sentence.words[ i_precedent ].type ]
|
|
# si on a un meilleur score (plus faible)
|
|
if ( score < score_precedent ):
|
|
# on retourne vrai
|
|
return True
|
|
else:
|
|
return False
|
|
except Exception as erreur:
|
|
print 'type sans score : ' + str( erreur )
|
|
return False
|
|
|
|
def phrase_vers_liste( phrase ):
|
|
''''''
|
|
liste = []
|
|
for mot in phrase:
|
|
liste.append( mot.string )
|
|
return liste
|
|
|
|
def index_correspondances ( liste_1, liste_2, dernier_id_phrase_2=0 ):
|
|
'''renvoie un tableau avec pour chaque mot, soit False si pas de correspondance, soit l'index dans la phrase + celle dans le texte'''
|
|
sortie = len(liste_1) * [False]
|
|
|
|
if ( not dernier_id_phrase_2 ):
|
|
dernier_id_phrase_2 = 0
|
|
|
|
for a in range( len(liste_1) ):
|
|
for b in range( len(liste_2) ):
|
|
if ( liste_1[a].string == liste_2[b].string ):
|
|
#print( str(liste_1[a]) + ' = ' + str(liste_2[b]) )
|
|
sortie[a] = [b, b + dernier_id_phrase_2]
|
|
#else:
|
|
#print( str(liste_1[a]) + ' != ' + str(liste_2[b]))
|
|
return sortie
|
|
|
|
def traiter_fichier ( fichier=False ):
|
|
'''traite le fichier. Retourne une liste contenant des dictionnaires contenant :
|
|
- sentence : la phrase au format pattern sentence
|
|
- correspondance : un index indiquant les correspondances avec la phrase précédente'''
|
|
|
|
# liste des phrases avant traitement
|
|
phrases_a_traiter = []
|
|
# la liste à retourner
|
|
phrases_traitees = []
|
|
|
|
# si on a bien un fichier
|
|
if ( fichier != False ):
|
|
|
|
# on lit les lignes
|
|
lignes = fichier.readlines()
|
|
|
|
# on ferme le fichier
|
|
fichier.close()
|
|
|
|
compteur_mots = 0;
|
|
|
|
# pour chaque ligne
|
|
for ligne in lignes:
|
|
|
|
# on parse
|
|
texte_traite = parse( ligne )
|
|
|
|
# on sépare les phrases
|
|
phrases_dans_la_ligne = split( texte_traite )
|
|
|
|
# on ajoute les phrases de la ligne à la liste générale
|
|
for phrase in phrases_dans_la_ligne:
|
|
phrases_a_traiter.append ( phrase )
|
|
|
|
# pour chaque phrase, on traite
|
|
for i in range( len( phrases_a_traiter ) ):
|
|
phrase_precedente = False
|
|
if ( i > 0 ):
|
|
phrase_precedente = phrases_a_traiter[ i - 1 ]
|
|
phrases_traitees.append( traiter_phrase( phrases_a_traiter[i], phrase_precedente, compteur_mots ) )
|
|
compteur_mots += len( phrases_a_traiter[i] )
|
|
# for i in range( len( phrases_dans_la_ligne) ) :
|
|
# compteur_phrases++
|
|
# phrase_precedente = False
|
|
# print('---')
|
|
# print( 'i :' + str(i))
|
|
# if ( compteur_phrases > 0 ):
|
|
# phrase_precedente = phrases_dans_la_ligne[ i - 1 ]
|
|
# phrases.append( traiter_phrase( phrases_dans_la_ligne[i], phrase_precedente ) )
|
|
#print ('len' + str(len(phrases)))
|
|
#for i in range( len( phrases) ):
|
|
#print i
|
|
#liste[i] = phrase_vers_liste( phrases[i] )
|
|
#print str(phrases[i].__dict__.keys())
|
|
#for mot in phrases[i].words:
|
|
# print mot.string
|
|
# print str(mot) + str( mot.__dict__.keys() )
|
|
#print( '---' )
|
|
#print(liste)
|
|
#print( index_correspondances( liste[0], liste[1] ))
|
|
#for lexeme in split( texte_traite )
|
|
# on ajoute à la liste à retourner
|
|
#liste_phrases.insert( len(liste_phrases), phrases )
|
|
|
|
# on retourne la liste
|
|
#return liste_phrases
|
|
# print phrases
|
|
# mots_des_phrases = len( phrases ) * [None]
|
|
# for i in range( len( phrases ) ):
|
|
# mots_des_phrases[i] = phrase_vers_liste( phrases[i] )
|
|
# print( index_correspondances( mots_des_phrases[0], mots_des_phrases[i] ) )
|
|
# return sortie
|
|
return phrases_traitees
|
|
|
|
def generer_graphe ( data ):
|
|
'''génère le graphe à partir des données'''
|
|
compteur_mots = 0 # pour les id des noeuds
|
|
for p in range( len( data ) ):
|
|
for m in range( len( data[p]['sentence'].words ) ):
|
|
compteur_mots += 1
|
|
id = compteur_mots
|
|
a = data[p]['correspondances'][m]
|
|
print a
|
|
#if ( data[p]['correspondances'][m] != False ) :
|
|
# id = data[p]['correspondances'][m][1]
|
|
#print id
|
|
# print( str(p) + ':' + str(m) + ' : ' + str( compteur_mots ) + ' mots.' )
|
|
|
|
|
|
def main ():
|
|
''''''
|
|
|
|
elements = traiter_fichier( fichier )
|
|
print elements
|
|
generer_graphe( elements )
|
|
# for e in elements:
|
|
# print('---')
|
|
# for i in e:
|
|
# print('>')
|
|
# print(i)
|
|
# construction = {
|
|
# 'ligne precedente': False,
|
|
# 'lignes a traiter': False,
|
|
# 'lignes traitees': False,
|
|
# }
|
|
#
|
|
# if ( fichier != False ):
|
|
# construction['lignes a traiter'] = fichier.readlines()
|
|
# fichier.close()
|
|
# # fichiers.exporter( lignes )
|
|
# for i in range(len( construction['lignes a traiter'] )):
|
|
# #traiter_ligne( ligne )
|
|
# print i
|
|
# construction['lignes a traiter'][i] = '_'
|
|
# print construction['lignes a traiter']
|
|
|
|
main()
|