Software Público Brasileiro

#!/usr/bin/python
# -*- coding: utf-8 -*-

#Autor: Erickson Silva 
#Email: <erickson.silva@lavid.ufpb.br> <ericksonsilva@live.com>

#LAViD - Laboratório de Aplicações de Vídeo Digital

import platform
import re
import xml.etree.ElementTree as ET
from os.path import expanduser
from collections import deque
from LerDicionarios import *
from Iterator import *
from ConverteExtenso import *
from nltk_tgrep import tgrep_positions, tgrep_nodes
from nltk import ParentedTree, Tree, draw

class AplicaRegras(object):

	def __init__(self):	
		self.__root = self.get_root()
		self.dicionarios = LerDicionarios()
		# Dicionário de funcões do campo specific do arquivo de regras
		self.__especificos = {"advt":self.verificar_adv_tempo, "v":self.verificar_vb_infinitivo, "x":self.verificar_preposicao,
								"c":self.verificar_subst_genero, "a":self.verificar_artigo, "l":self.verificar_vb_ligacao,
									"i":self.verificar_adv_intensidade, "vbi":"zero", "n":self.verificar_vb_muda_negacao, "abmn":"zero",
										"adji":"zero","adjn":"zero", "advi":"zero"}

		self.__acoes = {"change_vb":self.get_vb_infinitivo, "concate_intens":self.get_token_intensidade}

	# Gera arvore a partir do arquivos regras.xml
	def get_root(self):
		if platform.system() == 'Windows':
			return ET.parse(expanduser("~")+'\\vlibras-translate\data\\regras.xml').getroot()
		return ET.parse(expanduser("~")+'/vlibras-translate/data/regras.xml').getroot()

	# Aplica regras morfológicas apartir do arquivo regras.xml
	def aplicar_regras_morfo(self, lista, sint=False):
		self.lista = list(lista) # Nova cópia da lista morfológica
		self.lista_corrigida =[] # Lista morfológica após a aplicação das regras

		it = Iterator()
		it.load(self.lista)

		while(it.has_next()):
			for morpho in self.__root.findall('morphological'):
				self.has_rule = False # Boolean caso encontre encontre regra compativel
				for rule in morpho.findall('rule'):
					# Verifica se a regra está ativa e se o nome da regra, ou o ínicio, é igual a tag de classificação do token atual
					if rule.find('active').text == "true" and rule.get('name').split("_")[0] == it.get_ticket():
						count = int(rule.find('count').text)
						self.lista_iteracoes = [] # Lista que conterá todas tuplas referentes a quantidade de classes da regra

						# Obtém o intervalo de tuplas de acordo com o número de classes da regra
						try:
							self.lista_iteracoes = it.get_interval(count)
							print '# LISTA DA ITERAÇÂO: '
							print self.lista_iteracoes
						except:
							continue

						# Gera o nome da regra do intervalo de tuplas e verifica se é igual ao nome da regra em si
						self.nome_regra = self.gerar_nome_regra(self.lista_iteracoes)
						if rule.get('name') == self.nome_regra:
							self.has_rule = True
							self.count_iteracao_regra = -1

							print "REGRA MORFOLÓGICA ENCONTRADA: " + rule.get('name')

							self.lista_iteracao_regra = [] # Lista temporária | Insere tokens após a aplicação das regras
							
							for classe in rule.iter('class'): # for nas tags class
								action = classe.find('action')
								newprop = classe.find('newprop')
								newtoken = classe.find('newtoken')
								newtokenpos = classe.find('newtokenpos')
								specific = classe.find('specific')

								self.count_iteracao_regra += 1
								tupla = self.lista_iteracoes[self.count_iteracao_regra]

								if specific is not None:
									result_specific = self.__especificos[specific.text](tupla[0])
									if result_specific is False:
										print "REGRA MORFOLÓGICA " + rule.get('name') + " INVÁLIDA. PROCURANDO OUTRA..."
										self.has_rule = False
										break

								if action is not None:
									action_text = action.text
									if action_text == "remove":
										self.lista_iteracao_regra.append(None)
										continue
									elif action_text == "invert":
										self.lista_iteracao_regra.reverse()
									elif self.__acoes.has_key(action_text):
										result_action = self.__acoes[action_text](tupla[0]).lower()
										self.lista_iteracao_regra.append([result_action, tupla[1]])
								else:
									self.lista_iteracao_regra.append(tupla)

								if newprop is not None:
									self.lista_iteracao_regra[self.count_iteracao_regra][1] = newprop.text

								if newtoken is not None:
									if newtokenpos.text == "next":
										self.lista_iteracao_regra.append([newtoken.text.lower(), "NTK"])
									elif newtokenpos.text == "previous":
										self.lista_iteracao_regra.append(self.lista_iteracao_regra[-1])
										self.lista_iteracao_regra[-2] = [newtoken.text.lower(), "NTK"]
									elif newtokenpos.text == "end":
										print "TODO"
						
						if self.has_rule:
							it.skip(count-1)
							self.lista_corrigida.extend(self.lista_iteracao_regra)
							break

				if self.has_rule is False:
					print 'NÃO ACHOU REGRA - ' + it.get_word().encode('utf-8')
					self.lista_corrigida.append(it.get_token()) #se nao achou regra, entao adiciona a tupla original
		if sint:
			return self.lista_corrigida        
		return filter(None, self.lista_corrigida)


	def aplicar_regras_sint(self, lista, arvore):
		p_arvore = ParentedTree.convert(arvore)
		self.adaptar_regras_morfo_arvore(lista, p_arvore)
		for morpho in self.__root.findall('syntactic'):
			for rule in morpho.findall('rule'): # procura a tag rule
				nome_regra = self.corrigir_nome_regra(rule.get('name'))
				regra = self.separar_regra(nome_regra)
				node_pai = tgrep_nodes(p_arvore, regra[0], search_leaves=False)
				if node_pai and rule.find('active').text == "true":
					node_pai = node_pai[0]
					node_regra = tgrep_nodes(node_pai, regra[1].replace('$', '..'), search_leaves=False)
					if node_regra:
						node_esq_pos = tgrep_positions(node_pai, regra[1], search_leaves=False)
						node_dir_pos = tgrep_positions(node_pai, regra[2], search_leaves=False)
						if node_esq_pos and node_dir_pos:
							print "REGRA SINTÁTICA ENCONTRADA: " + rule.get('name')
							nodes_positions = node_esq_pos + node_dir_pos
							self.count = -1
							self.has_rule = True
							
							count_temp = -1
							for classe in rule.findall('class'):
								count_temp += 1
								leaves = node_pai[nodes_positions[count_temp]].leaves()
								token = filter(None, leaves)[0]
								specific = classe.find('specific')
								if specific is not None:
									result_specific = self.__especificos[specific.text](token)
									if result_specific is False:
										self.has_rule = False
									
							if self.has_rule is False:
								print "REGRA SINTÁTICA " + rule.get('name') + " INVÁLIDA. PROCURANDO OUTRA..."
								break

							nodes_deleted = []

							for classe in rule.iter('class'):
								action = classe.find('action')
								newprop = classe.find('newprop')

								self.count += 1

								if action is not None:
									action_text = action.text

									if action_text == "remove":
										pos_del = nodes_positions[self.count]
										nodes_deleted.append(node_pai[pos_del])
										node_pai[pos_del] = None
										continue

									elif action_text == "invert":
										aux1 = node_pai[nodes_positions[self.count]]
										aux2 = node_pai[nodes_positions[self.count+1]]
										node_pai[nodes_positions[self.count]] = None
										node_pai[nodes_positions[self.count+1]] = None
										node_pai[nodes_positions[self.count]] = aux2
										node_pai[nodes_positions[self.count+1]] = aux1

									'''
									elif self.__acoes.has_key(action_text):
										leaves = node_pai[nodes_positions[self.count]].leaves()
										token = filter(None, leaves)[0]
										result_action = self.__acoes[action_text](token)

										#self.lista_iteracao_regra.append([result_action, tupla[1]])
										nodes_positions[self.count] = 'TODO'

										if action_text == "concate_intens":
											leaves_prev = node_pai[nodes_positions[self.count-1]].leaves()
											token_prev = filter(None, leaves_prev)[0]
											title_text = classe.find('title').text
											if title_text == "ADV-R":
												node_prev = nodes_deleted.pop()
												label_prev = node_prev[0][0].label()
												token_prev = filter(None, node_pai[nodes_positions[count_temp-1]].leaves())[0]
												token = filter(None, node_pai[nodes_positions[count_temp]].leaves())[0]
												token_concate = token_prev + "_" + token
												node_pai[nodes_positions[count_temp-1]][0][0][0] = token_concate
												newprop = ""
												if label_prev[:-2] == "VB":
													newprop = "VBi"
												elif label_prev[:-3] == "ADJ":
													newprop = "ADJi"

												# TODO: Verifica qual newprop adicionada e remove o nó corrente
												node_pai[nodes_positions[count_temp-1]][0][0].set_label(newprop)
												pos_del = nodes_positions[self.count]
												node_pai[pos_del] = None
												
											else:
												token_prev = filter(None, nodes_deleted.pop().leaves())[0]
												token = filter(None, node_pai[nodes_positions[count_temp]].leaves())[0]
												token_concate = token +  "_" + token_prev
												node_pai[nodes_positions[count_temp]][0][0][0] = token_concate

										elif action_text == "concate_neg":
											print "TODO"
										'''

								if newprop is not None:
									node_pai[nodes_positions[self.count]].set_label(newprop.text)

								break
								
		return self.converter_arv_para_lista(p_arvore)
								

	# Aplica regras morfológicas na árvore sintática
	def adaptar_regras_morfo_arvore(self, lista, arvore):
		lista_pos_arv = []
		# Pega as posições das classificações morfológicas dos tokens na arvore sintática
		for tupla in lista:
			string_grep = self.corrigir_nome_regra(tupla[1]) + " < " + tupla[0].lower()
			node = tgrep_positions(arvore, string_grep)
			if not node:
				string_grep = self.corrigir_nome_regra(tupla[1]) + " < " + self.remover_acento(tupla[0].lower())
				node = tgrep_positions(arvore, string_grep)
			if node[0] in lista_pos_arv:
				node.reverse()
			lista_pos_arv.append(node[0])

		# Aplica regras morfológicas na lista
		morfo = self.aplicar_regras_morfo(lista, sint=True)

		# Corrige arvore de acordo com a lista após aplicar as regras morfológicas
		for i in range(0, len(morfo)):
			if morfo[i] is not None and morfo[i][1] == "NTK":
				new_node = self.gerar_no(morfo[i])
				arvore[lista_pos_arv[i-1][:-2]].insert(2, new_node)
				try:
					lista_pos_arv.insert(i,lista_pos_arv[i])
				except:
					continue

			arv_ticket = arvore[lista_pos_arv[i]].label()
			arv_token = arvore[lista_pos_arv[i]][0]
			
			if morfo[i] is None:
				arvore[lista_pos_arv[i]] = None
			
			elif arv_token != morfo[i][0] and arv_ticket != morfo[i][1]:
				arvore[lista_pos_arv[i]][0] = morfo[i][0]
				arvore[lista_pos_arv[i]].set_label(morfo[i][1])
			
			elif arv_token != morfo[i][0]:
				arvore[lista_pos_arv[i]][0] = morfo[i][0]
			
			elif arv_ticket != morfo[i][1]:
				arvore[lista_pos_arv[i]].set_label(morfo[i][1])

	# Converte árvore sintática para uma lista de tuplas (igual a lista morfológica)
	def converter_arv_para_lista(self, arvore):
		folhas = filter(None, arvore.leaves())
		lista_nodes = []
		for folha in folhas:
			pos = tgrep_positions(arvore, folha)
			node = arvore[pos[0][:-1]]
			#decode node[0]
			lista_nodes.append([node[0], self.corrigir_nome_regra(node.label())])
		return lista_nodes

	def remover_acento(self, texto):
		return normalize('NFKD', texto.encode('utf-8').decode('utf-8')).encode('ascii', 'ignore')

	# Gera um ParentedTree do NLTK apartir da string recebida
	def gerar_no(self, s):
		all_ptrees = []
		t_string = '('+s[1] + ' ' + s[0]+')'
		ptree = ParentedTree.convert(Tree.fromstring(t_string))
		all_ptrees.extend(t for t in ptree.subtrees()
							if isinstance(t, Tree))
		return ptree

	# Corrige nome da regra descrita no arquivo de regras para como está na árvore sintática
	def corrigir_nome_regra(self, anotacao):
		split = anotacao.split('_')
		for i in range(0, len(split)):
			split[i] = re.sub(r"[-+]","_", split[i])
			split[i] = re.sub(r"\$","_S",split[i])
		return "-".join(split).encode('utf-8')

	# Separa a regra por nó pai e seus filhos
	def separar_regra(self, regra):
		split = regra.split("(")
		split[1] = split[1].replace(")","").split("-")
		rev = list(split[1])
		rev.reverse() 
		split.append(rev)
		split[1] = ' $ '.join(split[1])
		split[2] = ' $ '.join(split[2])
		return split

	# Gera nome de regra apartir de uma lista
	def gerar_nome_regra(self, lista):
		nome_regra = []
		for t in lista:
			nome_regra.append(t[1])
		return "_".join(nome_regra)

	def verificar_adv_tempo(self, token):
		for tupla in self.lista:
			if self.dicionarios.has_adverbio_tempo(tupla[0]):
				return True
		return False

	def verificar_excecao_plural(self, token):
		return self.dicionarios.has_excecao_plural(token)

	def verificar_vb_infinitivo(self, token):
		return self.dicionarios.has_verbo_infinitivo(token)

	def verificar_preposicao(self, token):
		return self.dicionarios.has_preposicao(token)

	def verificar_subst_genero(self, token):
		return self.dicionarios.has_subst_2_generos(token)

	def verificar_artigo(self, token):
		return self.dicionarios.has_artigo(token)

	def verificar_vb_ligacao(self, token):
		return self.dicionarios.has_verbo_ligacao(token)

	def verificar_adv_intensidade(self, token):
		return self.dicionarios.has_adverbio_intensidade(token)

	def verificar_vb_muda_negacao(self, token):
		return self.dicionarios.has_verbo_muda_negacao(token)

	def get_vb_infinitivo(self, token):
		if self.dicionarios.has_verbo_infinitivo(token):
			return self.dicionarios.get_verbo_infinitivo(token)
		return token

	def get_token_intensidade(self, token):
		print 'TODO'


	# Simplifica a sentença para que possa evitar a ditalogia
	def simplificar_sentenca(self, lista):
		lista_simplificada = list(lista)
		it = Iterator()
		it.load(lista_simplificada)
		num = False
		while(it.has_next()):
			tag = it.get_ticket()

			if tag == "NUM":
				num = True

			if tag[-2:] == "-P" and self.verificar_excecao_plural(it.get_word()):
				singular = self.analisar_plural(it.get_word())
				lista_simplificada[it.get_count()][0] = singular

		if num: 
			return self.converter_extenso(lista_simplificada)
		return lista_simplificada

	# Alterar uma palavra do plural para o singular
	def analisar_plural(self, token):
		if(token[-3:] == "OES" or token[-2:] == "AES" or token[-2:] == "AOS"):
			return token[0:-3]+"AO"
		elif(token[-3:] == "RES" or token[-2:] == "ZES" or token[-2:] == "NES"):
			return token[0:-2]
		elif(token[-3:] == "SES"):
			#TODO: Algumas palavras possuem marcações gráficas na raiz singular. Ex: Gás – Gases
			return token[0:-2]
		elif(token[-2:] == "NS"):
			return token[0:-2]+"M"
		elif(token[-3:] == "EIS"):
			return token[0:-3]+"IL"
		elif(token[-2:] == "IS"):
			if(token[-3] == "A" or token[-3] == "E" or token[-3] == "O" or token[-3] == "U"):
				return token[0:-2]+"L"	
			return token	
		elif(token[-1] == "S"):
	    	#TODO: Palavras paroxítonas ou proparoxítonas terminadas em S. Ex: lápis, vírus, tagênis, ônibus, etc
			return token[0:-1]
		else:
			return token

	# Converter número por extenso para numeral
	def converter_extenso(self, lista):
		lista_extensos = []
		indices_deletar = []
		count = 0
		is_sequence = False

		for i in range(0, len(lista)):
			token = lista[i][0]
			tag = lista[i][1]
			if tag == "NUM":
				# Verifico se não há sequência de obtenção de extenso em andamento para começar a obter um nova sequência
				if (is_sequence is False): # and len(lista_extensos) == count (???)
					lista_extensos.append([i,[token]]) # i = Posição do primeiro extenso encontrado, token = número por extenso
					is_sequence = True
				else:
					lista_extensos[count][1].append(token) # Pego número por extenso que está na sequência e adiciona na lista
					indices_deletar.append(i) # Insiro indice na lista para ser removido depois
			elif (is_sequence):
				# Se o token anterior e o próximo foram classificados como número, e o token atual como conjunção, significa que podemos remove-lo 
				if ((lista[i-1][1] == "NUM") and (lista[i+1][1] == "NUM") and (tag == "CONJ")):
					indices_deletar.append(i)
				else:
					# A sequência foi quebrada, o que significa que selecionamos o extenso do número por completo
					# Podemos agora procurar por outra sequencia de número por extenso na lista
					is_sequence = False
					count += 1

		for extenso in lista_extensos:
			ext = convert_extenso(' '.join(extenso[1]))
			lista[extenso[0]] = [ext, "NUM"]

		deque((list.pop(lista, i) for i in sorted(indices_deletar, reverse=True)), maxlen=0)
		return lista