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