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

   1 #!/bin/env python
   2 # -*- coding: utf-8 -*-
   3 #Author: Pierre Ratinaud
   4 #Copyright (c) 2010 Pierre Ratinaud
   5 #License: GNU/GPL
   6
   7 import os
   8 from optparse import OptionParser
   9 import sys
  10 reload(sys)
  11 import locale
  12 import codecs
  13 sys.setdefaultencoding(locale.getpreferredencoding())
  14 from chemins import ConstructConfigPath, ConstructDicoPath, ConstructRscriptsPath, PathOut
  15 from functions import ReadLexique, DoConf, History, ReadDicoAsDico
  16 from ConfigParser import *
  17 #######################################
  18 #from textchdalc import AnalyseAlceste
  19 #from textdist import PamTxt
  20 #from textafcuci import AfcUci
  21 from textreinert import Reinert
  22 from corpus import Corpus, copycorpus, BuildFromAlceste, BuildSubCorpus
  23 from textaslexico import Lexico
  24 from textstat import Stat
  25 from tools import SubCorpus
  26 from textsimi import SimiTxt
  27 import tempfile
  28 ######################################
  29 import logging
  30 log = logging.getLogger('iramuteq')
  31 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  32 ch = logging.StreamHandler()
  33 ch.setFormatter(formatter)
  34 log.addHandler(ch)
  35 log.setLevel(logging.DEBUG)
  36 #######################################
  37
  38
  39
  40 #cmd = iracmd.CmdLine(args=['-f','/home/pierre/workspace/iramuteq/corpus/lru2.txt','-t','alceste'])
  41
  42 AppliPath = os.path.abspath(os.path.dirname(os.path.realpath(sys.argv[0])))
  43 if os.getenv('HOME') != None:
  44     user_home = os.getenv('HOME')
  45 else:
  46     user_home = os.getenv('HOMEPATH')
  47 UserConfigPath = os.path.abspath(os.path.join(user_home, '.iramuteq'))
  48
  49 class CmdLine :
  50     def __init__(self, args = None, AppliPath = None, parametres = None) :
  51         AppliPath = AppliPath
  52         self.DictPath = ConstructDicoPath(AppliPath)
  53         self.ConfigPath = ConstructConfigPath(UserConfigPath)
  54         self.syscoding = sys.getdefaultencoding()
  55         self.TEMPDIR = tempfile.mkdtemp('iramuteq')
  56         self.RscriptsPath = ConstructRscriptsPath(AppliPath)
  57         self.PathPath = ConfigParser()
  58         self.PathPath.read(self.ConfigPath['path'])
  59         self.RPath = self.PathPath.get('PATHS', 'rpath')
  60         self.pref = RawConfigParser()
  61         self.pref.read(self.ConfigPath['preferences'])
  62         self.history = History(os.path.join(UserConfigPath, 'history.db'))
  63         print 'CLEAN HISTORY'
  64 #        self.history.clean()
  65
  66         parser = OptionParser()
  67
  68         parser.add_option("-f", "--file", dest="filename", help="chemin du corpus", metavar="FILE", default=False)
  69         parser.add_option("-t", "--type", dest="type_analyse", help="type d'analyse", metavar="TYPE D'ANALYSE", default=False)
  70         parser.add_option("-c", "--conf", dest="configfile", help="chemin du fichier de configuration pour l'analyse", metavar="CONF", default=None)
  71         parser.add_option("-d", "--confcorp", dest="corpusconfigfile", help="chemin du fichier de configuration pour le corpus", metavar="CONF", default=None)
  72         parser.add_option("-e", "--enc", dest="encodage", help="encodage du corpus", metavar="ENC", default=locale.getpreferredencoding())
  73         parser.add_option("-l", "--lang", dest="language", help="langue du corpus", metavar="LANG", default='french')
  74         parser.add_option("-r", "--read", dest="read", help="lire un corpus", metavar="READ", default = False)
  75         parser.add_option("-b", "--build", action="store_true", dest="build", help = "construire un corpus", default = False)
  76
  77         if args is None :
  78             (options, args) = parser.parse_args()
  79         else :
  80             (options, args) = parser.parse_args(args)
  81         print args
  82         print options
  83         options.type_analyse
  84         if options.configfile is not None:
  85             config = DoConf(os.path.abspath(options.configfile)).getoptions()
  86         elif options.filename and options.type_analyse :
  87             config = DoConf(self.ConfigPath[options.type_analyse]).getoptions()
  88         elif options.read and options.type_analyse :
  89             config = DoConf(self.ConfigPath[options.type_analyse]).getoptions()
  90         elif options.read :
  91             pass
  92         elif options.filename and options.build :
  93             pass
  94         else :
  95             print 'rien a faire'
  96             return
  97
  98         if options.filename or options.read :
  99             self.corpus_encodage = options.encodage
 100             self.corpus_lang = options.language
 101             self.keys = DoConf(self.ConfigPath['key']).getoptions()
 102
 103
 104             ReadLexique(self, lang = options.language)
 105             self.expressions = ReadDicoAsDico(self.DictPath.get(options.language + '_exp', 'french_exp'))
 106             gramact = [k for k in self.keys if self.keys[k] == 1]
 107             gramsup = [k for k in self.keys if self.keys[k] == 2]
 108
 109             if options.filename :
 110                 self.filename = os.path.abspath(options.filename)
 111                 if options.corpusconfigfile is not None :
 112                     corpus_parametres = DoConf(options.corpusconfigfile).getoptions('corpus')
 113                 else :
 114                     corpus_parametres = DoConf(self.ConfigPath['corpus']).getoptions()
 115                 dire, corpus_parametres['filename'] = os.path.split(self.filename)
 116                 corpus_parametres['originalpath'] = self.filename
 117                 corpus_parametres['encoding'] = self.corpus_encodage
 118                 corpus_parametres['syscoding'] = locale.getpreferredencoding()
 119                 corpus_parametres['pathout'] = PathOut(self.filename, 'corpus').mkdirout()
 120                 try :
 121                     corpus = BuildFromAlceste(self.filename, corpus_parametres, self.lexique, self.expressions).corpus
 122                 except Exception, txt:
 123                     log.info('probleme lors de la construction: %s' %txt)
 124                     corpus = None
 125                     raise
 126                 else :
 127                     self.history.add(corpus.parametres)
 128                     corpus = copycorpus(corpus)
 129             elif options.read :
 130                 corpus = Corpus(self, parametres = DoConf(options.read).getoptions('corpus'), read = options.read)
 131                 corpus.parametres['pathout'] = os.path.dirname(os.path.abspath(options.read))
 132                 pathout = os.path.dirname(os.path.dirname(os.path.abspath(options.read)))
 133                 self.corpus = corpus
 134                 print self.corpus
 135                 corpus.parametres['pathout'] = '/home/pierre/fac/etudiant/verdier/corpus20_corpus_2/test2'
 136                 BuildSubCorpus(corpus, parametres = {'fromthem' : True, 'theme' : [u'-*thématique_idéal']})
 137
 138             if corpus is not None :
 139                 corpus.conn_all()
 140                 #corpus = SubCorpus(self, corpus, [0,1,2,3,4,5,6,7])
 141                 #corpus.conn_all()
 142                 corpus.make_lems()
 143                 corpus.parse_active(gramact, gramsup)
 144                 #print corpus.getlemconcorde('de').fetchall()
 145 #            log.warning('ATTENTION gethapaxuces')
 146 #            MakeUciStat(corpus)
 147             #corpus.gethapaxuces()
 148              #   ucisize = corpus.getucisize()
 149              #   ucisize = [`val` for val in ucisize]
 150                 #uciet = [uci.etoiles[1:] for uci in corpus.ucis]
 151                 #uceet = [corpus.ucis[uce.uci].etoiles[1:] for uci in corpus.ucis for uce in uci.uces]
 152                 #print uceet[0:10]
 153                 #for line in uceet :
 154                 #    print '\t'.join(line)
 155                 #res = zip(uciet, ucisize)
 156              #   res = [uciet[i] + [ucisize[i]] for i, val in enumerate(uciet)]
 157              #   print res[0:10]
 158                 #ucesize = corpus.getucesize()
 159                 #print ucesize[0:40]
 160                 #with open('sentences_size.csv', 'w') as f :
 161                 #    f.write('\n'.join([`val`  for val in ucesize]))
 162                 #    self.content = f.read()
 163                 #self.content = self.content.replace('\r','')
 164                 if options.type_analyse == 'alceste' :
 165                     log.debug('ATTENTION : ANALYSE NG')
 166                         #print corpus.make_etoiles()
 167                         #zerzre
 168                     #corpus.read_corpus()
 169                     #corpus.parse_active(gramact, gramsup)
 170                     config['type'] = 'alceste'
 171                     self.Text = Reinert(self, corpus, parametres = config)
 172                 #    self.Text = AnalyseAlceste(self, cmd = True, big = True)
 173                     #self.Text = AnalyseAlceste(self, cmd = True)
 174                 elif options.type_analyse == 'pam' :
 175                     self.Text = PamTxt(self, cmd = True)
 176                 elif options.type_analyse == 'afcuci' :
 177                     self.Text = AfcUci(self, cmd = True)
 178                 elif options.type_analyse == 'stat' :
 179                     self.Text = Stat(self, corpus, parametres = {'type':'stat'})
 180                 elif options.type_analyse == 'spec' :
 181                     self.Text = Lexico(self, corpus, config = {'type' : 'spec'})
 182                 elif options.type_analyse == 'simitxt' :
 183                     self.Text = SimiTxt(self, corpus, parametres = parametres)
 184             #print self.Text.corpus.hours, 'h', self.Text.corpus.minutes,'min', self.Text.corpus.seconds, 's'
 185 #            self.Text.corpus.make_colored_corpus('colored.html')
 186
 187 if __name__ == '__main__':
 188     __name__ = 'Main'
 189     CmdLine(AppliPath = AppliPath)
 190