commited all contents created by participants
This commit is contained in:
Bachir Soussi Chiadmi
Binary file not shown.
|
After Width: | Height: | Size: 203 KiB |
@@ -0,0 +1,3 @@
|
||||
h1. undefined
|
||||
|
||||
h2. Léo Martin
|
||||
@@ -0,0 +1,9 @@
|
||||
h1. undefined
|
||||
|
||||
h2. Léo Martin
|
||||
|
||||
h3. pattern
|
||||
|
||||
J'ai produit un graphe de ce que propose pattern après analyse d'un texte.
|
||||
|
||||
!images/graphe_pattern.png!
|
||||
@@ -0,0 +1,13 @@
|
||||
h1. undefined
|
||||
|
||||
h2. Léo Martin
|
||||
|
||||
h3. pattern
|
||||
|
||||
J'ai produit un graphe de ce que propose pattern après analyse d'un texte.
|
||||
|
||||
!images/graphe_pattern.png!
|
||||
|
||||
Et je commence à utiliser le langage dot pour visualiser du texte. Cela pourrait être intéressant de voir comment représenter graphiquement des textes avec cet outil en utilisant l'analyse avec pattern pour isoler les sujets. (Ou possible isolation des sujets pendant l'écriture, l'outil ne visera pas nécéssairement à s'appliquer à n'importe quel texte).
|
||||
|
||||
!images/phrase-vers-dot.png!
|
||||
@@ -0,0 +1,3 @@
|
||||
ghjk
|
||||
lkjhghjhg
|
||||
lkjhgfd
|
||||
@@ -0,0 +1,5 @@
|
||||
digraph G {
|
||||
"fou" -> "barre"
|
||||
"fou" -> "barre"
|
||||
"fou" -> "barre"
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
digraph G {
|
||||
graph [ rankdir=LR ];
|
||||
0 [label="Suivez"];
|
||||
type__0__VB [label="VB"];
|
||||
0 -> type__0__VB
|
||||
1 [label="les"];
|
||||
type__1__DT [label="déterminant"];
|
||||
1 -> type__1__DT
|
||||
0 -> 1
|
||||
2 [label="flèches"];
|
||||
type__2__NNS [label="nom, pluriel"];
|
||||
2 -> type__2__NNS
|
||||
1 -> 2
|
||||
3 [label=","];
|
||||
type__3__virgule [label=","];
|
||||
3 -> type__3__virgule
|
||||
2 -> 3
|
||||
4 [label="attention"];
|
||||
type__4__NN [label="nm, singulier ou mass"];
|
||||
4 -> type__4__NN
|
||||
3 -> 4
|
||||
5 [label="aux"];
|
||||
type__5__IN [label="préposition ou conjonction de subordination"];
|
||||
5 -> type__5__IN
|
||||
4 -> 5
|
||||
6 [label="trous"];
|
||||
type__6__NNS [label="nom, pluriel"];
|
||||
6 -> type__6__NNS
|
||||
5 -> 6
|
||||
7 [label="."];
|
||||
type__7__point [label="."];
|
||||
7 -> type__7__point
|
||||
6 -> 7
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
digraph G {
|
||||
graph [ rankdir=LR ];
|
||||
0 [label="Suivez"];
|
||||
type__0__VB [label="VB"];
|
||||
0 -> type__0__VB
|
||||
1 [label="les"];
|
||||
type__1__DT [label="DT"];
|
||||
1 -> type__1__DT
|
||||
0 -> 1
|
||||
2 [label="flèches"];
|
||||
type__2__NNS [label="NNS"];
|
||||
2 -> type__2__NNS
|
||||
1 -> 2
|
||||
3 [label=","];
|
||||
type__3__virgule [label=","];
|
||||
3 -> type__3__virgule
|
||||
2 -> 3
|
||||
4 [label="attention"];
|
||||
type__4__NN [label="NN"];
|
||||
4 -> type__4__NN
|
||||
3 -> 4
|
||||
5 [label="aux"];
|
||||
type__5__IN [label="IN"];
|
||||
5 -> type__5__IN
|
||||
4 -> 5
|
||||
6 [label="trous"];
|
||||
type__6__NNS [label="NNS"];
|
||||
6 -> type__6__NNS
|
||||
5 -> 6
|
||||
7 [label="."];
|
||||
type__7__point [label="."];
|
||||
7 -> type__7__point
|
||||
6 -> 7
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
import imports.arguments as ARG
|
||||
import imports.fichiers as fichiers
|
||||
|
||||
fichier = ARG.obtenir( '-f' )
|
||||
|
||||
|
||||
if ( fichier ):
|
||||
fichiers.exporter( 'toto.txt', 'kikoo' )
|
||||
@@ -0,0 +1,20 @@
|
||||
import imports.arguments as ARG
|
||||
import imports.fichiers as fichiers
|
||||
|
||||
fichier = ARG.obtenir( '-f' )
|
||||
|
||||
|
||||
if ( fichier ):
|
||||
fichiers.exporter( 'toto.txt', 'kikoo' )
|
||||
|
||||
|
||||
def main ():
|
||||
kopi = []
|
||||
salut( kopi )
|
||||
print kopi
|
||||
|
||||
|
||||
def salut ( a ):
|
||||
a.append( 'mdr' )
|
||||
|
||||
main()
|
||||
@@ -0,0 +1,20 @@
|
||||
import imports.arguments as ARG
|
||||
import imports.fichiers as fichiers
|
||||
|
||||
fichier = ARG.obtenir( '-f' )
|
||||
|
||||
|
||||
if ( fichier ):
|
||||
fichiers.exporter( 'toto.txt', 'kikoo' )
|
||||
|
||||
|
||||
def main ():
|
||||
kopi = ['a','b','c']
|
||||
salut( kopi )
|
||||
print kopi
|
||||
|
||||
|
||||
def salut ( a ):
|
||||
a = ['d']
|
||||
|
||||
main()
|
||||
@@ -0,0 +1,22 @@
|
||||
import imports.arguments as ARG
|
||||
import imports.fichiers as fichiers
|
||||
|
||||
fichier = ARG.obtenir( '-f' )
|
||||
|
||||
|
||||
if ( fichier ):
|
||||
fichiers.exporter( 'toto.txt', 'kikoo' )
|
||||
|
||||
|
||||
def main ():
|
||||
kopi = {
|
||||
data : ['a','b','c'],
|
||||
}
|
||||
salut( kopi )
|
||||
print kopi
|
||||
|
||||
|
||||
def salut ( a ):
|
||||
a.
|
||||
|
||||
main()
|
||||
@@ -0,0 +1,23 @@
|
||||
import imports.arguments as ARG
|
||||
import imports.fichiers as fichiers
|
||||
|
||||
fichier = ARG.obtenir( '-f' )
|
||||
|
||||
|
||||
if ( fichier ):
|
||||
fichiers.exporter( 'toto.txt', 'kikoo' )
|
||||
|
||||
|
||||
def main ():
|
||||
kopi = {
|
||||
data : ['a','b','c'],
|
||||
}
|
||||
salut( kopi )
|
||||
print kopi
|
||||
|
||||
|
||||
def salut ( a ):
|
||||
print a
|
||||
a.data = [ 'c', 'd', 'e' ]
|
||||
|
||||
main()
|
||||
@@ -0,0 +1,3 @@
|
||||
ghjk
|
||||
lkjhghjhg
|
||||
lkjhgfd
|
||||
@@ -0,0 +1,3 @@
|
||||
Je suis allé à la plage avec toto le chien.
|
||||
Toto a mordu des enfants.
|
||||
on a bien rigolé.
|
||||
@@ -0,0 +1,3 @@
|
||||
Je suis allé à la plage avec toto le chien.
|
||||
Toto a mordu des enfants.
|
||||
On a bien rigolé.
|
||||
@@ -0,0 +1,3 @@
|
||||
Je suis allé à la plage avec toto le chien.
|
||||
Toto a mordu des enfants.
|
||||
On a bien rigolé, les enfants moins.
|
||||
@@ -0,0 +1,4 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
print u"Je serais d'une joie indéfinissable lorsque python acceptera mes caractères accentués sans hurler à la mort comme si on le taquinait au fer chauffé à blanc. â"
|
||||
@@ -0,0 +1,259 @@
|
||||
#!/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 main ():
|
||||
''''''
|
||||
|
||||
elements = traiter_fichier( fichier )
|
||||
print 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()
|
||||
@@ -0,0 +1,262 @@
|
||||
#!/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 ):
|
||||
''''''
|
||||
|
||||
|
||||
def main ():
|
||||
''''''
|
||||
|
||||
elements = traiter_fichier( fichier )
|
||||
print 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()
|
||||
@@ -0,0 +1,263 @@
|
||||
#!/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
|
||||
|
||||
|
||||
def main ():
|
||||
''''''
|
||||
|
||||
elements = traiter_fichier( fichier )
|
||||
print 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()
|
||||
@@ -0,0 +1,267 @@
|
||||
#!/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] ) ):
|
||||
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()
|
||||
@@ -0,0 +1,267 @@
|
||||
#!/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()
|
||||
@@ -0,0 +1,49 @@
|
||||
digraph G {
|
||||
graph [ rankdir=LR ];
|
||||
Phrase [ label="Phrase", shape = polygon, sides = 4, color="blue", fillcolor=red ];
|
||||
phrase__pnp [label="pnp"];
|
||||
Word [ label="Word", shape = polygon, sides = 4, color="blue" ];
|
||||
word__pnp [label="pnp"];
|
||||
word__chunk [label="chunk"];
|
||||
Chunk [ label="Chunk", shape = polygon, sides = 4, color="blue" ];
|
||||
chunk__pnp [label="pnp"];
|
||||
chunk__relations [label="relations"];
|
||||
chunk__sentence [label="sentence"];
|
||||
chunk__words [label="words"];
|
||||
chunk__type [label="type"];
|
||||
"texte" -> Phrase
|
||||
Phrase -> "parent"
|
||||
Phrase -> "language"
|
||||
Phrase -> "_anchors"
|
||||
Phrase -> "text"
|
||||
Phrase -> "_relation"
|
||||
Phrase -> "relations"
|
||||
Phrase -> "token"
|
||||
Phrase -> "words"
|
||||
Phrase -> phrase__pnp
|
||||
Phrase -> "chunks"
|
||||
Phrase -> "attachment"
|
||||
Phrase -> "id"
|
||||
Phrase -> "_previous"
|
||||
"words" -> Word
|
||||
"chunks" -> Chunk
|
||||
Chunk -> "_modifiers"
|
||||
Chunk -> "attachments"
|
||||
Chunk -> chunk__sentence
|
||||
Chunk -> chunk__pnp
|
||||
Chunk -> chunk__relations
|
||||
Chunk -> "_conjunctions"
|
||||
Chunk -> chunk__words
|
||||
Chunk -> chunk__type
|
||||
Chunk -> "anchor"
|
||||
chunk__words -> Word
|
||||
Word -> "index"
|
||||
Word -> "string"
|
||||
Word -> "_custom_tags"
|
||||
Word -> "sentence"
|
||||
Word -> word__pnp
|
||||
Word -> word__chunk
|
||||
Word -> "lemma"
|
||||
Word -> "type"
|
||||
word__chunk -> Chunk
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 196 KiB |
@@ -0,0 +1,49 @@
|
||||
digraph G {
|
||||
graph [ rankdir=LR ];
|
||||
Phrase [ label="Phrase", shape = polygon, sides = 4, color="blue", style=filled, fillcolor=red ];
|
||||
phrase__pnp [label="pnp"];
|
||||
Word [ label="Word", shape = polygon, sides = 4, color="blue" ];
|
||||
word__pnp [label="pnp"];
|
||||
word__chunk [label="chunk"];
|
||||
Chunk [ label="Chunk", shape = polygon, sides = 4, color="blue" ];
|
||||
chunk__pnp [label="pnp"];
|
||||
chunk__relations [label="relations"];
|
||||
chunk__sentence [label="sentence"];
|
||||
chunk__words [label="words"];
|
||||
chunk__type [label="type"];
|
||||
"texte" -> Phrase
|
||||
Phrase -> "parent"
|
||||
Phrase -> "language"
|
||||
Phrase -> "_anchors"
|
||||
Phrase -> "text"
|
||||
Phrase -> "_relation"
|
||||
Phrase -> "relations"
|
||||
Phrase -> "token"
|
||||
Phrase -> "words"
|
||||
Phrase -> phrase__pnp
|
||||
Phrase -> "chunks"
|
||||
Phrase -> "attachment"
|
||||
Phrase -> "id"
|
||||
Phrase -> "_previous"
|
||||
"words" -> Word
|
||||
"chunks" -> Chunk
|
||||
Chunk -> "_modifiers"
|
||||
Chunk -> "attachments"
|
||||
Chunk -> chunk__sentence
|
||||
Chunk -> chunk__pnp
|
||||
Chunk -> chunk__relations
|
||||
Chunk -> "_conjunctions"
|
||||
Chunk -> chunk__words
|
||||
Chunk -> chunk__type
|
||||
Chunk -> "anchor"
|
||||
chunk__words -> Word
|
||||
Word -> "index"
|
||||
Word -> "string"
|
||||
Word -> "_custom_tags"
|
||||
Word -> "sentence"
|
||||
Word -> word__pnp
|
||||
Word -> word__chunk
|
||||
Word -> "lemma"
|
||||
Word -> "type"
|
||||
word__chunk -> Chunk
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 196 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 195 KiB |
Binary file not shown.
@@ -0,0 +1,8 @@
|
||||
import sys
|
||||
|
||||
def obtenir ( option ) :
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
if len( sys.argv ) > index :
|
||||
return sys.argv[ index ]
|
||||
return False
|
||||
Binary file not shown.
@@ -0,0 +1,8 @@
|
||||
import sys
|
||||
|
||||
def obtenir ( option, fallback=False ) :
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
if len( sys.argv ) > index :
|
||||
return sys.argv[ index ]
|
||||
return fallback
|
||||
Binary file not shown.
@@ -0,0 +1,12 @@
|
||||
import sys
|
||||
|
||||
def obtenir ( option, fallback=False ) :
|
||||
'''String -> String/Boolean
|
||||
Si l'option demandée n'existe pas, renvoie False.
|
||||
Si l'option demandée existe'''
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
if len( sys.argv ) > index :
|
||||
print type( sys.argv[ index - 1 ])
|
||||
return sys.argv[ index ]
|
||||
return fallback
|
||||
@@ -0,0 +1,17 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
|
||||
def obtenir ( option, fallback=False ) :
|
||||
'''String -> String/Boolean
|
||||
Si l'option demandée n'existe pas, renvoie False.
|
||||
Si l'option demandée existe'''
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
if len( sys.argv ) > index :
|
||||
print type( sys.argv[ index - 1 ])
|
||||
print type( sys.argv[ index ])
|
||||
print sys.argv[ index ]
|
||||
return sys.argv[ index ]
|
||||
return fallback
|
||||
Binary file not shown.
@@ -0,0 +1,17 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
|
||||
def obtenir ( option, fallback=False ) :
|
||||
'''String -> String/Boolean
|
||||
Si l'option demandée n'existe pas, renvoie False.
|
||||
Si l'option demandée existe'''
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
if len( sys.argv ) > index :
|
||||
print type( sys.argv[ index - 1 ])
|
||||
print type( sys.argv[ index ])
|
||||
print sys.argv[ index ][0]
|
||||
return sys.argv[ index ]
|
||||
return fallback
|
||||
Binary file not shown.
@@ -0,0 +1,21 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
|
||||
def obtenir ( option, fallback=False ) :
|
||||
'''String -> String/Boolean
|
||||
Si l'option demandée n'existe pas, renvoie False.
|
||||
Si l'option demandée existe'''
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
# si on a quelque chose après notre option
|
||||
if len( sys.argv ) > index :
|
||||
# si ce quelque chose ne commence pas par -
|
||||
if sys.argv[ index ][0] != '-':
|
||||
return sys.argv[ index ]
|
||||
# si c'est le cas on a à priori une option booléenne, on renvoie true
|
||||
else:
|
||||
return True
|
||||
# dans les autres cas on renvoie False ou le fallback si défini
|
||||
return fallback
|
||||
Binary file not shown.
@@ -0,0 +1,26 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
|
||||
def obtenir ( option, fallback=False ) :
|
||||
'''String -> String/Boolean
|
||||
Si l'option demandée n'existe pas, renvoie False.
|
||||
Si l'option demandée existe'''
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
# si on a quelque chose après notre option
|
||||
if len( sys.argv ) > index :
|
||||
# si ce quelque chose ne commence pas par -
|
||||
if sys.argv[ index ][0] != '-':
|
||||
return sys.argv[ index ]
|
||||
# si c'est le cas on a à priori une option booléenne
|
||||
else:
|
||||
# si pas de fallback
|
||||
if !(fallback):
|
||||
return True
|
||||
# sinon on retourne le fallback
|
||||
else:
|
||||
return fallback
|
||||
# dans les autres cas on renvoie False ou le fallback si défini
|
||||
return fallback
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
|
||||
def obtenir ( option, fallback=False ) :
|
||||
'''String -> String/Boolean
|
||||
Si l'option demandée n'existe pas, renvoie False.
|
||||
Si l'option demandée existe'''
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
# si on a quelque chose après notre option
|
||||
if len( sys.argv ) > index :
|
||||
# si ce quelque chose ne commence pas par -
|
||||
if sys.argv[ index ][0] != '-':
|
||||
return sys.argv[ index ]
|
||||
# si c'est le cas on a à priori une option booléenne
|
||||
else:
|
||||
# si pas de fallback
|
||||
if not fallback:
|
||||
return True
|
||||
# sinon on retourne le fallback
|
||||
else:
|
||||
return fallback
|
||||
# dans les autres cas on renvoie False ou le fallback si défini
|
||||
return fallback
|
||||
Binary file not shown.
@@ -0,0 +1,29 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
|
||||
def obtenir ( option, fallback=False ) :
|
||||
'''String -> String/Boolean
|
||||
Si l'option demandée n'existe pas, renvoie False.
|
||||
Si l'option demandée existe'''
|
||||
# si on a l'option
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
# si on a quelque chose après notre option
|
||||
if len( sys.argv ) > index :
|
||||
# si ce quelque chose ne commence pas par -
|
||||
if sys.argv[ index ][0] != '-':
|
||||
return sys.argv[ index ]
|
||||
# si c'est le cas on a à priori une option booléenne
|
||||
else:
|
||||
# si pas de fallback
|
||||
if not fallback:
|
||||
return True
|
||||
# sinon on retourne le fallback
|
||||
else:
|
||||
return fallback
|
||||
else:
|
||||
return True
|
||||
# dans les autres cas on renvoie False ou le fallback si défini
|
||||
return fallback
|
||||
@@ -0,0 +1,31 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
|
||||
def obtenir ( option, fallback=False ) :
|
||||
'''String -> String/Boolean
|
||||
Si l'option demandée n'existe pas, renvoie False.
|
||||
Si l'option demandée existe'''
|
||||
# si on a l'option
|
||||
if option in sys.argv:
|
||||
index = sys.argv.index( option ) + 1
|
||||
# si on a quelque chose après notre option
|
||||
if len( sys.argv ) > index :
|
||||
# si ce quelque chose ne commence pas par -
|
||||
if sys.argv[ index ][0] != '-':
|
||||
return sys.argv[ index ]
|
||||
# si c'est le cas on a à priori une option booléenne
|
||||
else:
|
||||
# si pas de fallback
|
||||
if not fallback:
|
||||
return True
|
||||
# sinon on retourne le fallback
|
||||
else:
|
||||
return fallback
|
||||
# si on a l'option mais rien derrière
|
||||
else:
|
||||
# on renvoie True
|
||||
return True
|
||||
# dans les autres cas on renvoie False ou le fallback si défini
|
||||
return fallback
|
||||
Binary file not shown.
@@ -0,0 +1,2 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
Binary file not shown.
@@ -0,0 +1,30 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
Ce module facilite l'import/export de fichiers
|
||||
'''
|
||||
|
||||
|
||||
def importer ( chemin ) :
|
||||
'''String -> File
|
||||
tente d'importer le fichier dont le chemin est spécifié'''
|
||||
try:
|
||||
fichier = open( chemin, 'r' )
|
||||
lignes = fichier.readlines()
|
||||
fichier.close()
|
||||
return lignes
|
||||
except Exception as erreur:
|
||||
print erreur
|
||||
return False
|
||||
|
||||
def exporter ( contenu, chemin=False ):
|
||||
''''''
|
||||
if ( chemin == False ):
|
||||
chemin = generer_nom_de_fichier()
|
||||
fichier = open( chemin, 'w' )
|
||||
fichier.write( contenu )
|
||||
fichier.close()
|
||||
|
||||
def generer_nom_de_fichier ():
|
||||
return datetime.datetime.now().strftime("%Y-%m-%d-%Hh%Mm%Ss.txt")
|
||||
@@ -0,0 +1,29 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
Ce module facilite l'import/export de fichiers
|
||||
'''
|
||||
|
||||
|
||||
def importer ( chemin ) :
|
||||
'''String -> File
|
||||
tente d'importer le fichier dont le chemin est spécifié'''
|
||||
try:
|
||||
fichier = open( chemin, 'r' )
|
||||
fichier.close()
|
||||
return fichier
|
||||
except Exception as erreur:
|
||||
print erreur
|
||||
return False
|
||||
|
||||
def exporter ( contenu, chemin=False ):
|
||||
''''''
|
||||
if ( chemin == False ):
|
||||
chemin = generer_nom_de_fichier()
|
||||
fichier = open( chemin, 'w' )
|
||||
fichier.write( contenu )
|
||||
fichier.close()
|
||||
|
||||
def generer_nom_de_fichier ():
|
||||
return datetime.datetime.now().strftime("%Y-%m-%d-%Hh%Mm%Ss.txt")
|
||||
Binary file not shown.
@@ -0,0 +1,28 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
Ce module facilite l'import/export de fichiers
|
||||
'''
|
||||
|
||||
|
||||
def importer ( chemin ) :
|
||||
'''String -> File
|
||||
tente d'importer le fichier dont le chemin est spécifié'''
|
||||
try:
|
||||
fichier = open( chemin, 'r' )
|
||||
return fichier
|
||||
except Exception as erreur:
|
||||
print erreur
|
||||
return False
|
||||
|
||||
def exporter ( contenu, chemin=False ):
|
||||
''''''
|
||||
if ( chemin == False ):
|
||||
chemin = generer_nom_de_fichier()
|
||||
fichier = open( chemin, 'w' )
|
||||
fichier.write( contenu )
|
||||
fichier.close()
|
||||
|
||||
def generer_nom_de_fichier ():
|
||||
return datetime.datetime.now().strftime("%Y-%m-%d-%Hh%Mm%Ss.txt")
|
||||
Binary file not shown.
@@ -0,0 +1,37 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
Ce module facilite l'import/export de fichiers
|
||||
'''
|
||||
|
||||
|
||||
def importer ( chemin ) :
|
||||
'''String -> File
|
||||
tente d'importer le fichier dont le chemin est spécifié'''
|
||||
try:
|
||||
fichier = open( chemin, 'r' )
|
||||
return fichier
|
||||
except Exception as erreur:
|
||||
print erreur
|
||||
return False
|
||||
|
||||
def exporter ( contenu, chemin=False ):
|
||||
''''''
|
||||
if ( chemin == False ):
|
||||
chemin = generer_nom_de_fichier()
|
||||
fichier = open( chemin, 'w' )
|
||||
if ( isinstance( contenu, basestring) ):
|
||||
fichier.write( contenu )
|
||||
elif ( isinstance( contenu, (list, tuple) ) ):
|
||||
traiter_liste ( contenu, fichier )
|
||||
fichier.close()
|
||||
|
||||
def generer_nom_de_fichier ():
|
||||
return datetime.datetime.now().strftime("%Y-%m-%d-%Hh%Mm%Ss.txt")
|
||||
|
||||
def traiter_liste ( liste, fichier ):
|
||||
if ( isinstance( contenu, basestring) ):
|
||||
fichier.write( contenu )
|
||||
else if isinstance( contenu, (list, tuple)):
|
||||
pass
|
||||
Binary file not shown.
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
Ce module facilite l'import/export de fichiers
|
||||
'''
|
||||
|
||||
|
||||
def importer ( chemin ) :
|
||||
'''String -> File
|
||||
tente d'importer le fichier dont le chemin est spécifié'''
|
||||
try:
|
||||
fichier = open( chemin, 'r' )
|
||||
return fichier
|
||||
except Exception as erreur:
|
||||
print erreur
|
||||
return False
|
||||
|
||||
def exporter ( contenu, chemin=False ):
|
||||
''''''
|
||||
if ( chemin == False ):
|
||||
chemin = generer_nom_de_fichier()
|
||||
fichier = open( chemin, 'w' )
|
||||
if ( isinstance( contenu, basestring) ):
|
||||
fichier.write( contenu )
|
||||
elif ( isinstance( contenu, (list, tuple) ) ):
|
||||
traiter_liste ( contenu, fichier )
|
||||
fichier.close()
|
||||
|
||||
def generer_nom_de_fichier ():
|
||||
''''''
|
||||
return datetime.datetime.now().strftime("%Y-%m-%d-%Hh%Mm%Ss.txt")
|
||||
|
||||
def traiter_liste ( liste, fichier ):
|
||||
''''''
|
||||
for item in liste:
|
||||
if ( isinstance( item, basestring) ):
|
||||
fichier.write( item )
|
||||
elif isinstance( item, (list, tuple)):
|
||||
traiter_liste ( item, fichier )
|
||||
Binary file not shown.
+22
@@ -0,0 +1,22 @@
|
||||
# coding:utf-8
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte = parse(u"Le chat joue au tennis.")
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
for mot in phrase.words:
|
||||
# print mot.__dict__.keys()
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
# coding:utf-8
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte = parse(u"Le chat joue au tennis.")
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure du mot'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
for mot in phrase.words:
|
||||
# print mot.__dict__.keys()
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
# coding:utf-8
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte = parse(u"Le chat joue au tennis.")
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure du mot'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
# pour chaque phrase dans le texte
|
||||
for phrase in split( texte ):
|
||||
# pour chaque mot dans la phrase
|
||||
for mot in phrase.words:
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Suivez les flèches, attention aux trous.".encode('utf-8')
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
numero_mot = -1
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def demarrer_graphe () :
|
||||
print 'digraph G {'
|
||||
print ' graph [ rankdir=LR ];'
|
||||
|
||||
def ajouter_noeud_mot ( word, numero ):
|
||||
print ' ' + str( numero ) + ' [label="' + word.string + '"];'
|
||||
|
||||
def ajouter_noeud_type ( word, numero ):
|
||||
type_pos = word.type.replace( '.', 'point' ).replace( ',', 'virgule' )
|
||||
print ' type__' + str( numero ) + '__' + type_pos + ' [label="' + word.type + '"];'
|
||||
print ' ' + str( numero ) +' -> type__' + str( numero ) + '__' + type_pos;
|
||||
|
||||
def lier_a_noeud_precedent ( numero ):
|
||||
if ( numero_mot > 0 ):
|
||||
print ' ' + str( numero - 1 ) + ' -> ' + str ( numero )
|
||||
|
||||
def clore_graphe () :
|
||||
print '}'
|
||||
|
||||
demarrer_graphe ()
|
||||
|
||||
# pour chaque phrase
|
||||
for phrase in split( texte_traite ):
|
||||
# pour chaque mot
|
||||
for word in phrase.words:
|
||||
# on incrément le numéro du mot
|
||||
numero_mot = numero_mot + 1
|
||||
ajouter_noeud_mot ( word, numero_mot )
|
||||
ajouter_noeud_type ( word, numero_mot )
|
||||
lier_a_noeud_precedent ( numero_mot )
|
||||
|
||||
clore_graphe ()
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Suivez les flèches, attention aux trous.".encode('utf-8')
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
numero_mot = -1
|
||||
|
||||
posse = {
|
||||
"CC" : u"conjonction de coordination",
|
||||
"CD" : u"nombre cardinal",
|
||||
"DT" : u"déterminant",
|
||||
"EX" : u"Existential there",
|
||||
"FW" : u"mot étranger",
|
||||
"IN" : u"préposition ou conjonction de subordination",
|
||||
"JJ" : u"adjectif",
|
||||
"JJR" : u"adjectif comparatif",
|
||||
"JJS" : u"adjectif superlatif",
|
||||
"LS" : u"marqueur d'élément de liste",
|
||||
"MD" : u"modal",
|
||||
"NN" : u"nm, singulier ou mass",
|
||||
"NNS" : u"nom, pluriel",
|
||||
"NNP" : u"nom propre, singulier",
|
||||
"NNPS" : u"nom propre, pluriel",
|
||||
"PDT" : u"predeterminer",
|
||||
"POS" : u"possessive ending",
|
||||
"PRP" : u"pronom personnel",
|
||||
"PRP$" : u"pronom possessif",
|
||||
"RB" : u"adverbe",
|
||||
"RBR" : u"adverbe, comparatif",
|
||||
"RBS" : u"adverbe, superlatif",
|
||||
"RP" : u"particle",
|
||||
"SYM" : u"symbole",
|
||||
}
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def demarrer_graphe () :
|
||||
print 'digraph G {'
|
||||
print ' graph [ rankdir=LR ];'
|
||||
|
||||
def ajouter_noeud_mot ( word, numero ):
|
||||
print ' ' + str( numero ) + ' [label="' + word.string + '"];'
|
||||
|
||||
def ajouter_noeud_type ( word, numero ):
|
||||
if word.type in posse:
|
||||
type_pos_label = posse[word.type]
|
||||
else:
|
||||
type_pos_label = word.type
|
||||
type_pos = word.type.replace( '.', 'point' ).replace( ',', 'virgule' )
|
||||
print ' type__' + str( numero ) + '__' + type_pos + ' [label="' + type_pos_label + '"];'
|
||||
print ' ' + str( numero ) +' -> type__' + str( numero ) + '__' + type_pos;
|
||||
|
||||
def lier_a_noeud_precedent ( numero ):
|
||||
if ( numero_mot > 0 ):
|
||||
print ' ' + str( numero - 1 ) + ' -> ' + str ( numero )
|
||||
|
||||
def clore_graphe () :
|
||||
print '}'
|
||||
|
||||
demarrer_graphe ()
|
||||
|
||||
# pour chaque phrase
|
||||
for phrase in split( texte_traite ):
|
||||
# pour chaque mot
|
||||
for word in phrase.words:
|
||||
# on incrément le numéro du mot
|
||||
numero_mot = numero_mot + 1
|
||||
ajouter_noeud_mot ( word, numero_mot )
|
||||
ajouter_noeud_type ( word, numero_mot )
|
||||
lier_a_noeud_precedent ( numero_mot )
|
||||
|
||||
clore_graphe ()
|
||||
@@ -0,0 +1,76 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Suivez les flèches, attention aux trous.".encode('utf-8')
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
numero_mot = -1
|
||||
|
||||
posse = {
|
||||
"CC" : u"conjonction de coordination",
|
||||
"CD" : u"nombre cardinal",
|
||||
"DT" : u"déterminant",
|
||||
"EX" : u"Existential there",
|
||||
"FW" : u"mot étranger",
|
||||
"IN" : u"préposition ou conjonction de subordination",
|
||||
"JJ" : u"adjectif",
|
||||
"JJR" : u"adjectif comparatif",
|
||||
"JJS" : u"adjectif superlatif",
|
||||
"LS" : u"marqueur d'élément de liste",
|
||||
"MD" : u"modal",
|
||||
"NN" : u"nm, singulier ou mass",
|
||||
"NNS" : u"nom, pluriel",
|
||||
"NNP" : u"nom propre, singulier",
|
||||
"NNPS" : u"nom propre, pluriel",
|
||||
"PDT" : u"predeterminer",
|
||||
"POS" : u"possessive ending",
|
||||
"PRP" : u"pronom personnel",
|
||||
"PRP$" : u"pronom possessif",
|
||||
"RB" : u"adverbe",
|
||||
"RBR" : u"adverbe, comparatif",
|
||||
"RBS" : u"adverbe, superlatif",
|
||||
"RP" : u"particle",
|
||||
"SYM" : u"symbole",
|
||||
}
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def demarrer_graphe () :
|
||||
print 'digraph G {'
|
||||
print ' graph [ rankdir=LR ];'
|
||||
|
||||
def ajouter_noeud_mot ( word, numero ):
|
||||
print ' ' + str( numero ) + ' [label="' + word.string + '"];'
|
||||
|
||||
def ajouter_noeud_type ( word, numero ):
|
||||
if word.type in posse:
|
||||
type_pos_label = posse[word.type]
|
||||
else:
|
||||
type_pos_label = word.type
|
||||
type_pos = word.type.replace( '.', 'point' ).replace( ',', 'virgule' )
|
||||
print ' type__' + str( numero ) + '__' + type_pos + ' [label="' + type_pos_label + '"];'
|
||||
print ' ' + str( numero ) +' -> type__' + str( numero ) + '__' + type_pos;
|
||||
|
||||
def lier_a_noeud_precedent ( numero ):
|
||||
if ( numero_mot > 0 ):
|
||||
print ' ' + str( numero - 1 ) + ' -> ' + str ( numero )
|
||||
|
||||
def clore_graphe () :
|
||||
print '}'
|
||||
|
||||
demarrer_graphe ()
|
||||
|
||||
# pour chaque phrase
|
||||
for phrase in split( texte_traite ):
|
||||
# pour chaque mot
|
||||
for word in phrase.words:
|
||||
# on incrément le numéro du mot
|
||||
numero_mot = numero_mot + 1
|
||||
ajouter_noeud_mot ( word, numero_mot )
|
||||
ajouter_noeud_type ( word, numero_mot )
|
||||
lier_a_noeud_precedent ( numero_mot )
|
||||
|
||||
clore_graphe ()
|
||||
@@ -0,0 +1,39 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Suivez les flèches, attention aux trous.".encode('utf-8')
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
numero_mot = -1
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def demarrer_graphe () :
|
||||
print 'digraph G {'
|
||||
print ' graph [ rankdir=LR ];'
|
||||
|
||||
def ajouter_noeud_mot ( word, numero ):
|
||||
print ' ' + str( numero ) + ' [label="' + word.string + '"];'
|
||||
|
||||
def lier_a_noeud_precedent ( numero ):
|
||||
if ( numero_mot > 0 ):
|
||||
print ' ' + str( numero - 1 ) + ' -> ' + str ( numero )
|
||||
|
||||
def clore_graphe () :
|
||||
print '}'
|
||||
|
||||
demarrer_graphe ()
|
||||
|
||||
# pour chaque phrase
|
||||
for phrase in split( texte_traite ):
|
||||
# pour chaque mot
|
||||
for word in phrase.words:
|
||||
# on incrément le numéro du mot
|
||||
numero_mot = numero_mot + 1
|
||||
ajouter_noeud_mot ( word, numero_mot )
|
||||
lier_a_noeud_precedent ( numero_mot )
|
||||
|
||||
clore_graphe ()
|
||||
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import imports.arguments as ARG
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = ARG.obtenir( '-p' ) OR u"Suivez les flèches, attention aux trous.".encode('utf-8')
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
numero_mot = -1
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def demarrer_graphe () :
|
||||
print 'digraph G {'
|
||||
print ' graph [ rankdir=LR ];'
|
||||
|
||||
def ajouter_noeud_mot ( word, numero ):
|
||||
print ' ' + str( numero ) + ' [label="' + word.string + '"];'
|
||||
|
||||
def lier_a_noeud_precedent ( numero ):
|
||||
if ( numero_mot > 0 ):
|
||||
print ' ' + str( numero - 1 ) + ' -> ' + str ( numero )
|
||||
|
||||
def clore_graphe () :
|
||||
print '}'
|
||||
|
||||
demarrer_graphe ()
|
||||
|
||||
# pour chaque phrase
|
||||
for phrase in split( texte_traite ):
|
||||
# pour chaque mot
|
||||
for word in phrase.words:
|
||||
# on incrément le numéro du mot
|
||||
numero_mot = numero_mot + 1
|
||||
ajouter_noeud_mot ( word, numero_mot )
|
||||
lier_a_noeud_precedent ( numero_mot )
|
||||
|
||||
clore_graphe ()
|
||||
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import imports.arguments as ARG
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = ( ARG.obtenir( '-p' ) ) OR ( u"Suivez les flèches, attention aux trous.".encode('utf-8') )
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
numero_mot = -1
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def demarrer_graphe () :
|
||||
print 'digraph G {'
|
||||
print ' graph [ rankdir=LR ];'
|
||||
|
||||
def ajouter_noeud_mot ( word, numero ):
|
||||
print ' ' + str( numero ) + ' [label="' + word.string + '"];'
|
||||
|
||||
def lier_a_noeud_precedent ( numero ):
|
||||
if ( numero_mot > 0 ):
|
||||
print ' ' + str( numero - 1 ) + ' -> ' + str ( numero )
|
||||
|
||||
def clore_graphe () :
|
||||
print '}'
|
||||
|
||||
demarrer_graphe ()
|
||||
|
||||
# pour chaque phrase
|
||||
for phrase in split( texte_traite ):
|
||||
# pour chaque mot
|
||||
for word in phrase.words:
|
||||
# on incrément le numéro du mot
|
||||
numero_mot = numero_mot + 1
|
||||
ajouter_noeud_mot ( word, numero_mot )
|
||||
lier_a_noeud_precedent ( numero_mot )
|
||||
|
||||
clore_graphe ()
|
||||
@@ -0,0 +1,44 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import imports.arguments as ARG
|
||||
from pattern.fr import parse, split
|
||||
|
||||
phrase_en_entree = ARG.obtenir( '-p' )
|
||||
if phrase_en_entree :
|
||||
texte_brut = phrase_en_entree
|
||||
else :
|
||||
texte_brut = u"Suivez les flèches, attention aux trous.".encode('utf-8')
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
numero_mot = -1
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def demarrer_graphe () :
|
||||
print 'digraph G {'
|
||||
print ' graph [ rankdir=LR ];'
|
||||
|
||||
def ajouter_noeud_mot ( word, numero ):
|
||||
print ' ' + str( numero ) + ' [label="' + word.string + '"];'
|
||||
|
||||
def lier_a_noeud_precedent ( numero ):
|
||||
if ( numero_mot > 0 ):
|
||||
print ' ' + str( numero - 1 ) + ' -> ' + str ( numero )
|
||||
|
||||
def clore_graphe () :
|
||||
print '}'
|
||||
|
||||
demarrer_graphe ()
|
||||
|
||||
# pour chaque phrase
|
||||
for phrase in split( texte_traite ):
|
||||
# pour chaque mot
|
||||
for word in phrase.words:
|
||||
# on incrément le numéro du mot
|
||||
numero_mot = numero_mot + 1
|
||||
ajouter_noeud_mot ( word, numero_mot )
|
||||
lier_a_noeud_precedent ( numero_mot )
|
||||
|
||||
clore_graphe ()
|
||||
@@ -0,0 +1,13 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
from pattern.fr import parse, split
|
||||
|
||||
|
||||
print sys.argv[1]
|
||||
'''
|
||||
texte_brut = sys.argv[1].encode('utf-8');
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
'''
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Suivez les flèches, attention aux trous.".encode('utf-8')
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
numero_mot = -1
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def demarrer_graphe () :
|
||||
print 'digraph G {'
|
||||
print ' graph [ rankdir=LR ];'
|
||||
|
||||
def ajouter_noeud_mot ( word, numero ):
|
||||
print ' ' + str( numero ) + ' [label="' + word.string + '"];'
|
||||
|
||||
def ajouter_noeud_type ( word, numero ):
|
||||
type_pos = word.type.replace( '.', 'point' ).replace( ',', 'virgule' )
|
||||
print ' type__' + str( numero ) + '__' + type_pos + ' [label="' + word.type + '"];'
|
||||
print ' ' + str( numero ) +' -> type__' + str( numero ) + '__' + type_pos;
|
||||
|
||||
def lier_a_noeud_precedent ( numero ):
|
||||
if ( numero_mot > 0 ):
|
||||
print ' ' + str( numero - 1 ) + ' -> ' + str ( numero )
|
||||
|
||||
def clore_graphe () :
|
||||
print '}'
|
||||
|
||||
demarrer_graphe ()
|
||||
|
||||
# pour chaque phrase
|
||||
for phrase in split( texte_traite ):
|
||||
# pour chaque mot
|
||||
for word in phrase.words:
|
||||
# on incrément le numéro du mot
|
||||
numero_mot = numero_mot + 1
|
||||
ajouter_noeud_mot ( word, numero_mot )
|
||||
ajouter_noeud_type ( word, numero_mot )
|
||||
lier_a_noeud_precedent ( numero_mot )
|
||||
|
||||
clore_graphe ()
|
||||
@@ -0,0 +1,46 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#from __future__ import unicode_literals
|
||||
from pattern.fr import parse, split
|
||||
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte_brut.encode('utf-8')
|
||||
texte = parse( texte_brut )
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
print phrase.words
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
print phrase.chunks
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
'''
|
||||
for mot in phrase.words:
|
||||
# print mot.__dict__.keys()
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
# imprimer_la_structure_de_la_phrase( phrase.words[0] )
|
||||
'''
|
||||
@@ -0,0 +1,48 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#from __future__ import unicode_literals
|
||||
from pattern.fr import parse, split
|
||||
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte = parse( texte_brut )
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
print phrase
|
||||
'''
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
print phrase.words
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
print phrase.chunks
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
'''
|
||||
'''
|
||||
for mot in phrase.words:
|
||||
# print mot.__dict__.keys()
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
# imprimer_la_structure_de_la_phrase( phrase.words[0] )
|
||||
'''
|
||||
@@ -0,0 +1,47 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#from __future__ import unicode_literals
|
||||
from pattern.fr import parse, split
|
||||
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte = parse( texte_brut )
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
print phrase.words
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
print phrase.chunks
|
||||
'''
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
'''
|
||||
'''
|
||||
for mot in phrase.words:
|
||||
# print mot.__dict__.keys()
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
# imprimer_la_structure_de_la_phrase( phrase.words[0] )
|
||||
'''
|
||||
@@ -0,0 +1,38 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#from __future__ import unicode_literals
|
||||
from pattern.fr import parse, split
|
||||
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte = parse( texte_brut )
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
print phrase.words
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
# print phrase.chunks
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
@@ -0,0 +1,36 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#from __future__ import unicode_literals
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte = parse( texte_brut )
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
print phrase.words
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
print phrase.chunks
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
@@ -0,0 +1,36 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#from __future__ import unicode_literals
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte_traite ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
print phrase.words
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
print phrase.chunks
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
@@ -0,0 +1,39 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#from __future__ import unicode_literals
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte_traite ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
print phrase.words
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
try:
|
||||
print str(phrase.chunks)
|
||||
except Exception as e:
|
||||
print 'erreur : ' + str(e)
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
@@ -0,0 +1,51 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#from __future__ import unicode_literals
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte_traite ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
|
||||
try:
|
||||
print phrase.words
|
||||
except Exception as e:
|
||||
print 'erreur : ' + str(e)
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
try:
|
||||
print str(phrase.chunks)
|
||||
except Exception as e:
|
||||
print 'erreur : ' + str(e)
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
|
||||
try:
|
||||
print phrase.__dict__.keys()
|
||||
except Exception as e:
|
||||
print '💩 erreur : ' + str(e)
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
|
||||
try:
|
||||
print phrase.words[0].__dict__.keys()
|
||||
except Exception as e:
|
||||
print 'erreur : ' + str(e)
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
@@ -0,0 +1,53 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#from __future__ import unicode_literals
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte_traite ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
try:
|
||||
print phrase.words
|
||||
except Exception as erreur:
|
||||
imprimer_erreur( erreur )
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
try:
|
||||
print str(phrase.chunks)
|
||||
except Exception as erreur:
|
||||
imprimer_erreur( erreur )
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
|
||||
try:
|
||||
print phrase.__dict__.keys()
|
||||
except Exception as erreur:
|
||||
imprimer_erreur( erreur )
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
|
||||
try:
|
||||
print phrase.words[0].__dict__.keys()
|
||||
except Exception as erreur:
|
||||
imprimer_erreur( erreur )
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
@@ -0,0 +1,52 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte_brut = u"Le petit chat rugit alors que l'esclave humain tarde à accomplir sa tâche de nourrissage du maître et seigneur."
|
||||
texte_traite = parse( texte_brut )
|
||||
|
||||
def imprimer_erreur ( erreur ):
|
||||
print '💩 erreur : ' + str( erreur )
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte_traite ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
try:
|
||||
print phrase.words
|
||||
except Exception as erreur:
|
||||
imprimer_erreur( erreur )
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
try:
|
||||
print str(phrase.chunks)
|
||||
except Exception as erreur:
|
||||
imprimer_erreur( erreur )
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
|
||||
try:
|
||||
print phrase.__dict__.keys()
|
||||
except Exception as erreur:
|
||||
imprimer_erreur( erreur )
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
|
||||
try:
|
||||
print phrase.words[0].__dict__.keys()
|
||||
except Exception as erreur:
|
||||
imprimer_erreur( erreur )
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 70 KiB |
+6
@@ -0,0 +1,6 @@
|
||||
from pattern.fr import parse, split
|
||||
|
||||
lexemes = parse(u"Le petit chat attend que l'esclave humain daigne lui apporter son repas..")
|
||||
|
||||
for sentence in split( lexemes ):
|
||||
print sentence
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
from pattern.fr import parse, split
|
||||
|
||||
lexemes = parse(u"Le petit chat attend que l'esclave humain daigne lui apporter son repas..")
|
||||
|
||||
print lexemes
|
||||
|
||||
'''
|
||||
for sentence in split( lexemes ):
|
||||
print sentence
|
||||
'''
|
||||
|
||||
for lexeme in lexemes:
|
||||
for chunk in lexeme.chunks:
|
||||
print chunk.type, [(w.string, w.type) for w in chunk.words]
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
from pattern.fr import parsetree, parse, split
|
||||
|
||||
texte = parse(u"Le petit chat attend que l'esclave humain daigne lui apporter son repas.")
|
||||
|
||||
#print texte
|
||||
|
||||
|
||||
for phrase in split( texte ):
|
||||
# print sentence.__dict__.keys()
|
||||
print phrase.words
|
||||
|
||||
|
||||
print "---"
|
||||
# print split( texte ).words[0].__dict__.keys()
|
||||
print split( texte ).words[0].type
|
||||
|
||||
'''
|
||||
for lexeme in lexemes:
|
||||
for chunk in lexeme.chunks:
|
||||
print chunk.type, [(w.string, w.type) for w in chunk.words]
|
||||
'''
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
# coding:utf-8
|
||||
from pattern.fr import parsetree, parse, split
|
||||
|
||||
texte = parse(u"Le petit chat attend que l'esclave humain daigne lui apporter son repas.")
|
||||
|
||||
|
||||
def imprimer_la_structure_de_la_phrase ( phrase ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( phrase.index )
|
||||
print 'string : ' + str( phrase.string )
|
||||
print '_custom_tags : ' + str( phrase._custom_tags )
|
||||
print 'sentence : ' + str( phrase.sentence )
|
||||
print 'pnp : ' + str( phrase.pnp )
|
||||
print 'chunk : ' + str( phrase.chunk )
|
||||
print 'lemma : ' + str( phrase.lemma )
|
||||
print 'type : ' + str( phrase.type )
|
||||
|
||||
|
||||
#print texte
|
||||
|
||||
|
||||
for phrase in split( texte ):
|
||||
print phrase.__dict__.keys()
|
||||
print "---"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
# print phrase.pnp.__dict__.keys()
|
||||
#imprimer_la_structure_de_la_phrase( phrase.words[0] )
|
||||
|
||||
'''
|
||||
print "---"
|
||||
print "contenu :"
|
||||
print split( texte ).words[0].__dict__.keys()
|
||||
print ""
|
||||
print 'index : ' + str( split( texte ).words[0].index )
|
||||
print 'string : ' + str( split( texte ).words[0].string )
|
||||
print '_custom_tags : ' + str( split( texte ).words[0]._custom_tags )
|
||||
print 'sentence : ' + str( split( texte ).words[0].sentence )
|
||||
print 'pnp : ' + str( split( texte ).words[0].pnp )
|
||||
print 'chunk : ' + str( split( texte ).words[0].chunk )
|
||||
print 'lemma : ' + str( split( texte ).words[0].lemma )
|
||||
print 'type : ' + str( split( texte ).words[0].type )
|
||||
'''
|
||||
#print split( texte ).words[0].type
|
||||
# 'index', 'string', '_custom_tags', 'sentence', 'pnp', 'chunk', 'lemma', 'type'
|
||||
|
||||
'''
|
||||
for lexeme in lexemes:
|
||||
for chunk in lexeme.chunks:
|
||||
print chunk.type, [(w.string, w.type) for w in chunk.words]
|
||||
'''
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
# coding:utf-8
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte = parse(u"Le petit chat attend que l'esclave humain daigne lui apporter son repas.")
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( phrase.index )
|
||||
print 'string : ' + str( phrase.string )
|
||||
print '_custom_tags : ' + str( phrase._custom_tags )
|
||||
print 'sentence : ' + str( phrase.sentence )
|
||||
print 'pnp : ' + str( phrase.pnp )
|
||||
print 'chunk : ' + str( phrase.chunk )
|
||||
print 'lemma : ' + str( phrase.lemma )
|
||||
print 'type : ' + str( phrase.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
# print phrase.__dict__.keys()
|
||||
# print "---"
|
||||
# print phrase.chunks[0].__dict__.keys()
|
||||
# print phrase.pnp.__dict__.keys()
|
||||
for mot in phrase.words:
|
||||
print mot.__dict__.keys()
|
||||
print "---"
|
||||
#imprimer_structure_mot( mot )
|
||||
# imprimer_la_structure_de_la_phrase( phrase.words[0] )
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
# coding:utf-8
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte = parse(u"Le petit chat attend que l'esclave humain daigne lui apporter son repas.")
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
# print phrase.__dict__.keys()
|
||||
# print "---"
|
||||
# print phrase.chunks[0].__dict__.keys()
|
||||
# print phrase.pnp.__dict__.keys()
|
||||
for mot in phrase.words:
|
||||
# print mot.__dict__.keys()
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
# imprimer_la_structure_de_la_phrase( phrase.words[0] )
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
# coding:utf-8
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte = parse(u"Le chat joue au tennis.")
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print ""
|
||||
|
||||
for mot in phrase.words:
|
||||
# print mot.__dict__.keys()
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
# imprimer_la_structure_de_la_phrase( phrase.words[0] )
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
# coding:utf-8
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte = parse(u"Le chat joue au tennis.")
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
print "mots :"
|
||||
print phrase.words
|
||||
print "groupes de mots :"
|
||||
print phrase.chunks
|
||||
print "groupes de mots :"
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
'''
|
||||
for mot in phrase.words:
|
||||
# print mot.__dict__.keys()
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
# imprimer_la_structure_de_la_phrase( phrase.words[0] )
|
||||
'''
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
# coding:utf-8
|
||||
from pattern.fr import parse, split
|
||||
|
||||
texte = parse(u"Le chat joue au tennis.")
|
||||
|
||||
|
||||
def imprimer_structure_mot ( mot ):
|
||||
'''imprime la structure de la phrase'''
|
||||
print 'index : ' + str( mot.index )
|
||||
print 'string : ' + str( mot.string )
|
||||
print '_custom_tags : ' + str( mot._custom_tags )
|
||||
print 'sentence : ' + str( mot.sentence )
|
||||
print 'pnp : ' + str( mot.pnp )
|
||||
print 'chunk : ' + str( mot.chunk )
|
||||
print 'lemma : ' + str( mot.lemma )
|
||||
print 'type : ' + str( mot.type )
|
||||
|
||||
for phrase in split( texte ):
|
||||
print "——————————"
|
||||
print "mots :"
|
||||
print phrase.words
|
||||
print "——————————"
|
||||
print "groupes de mots :"
|
||||
print phrase.chunks
|
||||
print "——————————"
|
||||
print "structure, phrase :"
|
||||
print phrase.__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, mot :"
|
||||
print phrase.words[0].__dict__.keys()
|
||||
print "——————————"
|
||||
print "structure, chunk (groupe de mots) :"
|
||||
print phrase.chunks[0].__dict__.keys()
|
||||
'''
|
||||
for mot in phrase.words:
|
||||
# print mot.__dict__.keys()
|
||||
print "---"
|
||||
imprimer_structure_mot( mot )
|
||||
# imprimer_la_structure_de_la_phrase( phrase.words[0] )
|
||||
'''
|
||||
Reference in New Issue
Block a user