iramuteq.org Git - iramuteq/blob - corpusNG.py

   1 # -*- coding: utf-8 -*-
   2 #Author: Pierre Ratinaud
   3
   4 import codecs
   5 import os
   6 import gettext
   7 _ = gettext.gettext
   8 import locale
   9 import sys
  10 from time import time
  11 from functions import decoupercharact, ReadDicoAsDico, DoConf
  12 import re
  13 import sqlite3
  14 import numpy
  15 import itertools
  16 import logging
  17 from operator import itemgetter
  18 from uuid import uuid4
  19 from chemins import PathOut
  20 from dialog import CorpusPref
  21 from functions import ReadLexique, ReadDicoAsDico
  22 from colors import colors
  23 import datetime
  24
  25
  26 log = logging.getLogger('iramuteq.corpus')
  27
  28
  29 def copycorpus(corpus) :
  30     log.info('copy corpus')
  31     copy_corpus = Corpus(corpus.parent, parametres = corpus.parametres)
  32     copy_corpus.ucis = corpus.ucis
  33     copy_corpus.formes = corpus.formes
  34     copy_corpus.pathout = corpus.pathout
  35     copy_corpus.conn_all()
  36     return copy_corpus
  37
  38
  39
  40 class Corpus :
  41     """Corpus class
  42     list of uci
  43
  44     """
  45     def __init__(self, parent, parametres = {}, read = False) :
  46         self.parent = parent
  47         self.parametres = parametres
  48         self.cformes = None
  49         self.connformes = None
  50         self.connuces = None
  51         self.conncorpus = None
  52         self.islem = False
  53         self.cuces = None
  54         self.ucis = []
  55         self.formes = {}
  56         self.flems = {}
  57         self.lems = None
  58         self.idformesuces = {}
  59         self.iduces = None
  60         self.idformes = None
  61         self.uceuci = None
  62         if read :
  63             self.pathout = PathOut(dirout = parametres['pathout'])
  64             self.read_corpus()
  65
  66     def add_word(self, word) :
  67         if word in self.formes :
  68             self.formes[word].freq += 1
  69             if self.formes[word].ident in self.idformesuces :
  70                 if self.ucis[-1].uces[-1].ident in self.idformesuces[self.formes[word].ident] :
  71                     self.idformesuces[self.formes[word].ident][self.ucis[-1].uces[-1].ident] += 1
  72                 else :
  73                     self.idformesuces[self.formes[word].ident][self.ucis[-1].uces[-1].ident] = 1
  74             else :
  75                 self.idformesuces[self.formes[word].ident] = {self.ucis[-1].uces[-1].ident: 1}
  76         else :
  77             if word in self.parent.lexique :
  78                 gramtype = self.parent.lexique[word][1]
  79                 lem = self.parent.lexique[word][0]
  80             elif word.isdigit() :
  81                 gramtype = 'num'
  82                 lem = word
  83             else :
  84                 gramtype = 'nr'
  85                 lem = word
  86             self.formes[word] =  Word(word, gramtype, len(self.formes), lem)
  87             self.idformesuces[self.formes[word].ident] = {self.ucis[-1].uces[-1].ident : 1}
  88
  89     def conn_all(self):
  90         """connect corpus to db"""
  91         if self.connformes is None :
  92             log.info('connexion corpus')
  93             self.connuces = sqlite3.connect(self.pathout['uces.db'])
  94             self.cuces = self.connuces.cursor()
  95             self.connformes = sqlite3.connect(self.pathout['formes.db'])
  96             self.cformes = self.connformes.cursor()
  97             self.conncorpus = sqlite3.connect(self.pathout['corpus.db'])
  98             self.ccorpus = self.conncorpus.cursor()
  99             self.cformes.execute('PRAGMA temp_store=MEMORY;')
 100             self.cformes.execute('PRAGMA journal_mode=MEMORY;')
 101             self.cformes.execute('PRAGMA  synchronous = OFF;')
 102             self.cuces.execute('PRAGMA temp_store=MEMORY;')
 103             self.cuces.execute('PRAGMA journal_mode=MEMORY;')
 104             self.cuces.execute('PRAGMA  synchronous = OFF;')
 105             self.ccorpus.execute('PRAGMA temp_store=MEMORY;')
 106             self.ccorpus.execute('PRAGMA journal_mode=MEMORY;')
 107             self.ccorpus.execute('PRAGMA  synchronous = OFF;')
 108
 109     def read_corpus(self) :
 110         log.info('read corpus')
 111         self.parametres['syscoding'] = sys.getdefaultencoding()
 112         if self.conncorpus is None :
 113             self.conn_all()
 114         res = self.ccorpus.execute('SELECT * FROM etoiles;')
 115         for row in res :
 116             self.ucis.append(Uci(row[0], row[1], row[2]))
 117             uces = self.conncorpus.cursor().execute('SELECT * FROM luces where uci=?;',(`self.ucis[-1].ident`,))
 118             for uce in uces:
 119                 self.ucis[-1].uces.append(Uce(uce[2], uce[1], uce[0]))
 120         res = self.ccorpus.execute('SELECT * FROM formes;')
 121         self.formes = dict([[forme[1], Word(forme[1], forme[3], forme[0], lem = forme[2], freq = forme[4])] for forme in res])
 122         self.ccorpus.close()
 123
 124     def getworduces(self, wordid) :
 125         if isinstance(wordid, basestring) :
 126             wordid = self.formes[wordid].ident
 127         res = self.cformes.execute('SELECT uces FROM uces where id=? ORDER BY id;', (`wordid`,))
 128         return list(itertools.chain(*[[int(val) for val in row[0].split()] if not isinstance(row[0], int) else [row[0]] for row in res]))
 129
 130     def getlemuces(self, lem) :
 131         formesid = ', '.join([`val` for val in self.lems[lem].formes])
 132         query = 'SELECT uces FROM uces where id IN (%s) ORDER BY id' % formesid
 133         res = self.cformes.execute(query)
 134         return list(set(list(itertools.chain(*[[int(val) for val in row[0].split()] if not isinstance(row[0], int) else [row[0]] for row in res]))))
 135
 136     def getlemucis(self, lem) :
 137         uces = self.getlemuces(lem)
 138         return list(set([self.getucefromid(val).uci for val in uces]))
 139
 140     def getlemuceseff(self, lem) :
 141         formesid = ', '.join([`val` for val in self.lems[lem].formes])
 142         query = 'SELECT uces FROM uces where id IN (%s) ORDER BY id' % formesid
 143         res = self.cformes.execute(query)
 144         uces = list(itertools.chain(*[[int(val) for val in row[0].split()] if not isinstance(row[0], int) else [row[0]] for row in res]))
 145         query = 'SELECT eff FROM eff where id IN (%s) ORDER BY id' % formesid
 146         res = self.cformes.execute(query)
 147         eff = list(itertools.chain(*[[int(val) for val in row[0].split()] if not isinstance(row[0], int) else [row[0]] for row in res]))
 148         lemuceeff = {}
 149         for i, uce in enumerate(uces) :
 150             lemuceeff[uce] = lemuceeff.get(uce, 0) + eff[i]
 151         return lemuceeff
 152
 153     def getlemeff(self, lem) :
 154         return self.lems[lem].freq
 155
 156     def getlems(self) :
 157         return self.lems
 158
 159     def getforme(self, formeid) :
 160         if self.idformes is None : self.make_idformes()
 161         return self.idformes[formeid]
 162
 163     def gettotocc(self) :
 164         return sum([self.formes[forme].freq for forme in self.formes])
 165
 166     def getucemean(self) :
 167         return float(self.gettotocc())/self.getucenb()
 168
 169     def getucenb(self) :
 170         return self.ucis[-1].uces[-1].ident + 1
 171
 172     def getucinb(self) :
 173         return self.ucis[-1].ident + 1
 174
 175     def getucisize(self) :
 176         ucesize = self.getucesize()
 177         return [sum(ucesize[uci.uces[0].ident:(uci.uces[-1].ident + 1)]) for uci in self.ucis]
 178
 179     def getucesize(self) :
 180         res = self.getalluces()
 181         return [len(uce[1].split()) for uce in res]
 182
 183 #    def getlemseff(self) :
 184 #        if self.idformes is None :
 185 #            self.make_idformes()
 186 #        return dict([[lem, sum([self.idformes[forme].freq for forme in self.lems[lem]])] for lem in self.lems])
 187
 188 #    def getlemsefftype(self) :
 189 #        if self.idformes is None :
 190 #            self.make_idformes()
 191 #        if self.lems is None :
 192 #            self.make_lems()
 193 #        return dict([[lem, [sum([self.idformes[forme].freq for forme in self.lems[lem]]), '', self.idformes[self.lems[lem].keys()[0]].gram]] for lem in self.lems])
 194
 195     def getconcorde(self, uces) :
 196         return self.cuces.execute('select * from uces where id IN (%s);' % ', '.join([`i` for i in uces]))
 197
 198     def getwordconcorde(self, word) :
 199         return self.getconcorde(self.getworduces(word))
 200
 201     def getlemconcorde(self, lem) :
 202         return self.getconcorde(self.getlemuces(lem))
 203
 204     def getalluces(self) :
 205         return self.cuces.execute('SELECT * FROM uces')
 206
 207     def getucesfrometoile(self, etoile) :
 208         return [uce.ident for uci in self.ucis for uce in uci.uces if etoile in uci.etoiles]
 209
 210     def getucefromid(self, uceid) :
 211         if self.iduces is None : self.make_iduces()
 212         return self.iduces[uceid]
 213
 214     def gethapaxnb(self) :
 215         return len([None for forme in self.formes if self.formes[forme].freq == 1])
 216
 217     def getactivesnb(self, key) :
 218         return len([lem for lem in self.lems if self.lems[lem].act == key])
 219 #    def make_lems(self, lem = True) :
 220 #        log.info('make lems')
 221 #        self.lems = {}
 222 #        for forme in self.formes :
 223 #            if self.formes[forme].lem in self.lems :
 224 #                if self.formes[forme].ident not in self.lems[self.formes[forme].lem] :
 225 #                    self.lems[self.formes[forme].lem][self.formes[forme].ident] = 0
 226 #            else :
 227 #                    self.lems[self.formes[forme].lem] = {self.formes[forme].ident : 0}
 228
 229     def getetbyuceid(self, uceid) :
 230         if self.uceuci is None : self.uceuci = dict([[uce.ident,uci.ident] for uci in self.ucis for uce in uci.uces])
 231         return self.ucis[self.uceuci[uceid]].etoiles
 232
 233     def make_lems(self, lem = True) :
 234         log.info('make lems')
 235         self.lems = {}
 236         if lem :
 237             for forme in self.formes :
 238                 if self.formes[forme].lem in self.lems :
 239                     if self.formes[forme].ident not in self.lems[self.formes[forme].lem].formes :
 240                         self.lems[self.formes[forme].lem].add_forme(self.formes[forme])
 241                 else :
 242                     self.lems[self.formes[forme].lem] = Lem(self, self.formes[forme])
 243         else :
 244             self.lems = dict([[forme, Lem(self, self.formes[forme])] for forme in self.formes])
 245
 246     def make_idformes(self) :
 247         self.idformes = dict([[self.formes[forme].ident, self.formes[forme]] for forme in self.formes])
 248
 249     def make_iduces(self) :
 250         if self.iduces is None :
 251             self.iduces = dict([[uce.ident, uce] for uci in self.ucis for uce in uci.uces])
 252
 253     def make_lexitable(self, mineff, etoiles) :
 254         tokeep = [lem for lem in self.lems if self.lems[lem].freq > mineff]
 255         etuces = [[] for et in etoiles]
 256         for uci in self.ucis :
 257             get = list(set(uci.etoiles).intersection(etoiles))
 258             if len(get) > 1 :
 259                 return '2 variables sur la meme ligne'
 260             elif get != [] :
 261                 etuces[etoiles.index(get[0])] += [uce.ident for uce in uci.uces]
 262         etuces = [set(val) for val in etuces]
 263         tab = []
 264         for lem in tokeep :
 265             deff = self.getlemuceseff(lem)
 266             ucesk = deff.keys()
 267             tab.append([lem] + [sum([deff[uce] for uce in et.intersection(ucesk)]) for et in etuces])
 268         tab.insert(0, [''] + etoiles)
 269         return tab
 270
 271     def make_efftype_from_etoiles(self, etoiles) :
 272         dtype = {}
 273         etuces = [[] for et in etoiles]
 274         for uci in self.ucis :
 275             get = list(set(uci.etoiles).intersection(etoiles))
 276             if len(get) > 1 :
 277                 return '2 variables sur la meme ligne'
 278             elif get != [] :
 279                 etuces[etoiles.index(get[0])] += [uce.ident for uce in uci.uces]
 280         etuces = [set(val) for val in etuces]
 281         for lem in self.lems :
 282             deff = self.getlemuceseff(lem)
 283             ucesk = deff.keys()
 284             gram = self.lems[lem].gram
 285             if gram in dtype :
 286                 dtype[gram] = [i + j for i, j in zip(dtype[gram], [sum([deff[uce] for uce in et.intersection(ucesk)]) for et in etuces])]
 287             else :
 288                 dtype[gram] = [sum([deff[uce] for uce in et.intersection(ucesk)]) for et in etuces]
 289         tabout = [[gram] + dtype[gram] for gram in dtype]
 290         tabout.insert(0, [''] + etoiles)
 291         return tabout
 292
 293     def make_uceactsize(self, actives) :
 294         res = self.getalluces()
 295         ucesize = {}
 296         for lem in actives:
 297             deff = self.getlemuceseff(lem)
 298             for uce in deff :
 299                 ucesize[uce] = ucesize.get(uce, 0) + 1
 300         return ucesize
 301
 302     def make_uc(self, actives, lim1, lim2) :
 303         uceactsize = self.make_uceactsize(actives)
 304         last1 = 0
 305         last2 = 0
 306         uc1 = [[]]
 307         uc2 = [[]]
 308         lastpara = 0
 309         for uce in [uce for uci in self.ucis for uce in uci.uces] :
 310             if uce.para == lastpara :
 311                 if last1 <= lim1 :
 312                     last1 += uceactsize.get(uce.ident,0)
 313                     uc1[-1].append(uce.ident)
 314                 else :
 315                     uc1.append([uce.ident])
 316                     last1 = 0
 317                 if last2 <= lim2 :
 318                     last2 += uceactsize.get(uce.ident, 0)
 319                     uc2[-1].append(uce.ident)
 320                 else :
 321                     uc2.append([uce.ident])
 322                     last2 = 0
 323             else :
 324                 last1 = uceactsize.get(uce.ident, 0)
 325                 last2 = uceactsize.get(uce.ident, 0)
 326                 lastpara = uce.para
 327                 uc1.append([uce.ident])
 328                 uc2.append([uce.ident])
 329         return uc1, uc2
 330
 331     def make_and_write_sparse_matrix_from_uc(self, actives, sizeuc1, sizeuc2, uc1out, uc2out, listuce1out, listuce2out) :
 332         uc1, uc2 = self.make_uc(actives, sizeuc1, sizeuc2)
 333         log.info('taille uc1 : %i - taille uc2 : %i' % (len(uc1), len(uc2)))
 334         self.write_ucmatrix(uc1, actives, uc1out)
 335         self.write_ucmatrix(uc2, actives, uc2out)
 336         listuce1 = [['uce', 'uc']] + [[`uce`, `i`] for i, ucl in enumerate(uc1) for uce in ucl]
 337         listuce2 = [['uce', 'uc']] + [[`uce`, `i`] for i, ucl in enumerate(uc2) for uce in ucl]
 338         with open(listuce1out, 'w') as f :
 339             f.write('\n'.join([';'.join(line) for line in listuce1]))
 340         with open(listuce2out, 'w') as f :
 341             f.write('\n'.join([';'.join(line) for line in listuce2]))
 342         return len(uc1), len(uc2)
 343
 344     def write_ucmatrix(self, uc, actives, fileout) :
 345         log.info('write uc matrix %s' % fileout)
 346         uces_uc = dict([[uce, i] for i, ucl in enumerate(uc) for uce in ucl])
 347         deja_la = {}
 348         nbl = 0
 349         with open(fileout + '~', 'w+') as f :
 350             for i, lem in enumerate(actives) :
 351                 for uce in self.getlemuces(lem):
 352                     if (uces_uc[uce], i) not in deja_la :
 353                         nbl += 1
 354                         f.write(''.join([' '.join([`uces_uc[uce]+1`,`i+1`,`1`]),'\n']))
 355                         deja_la[(uces_uc[uce], i)] = 0
 356             f.seek(0)
 357             with open(fileout, 'w') as ffin :
 358                 ffin.write("%%%%MatrixMarket matrix coordinate integer general\n%i %i %i\n" % (len(uc), len(actives), nbl))
 359                 for line in f :
 360                     ffin.write(line)
 361         os.remove(fileout + '~')
 362         del(deja_la)
 363
 364     def export_corpus(self, outf) :
 365         #outf = 'export_corpus.txt'
 366         self.make_iduces()
 367         res = self.getalluces()
 368         self.make_iduces()
 369         actuci = ''
 370         actpara = False
 371         with open(outf,'w') as f :
 372             for uce in res :
 373                 if self.iduces[uce[0]].uci == actuci and self.iduces[uce[0]].para == actpara :
 374                     f.write(uce[1].encode(self.parametres['syscoding']) + '\n')
 375                 elif self.iduces[uce[0]].uci != actuci :
 376                     actuci = self.iduces[uce[0]].uci
 377                     if self.ucis[self.iduces[uce[0]].uci].paras == [] :
 378                         actpara = self.iduces[uce[0]].para
 379                         f.write('\n' + ' '.join(self.ucis[self.iduces[uce[0]].uci].etoiles).encode(self.parametres['syscoding']) + '\n' + uce[1].encode(self.parametres['syscoding']) + '\n')
 380                     else :
 381                         ident = 0
 382                         actpara = self.iduces[uce[0]].para
 383                         f.write('\n'.join([' '.join(self.ucis[self.iduces[uce[0]].uci].etoiles).encode(self.parametres['syscoding']), self.ucis[self.iduces[uce[0]].uci].paras[ident].encode(self.parametres['syscoding']), uce[1].encode(self.parametres['syscoding'])]) + '\n')
 384                 elif self.iduces[uce[0]].para != actpara :
 385                     actpara = self.iduces[uce[0]].para
 386                     ident += 1
 387                     f.write('\n'.join([self.ucis[self.iduces[uce[0]].uci].paras[ident].encode(self.parametres['syscoding']), uce[1].encode(self.parametres['syscoding'])]) + '\n')
 388
 389     def make_and_write_sparse_matrix_from_uces(self, actives, outfile, listuce = False) :
 390         log.info('make_and_write_sparse_matrix_from_uces %s' % outfile)
 391         nbl = 0
 392         with open(outfile + '~', 'w+') as f :
 393             for i, lem in enumerate(actives) :
 394                 for uce in sorted(self.getlemuces(lem)) :
 395                     nbl += 1
 396                     f.write(''.join([' '.join([`uce+1`, `i+1`,`1`]),'\n']))
 397             f.seek(0)
 398             with open(outfile, 'w') as ffin :
 399                 ffin.write("%%%%MatrixMarket matrix coordinate integer general\n%i %i %i\n" % (self.getucenb(), len(actives), nbl))
 400                 for line in f :
 401                     ffin.write(line)
 402         os.remove(outfile + '~')
 403         if listuce :
 404             with open(listuce, 'w') as f :
 405                 f.write('\n'.join(['uce;uc'] + [';'.join([`i`,`i`]) for i in range(0, self.getucenb())]))
 406
 407     def make_and_write_sparse_matrix_from_uci(self, actives, outfile, listuci = False) :
 408         log.info('make_and_write_sparse_matrix_from_ucis %s' % outfile)
 409         nbl = 0
 410         with open(outfile + '~', 'w+') as f :
 411             for i, lem in enumerate(actives) :
 412                 for uci in sorted(self.getlemucis(lem)) :
 413                     nbl += 1
 414                     f.write(''.join([' '.join([`uci+1`, `i+1`,`1`]),'\n']))
 415             f.seek(0)
 416             with open(outfile, 'w') as ffin :
 417                 ffin.write("%%%%MatrixMarket matrix coordinate integer general\n%i %i %i\n" % (self.getucinb(), len(actives), nbl))
 418                 for line in f :
 419                     ffin.write(line)
 420         os.remove(outfile + '~')
 421         if listuci :
 422             with open(listuci, 'w') as f :
 423                 f.write('\n'.join(['uci;uc'] + [';'.join([`i`,`i`]) for i in range(0, self.getucinb())]))
 424
 425     def make_and_write_sparse_matrix_from_classe(self, actives, uces, outfile) :
 426         log.info('make_and_write_sparse_matrix_from_classe %s' % outfile)
 427         nbl = 0
 428         duces = dict([[uce, i] for i, uce in enumerate(uces)])
 429         with open(outfile + '~', 'w+') as f :
 430             for i, lem in enumerate(actives) :
 431                 uces_ok = list(set(self.getlemuces(lem)).intersection(uces))
 432                 for uce in uces_ok :
 433                     f.write(''.join([' '.join([`duces[uce]+1`,`i+1`,`1`]),'\n']))
 434             f.seek(0)
 435             with open(outfile, 'w') as ffin :
 436                 ffin.write("%%%%MatrixMarket matrix coordinate integer general\n%i %i %i\n" % (self.getucenb(), len(actives), nbl))
 437                 for line in f :
 438                     ffin.write(line)
 439         os.remove(outfile + '~')
 440
 441     def make_table_with_classe(self, uces, list_act) :
 442         table_uce = [[0 for val in list_act] for line in range(0,len(uces))]
 443         uces = dict([[uce, i] for i, uce in enumerate(uces)])
 444         for i, lem in enumerate(list_act) :
 445             lemuces = list(set(self.getlemuces(lem)).intersection(uces))
 446             for uce in lemuces :
 447                 table_uce[uces[uce]][i] = 1
 448         table_uce.insert(0, list_act)
 449         return table_uce
 450
 451     def parse_active(self, gramact, gramsup = None) :
 452         log.info('parse actives')
 453         for lem in self.lems :
 454             if self.lems[lem].gram in gramact :
 455                 self.lems[lem].act = 1
 456             elif gramsup is not None :
 457                 if self.lems[lem].gram in gramsup :
 458                     self.lems[lem].act = 2
 459                 else :
 460                     self.lems[lem].act =  0
 461             else :
 462                 self.lems[lem].act = 2
 463
 464     def make_actives_limit(self, limit, key = 1) :
 465         if self.idformes is None :
 466             self.make_idformes()
 467         return [lem for lem in self.lems if self.getlemeff(lem) >= limit and self.lems[lem].act == key]
 468
 469     def make_actives_nb(self, nbmax, key) :
 470         log.info('make_actives_nb : %i - %i' % (nbmax,key))
 471         if self.idformes is None :
 472             self.make_idformes()
 473         allactives = [[self.lems[lem].freq, lem] for lem in self.lems if self.lems[lem].act == key and self.lems[lem].freq >= 3]
 474         self.activenb = len(allactives)
 475         allactives = sorted(allactives, reverse = True)
 476         if len(allactives) <= nbmax :
 477             log.info('nb = %i - eff min = %i ' % (len(allactives), allactives[-1][0]))
 478             return [val[1] for val in allactives], allactives[-1][0]
 479         else :
 480             effs = [val[0] for val in allactives]
 481             if effs.count(effs[nbmax - 1]) > 1 :
 482                 lim = effs[nbmax - 1] + 1
 483                 nok = True
 484                 while nok :
 485                     try :
 486                         stop = effs.index(lim)
 487                         nok = False
 488                     except ValueError:
 489                         lim -= 1
 490             else :
 491                 stop = nbmax - 1
 492         log.info('nb actives = %i - eff min = %i ' % (stop, lim))
 493         return [val[1] for val in allactives[0:stop + 1]], lim
 494
 495     def make_and_write_profile(self, actives, ucecl, fileout) :
 496         log.info('formes/classes')
 497         tab = [[lem] + [len(set(self.getlemuces(lem)).intersection(classe)) for classe in ucecl] for lem in actives]
 498         tab = [[line[0]] + [`val` for val in line[1:]] for line in tab if sum(line[1:]) >= 3]
 499         with open(fileout, 'w') as f :
 500             f.write('\n'.join([';'.join(line) for line in tab]).encode(self.parametres['syscoding']))
 501
 502     def make_etoiles(self) :
 503         etoiles = set([])
 504         for uci in self.ucis :
 505             etoiles.update(uci.etoiles[1:] + uci.paras)
 506         return list(etoiles)
 507
 508     def make_etoiles_dict(self) :
 509         etoiles = [et for uci in self.ucis for et in uci.etoiles[1:]]
 510         det = {}
 511         for etoile in etoiles :
 512             et = etoile.split('_')
 513             if et[0] in det :
 514                 try :
 515                     if et[1] in det[et[0]] :
 516                         det[et[0]][et[1]] += 1
 517                     else :
 518                         det[et[0]][et[1]] = 1
 519                 except IndexError :
 520                     det[et[0]] += 1
 521             else :
 522                 try :
 523                     det[et[0]] = {et[1] :1}
 524                 except IndexError :
 525                     det[et[0]] = 1
 526         print det
 527
 528     def make_and_write_profile_et(self, ucecl, fileout) :
 529         log.info('etoiles/classes')
 530         etoiles = self.make_etoiles()
 531         with open(fileout, 'w') as f :
 532             f.write('\n'.join([';'.join([etoile] + [`len(set(self.getucesfrometoile(etoile)).intersection(classe))` for classe in ucecl]) for etoile in etoiles]).encode(self.parametres['syscoding']))
 533
 534     def make_colored_corpus(self) :
 535         ucecl = {}
 536         for i, lc in enumerate(self.lc) :
 537             for uce in lc :
 538                 ucecl[uce] = i + 1
 539         for uce in self.lc0 :
 540             ucecl[uce] = 0
 541         color = ['black'] + colors[len(self.lc) - 1]
 542         txt = '''<html>
 543         <meta http-equiv="content-Type" content="text/html; charset=%s" />
 544         <body>
 545 ''' % sys.getdefaultencoding()
 546         res = self.getalluces()
 547         self.make_iduces()
 548         actuci = ''
 549         actpara = False
 550         for uce in res :
 551             if self.iduces[uce[0]].uci != actuci :
 552                 actuci = self.iduces[uce[0]].uci
 553                 txt += '<br><hr>' + ' '.join(self.ucis[self.iduces[uce[0]].uci].etoiles) + '<br><br>'
 554                 txt += '<font color="%s">' % (color[ucecl[uce[0]]]) + uce[1] + '</font><br><br>'
 555             else :
 556                 txt += '<font color="%s">' % (color[ucecl[uce[0]]]) + uce[1] + '</font><br><br>'
 557         return txt + '\n</body></html>'
 558
 559     def count_from_list(self, l, d) :
 560         for val in l :
 561             if val in d :
 562                 d[val] += 1
 563             else :
 564                 d[val] = 1
 565         return d
 566
 567     def count_from_list_cl(self, l, d, a, clnb) :
 568         for val in l :
 569             if val in d :
 570                 d[val][a] += 1
 571             else :
 572                 d[val] = [0] * clnb
 573                 d[val][a] = 1
 574         return d
 575
 576     def find_segments(self, taille_segment, taille_limite) :
 577         d = {}
 578         for uce in self.getalluces() :
 579             uce = uce[1].split()
 580             d = self.count_from_list([' '.join(uce[i:i+taille_segment]) for i in range(len(uce)-(taille_segment - 1))], d)
 581         l = [[d[val], val] for val in d if d[val] >= 3]
 582         del(d)
 583         l.sort()
 584         if len(l) > taille_limite :
 585             l = l[-taille_limite:]
 586         return l
 587
 588     def find_segments_in_classe(self, list_uce, taille_segment, taille_limite):
 589         d={}
 590         for uce in self.getconcorde(list_uce) :
 591             uce = uce[1].split()
 592             d =self.count_from_list([' '.join(uce[i:i+taille_segment]) for i in range(len(uce)-(taille_segment - 1))], d)
 593         l = [[d[val], val, taille_segment] for val in d if d[val] >= 3]
 594         del(d)
 595         l.sort()
 596         if len(l) > taille_limite :
 597             l = l[-taille_limite:]
 598         return l
 599
 600     def make_segments_profile(self, fileout, lenmin = 3, lenmax = 10, effmin = 50, lem = False) :
 601         d = {}
 602         for b, classe in enumerate(self.lc) :
 603             for uce in self.getconcorde(classe) :
 604                 uce = uce[1].split()
 605                 if lem :
 606                     uce = [self.formes[forme].lem for forme in uce]
 607                 for taille_segment in range(lenmin,lenmax) :
 608                     d =self.count_from_list_cl([' '.join(uce[i:i+taille_segment]) for i in range(len(uce)-(taille_segment - 1))], d, b, len(self.lc))
 609         result = [[seg] + [str(val) for val in d[seg]] for seg in d if sum(d[seg]) >= effmin]
 610         with open(fileout, 'w') as f :
 611             f.write('\n'.join([';'.join(line) for line in result]))
 612
 613     def make_ucecl_from_R(self, filein) :
 614         with open(filein, 'rU') as f :
 615             c = f.readlines()
 616         c.pop(0)
 617         self.lc = []
 618         for line in c :
 619             line = line.replace('\n', '').replace('"', '').split(';')
 620             self.lc.append([int(line[0]) - 1, int(line[1])])
 621         classesl = [val[1] for val in self.lc]
 622         clnb = max(classesl)
 623         self.lc = sorted(self.lc, key=itemgetter(1))
 624         self.lc = [[uce[0] for uce in self.lc if uce[1] == i] for i in range(clnb+1)]
 625         self.lc0 = self.lc.pop(0)
 626         #return ucecl
 627
 628     def gethapaxbyet(self, etoiles) :
 629         hapaxuces = [self.getlemuces(forme)[0] for forme in self.lems if self.lems[forme].freq == 1]
 630         hucesdict = {}
 631         for uce in hapaxuces :
 632             if uce in hucesdict :
 633                 hucesdict[uce] += 1
 634             else :
 635                 hucesdict[uce] = 1
 636         etuces = [[] for et in etoiles]
 637         for uci in self.ucis :
 638             get = list(set(uci.etoiles).intersection(etoiles))
 639             if len(get) > 1 :
 640                 return '2 variables sur la meme ligne'
 641             elif get != [] :
 642                 etuces[etoiles.index(get[0])] += [uce.ident for uce in uci.uces]
 643         etuces = [set(val) for val in etuces]
 644         return [sum([hucesdict[uce] for uce in list(etuce.intersection(hapaxuces))]) for etuce in etuces]
 645
 646     def gethapaxuces(self) :
 647         hapaxuces = [self.getlemuces(forme)[0] for forme in self.lems if self.lems[forme].freq == 1]
 648         hapax = [forme for forme in self.lems if self.lems[forme].freq == 1]
 649         hucesdict = {}
 650         for i,uce in enumerate(hapaxuces) :
 651             if uce in hucesdict :
 652                 hucesdict[uce][0] += 1
 653                 hucesdict[uce][1].append(hapax[i])
 654             else :
 655                 hucesdict[uce] = [1,[hapax[i]]]
 656         huces = {}
 657         for uce in hucesdict :
 658             if hucesdict[uce][0] in huces :
 659                 huces[hucesdict[uce][0]].append(uce)
 660             else :
 661                 huces[hucesdict[uce][0]] = [uce]
 662         huces = zip(huces, huces.values())
 663         huces.sort(reverse=True)
 664         txt = """
 665         <html><body>
 666         """
 667         for nb in huces[0:4] :
 668             txt += "<p><h2>%i hapax par uce</h2><p>\n" % nb[0]
 669             for uce in nb[1] :
 670                 res = self.getconcorde([uce])
 671                 for row in res :
 672                     ucetxt = ' ' + row[1] + ' '
 673                     uceid = row[0]
 674                 for hap in hucesdict[uce][1] :
 675                     laforme = self.getforme([forme for forme in self.lems[hap].formes][0]).forme
 676                     ucetxt = ucetxt.replace(' '+laforme+' ', ' <font color=red>'+laforme+'</font> ')
 677                 txt += '<p><b>' + ' '.join(self.getetbyuceid(uceid)) + '</b></p>'
 678                 txt += '<p>'+ucetxt+'</p>\n'
 679         txt += """
 680         </body></html>
 681         """
 682         with open('/tmp/testhapxuce.html','w') as f :
 683             f.write(txt)
 684
 685
 686 class MakeUciStat :
 687     def __init__(self, corpus) :
 688         ucinb = corpus.getucinb()
 689         ucisize = corpus.getucisize()
 690         ucimean = float(sum(ucisize))/float(ucinb)
 691         detoile = corpus.make_etoiles_dict()
 692
 693
 694 class Uci :
 695     def __init__(self, iduci, line, paraset = None) :
 696         self.ident = iduci
 697         self.etoiles = line.split()
 698         self.uces = []
 699         if paraset is not None :
 700             self.paras = paraset.split()
 701         else :
 702             self.paras = []
 703
 704 class Uce :
 705     def __init__(self, iduce, idpara, iduci) :
 706         self.ident = iduce
 707         self.para = idpara
 708         self.uci = iduci
 709
 710 class Word :
 711     def __init__(self, word, gramtype, idword, lem = None, freq = None) :
 712         self.forme = word
 713         self.lem = lem
 714         self.gram = gramtype
 715         self.ident = idword
 716         self.act = 1
 717         if freq is not None :
 718             self.freq = freq
 719         else :
 720             self.freq = 1
 721
 722 class Lem :
 723     def __init__(self, parent, forme) :
 724         self.formes = {forme.ident : forme.freq}
 725         self.gram = forme.gram
 726         self.freq = forme.freq
 727         self.act = forme.act
 728
 729     def add_forme(self, forme) :
 730         self.formes[forme.ident] = forme.freq
 731         self.freq += forme.freq
 732
 733 def decouperlist(chaine, longueur, longueurOptimale) :
 734     """
 735         on part du dernier caractère, et on recule jusqu'au début de la chaîne.
 736         Si on trouve un '$', c'est fini.
 737         Sinon, on cherche le meilleur candidat. C'est-à-dire le rapport poids/distance le plus important.
 738     """
 739     separateurs = [[u'.', 6.0], [u'?', 6.0], [u'!', 6.0], [u'£$£', 6.0], [u':', 5.0], [u';', 4.0], [u',', 1.0], [u' ', 0.01]]
 740     dsep = dict([[val[0],val[1]] for val in separateurs])
 741     trouve = False                 # si on a trouvé un bon séparateur
 742     iDecoupe = 0                # indice du caractere ou il faut decouper
 743
 744     longueur = min(longueur, len(chaine) - 1)
 745     chaineTravail = chaine[:longueur + 1]
 746     nbCar = longueur
 747     meilleur = ['', 0, 0]        # type, poids et position du meilleur separateur
 748
 749     try :
 750         indice = chaineTravail.index(u'$')
 751         trouve = True
 752         iDecoupe = indice - 1
 753     except ValueError :
 754         pass
 755     if not trouve:
 756         while nbCar >= 0:
 757             caractere = chaineTravail[nbCar]
 758             distance = abs(longueurOptimale - nbCar) + 1
 759             meilleureDistance = abs(longueurOptimale - meilleur[2]) + 1
 760             if caractere in dsep :
 761                 if (float(dsep[caractere]) / distance) > (float(meilleur[1]) / meilleureDistance) :
 762                     meilleur[0] = caractere
 763                     meilleur[1] = dsep[caractere]
 764                     meilleur[2] = nbCar
 765                     trouve = True
 766                     iDecoupe = nbCar
 767             else :
 768                 if (float(dsep[' ']) / distance) > (float(meilleur[1]) / meilleureDistance) :
 769                     meilleur[0] = ' '
 770                     meilleur[1] = dsep[' ']
 771                     meilleur[2] = nbCar
 772                     trouve = True
 773                     iDecoupe = nbCar
 774             nbCar = nbCar - 1
 775     # si on a trouvé
 776     if trouve:
 777         #if meilleur[0] != ' ' :
 778         #    fin = chaine[iDecoupe + 1:]
 779         #    retour = chaineTravail[:iDecoupe]
 780         #else :
 781         fin = chaine[iDecoupe + 1:]
 782         retour = chaineTravail[:iDecoupe + 1]
 783         return len(retour) > 0, retour, fin
 784     # si on a rien trouvé
 785     return False, chaine, ''
 786
 787 def testetoile(line) :
 788     return line.startswith(u'****')
 789
 790 def testint(line) :
 791     return line[0:4].isdigit() and u'*' in line
 792
 793 def prep_txtlist(txt) :
 794     return txt.split() + [u'$']
 795
 796 def prep_txtcharact(txt) :
 797     return txt + u'$'
 798
 799 class BuildCorpus :
 800     """
 801     Class for building a corpus
 802     """
 803     def __init__(self, infile, parametres_corpus, lexique = None, expressions = None, dlg = None) :
 804         log.info('begin building corpus...')
 805         self.lexique = lexique
 806         self.expressions = expressions
 807         self.dlg = dlg
 808         self.corpus = Corpus(self, parametres_corpus)
 809         self.infile = infile
 810         self.last = 0
 811         self.lim = parametres_corpus.get('lim', 1000000)
 812         self.encoding = parametres_corpus['encoding']
 813         self.corpus.pathout = PathOut(filename = parametres_corpus['originalpath'], dirout = parametres_corpus['pathout'])
 814         self.corpus.pathout.createdir(parametres_corpus['pathout'])
 815         self.corpus.parametres['uuid'] = str(uuid4())
 816         self.corpus.parametres['corpus_name'] = os.path.split(self.corpus.parametres['pathout'])[1]
 817         self.corpus.parametres['type'] = 'corpus'
 818         if self.corpus.parametres['keep_ponct'] :
 819             self.ponctuation_espace = [' ', '']
 820         else :
 821             self.ponctuation_espace =  [' ','.', u'£$£', ';', '?', '!', ',', ':','']
 822         self.cleans = []
 823         self.tolist = self.corpus.parametres.get('tolist', 0)
 824         self.buildcleans()
 825         self.prep_makeuce()
 826         #create database
 827         self.connect()
 828         self.dobuild()
 829
 830     def prep_makeuce(self) :
 831         method = self.corpus.parametres.get('ucemethod', 0)
 832         if method == 1 :
 833             self.decouper = decouperlist
 834             self.prep_txt = prep_txtlist
 835             self.ucesize = self.corpus.parametres.get('ucesize', 40)
 836         elif method == 0 :
 837             self.decouper = decoupercharact
 838             self.prep_txt = prep_txtcharact
 839             self.ucesize = self.corpus.parametres.get('ucesize', 240)
 840         log.info('method uce : %s' % method)
 841
 842     def dobuild(self) :
 843         t1 = time()
 844         try :
 845             self.read_corpus(self.infile)
 846         except Warning, args :
 847             log.info('pas kool %s' % args)
 848             raise Warning
 849         else :
 850             self.indexdb()
 851             self.corpus.parametres['ira'] = self.corpus.pathout['Corpus.cira']
 852             self.time = time() - t1
 853             self.dofinish()
 854             DoConf().makeoptions(['corpus'],[self.corpus.parametres], self.corpus.pathout['Corpus.cira'])
 855             log.info('time : %f' % (time() - t1))
 856
 857     def connect(self) :
 858         self.conn_f = sqlite3.connect(self.corpus.pathout['formes.db'])
 859         self.cf = self.conn_f.cursor()
 860         self.cf.execute('CREATE TABLE IF NOT EXISTS uces (id INTEGER, uces TEXT);')
 861         self.cf.execute('CREATE TABLE IF NOT EXISTS eff (id INTEGER, eff TEXT);')
 862         self.conn_f.commit()
 863         self.cf = self.conn_f.cursor()
 864         self.cf.execute('PRAGMA temp_store=MEMORY;')
 865         self.cf.execute('PRAGMA journal_mode=MEMORY;')
 866         self.cf.execute('PRAGMA  synchronous = OFF;')
 867         self.cf.execute('begin')
 868         self.conn = sqlite3.connect(self.corpus.pathout['uces.db'])
 869         self.c = self.conn.cursor()
 870         self.c.execute('CREATE TABLE IF NOT EXISTS uces (id INTEGER, uces TEXT);')
 871         self.conn.commit()
 872         self.c = self.conn.cursor()
 873         self.c.execute('PRAGMA temp_store=MEMORY;')
 874         self.c.execute('PRAGMA journal_mode=MEMORY;')
 875         self.c.execute('PRAGMA  synchronous = OFF;')
 876         self.c.execute('begin')
 877
 878     def indexdb(self) :
 879         #commit index and close db
 880         self.conn.commit()
 881         self.conn_f.commit()
 882         self.cf.execute('CREATE INDEX iduces ON uces (id);')
 883         self.cf.execute('CREATE INDEX ideff ON eff (id);')
 884         self.c.close()
 885         self.cf.close()
 886         #backup corpora
 887         self.conn_corpus = sqlite3.connect(self.corpus.pathout['corpus.db'])
 888         self.ccorpus = self.conn_corpus.cursor()
 889         self.ccorpus.execute('CREATE TABLE IF NOT EXISTS etoiles (uci INTEGER, et TEXT, paras TEXT);')
 890         self.ccorpus.execute('CREATE TABLE IF NOT EXISTS luces (uci INTEGER, para INTEGER, uce INTEGER);')
 891         self.ccorpus.execute('CREATE TABLE IF NOT EXISTS formes (ident INTEGER, forme TEXT, lem TEXT, gram TEXT, freq INTEGER);')
 892         self.conn_corpus.commit()
 893         self.ccorpus = self.conn_corpus.cursor()
 894         self.ccorpus.execute('PRAGMA temp_store=MEMORY;')
 895         self.ccorpus.execute('PRAGMA journal_mode=MEMORY;')
 896         self.ccorpus.execute('PRAGMA  synchronous = OFF;')
 897         self.ccorpus.execute('begin')
 898         self.backup_corpus()
 899         self.ccorpus.execute('CREATE INDEX iduci ON luces (uci);')
 900         self.conn_corpus.commit()
 901         self.conn_corpus.close()
 902         #self.corpus.parametres['corpus_ira'] = self.corpus.pathout['corpus.cira']
 903
 904     def buildcleans(self) :
 905         if self.corpus.parametres.get('lower', 1) :
 906             self.cleans.append(self.dolower)
 907         if self.corpus.parametres.get('firstclean', 1) :
 908             self.cleans.append(self.firstclean)
 909         self.rule = self.corpus.parametres.get('keep_caract', u"^a-zA-Z0-9àÀâÂäÄáÁéÉèÈêÊëËìÌîÎïÏòÒôÔöÖùÙûÛüÜçÇßœŒ’ñ.:,;!?*'_")
 910         self.cleans.append(self.docharact)
 911         if self.corpus.parametres.get('expressions', 1) :
 912             self.cleans.append(self.make_expression)
 913         if self.corpus.parametres.get('apos', 1) :
 914             self.cleans.append(self.doapos)
 915         if self.corpus.parametres.get('tiret', 1):
 916             self.cleans.append(self.dotiret)
 917
 918     def make_expression(self,txt) :
 919          for expression in self.expressions:
 920             if expression in txt :
 921                 txt = txt.replace(expression, self.expressions[expression][0])
 922          return txt
 923
 924     def dolower(self, txt) :
 925         return txt.lower()
 926
 927     def docharact(self, txt) :
 928         #rule = u"^a-zA-Z0-9àÀâÂäÄáÁéÉèÈêÊëËìÌîÎïÏòÒôÔöÖùÙûÛüÜçÇßœŒ’ñ.:,;!?*'_-"
 929         list_keep = u"[" + self.rule + "]+"
 930         return re.sub(list_keep, ' ', txt)
 931
 932     def doapos(self, txt) :
 933         return txt.replace(u'\'', u' ')
 934
 935     def dotiret(self, txt) :
 936         return txt.replace(u'-', u' ')
 937
 938     def firstclean(self, txt) :
 939         txt = txt.replace(u'’',"'")
 940         txt = txt.replace(u'œ', u'oe')
 941         return txt.replace('...',u' £$£ ').replace('?',' ? ').replace('.',' . ').replace('!', ' ! ').replace(',',' , ').replace(';', ' ; ').replace(':',' : ').replace(u'…', ' £$£ ')
 942
 943     def make_cleans(self, txt) :
 944         for clean in self.cleans :
 945             txt = clean(txt)
 946         return txt
 947
 948     def backup_uce(self) :
 949         if self.corpus.idformesuces != {} :
 950             log.info('backup %i' % len(self.corpus.idformesuces))
 951             touce = [(`forme`, ' '.join([`val` for val in  self.corpus.idformesuces[forme].keys()])) for forme in self.corpus.idformesuces]
 952             toeff = [(`forme`, ' '.join([`val` for val in  self.corpus.idformesuces[forme].values()])) for forme in self.corpus.idformesuces]
 953             self.cf.executemany('INSERT INTO uces VALUES (?,?);', touce)
 954             self.cf.executemany('INSERT INTO eff VALUES (?,?);', toeff)
 955         self.corpus.idformesuces = {}
 956         self.count = 1
 957
 958     def backup_corpus(self) :
 959         log.info('start backup corpus')
 960         t = time()
 961         for uci in self.corpus.ucis :
 962             self.ccorpus.execute('INSERT INTO etoiles VALUES (?,?,?);' ,(uci.ident,' '.join(uci.etoiles), ' '.join(uci.paras,)))
 963             for uce in uci.uces :
 964                 self.ccorpus.execute('INSERT INTO luces VALUES (?,?,?);',(`uci.ident`,`uce.para`,`uce.ident`,))
 965         for forme in self.corpus.formes :
 966             self.ccorpus.execute('INSERT INTO formes VALUES (?,?,?,?,?);', (`self.corpus.formes[forme].ident`, forme, self.corpus.formes[forme].lem, self.corpus.formes[forme].gram, `self.corpus.formes[forme].freq`,))
 967         log.info('%f' % (time() - t))
 968
 969     def dofinish(self) :
 970         self.corpus.parametres['date'] = datetime.datetime.now().ctime()
 971         minutes, seconds = divmod(self.time, 60)
 972         hours, minutes = divmod(minutes, 60)
 973         self.corpus.parametres['time'] = '%.0fh %.0fm %.0fs' % (hours, minutes, seconds)
 974         self.corpus.parametres['ucinb'] = self.corpus.getucinb()
 975         self.corpus.parametres['ucenb'] = self.corpus.getucenb()
 976         self.corpus.parametres['occurrences'] = self.corpus.gettotocc()
 977         self.corpus.parametres['formesnb'] = len(self.corpus.formes)
 978         hapaxnb = self.corpus.gethapaxnb()
 979         pourhapaxf = (float(hapaxnb) / len(self.corpus.formes)) * 100
 980         pourhapaxocc = (float(hapaxnb) / self.corpus.parametres['occurrences']) * 100
 981         self.corpus.parametres['hapax'] = '%i - %.2f %% des formes - %.2f %% des occurrences' % (hapaxnb, pourhapaxf, pourhapaxocc)
 982
 983
 984 class BuildFromAlceste(BuildCorpus) :
 985     #def __init___(self, infile, parametres_corpus) :
 986     #    BuildCorpus.__init__(self, infile, parametres_corpus)
 987
 988
 989     def read_corpus(self, infile) :
 990         self.limitshow = 0
 991         self.count = 1
 992         if self.corpus.parametres['ucimark'] == 0 :
 993             self.testuci = testetoile
 994         elif  self.corpus.parametres['ucimark'] == 1 :
 995             self.testuci = testint
 996         txt = []
 997         iduci = -1
 998         idpara = -1
 999         iduce = -1
