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

   1 # -*- coding: utf-8 -*-
   2 #Author: Pierre Ratinaud
   3 #Copyright (c) 2010 Pierre Ratinaud
   4 #Lisense: GNU/GPL
   5
   6 import codecs
   7 import sys
   8 import xlrd
   9 import ooolib
  10 import os
  11 import tempfile
  12 import re
  13 import htmlentitydefs
  14 import shelve
  15 from uuid import uuid4
  16 import logging
  17
  18 log = logging.getLogger('iramuteq.tableau')
  19
  20 ##
  21 # Removes HTML or XML character references and entities from a text string.
  22 #
  23 # @param text The HTML (or XML) source text.
  24 # @return The plain text, as a Unicode string, if necessary.
  25
  26 def unescape(text):
  27     def fixup(m):
  28         #apos is not in the dictionnary
  29         htmlentitydefs.name2codepoint['apos'] = ord("'")
  30         text = m.group(0)
  31         if text[:2] == "&#":
  32             # character reference
  33             try:
  34                 if text[:3] == "&#x":
  35                     return unichr(int(text[3:-1], 16))
  36                 else:
  37                     return unichr(int(text[2:-1]))
  38             except ValueError:
  39                 pass
  40         else:
  41             try:
  42                 text = unichr(htmlentitydefs.name2codepoint[text[1:-1]])
  43             except KeyError:
  44                 pass
  45         return text # leave as is
  46     return re.sub("&#?\w+;", fixup, text)
  47
  48 def UpdateDico(Dico, word, line):
  49     if word in Dico :
  50         Dico[word][0] += 1
  51         Dico[word][1].append(line)
  52     else:
  53         Dico[word] = [1, [line]]
  54
  55 class Tableau() :
  56     def __init__(self, parent, filename = '', filetype = 'csv', encodage = 'utf-8') :
  57         self.parent = parent
  58         self.parametre = {'filename' : filename}
  59         self.parametre['filetype'] = filetype
  60         self.parametre['encodage'] = encodage
  61         self.parametre['pathout'] = os.path.dirname(os.path.abspath(filename))
  62         self.parametre['mineff'] = 3
  63         self.parametre['syscoding'] = sys.getdefaultencoding()
  64         self.parametre['type'] = 'matrix'
  65         self.parametre['name'] = 'unNOm'
  66         self.sups = {}
  67         self.actives = {}
  68         self.listactives = None
  69         self.content = []
  70         self.linecontent = []
  71         self.isbinary = False
  72         self.binary = []
  73         self.firstrowiscolnames = True
  74         self.colnames = []
  75         self.firstcolisrownames = True
  76         self.rownames = []
  77         self.colnb = 0
  78         self.rownb = 0
  79         self.classes = []
  80         self.parametres = self.parametre
  81
  82     def read_tableau(self, fileout) :
  83         d=shelve.open(fileout)
  84         self.parametre = d['parametre']
  85         if 'syscoding' not in self.parametre :
  86             self.parametre['syscoding'] = sys.getdefaultencoding()
  87         self.actives = d['actives']
  88         self.sups = d['sups']
  89         self.classes = d['classes']
  90         self.listactives = d['listactives']
  91         if 'listet' in d :
  92             self.listet = d['listet']
  93         if 'selected_col' in d :
  94             self.selected_col = d['selected_col']
  95         if 'datas' in d :
  96             self.datas = d['datas']
  97         if 'lchi' in d :
  98             self.lchi = d['lchi']
  99         d.close()
 100
 101     def save_tableau(self, fileout) :
 102         d=shelve.open(fileout)
 103         d['parametre'] = self.parametre
 104         d['actives'] = self.actives
 105         d['sups'] = self.sups
 106         d['classes'] = self.classes
 107         d['listactives'] = self.listactives
 108         if 'listet' in dir(self) :
 109             d['listet'] = self.listet
 110         if 'selected_col' in dir(self) :
 111             d['selected_col'] = self.selected_col
 112         if 'datas' in dir(self) :
 113             d['datas'] = self.datas
 114         if 'lchi' in dir(self) :
 115             d['lchi'] = self.lchi
 116         d.close()
 117
 118     def make_content(self) :
 119         if self.parametre['filetype'] == 'csv' :
 120             self.read_csv()
 121         elif self.parametre['filetype'] == 'xls' :
 122             self.read_xls()
 123         elif self.parametre['filetype'] == 'ods' :
 124             self.read_ods()
 125         self.parametre['csvfile'] = tempfile.mktemp(dir=self.parent.TEMPDIR)
 126         self.make_tmpfile()
 127
 128     def read_xls(self) :
 129         #FIXME : encodage
 130         #print '############## ENCODING IN EXCEL #######################'
 131         #datafile = xlrd.open_workbook(self.parametre['filename'], encoding_override="azerazerazer")
 132         datafile = xlrd.open_workbook(self.parametre['filename'])
 133         datatable = datafile.sheet_by_index(self.parametre['sheetnb']-1)
 134         self.linecontent = [[str(datatable.cell_value(rowx = i, colx = j)) for j in range(datatable.ncols)] for i in range(datatable.nrows)]
 135
 136     def read_ods(self) :
 137         doc = ooolib.Calc(opendoc=self.parametre['filename'])
 138         doc.set_sheet_index(0)
 139         (cols, rows) = doc.get_sheet_dimensions()
 140         print cols, rows
 141         for row in range(1, rows + 1):
 142             ligne = []
 143             for col in range(1, cols + 1):
 144                 data = doc.get_cell_value(col, row)
 145                 if data is not None :
 146                     ligne.append(unescape(data[1]))
 147                 else :
 148                     ligne.append('')
 149             self.linecontent.append(ligne)
 150
 151     def read_csv(self) :
 152         with codecs.open(self.parametre['filename'], 'r', self.parametre['encodage']) as f :
 153             content = f.read()
 154         self.linecontent = [line.replace('"','').split(self.parametre['colsep']) for line in content.splitlines()]
 155
 156     def write_csvfile(self) :
 157         with open(self.parametre['csvfile'], 'w') as f :
 158             f.write('\n'.join([';'.join(line) for line in self.csvtable]))
 159
 160     def make_tmpfile(self) :
 161         self.rownb = len(self.linecontent)
 162         self.colnb = len(self.linecontent[0])
 163         if self.firstrowiscolnames :
 164             self.colnames = self.linecontent[0]
 165             self.linecontent.pop(0)
 166             self.rownb -= 1
 167         else :
 168             self.colnames = ['_'.join([u'colonne', `i`]) for i in range(self.colnb)]
 169         if self.firstcolisrownames :
 170             self.rownames = [row[0] for row in self.linecontent]
 171             self.linecontent = [row[1:] for row in self.linecontent]
 172             self.colnb -= 1
 173             self.idname = self.colnames[0]
 174             self.colnames.pop(0)
 175             self.check_rownames()
 176         else :
 177             self.rownames = [`i` for i in range(self.rownb)]
 178             self.idname = u'identifiant'
 179         self.csvtable = [[self.idname] + self.colnames] + [[self.rownames[i]] + self.linecontent[i] for i in range(len(self.rownames))]
 180         self.write_csvfile()
 181
 182     def show_tab(self) :
 183         self.parent.content = self.csvtable
 184         self.parent.ShowMenu(_("View"))
 185         self.parent.ShowMenu(_("Spreadsheet analysis"))
 186         self.parent.ShowMenu(_("Text analysis"), False)
 187         self.parent.type = "Data"
 188         self.parent.DataPop = False
 189         self.parent.OnViewData('')
 190
 191     def check_rownames(self) :
 192         if len(self.rownames) == len(list(set(self.rownames))) :
 193             print u'row names ok'
 194         else :
 195             print u'les noms de lignes ne sont pas uniques, ils sont remplaces'
 196             self.rownames = [`i` for i in range(self.rownb)]
 197
 198     def make_unique_list(self) :
 199         return list(set([val for line in self.linecontent for val in line if val.strip() != '']))
 200
 201     def make_dico(self, linecontent) :
 202         dico = {}
 203         for i, line in enumerate(linecontent) :
 204             for forme in line:
 205                 if forme.strip() != '' :
 206                     UpdateDico(dico, forme, i)
 207         return dico
 208
 209     def select_col(self, listcol) :
 210         dc = dict(zip(listcol, listcol))
 211         selcol = [[val for i, val in enumerate(row) if i in dc] for row in self.linecontent]
 212         return selcol
 213
 214     def write01(self, fileout, dico, linecontent) :
 215         self.listactives = [val for val in dico if val != 'NA' and dico[val] >= self.parametre['mineff']]
 216         out = [['0' for forme in self.listactives] for line in linecontent]
 217         for i, forme in enumerate(self.listactives) :
 218             for line in dico[forme][1] :
 219                 out[line][i] = '1'
 220         #out = [[self.rownames[i]] + out[i] for i in range(len(linecontent))]
 221         #out.insert(0,[self.idname] + self.listactives)
 222         out.insert(0, self.listactives)
 223         with open(fileout, 'w') as f :
 224             f.write('\n'.join([';'.join(line) for line in out]))
 225
 226     def make_01_from_selection(self, listact, listsup = None, dowrite = True) :
 227         selcol = self.select_col(listact)
 228         self.actives = self.make_dico(selcol)
 229         self.write01(self.dictpathout['mat01'], self.actives, selcol)
 230         if listsup is not None :
 231             selcol = self.select_col(listsup)
 232             self.sups = self.make_dico(selcol)
 233
 234     def make_01_alc_format(self, fileout) :
 235         for i, ligne in enumerate(self.linecontent) :
 236             for forme in ligne:
 237                 if len(forme) >= 1:
 238                     if forme[0] == u'*':
 239                         UpdateDico(self.sups, forme, i)
 240                     else:
 241                         UpdateDico(self.actives, forme, i)
 242         self.listactives = [val for val in self.actives if self.actives[val][0] >= self.parametre['mineff']]
 243         table = [['0' for i in range(len(self.listactives))] for j in range(self.rownb)]
 244         for i, val in enumerate(self.listactives) :
 245             for j, line in enumerate(self.linecontent) :
 246                 if val in line :
 247                     table[j][i] = '1'
 248         #table = [[self.rownames[i]] + table[i] for i in range(len(self.rownames))]
 249         #table.insert(0, [self.idname] + self.listactives)
 250         table.insert(0, self.listactives)
 251         with open(fileout, 'w') as f:
 252             f.write('\n'.join([';'.join(line) for line in table]))
 253
 254     def printtable(self, filename, Table):
 255         with open(filename, 'w') as f :
 256             f.write('\n'.join([';'.join(line) for line in Table]))
 257
 258     def buildprofil(self) :
 259         with open(self.dictpathout['uce'], 'rU') as filein :
 260             content = filein.readlines()
 261         content.pop(0)
 262         lsucecl = []
 263         dicocl = {}
 264         for i, line in enumerate(content) :
 265             line = line.replace('\n', '').replace('"', '').split(';')
 266             UpdateDico(dicocl, line[1], i)
 267             lsucecl.append([int(line[0]) - 1, int(line[1])])
 268         self.classes = lsucecl
 269         nlist = [[nbuce, cl] for nbuce, cl in lsucecl if cl != 0]
 270         self.ucecla = len(nlist)
 271         if '0' in dicocl :
 272             self.clnb = len(dicocl) - 1
 273         else:
 274             self.clnb = len(dicocl)
 275
 276         tablecont = []
 277         for active in self.listactives :
 278             line = [active]
 279             line0 = [0] * self.clnb
 280             line += line0
 281             for i in range(0, self.clnb) :
 282                 for uce, cl in nlist:
 283                     if cl == i + 1 :
 284                         if active in self.linecontent[uce]:
 285                             line[i + 1] += 1
 286             if sum(line[1:]) > self.parametre['mineff']:
 287                 tablecont.append([line[0]] + [`don` for don in line if type(don) == type(1)])
 288
 289         tablecontet = []
 290         for sup in self.sups :
 291             line = [sup]
 292             line0 = [0] * self.clnb
 293             line += line0
 294             for i in range(0, self.clnb) :
 295                 for uce, cl in nlist:
 296                     if cl == i + 1 :
 297                         if sup in self.linecontent[uce]:
 298                             line[i + 1] += 1
 299             tablecontet.append([line[0]] + [`don` for don in line if type(don) == type(1)])
 300
 301         self.printtable(self.dictpathout['ContEtOut'], tablecontet)
 302         self.printtable(self.dictpathout['Contout'], tablecont)
 303
 304     def get_colnames(self) :
 305         return self.colnames[:]
 306
 307     def make_table_from_classe(self, cl, la) :
 308         ln = [line[0] for line in self.classes if line[1] == cl]
 309         out = [['0' for col in la] for line in ln]
 310         print self.actives
 311         for i, act in enumerate(la) :
 312             for j, line in enumerate(ln) :
 313                 if line in self.actives[act][1] :
 314                     out[j][i] = '1'
 315         out.insert(0,[act for act in la])
 316         return out
 317
 318
 319
 320 #filename = 'corpus/cent3.csv'
 321 #filename = 'corpus/agir2sortie.csv'
 322 #tab = Tableau('',filename, encodage='utf-8')
 323 #tab.parametre['csvfile'] = tab.parametre['filename']
 324 #tab.parametre['sep'] = '\t'
 325 #tab.firstrowiscolnames = True
 326 #tab.firstcolisrownames = False
 327 #tab.read_data()
 328 #tab.make_01('corpus/matrice01.csv')