diff --git a/modules/c++/include/pyTradutor.h b/modules/c++/include/pyTradutor.h deleted file mode 100644 index f31ef7d..0000000 --- a/modules/c++/include/pyTradutor.h +++ /dev/null @@ -1,31 +0,0 @@ -/** - * @author Erickson Silva - * @date 14/10/2013 - * - */ - -#include "Python.h" -#include "dprintf.h" - -#ifndef _PYTRADUTOR_H -#define _PYTRADUTOR_H - -namespace Tradutor { - class PyTradutor{ - public: - PyTradutor(); - ~PyTradutor(); - char * convertStringToGlosa(const char * input); - PyObject * pName; - PyObject * pModule; - PyObject * pDict; - PyObject * pFunc; - PyObject * pArgs; - PyObject * pResult; - bool isRunning; - }; -} - -#endif - - diff --git a/modules/c++/pyTradutor.cpp b/modules/c++/pyTradutor.cpp deleted file mode 100644 index 3916aa3..0000000 --- a/modules/c++/pyTradutor.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/** - * Essa classe invoca os metodos do tradutor em Python - * Onde efetua a tradução do texto passado por parametro - * - * @author Erickson Silva - * @date 14/10/2013 - * - */ - - -#include "pyTradutor.h" - -namespace Tradutor { - PyTradutor::PyTradutor() { - DPRINTF("Done!\n"); - } - PyTradutor::~PyTradutor() { - Py_DECREF(pName); - Py_DECREF(pModule); - Py_DECREF(pDict); - Py_DECREF(pFunc); - Py_DECREF(pArgs); - Py_DECREF(pResult); - DDDPRINTF("PyTranslator finalized!\n"); - } - -/** -* Traduz um texto (char * input) para uma string contendo a -* traducao para glosa -* -* @param input texto de entrada -* @return string contendo os tokens em glosa traduzidos. -**/ - char * PyTradutor::convertStringToGlosa(const char * input) { - if(!isRunning){ - Py_Initialize(); - pName = PyString_FromString("ModuleTranslate"); - assert(pName!=NULL); - pModule = PyImport_Import(pName); - PyErr_Print(); - assert(pModule!=NULL); - pDict = PyModule_GetDict(pModule); - PyErr_Print(); - assert(pDict!=NULL); - pFunc = PyDict_GetItemString(pDict, "iniciar"); - PyErr_Print(); - assert(pFunc!=NULL); - isRunning = 1; - } - pArgs = PyTuple_Pack(1,PyString_FromString(input)); - PyErr_Print(); - assert(pArgs!=NULL); - pResult = PyObject_CallObject(pFunc, pArgs); - PyErr_Print(); - assert(pResult!=NULL); - return PyString_AsString(pResult); - } -} \ No newline at end of file diff --git a/modules/python/translate.py b/modules/python/translate.py deleted file mode 100644 index c9e72f7..0000000 --- a/modules/python/translate.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -from Tradutor import * - -tradutor = Tradutor() - -def iniciar(x): - try: - text = x.decode("utf-8") - except: - text = x.decode("iso-8859-1") - - return tradutor.traduzir(text) diff --git a/src/AplicaRegras.py b/src/AplicaRegras.py deleted file mode 100644 index 4897c99..0000000 --- a/src/AplicaRegras.py +++ /dev/null @@ -1,161 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva -#Email: - -#LAViD - Laboratório de Aplicações de Vídeo Digital - -from LeitorDicionarios import * -from Iterator import * -from StringAux import * - -class AplicaRegras(object): - - # inicializa todos as variaveis - def __init__(self): - self.__dicionarios = LeitorDicionarios() - - # retira artigos e preposicoes; passa verbos para infinitivo e verificar se há sinonimos - def simplificar(self, texto): - it = Iterator() - it.load(texto) - self.__ts = [] - self.__verb = False - self.__adv = False; - self.__countVerb = 0 - self.__countAdv = 0 - while(it.hasNext()): - token = it.getAtualW() - tag = it.getAtualT() - self.__b = False - if self.__dicionarios.hasPalavraIgnorada(tag) == False: # verifica se nao eh artigo/preposicao - - #VERIFICA SE É ADVERBIO E CONTA A QUANTIDADE - if tag[:3] == "ADV": - self.__adv = True - self.__countAdv += 1 - - if tag[:2] == "VB": - - #VERIFICA SE É VERBO NO INFINITIVO - if self.__dicionarios.hasVerboInfinitivo(token): # verifica se ha um verbo infinitivo desse token - verboInfinitivo = self.__dicionarios.getVerboInfinitivo(token) # se sim, adiciona numa string aux - self.__ts.append([verboInfinitivo,tag]) # caso contrario, adiciona so o verbo infinitivo msm - self.__b = True - - #VERIFICA SE É VERBO DE TEMPO E CONTA A QUANTIDADE - if tag == "VB-P" or tag == "VB-D" or tag == "VB-R": - self.__verb = True - self.__countVerb += 1 - - - #VERIFICA SE É SUBTANTIVO COMUM DOS 2 GENEROS - if self.__dicionarios.hasSubst2Genero(token): - #del self.__ts[-1] - lenTicket = len(it.getAntT()) - if ((self.__dicionarios.hasPalavraIgnorada(it.getAntT())) and (it.getAntT()[lenTicket-1:] == "F") or (it.getAntT()[lenTicket-3:] == "F-P")): - self.__ts.append(["MULHER ", "2GEN"]) - self.__ts.append([token,tag]) - else: - self.__ts.append(["HOMEM ", "2GEN"]) - self.__ts.append([token,tag]) - self.__b = True - - #VERIFICA SE É PLURAL - #if tag[-2:] == "-P": - # token = self.pluralAnalysis(token) - - #SE NÃO HOUVE NENHUM ALTERAÇÃO, OU SEJA, NÃO APLICOU NENHUMA REGRA, ADICIONA O TOKEN ORIGINAL - if self.__b == False: # verifica se nao encontrou nem verbo infinito ou sinonimo - self.__ts.append([token,tag]) - - #SE ENCONTROU VERBO, ENTÃO ANALISA a SENTENCA NOVAMENTE (again?) - if self.__verb == True: - return self.verbalAnalysis(self.__ts) - - return self.__ts - - - # converte romano para numero - def auxConvert(self, tag): - try: - return roman_to_int(tag) - except: - return tag - - def verbalAnalysis(self, lista): - lv = [] - it = Iterator() - it.load(lista) - hasFut = False - hasPas = False - count = 0 - while(it.hasNext()): - token = it.getAtualW().upper() - tag = it.getAtualT() - - if(tag[:3] == "ADV"): - if (self.__dicionarios.hasTempoVerbal(token)): - it.reset() - #print "ADV: retornou lista original" - return lista - - if(tag == "VB-P"): - if (self.__countVerb > 1): - count += 1 - #print "VB-P: Incrementou" - if(count == self.__countVerb): - #print "VB-P Adicionou " + token - lv.append([token,tag]) - else: - #print "VB-P: retornou lista original" - it.reset() - return lista - elif(tag == "VB-D"): - count += 1 - hasPas = True - #print "VB-D: Incrementou" - if(count == self.__countVerb): - #print "VB-D Adicionou " + token - lv.append([token,tag]) - elif(tag == "VB-R"): - count += 1 - hasFut = True - #print "VB-R: Incrementou" - if(count == self.__countVerb): - #print "VB-R Adicionou " + token - lv.append([token,tag]) - else: - lv.append([token,tag]) - if (hasFut): - lv.append(["FUTURO", "T-VB"]) - elif (hasPas): - lv.append(["PASSADO", "T-VB"]) - it.reset() - return lv - - - def pluralAnalysis(self, word): - - if(word[-3:] == "OES" or word[-2:] == "AES" or word[-2:] == "AOS"): - return word[0:-3]+"AO" - elif(word[-3:] == "RES" or word[-2:] == "ZES" or word[-2:] == "NES"): - return word[0:-2] - elif(word[-3:] == "SES"): - #TODO: Algumas palavras possuem marcações gráficas na raiz singular. Ex: Gás – Gases - return word[0:-2] - elif(word[-2:] == "NS"): - return word[0:-2]+"M" - elif(word[-3:] == "EIS"): - return word[0:-3]+"IL" - elif(word[-2:] == "IS"): - if(word[-3] == "A" or word[-3] == "E" or word[-3] == "O" or word[-3] == "U"): - return word[0:-2]+"L" - else: - return word - elif(word[-1] == "S"): - #TODO: Palavras paroxítonas ou proparoxítonas terminadas em S. Ex: lápis, vírus, tagênis, ônibus, etc - return word[0:-1] - else: - return word \ No newline at end of file diff --git a/src/AplicaSinonimos.py b/src/AplicaSinonimos.py deleted file mode 100644 index cf8e4f9..0000000 --- a/src/AplicaSinonimos.py +++ /dev/null @@ -1,48 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva -#Email: - -#LAViD - Laboratório de Aplicações de Vídeo Digital - -import os, csv, sys -from nltk.tree import * -from LeitorDicionarios import * - -class AplicaSinonimos(object): - - # Define e inicializa os atributos - def __init__(self): - self.__dicionarios = LeitorDicionarios() - - def sinonimosMorfologico(self, texto): - lista = texto - for i, elem in enumerate(lista): - token = self.verificaPalavra(elem[0]) - listmp = list(elem) - listmp[0] = token - lista[i] = listmp - return lista - - - def dicionarioSinonimoFolhas(self, folhas): - dic = {} - for f in folhas: - token = self.verificaPalavra(f) - dic[f] = token - return dic - - def sinonimosSintatico(self, texto): - folhas = Tree.leaves(texto) - dic = self.dicionarioSinonimoFolhas(folhas) - stringTree = str(texto) - for t in folhas: - stringTree.replace(t, dic[t]) - tree = Tree.fromstring(stringTree, brackets='()') - return tree - - def verificaPalavra(self, token): - if self.__dicionarios.hasSinonimo(token): - return self.__dicionarios.getSinonimo(token) - return token \ No newline at end of file diff --git a/src/AplicadorRegras.py b/src/AplicadorRegras.py new file mode 100644 index 0000000..8356ca9 --- /dev/null +++ b/src/AplicadorRegras.py @@ -0,0 +1,60 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva + +import xml.etree.ElementTree as ET +import os + +class AplicadorRegras(object): + + # inicializacao das variaves + def __init__(self): + self.__tree = ET.parse('vlibras_user/vlibras-core/data/regras.xml') + self.__root = self.__tree.getroot() + self.__tAux = [] + self.__dAux = {} + + # aplica as regras + def aplicarRegras(self, ts): + self.__n = len(ts) # quantidade de tokens + for i in range(0,self.__n): + self.__tAux.append(self.__n) + self.__name = self.getNameRule(ts) # todos os etiquetadores numa so string (ver linha 35) + for morpho in self.__root: + for rule in morpho.findall('rule'): # procura a tag rule + if rule.get('name') == self.__name: # procura o atributo name na tag rule (ver linha 17) + if rule.find('active').text == "true": # verifica se a regra esta ativa + self.__c = 0 + for classe in rule.iter('class'): # for nas tags class + self.__dAux[self.__c] = int(classe.find('newpos').text) # preenche dicionario com a ordem atual e futura das palavras + self.__c += 1 + self.__c = 0 + for w,t in ts: + i = self.__dAux.get(self.__c) # pega o indice de onde ficara a palavra + self.__tAux[i] = ([w,t]) # preenche a lista com a palavra+etiqueta na posicao correta (segundo o arquivo regras.xml) + self.__c += 1 + return self.__tAux # retorna nova lista (ordenada) + return ts # retorna a lista sem alteracoes (nao existe regra) + + def getNameRule(self, ts): + self.__name = "" + for w,t in ts: + if t[:2] != "VB": + self.__name += t + else: + self.__name += t[:2] + return self.__name + + + + + + + + + + + + + diff --git a/src/Classificador.py b/src/Classificador.py new file mode 100644 index 0000000..4d5bc60 --- /dev/null +++ b/src/Classificador.py @@ -0,0 +1,44 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva + +from Aelius import AnotaCorpus, Toqueniza, Extras + +class Classificador(object): + + # inicializacao das variaveis + def __init__(self): + self.__h = Extras.carrega("AeliusHunPos") # carrega o modelo de idioma (passado por parametro ao instanciar) + + def anotaSentencas(self, str): + self.__t = "" + self.__tokens = "" + #try: + # tokenizae + self.__tokens = Toqueniza.TOK_PORT.tokenize(str) + + # realiza a classificacao morfologica + self.__t = AnotaCorpus.anota_sentencas([self.__tokens],self.__h,'hunpos') + + return self.listClean(self.__t) + #except: + # print "Erro ao efetuar a classificação morfologica." + + + def listClean(self, l): + lClean = [] + for w,t in l[0]: + lClean.append([w,t]) + return lClean + + # faz a impressao (usado apenas pra testes) + def imprimeSentencas(self): + for w,t in self.t[0]: + print "%s_%s " % (w,t), + + + + + + diff --git a/src/Iterator.py b/src/Iterator.py index 82e3478..06053ed 100644 --- a/src/Iterator.py +++ b/src/Iterator.py @@ -1,10 +1,9 @@ #!/usr/bin/python # -*- coding: utf-8 -*- -#Autor: Erickson Silva -#Email: +#Autor: Erickson Silva -#LAViD - Laboratório de Aplicações de Vídeo Digital +from StringAux import * class Iterator(object): @@ -36,22 +35,22 @@ class Iterator(object): return self.__list[self.count] def getAtualW(self): - return self.getToken(0)[0].upper() + return remover_acentos(self.getToken(0)[0].upper().encode('utf-8')) def getAtualT(self): - return self.getToken(0)[1] + return self.getToken(0)[1].upper().encode('utf-8') def getProxW(self): - return self.getToken("+")[0].upper() + return remover_acentos(self.getToken("+")[0].upper().encode('utf-8')) def getProxT(self): - return self.getToken("+")[1] + return self.getToken("+")[1].upper().encode('utf-8') def getAntW(self): - return self.getToken("-")[0].upper() + return remover_acentos(self.getToken("-")[0].upper().encode('utf-8')) def getAntT(self): - return self.getToken("-")[1] + return self.getToken("-")[1].upper().encode('utf-8') def hasNext(self): if(self.count < self.size-1): diff --git a/src/LeitorDicionarios.py b/src/LeitorDicionarios.py deleted file mode 100644 index cc8375f..0000000 --- a/src/LeitorDicionarios.py +++ /dev/null @@ -1,139 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva -#Email: - -#LAViD - Laboratório de Aplicações de Vídeo Digital - -import os, csv, sys - -class LeitorDicionarios(object): - #_iInstance = None - - #class Singleton: - # def __init__(self): - # self.LeitorDicionarios = None - - #def __init__( self ): - # if LeitorDicionarios._iInstance is None: - # LeitorDicionarios._iInstance = LeitorDicionarios.Singleton() - - # self._EventHandler_instance = LeitorDicionarios._iInstance - - #def __getattr__(self, aAttr): - # return getattr(self._iInstance, aAttr) - - #def __setattr__(self, aAttr, aValue): - # return setattr(self._iInstance, aAttr, aValue) - - # Define e inicializa os atributos - def __init__(self): - self.__path = "/home/erickson/vlibras-translate/data/" - self.__dicInf = {} - self.__dicSin = {} - self.__dicWords = {} - self.__dic2Gen = {} - self.__dicTemVerbs = {} - self.__fileDic = '' - self.carregarVerbosInfinitivos() - self.carregarSinonimos() - self.carregarPalavrasIgnoradas() - self.carregarSubst2Generos() - self.carregarTemposVerbais() - - # Abre o self.__fileDic que contem os verbos no infinitivo e preenche o dicionario com os mesmos - def carregarVerbosInfinitivos(self): - try: - self.__fileDic = csv.reader(open(self.__path+"dicPortGlosa.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "carregarVerbosInfinitivos" - - for row in self.__fileDic: - if row[1] != "": - try: - self.__dicInf[row[0].decode("utf-8")] = row[1].decode("utf-8") - except UnicodeDecodeError: - self.__dicInf[row[0].decode('iso8859-1').encode('utf-8')] = row[1].decode('iso8859-1').encode('utf-8') - - # Abre o self.__fileDic que contem os sinonimos e preenche o dicionario com os mesmos - def carregarSinonimos(self): - try: - self.__fileDic = csv.reader(open(self.__path+"portuguesGlosa.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "carregarSinonimos" - - for row in self.__fileDic: - if row[1] != "": - self.__dicSin[row[0].decode("utf-8")] = row[1].decode("utf-8") - - - # Abre o self.__fileDic que contem os tempos verbais - def carregarTemposVerbais(self): - try: - self.__fileDic = csv.reader(open(self.__path+"temposVerbais.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "carregarTemposVerbais" - - for row in self.__fileDic: - self.__dicTemVerbs[row[0].decode("utf-8")] = row[0].decode("utf-8") - - # Abre o self.__fileDic que contem os artigos e preposicoes de acordo com o modelo de idioma passado na chamada e preenche o dicionario com os mesmos - def carregarPalavrasIgnoradas(self): - try: - self.__fileDic = csv.reader(open(self.__path+"hWordsRemove.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "carregarPalavrasIgnoradas" - - for row in self.__fileDic: - self.__dicWords[row[0].decode("utf-8")] = row[0].decode("utf-8") - - # Abre o self.__fileDic que contem os substantivos que sao comuns dos 2 generos e preenche o dicionario com os mesmos - def carregarSubst2Generos(self): - try: - self.__fileDic = csv.reader(open(self.__path+"subs2Generos.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "carregarSubst2Generos" - - for row in self.__fileDic: - self.__dic2Gen[row[0].decode("utf-8")] = row[0].decode("utf-8") - - # Retorna o dicionario dos verbos no infinitivo - def getVerboInfinitivo(self, token): - return self.__dicInf[token] - - # Retorna o dicionario dos sinonimos - def getSinonimo(self, token): - return self.__dicSin[token] - - # Retorna o dicionario dos artigos e preposicoes a serem removidos pelo simplificador - def getPalavraIgnorada(self, token): - return self.__dicWords[token] - - # Retorna o dicionario dos substantivos a serem analisados pelo simplificador - def getSubst2Generos(self, token): - return self.__dic2Gen[token] - - # Retorna o dicionario dos tempos verbais - def getTempoVerbal(self, token): - return self.__dicTemVerbs[token] - - def hasVerboInfinitivo(self, token): - return self.__dicInf.has_key(token) - - def hasSinonimo(self, token): - return self.__dicSin.has_key(token) - - def hasPalavraIgnorada(self, token): - return self.__dicWords.has_key(token) - - def hasSubst2Genero(self, token): - return self.__dic2Gen.has_key(token) - - def hasTempoVerbal(self, token): - return self.__dicTemVerbs.has_key(token) diff --git a/src/ModuleTranslate.py b/src/ModuleTranslate.py new file mode 100644 index 0000000..c9e72f7 --- /dev/null +++ b/src/ModuleTranslate.py @@ -0,0 +1,14 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +from Tradutor import * + +tradutor = Tradutor() + +def iniciar(x): + try: + text = x.decode("utf-8") + except: + text = x.decode("iso-8859-1") + + return tradutor.traduzir(text) diff --git a/src/Output.py b/src/Output.py new file mode 100644 index 0000000..3259d3c --- /dev/null +++ b/src/Output.py @@ -0,0 +1,24 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva + +import sys +from Iterator import * +from StringAux import * + +class Output(object): + + # inicializa a variavel com o valor passado por paramentro ao instanciar + def __init__(self): + self.it = Iterator() + + # executa a saida + def executeOut(self, ts): + self.__glosa = [] + self.it.load(ts) + while(self.it.hasNext()): + self.__glosa.append(self.it.getAtualW()) + self.it.reset() + return ' '.join(self.__glosa) + diff --git a/src/Simplificador.py b/src/Simplificador.py new file mode 100644 index 0000000..1e61b26 --- /dev/null +++ b/src/Simplificador.py @@ -0,0 +1,164 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva + +from WorkCSV import * +from Iterator import * +from StringAux import * + +class Simplificador(object): + + # inicializa todos as variaveis + def __init__(self): + self.it = Iterator() + self.__csv = WorkCSV() + self.__dicInf = {} + self.__dicSin = {} + self.__dicWords = {} + self.__dic2Gen = {} + self.__dicTemVerbs = {} + self.executeWorkCSV() + + # retira artigos e preposicoes; passa verbos para infinitivo e verificar se há sinonimos + def simplificar(self, texto): + self.__ts = [] + self.it.load(texto) + self.__verb = False + self.__adv = False; + self.__countVerb = 0 + self.__countAdv = 0 + countWords = 0 + while(self.it.hasNext()): + w = self.auxConvert(self.it.getAtualW()) + t = self.it.getAtualT() + self.__b = False + if self.__dicWords.has_key(t) == False: # verifica se nao eh artigo/preposicao + wu = w.upper() # deixa o token maiusculo + #if t[:2] == "VB": + if t[-2:] == "-P": + wu = self.pluralAnalysis(w) + if t == "VB-P" or t == "VB-D" or t == "VB-R": + self.__verb = True + self.__countVerb += 1 + if t[:3] == "ADV": + self.__adv = True + self.__countAdv += 1 + if self.__dicInf.has_key(wu): # verifica se ha um verbo infinitivo desse token + sAux = self.__dicInf[wu] # se sim, adiciona numa string aux + if self.__dicSin.has_key(sAux): # verifica se ha um sinonimo para esse verbo infinitivo + self.__ts.append([self.__dicSin[sAux],t]) # se sim, entao adiciona na lista + self.__b = True + else: + self.__ts.append([sAux,t]) # caso contrario, adiciona so o verbo infinitivo msm + self.__b = True + if self.__b == False and self.__dicSin.has_key(wu): # verifica se nao foi encontrado verbo infinitivo e se ha sinonimo + self.__ts.append([self.__dicSin[wu],t]) # adiciona na o sinonimo lista + self.__b = True + + if self.__dic2Gen.has_key(wu): + del self.__ts[-1] + lenTicket = len(self.it.getAntT()) + if ((self.__dicWords.has_key(self.it.getAntT())) and (self.it.getAntT()[lenTicket-1:] == "F") or (self.it.getAntT()[lenTicket-3:] == "F-P")): + self.__ts.append(["MULHER " + wu,t]) + else: + self.__ts.append(["HOMEM " + wu,t]) + self.__b = True + if self.__b == False: # verifica se nao encontrou nem verbo infinito ou sinonimo + self.__ts.append([wu,t]) + countWords += 1 + self.it.reset() + if self.__verb == True: + return self.verbalAnalysis(self.__ts) + return self.__ts + + # cria e recupera todos os dicionarios (verbos inf., sinonimos e artigos/preposicoes) + def executeWorkCSV(self): + self.__dicInf = self.__csv.getDicInf() + self.__dicSin = self.__csv.getDicSin() + self.__dicWords = self.__csv.getDicWords() + self.__dic2Gen = self.__csv.getDic2Gen() + self.__dicTemVerbs = self.__csv.getDicTemVerbs() + + # converte romano para numero + def auxConvert(self, t): + try: + return roman_to_int(t) + except: + return t + + + def verbalAnalysis(self, lista): + lv = [] + self.it.load(lista) + hasFut = False + hasPas = False + count = 0 + while(self.it.hasNext()): + w = self.it.getAtualW().upper() + t = self.it.getAtualT() + + if(t[:3] == "ADV"): + if (self.__dicTemVerbs.has_key(w)): + self.it.reset() + #print "ADV: retornou lista original" + return lista + + if(t == "VB-P"): + if (self.__countVerb > 1): + count += 1 + #print "VB-P: Incrementou" + if(count == self.__countVerb): + #print "VB-P Adicionou " + w + lv.append([w,t]) + else: + #print "VB-P: retornou lista original" + self.it.reset() + return lista + elif(t == "VB-D"): + count += 1 + hasPas = True + #print "VB-D: Incrementou" + if(count == self.__countVerb): + #print "VB-D Adicionou " + w + lv.append([w,t]) + elif(t == "VB-R"): + count += 1 + hasFut = True + #print "VB-R: Incrementou" + if(count == self.__countVerb): + #print "VB-R Adicionou " + w + lv.append([w,t]) + else: + lv.append([w,t]) + if (hasFut): + lv.append(["FUTURO", "TVB"]) + elif (hasPas): + lv.append(["PASSADO", "TVB"]) + self.it.reset() + return lv + + + def pluralAnalysis(self, word): + + if(word[-3:] == "OES" or word[-2:] == "AES" or word[-2:] == "AOS"): + return word[0:-3]+"AO" + elif(word[-3:] == "RES" or word[-2:] == "ZES" or word[-2:] == "NES"): + return word[0:-2] + elif(word[-3:] == "SES"): + #TODO: Algumas palavras possuem marcações gráficas na raiz singular. Ex: Gás – Gases + return word[0:-2] + elif(word[-2:] == "NS"): + return word[0:-2]+"M" + elif(word[-3:] == "EIS"): + return word[0:-3]+"IL" + elif(word[-2:] == "IS"): + if(word[-3] == "A" or word[-3] == "E" or word[-3] == "O" or word[-3] == "U"): + return word[0:-2]+"L" + else: + return word + elif(word[-1] == "S"): + #TODO: Palavras paroxítonas ou proparoxítonas terminadas em S. Ex: lápis, vírus, tênis, ônibus, etc + return word[0:-1] + else: + return word \ No newline at end of file diff --git a/src/StringAux.py b/src/StringAux.py new file mode 100644 index 0000000..e690a6b --- /dev/null +++ b/src/StringAux.py @@ -0,0 +1,83 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +from unicodedata import normalize + +ext = {1:"um", 2:"dois", 3:"três", 4:"quatro", 5:"cinco", 6:"seis", 7:"sete", 8:"oito", 9:"nove", 0:"zero"} + +def extenso(n): + strn = str(n) + sizen = len(strn) + tokens = [] + for i in range (0, sizen): + x = int(strn[i]) + tokens.append(ext[x]) + return ' '.join(tokens) + +""" +def extenso(n): + strn = str(n) + sizen = len(strn) + tokens = [] + for i in range (0, sizen): + tokens.append(strn[i]) + return ' '.join(tokens) +""" + +def remover_acentos(txt): + + """ Devolve cópia de uma str substituindo os caracteres + acentuados pelos seus equivalentes não acentuados. + + ATENÇÃO: carateres gráficos não ASCII e não alfa-numéricos, + tais como bullets, travessões, aspas assimétricas, etc. + são simplesmente removidos! + + >>> remover_acentos('[ACENTUAÇÃO] ç: áàãâä! éèêë? íìĩîï, óòõôö; úùũûü.') + '[ACENTUACAO] c: aaaaa! eeee? iiiii, ooooo; uuuuu.' + + """ + try: + return normalize('NFKD', txt.decode('utf-8')).encode('ASCII','ignore') + except: + return normalize('NFKD', txt.decode('iso-8859-1')).encode('ASCII','ignore') + + +def roman_to_int(input): + if not isinstance(input, type("")): + raise TypeError, "expected string, got %s" % type(input) + input = input.upper( ) + nums = {'M':1000, + 'D':500, + 'C':100, + 'L':50, + 'X':10, + 'V':5, + 'I':1} + sum = 0 + for i in range(len(input)): + try: + value = nums[input[i]] + if i+1 < len(input) and nums[input[i+1]] > value: + sum -= value + else: sum += value + except KeyError: + raise ValueError, 'input is not a valid Roman numeral: %s' % input + + if int_to_roman(sum) == input: return sum + else: raise ValueError, 'input is not a valid Roman numeral: %s' % input + +def int_to_roman(input): + if not isinstance(input, type(1)): + raise TypeError, "expected integer, got %s" % type(input) + if not 0 < input < 4000: + raise ValueError, "Argument must be between 1 and 3999" + ints = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1) + nums = ('M', 'CM', 'D', 'CD','C', 'XC','L','XL','X','IX','V','IV','I') + result = [] + + for i in range(len(ints)): + count = int(input / ints[i]) + result.append(nums[i] * count) + input -= ints[i] * count + return ''.join(result) \ No newline at end of file diff --git a/src/Tradutor.py b/src/Tradutor.py index 80c9bf5..395afde 100644 --- a/src/Tradutor.py +++ b/src/Tradutor.py @@ -1,45 +1,38 @@ #!/usr/bin/python # -*- coding: utf-8 -*- -#Autor: Erickson Silva -#Email: +#Autor: Erickson Silva -#LAViD - Laboratório de Aplicações de Vídeo Digital +from Classificador import * +from Simplificador import * +from AplicadorRegras import * +from Output import * +from StringAux import * -import alexp -from AplicaSinonimos import * -from AplicaRegras import * -sin = AplicaSinonimos() -reg = AplicaRegras() +class Tradutor(object): + def __init__(self): + #instanciando os objetos + self.__classificador = Classificador() + self.__simplificador = Simplificador() + self.__regras = AplicadorRegras() + self.__out = Output() -def iniciarTraducao(texto): - textoDividido = texto.split(".") - for w in textoDividido: - if len(w) > 0: - gerarAnalise(w) -def gerarAnalise(sentenca): - '''tokens = alexp.toqueniza(sentenca) - etiquetadas = alexp.etiquetaSentenca(tokens) - analiseMorf = analiseMorfologica(etiquetadas) - print analiseMorf''' + def traduzir(self, txt): + self.__tr = None - analise = alexp.run(sentenca) - - if (isinstance(analise,type(None))): - analise = alexp.getAnaliseMorfologica() - print analiseMorfologica(analise) - else: - print analiseSintatica(analise) + #faz a tokenizacao e a classificacao + self.__t = self.__classificador.anotaSentencas(txt) + #retira artigos e preposicoes + self.__ts = self.__simplificador.simplificar(self.__t) + self.__t = None + + #aplica as regras + #self.__tr = self.__regras.aplicarRegras(self.__ts) + #self.__ts = None -def analiseMorfologica(sentenca): - proc = reg.simplificar(sentenca) - return sin.sinonimosMorfologico(proc) - - -def analiseSintatica(sentenca): - analise = sin.sinonimosSintatico(sentenca) - return analise \ No newline at end of file + #executa a saida + return self.__out.executeOut(self.__ts).encode("utf-8") diff --git a/src/WorkCSV.py b/src/WorkCSV.py new file mode 100644 index 0000000..43e2a81 --- /dev/null +++ b/src/WorkCSV.py @@ -0,0 +1,125 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva + +import os, csv, sys + +class WorkCSV(object): + _iInstance = None + + class Singleton: + def __init__(self): + self.LeitorDicionarios = None + + def __init__( self ): + if LeitorDicionarios._iInstance is None: + LeitorDicionarios._iInstance = LeitorDicionarios.Singleton() + + self._EventHandler_instance = LeitorDicionarios._iInstance + + def __getattr__(self, aAttr): + return getattr(self._iInstance, aAttr) + + def __setattr__(self, aAttr, aValue): + return setattr(self._iInstance, aAttr, aValue) + + # Define e inicializa os atributos + def __init__(self): + self.__path = "vlibras_user/vlibras-core/data/" + self.__fileInf = '' + self.__dicInf = {} + self.__fileSin = '' + self.__dicSin = {} + self.__fileWords = '' + self.__dicWords = {} + self.__file2Gen = '' + self.__dic2Gen = {} + self.__fileTemVerbs = '' + self.__dicTemVerbs = {} + self.createDicInf() + self.createDicSin() + self.createDicWords() + self.createDic2Gen() + self.createDicTemVerbs() + + # Abre o arquivo que contem os verbos no infinitivo e preenche o dicionario com os mesmos + def createDicInf(self): + try: + self.__fileInf = csv.reader(open(self.__path+"dicPortGlosa.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "createDicInf" + + for row in self.__fileInf: + if row[1] != "": + try: + self.__dicInf[row[0].decode("utf-8")] = row[1].decode("utf-8") + except UnicodeDecodeError: + self.__dicInf[row[0].decode('iso8859-1').encode('utf-8')] = row[1].decode('iso8859-1').encode('utf-8') + + # Abre o arquivo que contem os sinonimos e preenche o dicionario com os mesmos + def createDicSin(self): + try: + self.__fileSin = csv.reader(open(self.__path+"portuguesGlosa.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "createDicSin" + + for row in self.__fileSin: + if row[1] != "": + self.__dicSin[row[0].decode("utf-8")] = row[1].decode("utf-8") + + + # Abre o arquivo que contem os tempos verbais + def createDicTemVerbs(self): + try: + self.__fileTemVerbs = csv.reader(open(self.__path+"temposVerbais.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "createDicTemVerbs" + + for row in self.__fileTemVerbs: + self.__dicTemVerbs[row[0].decode("utf-8")] = row[0].decode("utf-8") + + # Abre o arquivo que contem os artigos e preposicoes de acordo com o modelo de idioma passado na chamada e preenche o dicionario com os mesmos + def createDicWords(self): + try: + self.__fileWords = csv.reader(open(self.__path+"hWordsRemove.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "createDicWords" + + for row in self.__fileWords: + self.__dicWords[row[0].decode("utf-8")] = row[0].decode("utf-8") + + # Abre o arquivo que contem os substantivos que sao comuns dos 2 generos e preenche o dicionario com os mesmos + def createDic2Gen(self): + try: + self.__file2Gen = csv.reader(open(self.__path+"subs2Generos.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "createDic2Gen" + + for row in self.__file2Gen: + self.__dic2Gen[row[0].decode("utf-8")] = row[0].decode("utf-8") + + # Retorna o dicionario dos verbos no infinitivo + def getDicInf(self): + return self.__dicInf + + # Retorna o dicionario dos sinonimos + def getDicSin(self): + return self.__dicSin + + # Retorna o dicionario dos artigos e preposicoes a serem removidos pelo simplificador + def getDicWords(self): + return self.__dicWords + + # Retorna o dicionario dos substantivos a serem analisados pelo simplificador + def getDic2Gen(self): + return self.__dic2Gen + + # Retorna o dicionario dos tempos verbais + def getDicTemVerbs(self): + return self.__dicTemVerbs \ No newline at end of file diff --git a/src/alexp.py b/src/alexp.py deleted file mode 100644 index 96cbd80..0000000 --- a/src/alexp.py +++ /dev/null @@ -1,133 +0,0 @@ -#! /usr/bin/env python2.6 -# -*- coding: utf-8 -*- - -#--------------------------------- - -# Editado: - -#Autor: Erickson Silva -#Email: - -#LAViD - Laboratório de Aplicações de Vídeo Digital - -#--------------------------------- - - -# Donatus Brazilian Portuguese Parser -# -# Copyright (C) 2010-2013 Leonel F. de Alencar -# -# Author: Leonel F. de Alencar -# Homepage: -# -# Project's URL: -# For license information, see LICENSE.TXT -# -# $Id: alexp.py $ - -"""Este módulo contém funções que permitem utilizar o Aelius para etiquetar uma sentença, construindo entradas lexicais com base nas etiquetas atribuídas às palavras da sentença. Essas entradas lexicais são integradas em uma gramática CFG dada, que é transformada em um parser, utilizado para gerar uma árvore de estrutura sintagmática da sentença. -""" -import re, string,nltk,os -from Aelius.Extras import carrega -from Aelius import AnotaCorpus - -# definição de algumas variáveis globais para -# facilitar utilização das diferentes funções do módulo - -# sintaxe default em subpasta de nltk_data -DIR="/vlibras-translate/data/cfg.syn.nltk" - -# eventualmente será preciso incluir aqui outros sinais -# de pontuação, como o travessão -PUNCT=string.punctuation - -SENTENCA_ANOTADA="" - - -def toqueniza(s): - """Decodifica string utilizando utf-8, retornando uma lista de tokens em unicode. - """ - decodificada=s.decode("utf-8") - return AnotaCorpus.TOK_PORT.tokenize(decodificada) - -def getAnaliseMorfologica(): - return SENTENCA_ANOTADA - -def etiquetaSentenca(s): - """Aplica um dos etiquetadores do Aelius na etiquetagem da sentença dada como lista de tokens. - """ - etiquetador = list((carrega("AeliusHunPos"),"nltk")) - anotada = AnotaCorpus.anota_sentencas([s],etiquetador,"hunpos")[0] - return anotada - -def geraEntradasLexicais(lista): - """Gera entradas lexicais no formato CFG do NLTK a partir de lista de pares constituídos de tokens e suas etiquetas. - """ - entradas=[] - for e in lista: - # é necessário substituir símbolos como "-" e "+" do CHPTB - # que não são aceitos pelo NLTK como símbolos não terminais - c=re.sub(r"[-+]","_",e[1]) - c=re.sub(r"\$","_S",c) - entradas.append("%s -> '%s'" % (c, e[0].lower())) - return entradas - -def corrigeAnotacao(lista): - """Esta função deverá corrigir alguns dos erros de anotação mais comuns do Aelius. No momento, apenas é corrigida VB-AN depois de TR. - """ - i=1 - while i < len(lista): - if lista[i][1] == "VB-AN" and lista[i-1][1].startswith("TR"): - lista[i]=(lista[i][0],"VB-PP") - i+=1 - -# a função abaixo parece muito restritiva; talvez não seja necessário -# que o arquivo esteja no diretório nltk_data -def encontraArquivo(caminho=DIR): - """Encontra arquivo na pasta vlibras-translate. - """ - home = os.path.expanduser("~") - path = os.path.realpath(home+caminho) - return path - -def extraiSintaxe(caminho=DIR): - """Extrai gramática armazenada em arquivo cujo caminho é definido relativamente ao diretório nltk_data. - """ - arquivo=encontraArquivo(caminho) - if arquivo: - f=open(arquivo,"rU") - sintaxe=f.read() - f.close() - return sintaxe - else: - print "Arquivo %s não encontrado em nenhum dos diretórios de dados do NLTK:\n%s" % (caminho,"\n".join(nltk.data.path)) - - -def analisaSentenca(sentenca): - """Retorna lista de árvores de estrutura sintagmática para a sentença dada sob a forma de uma lista de tokens, com base na gramática CFG cujo caminho é especificado como segundo argumento da função. Esse caminho é relativo à pasta nltk_data da instalação local do NLTK. A partir da etiquetagem morfossintática da sentença são geradas entradas lexicais que passam a integrar a gramática CFG. O caminho da gramática e o parser gerado são armazenados como tupla na variável ANALISADORES. - """ - parser=constroiAnalisador(sentenca) - codificada=[w.encode("utf-8") for w in sentenca] - trees=parser.parse_one(codificada) - return trees - -def constroiAnalisador(s): - """Constrói analisador a partir de uma única sentença não anotada, dada como lista de tokens, e uma lista de regras sintáticas no formato CFG, armazenadas em arquivo. Esta função tem um bug, causado pela maneira como o Aelius etiqueta sentenças usando o módulo ProcessaNomesProprios: quando a sentença se inicia por paravra com inicial minúscula, essa palavra não é incorporada ao léxico, mas a versão com inicial maiúscula. - """ - global SENTENCA_ANOTADA - SENTENCA_ANOTADA=etiquetaSentenca(s) - corrigeAnotacao(SENTENCA_ANOTADA) - entradas=geraEntradasLexicais(SENTENCA_ANOTADA) - lexico="\n".join(entradas) - gramatica="%s\n%s" % (extraiSintaxe(DIR).strip(),lexico) - cfg=nltk.CFG.fromstring(gramatica) - return nltk.ChartParser(cfg) - -def exibeArvores(arvores): - """Função 'wrapper' para a função de exibição de árvores do NLTK""" - nltk.draw.draw_trees(*arvores) - -def run(sentenca): - tokens=toqueniza(sentenca) - trees=analisaSentenca(tokens) - return trees \ No newline at end of file diff --git a/src/new/AplicaRegras.py b/src/new/AplicaRegras.py new file mode 100644 index 0000000..4897c99 --- /dev/null +++ b/src/new/AplicaRegras.py @@ -0,0 +1,161 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva +#Email: + +#LAViD - Laboratório de Aplicações de Vídeo Digital + +from LeitorDicionarios import * +from Iterator import * +from StringAux import * + +class AplicaRegras(object): + + # inicializa todos as variaveis + def __init__(self): + self.__dicionarios = LeitorDicionarios() + + # retira artigos e preposicoes; passa verbos para infinitivo e verificar se há sinonimos + def simplificar(self, texto): + it = Iterator() + it.load(texto) + self.__ts = [] + self.__verb = False + self.__adv = False; + self.__countVerb = 0 + self.__countAdv = 0 + while(it.hasNext()): + token = it.getAtualW() + tag = it.getAtualT() + self.__b = False + if self.__dicionarios.hasPalavraIgnorada(tag) == False: # verifica se nao eh artigo/preposicao + + #VERIFICA SE É ADVERBIO E CONTA A QUANTIDADE + if tag[:3] == "ADV": + self.__adv = True + self.__countAdv += 1 + + if tag[:2] == "VB": + + #VERIFICA SE É VERBO NO INFINITIVO + if self.__dicionarios.hasVerboInfinitivo(token): # verifica se ha um verbo infinitivo desse token + verboInfinitivo = self.__dicionarios.getVerboInfinitivo(token) # se sim, adiciona numa string aux + self.__ts.append([verboInfinitivo,tag]) # caso contrario, adiciona so o verbo infinitivo msm + self.__b = True + + #VERIFICA SE É VERBO DE TEMPO E CONTA A QUANTIDADE + if tag == "VB-P" or tag == "VB-D" or tag == "VB-R": + self.__verb = True + self.__countVerb += 1 + + + #VERIFICA SE É SUBTANTIVO COMUM DOS 2 GENEROS + if self.__dicionarios.hasSubst2Genero(token): + #del self.__ts[-1] + lenTicket = len(it.getAntT()) + if ((self.__dicionarios.hasPalavraIgnorada(it.getAntT())) and (it.getAntT()[lenTicket-1:] == "F") or (it.getAntT()[lenTicket-3:] == "F-P")): + self.__ts.append(["MULHER ", "2GEN"]) + self.__ts.append([token,tag]) + else: + self.__ts.append(["HOMEM ", "2GEN"]) + self.__ts.append([token,tag]) + self.__b = True + + #VERIFICA SE É PLURAL + #if tag[-2:] == "-P": + # token = self.pluralAnalysis(token) + + #SE NÃO HOUVE NENHUM ALTERAÇÃO, OU SEJA, NÃO APLICOU NENHUMA REGRA, ADICIONA O TOKEN ORIGINAL + if self.__b == False: # verifica se nao encontrou nem verbo infinito ou sinonimo + self.__ts.append([token,tag]) + + #SE ENCONTROU VERBO, ENTÃO ANALISA a SENTENCA NOVAMENTE (again?) + if self.__verb == True: + return self.verbalAnalysis(self.__ts) + + return self.__ts + + + # converte romano para numero + def auxConvert(self, tag): + try: + return roman_to_int(tag) + except: + return tag + + def verbalAnalysis(self, lista): + lv = [] + it = Iterator() + it.load(lista) + hasFut = False + hasPas = False + count = 0 + while(it.hasNext()): + token = it.getAtualW().upper() + tag = it.getAtualT() + + if(tag[:3] == "ADV"): + if (self.__dicionarios.hasTempoVerbal(token)): + it.reset() + #print "ADV: retornou lista original" + return lista + + if(tag == "VB-P"): + if (self.__countVerb > 1): + count += 1 + #print "VB-P: Incrementou" + if(count == self.__countVerb): + #print "VB-P Adicionou " + token + lv.append([token,tag]) + else: + #print "VB-P: retornou lista original" + it.reset() + return lista + elif(tag == "VB-D"): + count += 1 + hasPas = True + #print "VB-D: Incrementou" + if(count == self.__countVerb): + #print "VB-D Adicionou " + token + lv.append([token,tag]) + elif(tag == "VB-R"): + count += 1 + hasFut = True + #print "VB-R: Incrementou" + if(count == self.__countVerb): + #print "VB-R Adicionou " + token + lv.append([token,tag]) + else: + lv.append([token,tag]) + if (hasFut): + lv.append(["FUTURO", "T-VB"]) + elif (hasPas): + lv.append(["PASSADO", "T-VB"]) + it.reset() + return lv + + + def pluralAnalysis(self, word): + + if(word[-3:] == "OES" or word[-2:] == "AES" or word[-2:] == "AOS"): + return word[0:-3]+"AO" + elif(word[-3:] == "RES" or word[-2:] == "ZES" or word[-2:] == "NES"): + return word[0:-2] + elif(word[-3:] == "SES"): + #TODO: Algumas palavras possuem marcações gráficas na raiz singular. Ex: Gás – Gases + return word[0:-2] + elif(word[-2:] == "NS"): + return word[0:-2]+"M" + elif(word[-3:] == "EIS"): + return word[0:-3]+"IL" + elif(word[-2:] == "IS"): + if(word[-3] == "A" or word[-3] == "E" or word[-3] == "O" or word[-3] == "U"): + return word[0:-2]+"L" + else: + return word + elif(word[-1] == "S"): + #TODO: Palavras paroxítonas ou proparoxítonas terminadas em S. Ex: lápis, vírus, tagênis, ônibus, etc + return word[0:-1] + else: + return word \ No newline at end of file diff --git a/src/new/AplicaSinonimos.py b/src/new/AplicaSinonimos.py new file mode 100644 index 0000000..cf8e4f9 --- /dev/null +++ b/src/new/AplicaSinonimos.py @@ -0,0 +1,48 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva +#Email: + +#LAViD - Laboratório de Aplicações de Vídeo Digital + +import os, csv, sys +from nltk.tree import * +from LeitorDicionarios import * + +class AplicaSinonimos(object): + + # Define e inicializa os atributos + def __init__(self): + self.__dicionarios = LeitorDicionarios() + + def sinonimosMorfologico(self, texto): + lista = texto + for i, elem in enumerate(lista): + token = self.verificaPalavra(elem[0]) + listmp = list(elem) + listmp[0] = token + lista[i] = listmp + return lista + + + def dicionarioSinonimoFolhas(self, folhas): + dic = {} + for f in folhas: + token = self.verificaPalavra(f) + dic[f] = token + return dic + + def sinonimosSintatico(self, texto): + folhas = Tree.leaves(texto) + dic = self.dicionarioSinonimoFolhas(folhas) + stringTree = str(texto) + for t in folhas: + stringTree.replace(t, dic[t]) + tree = Tree.fromstring(stringTree, brackets='()') + return tree + + def verificaPalavra(self, token): + if self.__dicionarios.hasSinonimo(token): + return self.__dicionarios.getSinonimo(token) + return token \ No newline at end of file diff --git a/src/new/Iterator.py b/src/new/Iterator.py new file mode 100644 index 0000000..82e3478 --- /dev/null +++ b/src/new/Iterator.py @@ -0,0 +1,60 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva +#Email: + +#LAViD - Laboratório de Aplicações de Vídeo Digital + +class Iterator(object): + + # inicializacao das variaveis + def __init__(self): + self.count = -1 + + def load(self, lista): + self.__list = list(lista); + self.size = len(lista) + + def reset(self): + self.count = -1 + + def getSize(self): + return self.size + + def getCount(self): + return self.count + + def getToken(self, i): + if(i == "+"): + return self.__list[self.count+1] + + elif(i == "-"): + return self.__list[self.count-1] + + else: + return self.__list[self.count] + + def getAtualW(self): + return self.getToken(0)[0].upper() + + def getAtualT(self): + return self.getToken(0)[1] + + def getProxW(self): + return self.getToken("+")[0].upper() + + def getProxT(self): + return self.getToken("+")[1] + + def getAntW(self): + return self.getToken("-")[0].upper() + + def getAntT(self): + return self.getToken("-")[1] + + def hasNext(self): + if(self.count < self.size-1): + self.count += 1 + return True + return False \ No newline at end of file diff --git a/src/new/LeitorDicionarios.py b/src/new/LeitorDicionarios.py new file mode 100644 index 0000000..cc8375f --- /dev/null +++ b/src/new/LeitorDicionarios.py @@ -0,0 +1,139 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva +#Email: + +#LAViD - Laboratório de Aplicações de Vídeo Digital + +import os, csv, sys + +class LeitorDicionarios(object): + #_iInstance = None + + #class Singleton: + # def __init__(self): + # self.LeitorDicionarios = None + + #def __init__( self ): + # if LeitorDicionarios._iInstance is None: + # LeitorDicionarios._iInstance = LeitorDicionarios.Singleton() + + # self._EventHandler_instance = LeitorDicionarios._iInstance + + #def __getattr__(self, aAttr): + # return getattr(self._iInstance, aAttr) + + #def __setattr__(self, aAttr, aValue): + # return setattr(self._iInstance, aAttr, aValue) + + # Define e inicializa os atributos + def __init__(self): + self.__path = "/home/erickson/vlibras-translate/data/" + self.__dicInf = {} + self.__dicSin = {} + self.__dicWords = {} + self.__dic2Gen = {} + self.__dicTemVerbs = {} + self.__fileDic = '' + self.carregarVerbosInfinitivos() + self.carregarSinonimos() + self.carregarPalavrasIgnoradas() + self.carregarSubst2Generos() + self.carregarTemposVerbais() + + # Abre o self.__fileDic que contem os verbos no infinitivo e preenche o dicionario com os mesmos + def carregarVerbosInfinitivos(self): + try: + self.__fileDic = csv.reader(open(self.__path+"dicPortGlosa.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "carregarVerbosInfinitivos" + + for row in self.__fileDic: + if row[1] != "": + try: + self.__dicInf[row[0].decode("utf-8")] = row[1].decode("utf-8") + except UnicodeDecodeError: + self.__dicInf[row[0].decode('iso8859-1').encode('utf-8')] = row[1].decode('iso8859-1').encode('utf-8') + + # Abre o self.__fileDic que contem os sinonimos e preenche o dicionario com os mesmos + def carregarSinonimos(self): + try: + self.__fileDic = csv.reader(open(self.__path+"portuguesGlosa.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "carregarSinonimos" + + for row in self.__fileDic: + if row[1] != "": + self.__dicSin[row[0].decode("utf-8")] = row[1].decode("utf-8") + + + # Abre o self.__fileDic que contem os tempos verbais + def carregarTemposVerbais(self): + try: + self.__fileDic = csv.reader(open(self.__path+"temposVerbais.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "carregarTemposVerbais" + + for row in self.__fileDic: + self.__dicTemVerbs[row[0].decode("utf-8")] = row[0].decode("utf-8") + + # Abre o self.__fileDic que contem os artigos e preposicoes de acordo com o modelo de idioma passado na chamada e preenche o dicionario com os mesmos + def carregarPalavrasIgnoradas(self): + try: + self.__fileDic = csv.reader(open(self.__path+"hWordsRemove.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "carregarPalavrasIgnoradas" + + for row in self.__fileDic: + self.__dicWords[row[0].decode("utf-8")] = row[0].decode("utf-8") + + # Abre o self.__fileDic que contem os substantivos que sao comuns dos 2 generos e preenche o dicionario com os mesmos + def carregarSubst2Generos(self): + try: + self.__fileDic = csv.reader(open(self.__path+"subs2Generos.csv"), delimiter=";") + except IOError, (errno, strerror): + print "I/O error(%s): %s" % (errno, strerror) + print "carregarSubst2Generos" + + for row in self.__fileDic: + self.__dic2Gen[row[0].decode("utf-8")] = row[0].decode("utf-8") + + # Retorna o dicionario dos verbos no infinitivo + def getVerboInfinitivo(self, token): + return self.__dicInf[token] + + # Retorna o dicionario dos sinonimos + def getSinonimo(self, token): + return self.__dicSin[token] + + # Retorna o dicionario dos artigos e preposicoes a serem removidos pelo simplificador + def getPalavraIgnorada(self, token): + return self.__dicWords[token] + + # Retorna o dicionario dos substantivos a serem analisados pelo simplificador + def getSubst2Generos(self, token): + return self.__dic2Gen[token] + + # Retorna o dicionario dos tempos verbais + def getTempoVerbal(self, token): + return self.__dicTemVerbs[token] + + def hasVerboInfinitivo(self, token): + return self.__dicInf.has_key(token) + + def hasSinonimo(self, token): + return self.__dicSin.has_key(token) + + def hasPalavraIgnorada(self, token): + return self.__dicWords.has_key(token) + + def hasSubst2Genero(self, token): + return self.__dic2Gen.has_key(token) + + def hasTempoVerbal(self, token): + return self.__dicTemVerbs.has_key(token) diff --git a/src/new/Tradutor.py b/src/new/Tradutor.py new file mode 100644 index 0000000..80c9bf5 --- /dev/null +++ b/src/new/Tradutor.py @@ -0,0 +1,45 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +#Autor: Erickson Silva +#Email: + +#LAViD - Laboratório de Aplicações de Vídeo Digital + +import alexp +from AplicaSinonimos import * +from AplicaRegras import * + +sin = AplicaSinonimos() +reg = AplicaRegras() + + +def iniciarTraducao(texto): + textoDividido = texto.split(".") + for w in textoDividido: + if len(w) > 0: + gerarAnalise(w) + +def gerarAnalise(sentenca): + '''tokens = alexp.toqueniza(sentenca) + etiquetadas = alexp.etiquetaSentenca(tokens) + analiseMorf = analiseMorfologica(etiquetadas) + print analiseMorf''' + + analise = alexp.run(sentenca) + + if (isinstance(analise,type(None))): + analise = alexp.getAnaliseMorfologica() + print analiseMorfologica(analise) + else: + print analiseSintatica(analise) + + +def analiseMorfologica(sentenca): + proc = reg.simplificar(sentenca) + return sin.sinonimosMorfologico(proc) + + +def analiseSintatica(sentenca): + analise = sin.sinonimosSintatico(sentenca) + return analise \ No newline at end of file diff --git a/src/new/alexp.py b/src/new/alexp.py new file mode 100644 index 0000000..96cbd80 --- /dev/null +++ b/src/new/alexp.py @@ -0,0 +1,133 @@ +#! /usr/bin/env python2.6 +# -*- coding: utf-8 -*- + +#--------------------------------- + +# Editado: + +#Autor: Erickson Silva +#Email: + +#LAViD - Laboratório de Aplicações de Vídeo Digital + +#--------------------------------- + + +# Donatus Brazilian Portuguese Parser +# +# Copyright (C) 2010-2013 Leonel F. de Alencar +# +# Author: Leonel F. de Alencar +# Homepage: +# +# Project's URL: +# For license information, see LICENSE.TXT +# +# $Id: alexp.py $ + +"""Este módulo contém funções que permitem utilizar o Aelius para etiquetar uma sentença, construindo entradas lexicais com base nas etiquetas atribuídas às palavras da sentença. Essas entradas lexicais são integradas em uma gramática CFG dada, que é transformada em um parser, utilizado para gerar uma árvore de estrutura sintagmática da sentença. +""" +import re, string,nltk,os +from Aelius.Extras import carrega +from Aelius import AnotaCorpus + +# definição de algumas variáveis globais para +# facilitar utilização das diferentes funções do módulo + +# sintaxe default em subpasta de nltk_data +DIR="/vlibras-translate/data/cfg.syn.nltk" + +# eventualmente será preciso incluir aqui outros sinais +# de pontuação, como o travessão +PUNCT=string.punctuation + +SENTENCA_ANOTADA="" + + +def toqueniza(s): + """Decodifica string utilizando utf-8, retornando uma lista de tokens em unicode. + """ + decodificada=s.decode("utf-8") + return AnotaCorpus.TOK_PORT.tokenize(decodificada) + +def getAnaliseMorfologica(): + return SENTENCA_ANOTADA + +def etiquetaSentenca(s): + """Aplica um dos etiquetadores do Aelius na etiquetagem da sentença dada como lista de tokens. + """ + etiquetador = list((carrega("AeliusHunPos"),"nltk")) + anotada = AnotaCorpus.anota_sentencas([s],etiquetador,"hunpos")[0] + return anotada + +def geraEntradasLexicais(lista): + """Gera entradas lexicais no formato CFG do NLTK a partir de lista de pares constituídos de tokens e suas etiquetas. + """ + entradas=[] + for e in lista: + # é necessário substituir símbolos como "-" e "+" do CHPTB + # que não são aceitos pelo NLTK como símbolos não terminais + c=re.sub(r"[-+]","_",e[1]) + c=re.sub(r"\$","_S",c) + entradas.append("%s -> '%s'" % (c, e[0].lower())) + return entradas + +def corrigeAnotacao(lista): + """Esta função deverá corrigir alguns dos erros de anotação mais comuns do Aelius. No momento, apenas é corrigida VB-AN depois de TR. + """ + i=1 + while i < len(lista): + if lista[i][1] == "VB-AN" and lista[i-1][1].startswith("TR"): + lista[i]=(lista[i][0],"VB-PP") + i+=1 + +# a função abaixo parece muito restritiva; talvez não seja necessário +# que o arquivo esteja no diretório nltk_data +def encontraArquivo(caminho=DIR): + """Encontra arquivo na pasta vlibras-translate. + """ + home = os.path.expanduser("~") + path = os.path.realpath(home+caminho) + return path + +def extraiSintaxe(caminho=DIR): + """Extrai gramática armazenada em arquivo cujo caminho é definido relativamente ao diretório nltk_data. + """ + arquivo=encontraArquivo(caminho) + if arquivo: + f=open(arquivo,"rU") + sintaxe=f.read() + f.close() + return sintaxe + else: + print "Arquivo %s não encontrado em nenhum dos diretórios de dados do NLTK:\n%s" % (caminho,"\n".join(nltk.data.path)) + + +def analisaSentenca(sentenca): + """Retorna lista de árvores de estrutura sintagmática para a sentença dada sob a forma de uma lista de tokens, com base na gramática CFG cujo caminho é especificado como segundo argumento da função. Esse caminho é relativo à pasta nltk_data da instalação local do NLTK. A partir da etiquetagem morfossintática da sentença são geradas entradas lexicais que passam a integrar a gramática CFG. O caminho da gramática e o parser gerado são armazenados como tupla na variável ANALISADORES. + """ + parser=constroiAnalisador(sentenca) + codificada=[w.encode("utf-8") for w in sentenca] + trees=parser.parse_one(codificada) + return trees + +def constroiAnalisador(s): + """Constrói analisador a partir de uma única sentença não anotada, dada como lista de tokens, e uma lista de regras sintáticas no formato CFG, armazenadas em arquivo. Esta função tem um bug, causado pela maneira como o Aelius etiqueta sentenças usando o módulo ProcessaNomesProprios: quando a sentença se inicia por paravra com inicial minúscula, essa palavra não é incorporada ao léxico, mas a versão com inicial maiúscula. + """ + global SENTENCA_ANOTADA + SENTENCA_ANOTADA=etiquetaSentenca(s) + corrigeAnotacao(SENTENCA_ANOTADA) + entradas=geraEntradasLexicais(SENTENCA_ANOTADA) + lexico="\n".join(entradas) + gramatica="%s\n%s" % (extraiSintaxe(DIR).strip(),lexico) + cfg=nltk.CFG.fromstring(gramatica) + return nltk.ChartParser(cfg) + +def exibeArvores(arvores): + """Função 'wrapper' para a função de exibição de árvores do NLTK""" + nltk.draw.draw_trees(*arvores) + +def run(sentenca): + tokens=toqueniza(sentenca) + trees=analisaSentenca(tokens) + return trees \ No newline at end of file diff --git a/src/old version/AplicadorRegras.py b/src/old version/AplicadorRegras.py deleted file mode 100644 index 8356ca9..0000000 --- a/src/old version/AplicadorRegras.py +++ /dev/null @@ -1,60 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva - -import xml.etree.ElementTree as ET -import os - -class AplicadorRegras(object): - - # inicializacao das variaves - def __init__(self): - self.__tree = ET.parse('vlibras_user/vlibras-core/data/regras.xml') - self.__root = self.__tree.getroot() - self.__tAux = [] - self.__dAux = {} - - # aplica as regras - def aplicarRegras(self, ts): - self.__n = len(ts) # quantidade de tokens - for i in range(0,self.__n): - self.__tAux.append(self.__n) - self.__name = self.getNameRule(ts) # todos os etiquetadores numa so string (ver linha 35) - for morpho in self.__root: - for rule in morpho.findall('rule'): # procura a tag rule - if rule.get('name') == self.__name: # procura o atributo name na tag rule (ver linha 17) - if rule.find('active').text == "true": # verifica se a regra esta ativa - self.__c = 0 - for classe in rule.iter('class'): # for nas tags class - self.__dAux[self.__c] = int(classe.find('newpos').text) # preenche dicionario com a ordem atual e futura das palavras - self.__c += 1 - self.__c = 0 - for w,t in ts: - i = self.__dAux.get(self.__c) # pega o indice de onde ficara a palavra - self.__tAux[i] = ([w,t]) # preenche a lista com a palavra+etiqueta na posicao correta (segundo o arquivo regras.xml) - self.__c += 1 - return self.__tAux # retorna nova lista (ordenada) - return ts # retorna a lista sem alteracoes (nao existe regra) - - def getNameRule(self, ts): - self.__name = "" - for w,t in ts: - if t[:2] != "VB": - self.__name += t - else: - self.__name += t[:2] - return self.__name - - - - - - - - - - - - - diff --git a/src/old version/Classificador.py b/src/old version/Classificador.py deleted file mode 100644 index 4d5bc60..0000000 --- a/src/old version/Classificador.py +++ /dev/null @@ -1,44 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva - -from Aelius import AnotaCorpus, Toqueniza, Extras - -class Classificador(object): - - # inicializacao das variaveis - def __init__(self): - self.__h = Extras.carrega("AeliusHunPos") # carrega o modelo de idioma (passado por parametro ao instanciar) - - def anotaSentencas(self, str): - self.__t = "" - self.__tokens = "" - #try: - # tokenizae - self.__tokens = Toqueniza.TOK_PORT.tokenize(str) - - # realiza a classificacao morfologica - self.__t = AnotaCorpus.anota_sentencas([self.__tokens],self.__h,'hunpos') - - return self.listClean(self.__t) - #except: - # print "Erro ao efetuar a classificação morfologica." - - - def listClean(self, l): - lClean = [] - for w,t in l[0]: - lClean.append([w,t]) - return lClean - - # faz a impressao (usado apenas pra testes) - def imprimeSentencas(self): - for w,t in self.t[0]: - print "%s_%s " % (w,t), - - - - - - diff --git a/src/old version/Iterator.py b/src/old version/Iterator.py deleted file mode 100644 index 06053ed..0000000 --- a/src/old version/Iterator.py +++ /dev/null @@ -1,59 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva - -from StringAux import * - -class Iterator(object): - - # inicializacao das variaveis - def __init__(self): - self.count = -1 - - def load(self, lista): - self.__list = list(lista); - self.size = len(lista) - - def reset(self): - self.count = -1 - - def getSize(self): - return self.size - - def getCount(self): - return self.count - - def getToken(self, i): - if(i == "+"): - return self.__list[self.count+1] - - elif(i == "-"): - return self.__list[self.count-1] - - else: - return self.__list[self.count] - - def getAtualW(self): - return remover_acentos(self.getToken(0)[0].upper().encode('utf-8')) - - def getAtualT(self): - return self.getToken(0)[1].upper().encode('utf-8') - - def getProxW(self): - return remover_acentos(self.getToken("+")[0].upper().encode('utf-8')) - - def getProxT(self): - return self.getToken("+")[1].upper().encode('utf-8') - - def getAntW(self): - return remover_acentos(self.getToken("-")[0].upper().encode('utf-8')) - - def getAntT(self): - return self.getToken("-")[1].upper().encode('utf-8') - - def hasNext(self): - if(self.count < self.size-1): - self.count += 1 - return True - return False \ No newline at end of file diff --git a/src/old version/ModuleTranslate.py b/src/old version/ModuleTranslate.py deleted file mode 100644 index c9e72f7..0000000 --- a/src/old version/ModuleTranslate.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -from Tradutor import * - -tradutor = Tradutor() - -def iniciar(x): - try: - text = x.decode("utf-8") - except: - text = x.decode("iso-8859-1") - - return tradutor.traduzir(text) diff --git a/src/old version/Output.py b/src/old version/Output.py deleted file mode 100644 index 3259d3c..0000000 --- a/src/old version/Output.py +++ /dev/null @@ -1,24 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva - -import sys -from Iterator import * -from StringAux import * - -class Output(object): - - # inicializa a variavel com o valor passado por paramentro ao instanciar - def __init__(self): - self.it = Iterator() - - # executa a saida - def executeOut(self, ts): - self.__glosa = [] - self.it.load(ts) - while(self.it.hasNext()): - self.__glosa.append(self.it.getAtualW()) - self.it.reset() - return ' '.join(self.__glosa) - diff --git a/src/old version/Simplificador.py b/src/old version/Simplificador.py deleted file mode 100644 index 1e61b26..0000000 --- a/src/old version/Simplificador.py +++ /dev/null @@ -1,164 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva - -from WorkCSV import * -from Iterator import * -from StringAux import * - -class Simplificador(object): - - # inicializa todos as variaveis - def __init__(self): - self.it = Iterator() - self.__csv = WorkCSV() - self.__dicInf = {} - self.__dicSin = {} - self.__dicWords = {} - self.__dic2Gen = {} - self.__dicTemVerbs = {} - self.executeWorkCSV() - - # retira artigos e preposicoes; passa verbos para infinitivo e verificar se há sinonimos - def simplificar(self, texto): - self.__ts = [] - self.it.load(texto) - self.__verb = False - self.__adv = False; - self.__countVerb = 0 - self.__countAdv = 0 - countWords = 0 - while(self.it.hasNext()): - w = self.auxConvert(self.it.getAtualW()) - t = self.it.getAtualT() - self.__b = False - if self.__dicWords.has_key(t) == False: # verifica se nao eh artigo/preposicao - wu = w.upper() # deixa o token maiusculo - #if t[:2] == "VB": - if t[-2:] == "-P": - wu = self.pluralAnalysis(w) - if t == "VB-P" or t == "VB-D" or t == "VB-R": - self.__verb = True - self.__countVerb += 1 - if t[:3] == "ADV": - self.__adv = True - self.__countAdv += 1 - if self.__dicInf.has_key(wu): # verifica se ha um verbo infinitivo desse token - sAux = self.__dicInf[wu] # se sim, adiciona numa string aux - if self.__dicSin.has_key(sAux): # verifica se ha um sinonimo para esse verbo infinitivo - self.__ts.append([self.__dicSin[sAux],t]) # se sim, entao adiciona na lista - self.__b = True - else: - self.__ts.append([sAux,t]) # caso contrario, adiciona so o verbo infinitivo msm - self.__b = True - if self.__b == False and self.__dicSin.has_key(wu): # verifica se nao foi encontrado verbo infinitivo e se ha sinonimo - self.__ts.append([self.__dicSin[wu],t]) # adiciona na o sinonimo lista - self.__b = True - - if self.__dic2Gen.has_key(wu): - del self.__ts[-1] - lenTicket = len(self.it.getAntT()) - if ((self.__dicWords.has_key(self.it.getAntT())) and (self.it.getAntT()[lenTicket-1:] == "F") or (self.it.getAntT()[lenTicket-3:] == "F-P")): - self.__ts.append(["MULHER " + wu,t]) - else: - self.__ts.append(["HOMEM " + wu,t]) - self.__b = True - if self.__b == False: # verifica se nao encontrou nem verbo infinito ou sinonimo - self.__ts.append([wu,t]) - countWords += 1 - self.it.reset() - if self.__verb == True: - return self.verbalAnalysis(self.__ts) - return self.__ts - - # cria e recupera todos os dicionarios (verbos inf., sinonimos e artigos/preposicoes) - def executeWorkCSV(self): - self.__dicInf = self.__csv.getDicInf() - self.__dicSin = self.__csv.getDicSin() - self.__dicWords = self.__csv.getDicWords() - self.__dic2Gen = self.__csv.getDic2Gen() - self.__dicTemVerbs = self.__csv.getDicTemVerbs() - - # converte romano para numero - def auxConvert(self, t): - try: - return roman_to_int(t) - except: - return t - - - def verbalAnalysis(self, lista): - lv = [] - self.it.load(lista) - hasFut = False - hasPas = False - count = 0 - while(self.it.hasNext()): - w = self.it.getAtualW().upper() - t = self.it.getAtualT() - - if(t[:3] == "ADV"): - if (self.__dicTemVerbs.has_key(w)): - self.it.reset() - #print "ADV: retornou lista original" - return lista - - if(t == "VB-P"): - if (self.__countVerb > 1): - count += 1 - #print "VB-P: Incrementou" - if(count == self.__countVerb): - #print "VB-P Adicionou " + w - lv.append([w,t]) - else: - #print "VB-P: retornou lista original" - self.it.reset() - return lista - elif(t == "VB-D"): - count += 1 - hasPas = True - #print "VB-D: Incrementou" - if(count == self.__countVerb): - #print "VB-D Adicionou " + w - lv.append([w,t]) - elif(t == "VB-R"): - count += 1 - hasFut = True - #print "VB-R: Incrementou" - if(count == self.__countVerb): - #print "VB-R Adicionou " + w - lv.append([w,t]) - else: - lv.append([w,t]) - if (hasFut): - lv.append(["FUTURO", "TVB"]) - elif (hasPas): - lv.append(["PASSADO", "TVB"]) - self.it.reset() - return lv - - - def pluralAnalysis(self, word): - - if(word[-3:] == "OES" or word[-2:] == "AES" or word[-2:] == "AOS"): - return word[0:-3]+"AO" - elif(word[-3:] == "RES" or word[-2:] == "ZES" or word[-2:] == "NES"): - return word[0:-2] - elif(word[-3:] == "SES"): - #TODO: Algumas palavras possuem marcações gráficas na raiz singular. Ex: Gás – Gases - return word[0:-2] - elif(word[-2:] == "NS"): - return word[0:-2]+"M" - elif(word[-3:] == "EIS"): - return word[0:-3]+"IL" - elif(word[-2:] == "IS"): - if(word[-3] == "A" or word[-3] == "E" or word[-3] == "O" or word[-3] == "U"): - return word[0:-2]+"L" - else: - return word - elif(word[-1] == "S"): - #TODO: Palavras paroxítonas ou proparoxítonas terminadas em S. Ex: lápis, vírus, tênis, ônibus, etc - return word[0:-1] - else: - return word \ No newline at end of file diff --git a/src/old version/StringAux.py b/src/old version/StringAux.py deleted file mode 100644 index e690a6b..0000000 --- a/src/old version/StringAux.py +++ /dev/null @@ -1,83 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -from unicodedata import normalize - -ext = {1:"um", 2:"dois", 3:"três", 4:"quatro", 5:"cinco", 6:"seis", 7:"sete", 8:"oito", 9:"nove", 0:"zero"} - -def extenso(n): - strn = str(n) - sizen = len(strn) - tokens = [] - for i in range (0, sizen): - x = int(strn[i]) - tokens.append(ext[x]) - return ' '.join(tokens) - -""" -def extenso(n): - strn = str(n) - sizen = len(strn) - tokens = [] - for i in range (0, sizen): - tokens.append(strn[i]) - return ' '.join(tokens) -""" - -def remover_acentos(txt): - - """ Devolve cópia de uma str substituindo os caracteres - acentuados pelos seus equivalentes não acentuados. - - ATENÇÃO: carateres gráficos não ASCII e não alfa-numéricos, - tais como bullets, travessões, aspas assimétricas, etc. - são simplesmente removidos! - - >>> remover_acentos('[ACENTUAÇÃO] ç: áàãâä! éèêë? íìĩîï, óòõôö; úùũûü.') - '[ACENTUACAO] c: aaaaa! eeee? iiiii, ooooo; uuuuu.' - - """ - try: - return normalize('NFKD', txt.decode('utf-8')).encode('ASCII','ignore') - except: - return normalize('NFKD', txt.decode('iso-8859-1')).encode('ASCII','ignore') - - -def roman_to_int(input): - if not isinstance(input, type("")): - raise TypeError, "expected string, got %s" % type(input) - input = input.upper( ) - nums = {'M':1000, - 'D':500, - 'C':100, - 'L':50, - 'X':10, - 'V':5, - 'I':1} - sum = 0 - for i in range(len(input)): - try: - value = nums[input[i]] - if i+1 < len(input) and nums[input[i+1]] > value: - sum -= value - else: sum += value - except KeyError: - raise ValueError, 'input is not a valid Roman numeral: %s' % input - - if int_to_roman(sum) == input: return sum - else: raise ValueError, 'input is not a valid Roman numeral: %s' % input - -def int_to_roman(input): - if not isinstance(input, type(1)): - raise TypeError, "expected integer, got %s" % type(input) - if not 0 < input < 4000: - raise ValueError, "Argument must be between 1 and 3999" - ints = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1) - nums = ('M', 'CM', 'D', 'CD','C', 'XC','L','XL','X','IX','V','IV','I') - result = [] - - for i in range(len(ints)): - count = int(input / ints[i]) - result.append(nums[i] * count) - input -= ints[i] * count - return ''.join(result) \ No newline at end of file diff --git a/src/old version/Tradutor.py b/src/old version/Tradutor.py deleted file mode 100644 index 68175ab..0000000 --- a/src/old version/Tradutor.py +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva - -from Classificador import * -from Simplificador import * -from AplicadorRegras import * -from Output import * -from StringAux import * - - -class Tradutor(object): - - def __init__(self): - #instanciando os objetos - self.__classificador = Classificador() - self.__simplificador = Simplificador() - self.__regras = AplicadorRegras() - self.__out = Output() - - - def traduzir(self, txt): - self.__tr = None - - #faz a tokenizacao e a classificacao - self.__t = self.__classificador.anotaSentencas(txt) - - #retira artigos e preposicoes - self.__ts = self.__simplificador.simplificar(self.__t) - self.__t = None - - #aplica as regras - self.__tr = self.__regras.aplicarRegras(self.__ts) - self.__ts = None - - #executa a saida - return self.__out.executeOut(self.__tr).encode("utf-8") diff --git a/src/old version/WorkCSV.py b/src/old version/WorkCSV.py deleted file mode 100644 index 43e2a81..0000000 --- a/src/old version/WorkCSV.py +++ /dev/null @@ -1,125 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -#Autor: Erickson Silva - -import os, csv, sys - -class WorkCSV(object): - _iInstance = None - - class Singleton: - def __init__(self): - self.LeitorDicionarios = None - - def __init__( self ): - if LeitorDicionarios._iInstance is None: - LeitorDicionarios._iInstance = LeitorDicionarios.Singleton() - - self._EventHandler_instance = LeitorDicionarios._iInstance - - def __getattr__(self, aAttr): - return getattr(self._iInstance, aAttr) - - def __setattr__(self, aAttr, aValue): - return setattr(self._iInstance, aAttr, aValue) - - # Define e inicializa os atributos - def __init__(self): - self.__path = "vlibras_user/vlibras-core/data/" - self.__fileInf = '' - self.__dicInf = {} - self.__fileSin = '' - self.__dicSin = {} - self.__fileWords = '' - self.__dicWords = {} - self.__file2Gen = '' - self.__dic2Gen = {} - self.__fileTemVerbs = '' - self.__dicTemVerbs = {} - self.createDicInf() - self.createDicSin() - self.createDicWords() - self.createDic2Gen() - self.createDicTemVerbs() - - # Abre o arquivo que contem os verbos no infinitivo e preenche o dicionario com os mesmos - def createDicInf(self): - try: - self.__fileInf = csv.reader(open(self.__path+"dicPortGlosa.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "createDicInf" - - for row in self.__fileInf: - if row[1] != "": - try: - self.__dicInf[row[0].decode("utf-8")] = row[1].decode("utf-8") - except UnicodeDecodeError: - self.__dicInf[row[0].decode('iso8859-1').encode('utf-8')] = row[1].decode('iso8859-1').encode('utf-8') - - # Abre o arquivo que contem os sinonimos e preenche o dicionario com os mesmos - def createDicSin(self): - try: - self.__fileSin = csv.reader(open(self.__path+"portuguesGlosa.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "createDicSin" - - for row in self.__fileSin: - if row[1] != "": - self.__dicSin[row[0].decode("utf-8")] = row[1].decode("utf-8") - - - # Abre o arquivo que contem os tempos verbais - def createDicTemVerbs(self): - try: - self.__fileTemVerbs = csv.reader(open(self.__path+"temposVerbais.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "createDicTemVerbs" - - for row in self.__fileTemVerbs: - self.__dicTemVerbs[row[0].decode("utf-8")] = row[0].decode("utf-8") - - # Abre o arquivo que contem os artigos e preposicoes de acordo com o modelo de idioma passado na chamada e preenche o dicionario com os mesmos - def createDicWords(self): - try: - self.__fileWords = csv.reader(open(self.__path+"hWordsRemove.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "createDicWords" - - for row in self.__fileWords: - self.__dicWords[row[0].decode("utf-8")] = row[0].decode("utf-8") - - # Abre o arquivo que contem os substantivos que sao comuns dos 2 generos e preenche o dicionario com os mesmos - def createDic2Gen(self): - try: - self.__file2Gen = csv.reader(open(self.__path+"subs2Generos.csv"), delimiter=";") - except IOError, (errno, strerror): - print "I/O error(%s): %s" % (errno, strerror) - print "createDic2Gen" - - for row in self.__file2Gen: - self.__dic2Gen[row[0].decode("utf-8")] = row[0].decode("utf-8") - - # Retorna o dicionario dos verbos no infinitivo - def getDicInf(self): - return self.__dicInf - - # Retorna o dicionario dos sinonimos - def getDicSin(self): - return self.__dicSin - - # Retorna o dicionario dos artigos e preposicoes a serem removidos pelo simplificador - def getDicWords(self): - return self.__dicWords - - # Retorna o dicionario dos substantivos a serem analisados pelo simplificador - def getDic2Gen(self): - return self.__dic2Gen - - # Retorna o dicionario dos tempos verbais - def getDicTemVerbs(self): - return self.__dicTemVerbs \ No newline at end of file diff --git a/translate.py b/translate.py deleted file mode 100644 index c9e72f7..0000000 --- a/translate.py +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -from Tradutor import * - -tradutor = Tradutor() - -def iniciar(x): - try: - text = x.decode("utf-8") - except: - text = x.decode("iso-8859-1") - - return tradutor.traduzir(text) -- libgit2 0.21.2