ola5doc/content/.stversions/leo-martin/sources/contrainte~20171217-185441.py

#!/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 ) ):
            print( str(p) + ':' + str(m) )


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()