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