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