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                     endet = '_'.join(et[1:])
 516                     if endet in det[et[0]] :
 517                         det[et[0]][endet] += 1
 518                     else :
 519                         det[et[0]][endet] = 1
 520                 except IndexError :
 521                     det[et[0]] += 1
 522             else :
 523                 try :
 524                     endet = '_'.join(et[1:])
 525                     det[et[0]] = {endet :1}
 526                 except IndexError :
 527                     det[et[0]] = 1
 528         print det
 529         return det
 530
 531     def make_and_write_profile_et(self, ucecl, fileout) :
 532         log.info('etoiles/classes')
 533         etoiles = self.make_etoiles()
 534         with open(fileout, 'w') as f :
 535             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']))
 536
 537     def make_colored_corpus(self) :
 538         ucecl = {}
 539         for i, lc in enumerate(self.lc) :
 540             for uce in lc :
 541                 ucecl[uce] = i + 1
 542         for uce in self.lc0 :
 543             ucecl[uce] = 0
 544         color = ['black'] + colors[len(self.lc) - 1]
 545         txt = '''<html>
 546         <meta http-equiv="content-Type" content="text/html; charset=%s" />
 547         <body>
 548 ''' % sys.getdefaultencoding()
 549         res = self.getalluces()
 550         self.make_iduces()
 551         actuci = ''
 552         actpara = False
 553         for uce in res :
 554             if self.iduces[uce[0]].uci != actuci :
 555                 actuci = self.iduces[uce[0]].uci
 556                 txt += '<br><hr>' + ' '.join(self.ucis[self.iduces[uce[0]].uci].etoiles) + '<br><br>'
 557                 txt += '<font color="%s">' % (color[ucecl[uce[0]]]) + uce[1] + '</font><br><br>'
 558             else :
 559                 txt += '<font color="%s">' % (color[ucecl[uce[0]]]) + uce[1] + '</font><br><br>'
 560         return txt + '\n</body></html>'
 561
 562     def count_from_list(self, l, d) :
 563         for val in l :
 564             if val in d :
 565                 d[val] += 1
 566             else :
 567                 d[val] = 1
 568         return d
 569
 570     def count_from_list_cl(self, l, d, a, clnb) :
 571         for val in l :
 572             if val in d :
 573                 d[val][a] += 1
 574             else :
 575                 d[val] = [0] * clnb
 576                 d[val][a] = 1
 577         return d
 578
 579     def find_segments(self, taille_segment, taille_limite) :
 580         d = {}
 581         for uce in self.getalluces() :
 582             uce = uce[1].split()
 583             d = self.count_from_list([' '.join(uce[i:i+taille_segment]) for i in range(len(uce)-(taille_segment - 1))], d)
 584         l = [[d[val], val] for val in d if d[val] >= 3]
 585         del(d)
 586         l.sort()
 587         if len(l) > taille_limite :
 588             l = l[-taille_limite:]
 589         return l
 590
 591     def find_segments_in_classe(self, list_uce, taille_segment, taille_limite):
 592         d={}
 593         for uce in self.getconcorde(list_uce) :
 594             uce = uce[1].split()
 595             d =self.count_from_list([' '.join(uce[i:i+taille_segment]) for i in range(len(uce)-(taille_segment - 1))], d)
 596         l = [[d[val], val, taille_segment] for val in d if d[val] >= 3]
 597         del(d)
 598         l.sort()
 599         if len(l) > taille_limite :
 600             l = l[-taille_limite:]
 601         return l
 602
 603     def make_segments_profile(self, fileout, lenmin = 3, lenmax = 10, effmin = 50, lem = False) :
 604         d = {}
 605         for b, classe in enumerate(self.lc) :
 606             for uce in self.getconcorde(classe) :
 607                 uce = uce[1].split()
 608                 if lem :
 609                     uce = [self.formes[forme].lem for forme in uce]
 610                 for taille_segment in range(lenmin,lenmax) :
 611                     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))
 612         result = [[seg] + [str(val) for val in d[seg]] for seg in d if sum(d[seg]) >= effmin]
 613         with open(fileout, 'w') as f :
 614             f.write('\n'.join([';'.join(line) for line in result]))
 615
 616     def make_ucecl_from_R(self, filein) :
 617         with open(filein, 'rU') as f :
 618             c = f.readlines()
 619         c.pop(0)
 620         self.lc = []
 621         for line in c :
 622             line = line.replace('\n', '').replace('"', '').split(';')
 623             self.lc.append([int(line[0]) - 1, int(line[1])])
 624         classesl = [val[1] for val in self.lc]
 625         clnb = max(classesl)
 626         self.lc = sorted(self.lc, key=itemgetter(1))
 627         self.lc = [[uce[0] for uce in self.lc if uce[1] == i] for i in range(clnb+1)]
 628         self.lc0 = self.lc.pop(0)
 629         #return ucecl
 630
 631     def gethapaxbyet(self, etoiles) :
 632         hapaxuces = [self.getlemuces(forme)[0] for forme in self.lems if self.lems[forme].freq == 1]
 633         hucesdict = {}
 634         for uce in hapaxuces :
 635             if uce in hucesdict :
 636                 hucesdict[uce] += 1
 637             else :
 638                 hucesdict[uce] = 1
 639         etuces = [[] for et in etoiles]
 640         for uci in self.ucis :
 641             get = list(set(uci.etoiles).intersection(etoiles))
 642             if len(get) > 1 :
 643                 return '2 variables sur la meme ligne'
 644             elif get != [] :
 645                 etuces[etoiles.index(get[0])] += [uce.ident for uce in uci.uces]
 646         etuces = [set(val) for val in etuces]
 647         return [sum([hucesdict[uce] for uce in list(etuce.intersection(hapaxuces))]) for etuce in etuces]
 648
 649     def gethapaxuces(self) :
 650         hapaxuces = [self.getlemuces(forme)[0] for forme in self.lems if self.lems[forme].freq == 1]
 651         hapax = [forme for forme in self.lems if self.lems[forme].freq == 1]
 652         hucesdict = {}
 653         for i,uce in enumerate(hapaxuces) :
 654             if uce in hucesdict :
 655                 hucesdict[uce][0] += 1
 656                 hucesdict[uce][1].append(hapax[i])
 657             else :
 658                 hucesdict[uce] = [1,[hapax[i]]]
 659         huces = {}
 660         for uce in hucesdict :
 661             if hucesdict[uce][0] in huces :
 662                 huces[hucesdict[uce][0]].append(uce)
 663             else :
 664                 huces[hucesdict[uce][0]] = [uce]
 665         huces = zip(huces, huces.values())
 666         huces.sort(reverse=True)
 667         txt = """
 668         <html><body>
 669         """
 670         for nb in huces[0:4] :
 671             txt += "<p><h2>%i hapax par uce</h2><p>\n" % nb[0]
 672             for uce in nb[1] :
 673                 res = self.getconcorde([uce])
 674                 for row in res :
 675                     ucetxt = ' ' + row[1] + ' '
 676                     uceid = row[0]
 677                 for hap in hucesdict[uce][1] :
 678                     laforme = self.getforme([forme for forme in self.lems[hap].formes][0]).forme
 679                     ucetxt = ucetxt.replace(' '+laforme+' ', ' <font color=red>'+laforme+'</font> ')
 680                 txt += '<p><b>' + ' '.join(self.getetbyuceid(uceid)) + '</b></p>'
 681                 txt += '<p>'+ucetxt+'</p>\n'
 682         txt += """
 683         </body></html>
 684         """
 685         with open('/tmp/testhapxuce.html','w') as f :
 686             f.write(txt)
 687
 688
 689 class MakeUciStat :
 690     def __init__(self, corpus) :
 691         ucinb = corpus.getucinb()
 692         ucisize = corpus.getucisize()
 693         ucimean = float(sum(ucisize))/float(ucinb)
 694         detoile = corpus.make_etoiles_dict()
 695
 696
 697 class Uci :
 698     def __init__(self, iduci, line, paraset = None) :
 699         self.ident = iduci
 700         self.etoiles = line.split()
 701         self.uces = []
 702         if paraset is not None :
 703             self.paras = paraset.split()
 704         else :
 705             self.paras = []
 706
 707 class Uce :
 708     def __init__(self, iduce, idpara, iduci) :
 709         self.ident = iduce
 710         self.para = idpara
 711         self.uci = iduci
 712
 713 class Word :
 714     def __init__(self, word, gramtype, idword, lem = None, freq = None) :
 715         self.forme = word
 716         self.lem = lem
 717         self.gram = gramtype
 718         self.ident = idword
 719         self.act = 1
 720         if freq is not None :
 721             self.freq = freq
 722         else :
 723             self.freq = 1
 724
 725 class Lem :
 726     def __init__(self, parent, forme) :
 727         self.formes = {forme.ident : forme.freq}
 728         self.gram = forme.gram
 729         self.freq = forme.freq
 730         self.act = forme.act
 731
 732     def add_forme(self, forme) :
 733         self.formes[forme.ident] = forme.freq
 734         self.freq += forme.freq
 735
 736 def decouperlist(chaine, longueur, longueurOptimale) :
 737     """
 738         on part du dernier caractère, et on recule jusqu'au début de la chaîne.
 739         Si on trouve un '$', c'est fini.
 740         Sinon, on cherche le meilleur candidat. C'est-à-dire le rapport poids/distance le plus important.
 741     """
 742     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]]
 743     dsep = dict([[val[0],val[1]] for val in separateurs])
 744     trouve = False                 # si on a trouvé un bon séparateur
 745     iDecoupe = 0                # indice du caractere ou il faut decouper
 746
 747     longueur = min(longueur, len(chaine) - 1)
 748     chaineTravail = chaine[:longueur + 1]
 749     nbCar = longueur
 750     meilleur = ['', 0, 0]        # type, poids et position du meilleur separateur
 751
 752     try :
 753         indice = chaineTravail.index(u'$')
 754         trouve = True
 755         iDecoupe = indice - 1
 756     except ValueError :
 757         pass
 758     if not trouve:
 759         while nbCar >= 0:
 760             caractere = chaineTravail[nbCar]
 761             distance = abs(longueurOptimale - nbCar) + 1
 762             meilleureDistance = abs(longueurOptimale - meilleur[2]) + 1
 763             if caractere in dsep :
 764                 if (float(dsep[caractere]) / distance) > (float(meilleur[1]) / meilleureDistance) :
 765                     meilleur[0] = caractere
 766                     meilleur[1] = dsep[caractere]
 767                     meilleur[2] = nbCar
 768                     trouve = True
 769                     iDecoupe = nbCar
 770             else :
 771                 if (float(dsep[' ']) / distance) > (float(meilleur[1]) / meilleureDistance) :
 772                     meilleur[0] = ' '
 773                     meilleur[1] = dsep[' ']
 774                     meilleur[2] = nbCar
 775                     trouve = True
 776                     iDecoupe = nbCar
 777             nbCar = nbCar - 1
 778     # si on a trouvé
 779     if trouve:
 780         #if meilleur[0] != ' ' :
 781         #    fin = chaine[iDecoupe + 1:]
 782         #    retour = chaineTravail[:iDecoupe]
 783         #else :
 784         fin = chaine[iDecoupe + 1:]
 785         retour = chaineTravail[:iDecoupe + 1]
 786         return len(retour) > 0, retour, fin
 787     # si on a rien trouvé
 788     return False, chaine, ''
 789
 790 def testetoile(line) :
 791     return line.startswith(u'****')
 792
 793 def testint(line) :
 794     return line[0:4].isdigit() and u'*' in line
 795
 796 def prep_txtlist(txt) :
 797     return txt.split() + [u'$']
 798
 799 def prep_txtcharact(txt) :
 800     return txt + u'$'
 801
 802 class BuildCorpus :
 803     """
 804     Class for building a corpus
 805     """
 806     def __init__(self, infile, parametres_corpus, lexique = None, expressions = None, dlg = None) :
 807         log.info('begin building corpus...')
 808         self.lexique = lexique
 809         self.expressions = expressions
 810         self.dlg = dlg
 811         self.corpus = Corpus(self, parametres_corpus)
 812         self.infile = infile
 813         self.last = 0
 814         self.lim = parametres_corpus.get('lim', 1000000)
 815         self.encoding = parametres_corpus['encoding']
 816         self.corpus.pathout = PathOut(filename = parametres_corpus['originalpath'], dirout = parametres_corpus['pathout'])
 817         self.corpus.pathout.createdir(parametres_corpus['pathout'])
 818         self.corpus.parametres['uuid'] = str(uuid4())
 819         self.corpus.parametres['corpus_name'] = os.path.split(self.corpus.parametres['pathout'])[1]
 820         self.corpus.parametres['type'] = 'corpus'
 821         if self.corpus.parametres['keep_ponct'] :
 822             self.ponctuation_espace = [' ', '']
 823         else :
 824             self.ponctuation_espace =  [' ','.', u'£$£', ';', '?', '!', ',', ':','']
 825         self.cleans = []
 826         self.tolist = self.corpus.parametres.get('tolist', 0)
 827         self.buildcleans()
 828         self.prep_makeuce()
 829         #create database
 830         self.connect()
 831         self.dobuild()
 832
 833     def prep_makeuce(self) :
 834         method = self.corpus.parametres.get('ucemethod', 0)
 835         if method == 1 :
 836             self.decouper = decouperlist
 837             self.prep_txt = prep_txtlist
 838             self.ucesize = self.corpus.parametres.get('ucesize', 40)
 839         elif method == 0 :
 840             self.decouper = decoupercharact
 841             self.prep_txt = prep_txtcharact
 842             self.ucesize = self.corpus.parametres.get('ucesize', 240)
 843         log.info('method uce : %s' % method)
 844
 845     def dobuild(self) :
 846         t1 = time()
 847         try :
 848             self.read_corpus(self.infile)
 849         except Warning, args :
 850             log.info('pas kool %s' % args)
 851             raise Warning
 852         else :
 853             self.indexdb()
 854             self.corpus.parametres['ira'] = self.corpus.pathout['Corpus.cira']
 855             self.time = time() - t1
 856             self.dofinish()
 857             DoConf().makeoptions(['corpus'],[self.corpus.parametres], self.corpus.pathout['Corpus.cira'])
 858             log.info('time : %f' % (time() - t1))
 859
 860     def connect(self) :
 861         self.conn_f = sqlite3.connect(self.corpus.pathout['formes.db'])
 862         self.cf = self.conn_f.cursor()
 863         self.cf.execute('CREATE TABLE IF NOT EXISTS uces (id INTEGER, uces TEXT);')
 864         self.cf.execute('CREATE TABLE IF NOT EXISTS eff (id INTEGER, eff TEXT);')
 865         self.conn_f.commit()
 866         self.cf = self.conn_f.cursor()
 867         self.cf.execute('PRAGMA temp_store=MEMORY;')
 868         self.cf.execute('PRAGMA journal_mode=MEMORY;')
 869         self.cf.execute('PRAGMA  synchronous = OFF;')
 870         self.cf.execute('begin')
 871         self.conn = sqlite3.connect(self.corpus.pathout['uces.db'])
 872         self.c = self.conn.cursor()
 873         self.c.execute('CREATE TABLE IF NOT EXISTS uces (id INTEGER, uces TEXT);')
 874         self.conn.commit()
 875         self.c = self.conn.cursor()
 876         self.c.execute('PRAGMA temp_store=MEMORY;')
 877         self.c.execute('PRAGMA journal_mode=MEMORY;')
 878         self.c.execute('PRAGMA  synchronous = OFF;')
 879         self.c.execute('begin')
 880
 881     def indexdb(self) :
 882         #commit index and close db
 883         self.conn.commit()
 884         self.conn_f.commit()
 885         self.cf.execute('CREATE INDEX iduces ON uces (id);')
 886         self.cf.execute('CREATE INDEX ideff ON eff (id);')
 887         self.c.close()
 888         self.cf.close()
 889         #backup corpora
 890         self.conn_corpus = sqlite3.connect(self.corpus.pathout['corpus.db'])
 891         self.ccorpus = self.conn_corpus.cursor()
 892         self.ccorpus.execute('CREATE TABLE IF NOT EXISTS etoiles (uci INTEGER, et TEXT, paras TEXT);')
 893         self.ccorpus.execute('CREATE TABLE IF NOT EXISTS luces (uci INTEGER, para INTEGER, uce INTEGER);')
 894         self.ccorpus.execute('CREATE TABLE IF NOT EXISTS formes (ident INTEGER, forme TEXT, lem TEXT, gram TEXT, freq INTEGER);')
 895         self.conn_corpus.commit()
 896         self.ccorpus = self.conn_corpus.cursor()
 897         self.ccorpus.execute('PRAGMA temp_store=MEMORY;')
 898         self.ccorpus.execute('PRAGMA journal_mode=MEMORY;')
 899         self.ccorpus.execute('PRAGMA  synchronous = OFF;')
 900         self.ccorpus.execute('begin')
 901         self.backup_corpus()
 902         self.ccorpus.execute('CREATE INDEX iduci ON luces (uci);')
 903         self.conn_corpus.commit()
 904         self.conn_corpus.close()
 905         #self.corpus.parametres['corpus_ira'] = self.corpus.pathout['corpus.cira']
 906
 907     def buildcleans(self) :
 908         if self.corpus.parametres.get('lower', 1) :
 909             self.cleans.append(self.dolower)
 910         if self.corpus.parametres.get('firstclean', 1) :
 911             self.cleans.append(self.firstclean)
 912         if self.corpus.parametres['charact'] :
 913             self.rule = self.corpus.parametres.get('keep_caract', u"^a-zA-Z0-9àÀâÂäÄáÁéÉèÈêÊëËìÌîÎïÏòÒôÔöÖùÙûÛüÜçÇßœŒ’ñ.:,;!?*'_")
 914             self.cleans.append(self.docharact)
 915         if self.corpus.parametres.get('expressions', 1) :
 916             self.cleans.append(self.make_expression)
 917         if self.corpus.parametres.get('apos', 1) :
 918             self.cleans.append(self.doapos)
 919         if self.corpus.parametres.get('tiret', 1):
 920             self.cleans.append(self.dotiret)
 921
 922     def make_expression(self,txt) :
 923          for expression in self.expressions:
 924             if expression in txt :
 925                 txt = txt.replace(expression, self.expressions[expression][0])
 926          return txt
 927
 928     def dolower(self, txt) :
 929         return txt.lower()
 930
 931     def docharact(self, txt) :
 932         #rule = u"^a-zA-Z0-9àÀâÂäÄáÁéÉèÈêÊëËìÌîÎïÏòÒôÔöÖùÙûÛüÜçÇßœŒ’ñ.:,;!?*'_-"
 933         list_keep = u"[" + self.rule + "]+"
 934         return re.sub(list_keep, ' ', txt)
 935
 936     def doapos(self, txt) :
 937         return txt.replace(u'\'', u' ')
 938
 939     def dotiret(self, txt) :
 940         return txt.replace(u'-', u' ')
 941
 942     def firstclean(self, txt) :
 943         txt = txt.replace(u'’',"'")
 944         txt = txt.replace(u'œ', u'oe')
 945         return txt.replace('...',u' £$£ ').replace('?',' ? ').replace('.',' . ').replace('!', ' ! ').replace(',',' , ').replace(';', ' ; ').replace(':',' : ').replace(u'…', ' £$£ ')
 946
 947     def make_cleans(self, txt) :
 948         for clean in self.cleans :
 949             txt = clean(txt)
 950         return txt
 951
 952     def backup_uce(self) :
 953         if self.corpus.idformesuces != {} :
 954             log.info('backup %i' % len(self.corpus.idformesuces))
 955             touce = [(`forme`, ' '.join([`val` for val in  self.corpus.idformesuces[forme].keys()])) for forme in self.corpus.idformesuces]
 956             toeff = [(`forme`, ' '.join([`val` for val in  self.corpus.idformesuces[forme].values()])) for forme in self.corpus.idformesuces]
 957             self.cf.executemany('INSERT INTO uces VALUES (?,?);', touce)
 958             self.cf.executemany('INSERT INTO eff VALUES (?,?);', toeff)
 959         self.corpus.idformesuces = {}
 960         self.count = 1
 961
 962     def backup_corpus(self) :
 963         log.info('start backup corpus')
 964         t = time()
 965         for uci in self.corpus.ucis :
 966             self.ccorpus.execute('INSERT INTO etoiles VALUES (?,?,?);' ,(uci.ident,' '.join(uci.etoiles), ' '.join(uci.paras,)))
 967             for uce in uci.uces :
 968                 self.ccorpus.execute('INSERT INTO luces VALUES (?,?,?);',(`uci.ident`,`uce.para`,`uce.ident`,))
 969         for forme in self.corpus.formes :
 970             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`,))
 971         log.info('%f' % (time() - t))
 972
 973     def dofinish(self) :
 974         self.corpus.parametres['date'] = datetime.datetime.now().ctime()
 975         minutes, seconds = divmod(self.time, 60)
 976         hours, minutes = divmod(minutes, 60)
 977         self.corpus.parametres['time'] = '%.0fh %.0fm %.0fs' % (hours, minutes, seconds)
 978         self.corpus.parametres['ucinb'] = self.corpus.getucinb()
 979         self.corpus.parametres['ucenb'] = self.corpus.getucenb()
 980         self.corpus.parametres['occurrences'] = self.corpus.gettotocc()
 981         self.corpus.parametres['formesnb'] = len(self.corpus.formes)
 982         hapaxnb = self.corpus.gethapaxnb()
 983         pourhapaxf = (float(hapaxnb) / len(self.corpus.formes)) * 100
 984         pourhapaxocc = (float(hapaxnb) / self.corpus.parametres['occurrences']) * 100
 985         self.corpus.parametres['hapax'] = '%i - %.2f %% des formes - %.2f %% des occurrences' % (hapaxnb, pourhapaxf, pourhapaxocc)
 986
 987
 988 class BuildFromAlceste(BuildCorpus) :
 989     #def __init___(self, infile, parametres_corpus) :
 990     #    BuildCorpus.__init__(self, infile, parametres_corpus)
 991
 992
 993     def read_corpus(self, infile) :
 994         self.limitshow = 0
 995         self.count = 1
 996         if self.corpus.parametres['ucimark'] == 0 :
 997             self.testuci = testetoile
 998         elif  self.corpus.parametres['ucimark'] == 1 :
 999             self.testuci = testint
1000         txt = []
1001         iduci = -1
1002         idpara = -1
1003         iduce = -1
1004         linenb = 0
1005         try :
1006             with codecs.open(infile, 'r', self.encoding) as f :
1007                 for line in f :
1008                     linenb += 1
1009                     line = line.rstrip('\n\r')
1010                     if self.testuci(line) :
1011                         iduci += 1
1012                         if txt != [] :
1013                             iduce, idpara = self.treattxt(txt, iduce, idpara, iduci - 1)
1014                             txt = []
1015                             self.corpus.ucis.append(Uci(iduci, line))
1016                         else :
1017                             if iduci > 0 :
1018                                 if self.corpus.ucis[-1].uces == [] :
1019                                     log.info('linenb : %i' % linenb)
1020                                     raise Exception("EmptyText %i" % linenb)
1021                             self.corpus.ucis.append(Uci(iduci, line))
1022                     elif line.startswith(u'-*') :
1023                         if iduci != -1 :
1024                             if txt != [] :
1025                                 iduce, idpara = self.treattxt(txt, iduce, idpara, iduci)
1026                                 txt = []
1027                             idpara += 1
1028                             self.corpus.ucis[-1].paras.append(line.split()[0])
1029                         else :
1030                             raise Exception('paragrapheOT')
1031                     elif line.strip() != '' and iduci != -1 :
1032                         txt.append(line)
1033             if txt != [] and iduci != -1 :
1034                 iduce, idpara = self.treattxt(txt, iduce, idpara, iduci)
1035                 del(txt)
1036             else :
1037                 raise Exception("EmptyText")
1038             if iduci != -1  and iduce != -1:
1039                 self.backup_uce()
1040             else :
1041                 log.info(_(u"No Texte in corpora. Are you sure of the formatting ?"))
1042                 raise Exception('TextBeforeTextMark')
1043         except UnicodeDecodeError :
1044             raise Exception("CorpusEncoding")
1045
1046     def treattxt(self, txt, iduce, idpara, iduci) :
1047         if self.corpus.parametres.get('ucemethod', 0) == 2 and self.corpus.parametres['douce']:
1048             txt = 'laphrasepoursplitter'.join(txt)
1049             txt = self.make_cleans(txt)
1050             txt = ' '.join([val for val in txt.split() if val not in self.ponctuation_espace])
1051             ucetxt = txt.split('laphrasepoursplitter')
1052         else :
1053             txt = ' '.join(txt)
1054
1055             print txt
1056             txt = self.make_cleans(txt)
1057
1058             print txt
1059             ucetxt = self.make_uces(txt, self.corpus.parametres['douce'])
1060         if self.corpus.ucis[-1].paras == [] :
1061             idpara += 1
1062         for uce in ucetxt :
1063             iduce += 1
1064             self.corpus.ucis[-1].uces.append(Uce(iduce, idpara, iduci))
1065             self.c.execute('INSERT INTO uces VALUES(?,?);', (`iduce`,uce))
1066             if not self.tolist :
1067                 uce = uce.split()
1068             else :
1069                 uce = list(uce)
1070             for word in uce :
1071                 self.last += 1
1072                 self.corpus.add_word(word)
1073         if self.dlg is not None :
1074             if self.limitshow > self.count :
1075                 self.dlg.Pulse('uci: %i - uce : %i' % (iduci + 1, iduce +1))
1076                 self.count += 1
1077                 self.limitshow = 0
1078             else :
1079                 self.limitshow = self.last / 100000
1080         log.debug(' '.join([`iduci`,`idpara`,`iduce`]))
1081         if self.last > self.lim :
1082             self.backup_uce()
1083             self.last = 0
1084         return iduce, idpara
1085
1086     def make_uces(self, txt, douce = True, keep_ponct = False) :
1087         txt = ' '.join(txt.split())
1088         if douce :
1089             out = []
1090             reste, texte_uce, suite = self.decouper(self.prep_txt(txt), self.ucesize + 15, self.ucesize)
1091 #            print 'reste'
1092 #            print reste
1093 #            print 'texte_uce'
1094 #            print texte_uce
1095 #            print 'suite'
1096 #            print suite
1097             while reste :
1098                 uce = ' '.join([val for val in texte_uce if val not in self.ponctuation_espace])
1099                 if uce != '' :
1100                     out.append(uce)
1101                 reste, texte_uce, suite = self.decouper(suite, self.ucesize + 15, self.ucesize)
1102 #                print 'reste'
1103 #                print reste
1104 #                print 'texte_uce'
1105 #                print texte_uce
1106 #                print 'suite'
1107 #                print suite
1108
1109             uce = ' '.join([val for val in texte_uce if val not in self.ponctuation_espace])
1110             if uce != '' :
1111                 #print 'RESTEE UUCEEEEEEEEEEEEE', uce
1112                 out.append(uce)
1113             return out
1114         else :
1115             return [' '.join([val for val in txt.split() if val not in self.ponctuation_espace])]
1116
1117 #decouper (list_sep)
1118 #make_uces (decouper)
1119 #treat_txt (make_uces)
1120 #read (treat_txt)
1121
1122 class Builder :
1123     def __init__(self, parent, dlg = None) :
1124         self.parent = parent
1125         self.dlg = dlg
1126         parametres = DoConf(os.path.join(self.parent.UserConfigPath,'corpus.cfg')).getoptions('corpus')
1127         parametres['pathout'] = PathOut(parent.filename, 'corpus').mkdirout()
1128         dial = CorpusPref(parent, parametres)
1129         dial.CenterOnParent()
1130         dial.txtpath.SetLabel(parent.filename)
1131         #dial.repout_choices.SetValue(parametres['pathout'])
1132         self.res = dial.ShowModal()
1133         if self.res == 5100 :
1134             parametres = dial.doparametres()
1135             parametres['originalpath'] = parent.filename
1136             PathOut().createdir(parametres['pathout'])
1137             ReadLexique(self.parent, lang = parametres['lang'])
1138             self.parent.expressions = ReadDicoAsDico(self.parent.DictPath.get(parametres['lang']+'_exp', 'french_exp'))
1139             self.parametres = parametres
1140         dial.Destroy()
1141
1142     def doanalyse(self) :
1143         return BuildFromAlceste(self.parent.filename, self.parametres, self.parent.lexique, self.parent.expressions, dlg = self.dlg).corpus
1144
1145
1146 if __name__ == '__main__' :
1147     t1 = time()
1148     parametres = {'formesdb':'formes.db', 'ucesdb': 'uces.db', 'corpusdb' : 'corpus.db', 'syscoding' : 'utf-8', 'encoding' : encoding}
1149     intro = BuildCorpus(infile, parametres)#, tar_in, tar_infouce)#, tar_formes)
1150     print time() - t1