#!/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()