1000         linenb = 0
1001         try :
1002             with codecs.open(infile, 'r', self.encoding) as f :
1003                 for line in f :
1004                     linenb += 1
1005                     line = line.rstrip('\n\r')
1006                     if self.testuci(line) :
1007                         iduci += 1
1008                         if txt != [] :
1009                             iduce, idpara = self.treattxt(txt, iduce, idpara, iduci - 1)
1010                             txt = []
1011                             self.corpus.ucis.append(Uci(iduci, line))
1012                         else :
1013                             if iduci > 0 :
1014                                 if self.corpus.ucis[-1].uces == [] :
1015                                     log.info('linenb : %i' % linenb)
1016                                     raise Exception("EmptyText %i" % linenb)
1017                             self.corpus.ucis.append(Uci(iduci, line))
1018                     elif line.startswith(u'-*') :
1019                         if iduci != -1 :
1020                             if txt != [] :
1021                                 iduce, idpara = self.treattxt(txt, iduce, idpara, iduci)
1022                                 txt = []
1023                             idpara += 1
1024                             self.corpus.ucis[-1].paras.append(line.split()[0])
1025                         else :
1026                             raise Exception('paragrapheOT')
1027                     elif line.strip() != '' and iduci != -1 :
1028                         txt.append(line)
1029             if txt != [] and iduci != -1 :
1030                 iduce, idpara = self.treattxt(txt, iduce, idpara, iduci)
1031                 del(txt)
1032             else :
1033                 raise Exception("EmptyText")
1034             if iduci != -1  and iduce != -1:
1035                 self.backup_uce()
1036             else :
1037                 log.info(_(u"No Texte in corpora. Are you sure of the formatting ?"))
1038                 raise Exception('TextBeforeTextMark')
1039         except UnicodeDecodeError :
1040             raise Exception("CorpusEncoding")
1041
1042     def treattxt(self, txt, iduce, idpara, iduci) :
1043         if self.corpus.parametres.get('ucemethod', 0) == 2 and self.corpus.parametres['douce']:
1044             txt = 'laphrasepoursplitter'.join(txt)
1045             txt = self.make_cleans(txt)
1046             txt = ' '.join([val for val in txt.split() if val not in self.ponctuation_espace])
1047             ucetxt = txt.split('laphrasepoursplitter')
1048         else :
1049             txt = ' '.join(txt)
1050             txt = self.make_cleans(txt)
1051             ucetxt = self.make_uces(txt, self.corpus.parametres['douce'])
1052         if self.corpus.ucis[-1].paras == [] :
1053             idpara += 1
1054         for uce in ucetxt :
1055             iduce += 1
1056             self.corpus.ucis[-1].uces.append(Uce(iduce, idpara, iduci))
1057             self.c.execute('INSERT INTO uces VALUES(?,?);', (`iduce`,uce))
1058             if not self.tolist :
1059                 uce = uce.split()
1060             else :
1061                 uce = list(uce)
1062             for word in uce :
1063                 self.last += 1
1064                 self.corpus.add_word(word)
1065         if self.dlg is not None :
1066             if self.limitshow > self.count :
1067                 self.dlg.Pulse('uci: %i - uce : %i' % (iduci + 1, iduce +1))
1068                 self.count += 1
1069                 self.limitshow = 0
1070             else :
1071                 self.limitshow = self.last / 100000
1072         log.debug(' '.join([`iduci`,`idpara`,`iduce`]))
1073         if self.last > self.lim :
1074             self.backup_uce()
1075             self.last = 0
1076         return iduce, idpara
1077
1078     def make_uces(self, txt, douce = True, keep_ponct = False) :
1079         txt = ' '.join(txt.split())
1080         if douce :
1081             out = []
1082             reste, texte_uce, suite = self.decouper(self.prep_txt(txt), self.ucesize + 15, self.ucesize)
1083 #            print 'reste'
1084 #            print reste
1085 #            print 'texte_uce'
1086 #            print texte_uce
1087 #            print 'suite'
1088 #            print suite
1089             while reste :
1090                 uce = ' '.join([val for val in texte_uce if val not in self.ponctuation_espace])
1091                 if uce != '' :
1092                     out.append(uce)
1093                 reste, texte_uce, suite = self.decouper(suite, self.ucesize + 15, self.ucesize)
1094 #                print 'reste'
1095 #                print reste
1096 #                print 'texte_uce'
1097 #                print texte_uce
1098 #                print 'suite'
1099 #                print suite
1100
1101             uce = ' '.join([val for val in texte_uce if val not in self.ponctuation_espace])
1102             if uce != '' :
1103                 #print 'RESTEE UUCEEEEEEEEEEEEE', uce
1104                 out.append(uce)
1105             return out
1106         else :
1107             return [' '.join([val for val in txt.split() if val not in self.ponctuation_espace])]
1108
1109 #decouper (list_sep)
1110 #make_uces (decouper)
1111 #treat_txt (make_uces)
1112 #read (treat_txt)
1113
1114 class Builder :
1115     def __init__(self, parent, dlg = None) :
1116         self.parent = parent
1117         self.dlg = dlg
1118         parametres = DoConf(os.path.join(self.parent.UserConfigPath,'corpus.cfg')).getoptions('corpus')
1119         parametres['pathout'] = PathOut(parent.filename, 'corpus').mkdirout()
1120         dial = CorpusPref(parent, parametres)
1121         dial.CenterOnParent()
1122         dial.txtpath.SetLabel(parent.filename)
1123         #dial.repout_choices.SetValue(parametres['pathout'])
1124         self.res = dial.ShowModal()
1125         if self.res == 5100 :
1126             parametres = dial.doparametres()
1127             parametres['originalpath'] = parent.filename
1128             PathOut().createdir(parametres['pathout'])
1129             ReadLexique(self.parent, lang = parametres['lang'])
1130             self.parent.expressions = ReadDicoAsDico(self.parent.DictPath.get(parametres['lang']+'_exp', 'french_exp'))
1131             self.parametres = parametres
1132         dial.Destroy()
1133
1134     def doanalyse(self) :
1135         return BuildFromAlceste(self.parent.filename, self.parametres, self.parent.lexique, self.parent.expressions, dlg = self.dlg).corpus
1136
1137
1138 if __name__ == '__main__' :
1139     t1 = time()
1140     parametres = {'formesdb':'formes.db', 'ucesdb': 'uces.db', 'corpusdb' : 'corpus.db', 'syscoding' : 'utf-8', 'encoding' : encoding}
1141     intro = BuildCorpus(infile, parametres)#, tar_in, tar_infouce)#, tar_formes)
1142     print time() - t1