# -*- coding: utf-8 -*-
"""
@project ensepro
@since 25/02/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
import re
from enum import Enum
from ensepro import configuracoes
from ensepro.constantes import ConfiguracoesConstantes, LoggerConstantes
regex_voz_passiva = re.compile(
configuracoes.get_config(ConfiguracoesConstantes.REGEX_VOZ_PASSIVA))
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_VOZ)
class Voz(Enum):
PASSIVA = 'passiva'
ATIVA = 'ativda'
def get(frase):
logger.info("Obtendo voz da frase: [%s]", frase)
for palavra in frase.palavras:
logger.debug(
"Verificando palavras: [palavra.tag_inicial=%s, regex=%s]",
palavra.tag_inicial, regex_voz_passiva)
if regex_voz_passiva.search(palavra.tag_inicial):
# -*- coding: utf-8 -*-
"""
@project ensepro
@since 25/02/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
from ensepro.constantes import SinonimosConstantes, LoggerConstantes
from nltk.corpus import wordnet as wn
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_SINONIMOS)
def get_sinonimos(palavra: str, lang: str) -> list:
"""
Execute a consulta de sinônimos na wordnet.
:param palavra: palavra que se deve bucar os sinônimos
:param lang: linguagem(abreviação) dos quais os sinônimos devem ser tradidos
:return: Lista de string com os sinônimos retornados pela wordnet. A string estará no formato "^.*\.(a|v|n).([0-9][0-9])\..*$"
"""
logger.info("Buscando sinonimos: [palavra=%s, lang=%s]", palavra, lang)
sinonimos = set()
lemmasDaPalavra = wn.lemmas(palavra, lang=SinonimosConstantes.LEMMAS_LANG)
logger.debug("Lemmas da palavra '%s' com lang=%s: %s", palavra, SinonimosConstantes.LEMMAS_LANG, lemmasDaPalavra)
for lemma in lemmasDaPalavra:
synsetNome = lemma.synset().name()
synsetLemmas = wn.synset(synsetNome).lemmas(lang)
# -*- coding: utf-8 -*-
"""
@project ensepro
@since 25/02/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
import re
from ensepro import configuracoes
from ensepro.constantes import ConfiguracoesConstantes, LoggerConstantes
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_TERMOS_RELEVANTES)
regex_termo_relevante = re.compile(
configuracoes.get_config(ConfiguracoesConstantes.REGEX_TERMO_RELEVANTE))
verbos_ligacao = configuracoes.get_config(
ConfiguracoesConstantes.VERBOS_DE_LIGACAO)
termos_ignorar = configuracoes.get_config(
ConfiguracoesConstantes.TERMOS_RELEVANTES_IGNORAR)
def __is_termo_relevante_base(frase, palavra, *args):
# 1. Deve ter palavra_canonica
if not palavra.palavra_canonica:
logger.debug(
"'__is_termo_relevante_base' -> palavra '%s' sem palavra canônica",
palavra.id)
return False
# 2. tagInicial da palavra deve bater com a regex de termos relevantes
if not regex_termo_relevante.search(palavra.tag_inicial):
# -*- coding: utf-8 -*-
"""
@project ensepro
@since 25/02/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
from ensepro.cln.complementos_nominais import ComplementoNominal
from ensepro.constantes import LoggerConstantes
logger = LoggerConstantes.get_logger(
LoggerConstantes.MODULO_COMPLEMENTOS_NOMINAIS)
def get(frase):
logger.info("Obtendo complementos nominais para frase: [%s]", frase)
complementos_nominais = []
for palavra in frase.palavras:
if palavra.tag_inicial in LOGICAS:
logger.debug("Chamando função '%s' para tag_inicial=%s",
LOGICAS[palavra.tag_inicial].__name__,
palavra.tag_inicial)
complemento_nominal = LOGICAS[palavra.tag_inicial](frase, palavra)
if complemento_nominal and complemento_nominal.ok:
logger.info("Complemento nominal encontrado: [%s]",
complemento_nominal)
complementos_nominais.append(complemento_nominal)
return complementos_nominais
"""
@project ensepro
@since 09/04/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
import requests
from ensepro.servicos.request import SpotlightRequest
from ensepro.servicos.response import SpotlightResponse
import ensepro.configuracoes as configuracoes
from ensepro.constantes import LoggerConstantes, DBPediaSpotlightConstantes
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_DBPEDIA_SPOTLIGHT_SERVICE)
endpoint = configuracoes.get_config(DBPediaSpotlightConstantes.ENDPOINT)
servico_spotlight = configuracoes.get_config(DBPediaSpotlightConstantes.SERVICO_SPOTLIGHT)
cache = {}
def spotlight(request: SpotlightRequest, lang="pt") -> SpotlightResponse:
logger.info("Service Spotlight request: [request=%s]", request)
value_in_cache = cache.get(request.hash(), None)
if value_in_cache:
logger.info("Retornando valor em cache")
logger.debug("CACHE: %s", value_in_cache)
return value_in_cache
url = __build_url([endpoint, servico_spotlight.format(lang=lang)])
params = request.__dict__
headers = {"Accept": "application/json"}
# -*- coding: utf-8 -*-
"""
@project ensepro
@since 08/03/2019
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
import requests
from requests import HTTPError
import ensepro.configuracoes as configuracoes
from ensepro.constantes import LoggerConstantes, WordEmbeddingServidorConstantes as wb_consts
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_WORD_EMBEDDING)
endpoint = configuracoes.get_config(wb_consts.ENDPOINT)
porta = configuracoes.get_config(wb_consts.PORTA)
servico_word_embedding = configuracoes.get_config(
wb_consts.SERVICO_WORD_EMBEDDING)
simple_cache = {}
def word_embedding(palavra1, palavra2):
if not palavra1 or not palavra2:
return 0
palavra1 = palavra1.lower()
palavra2 = palavra2.lower()
logger.debug("Verificando similaridade entra palavras: %s - %s", palavra1,
palavra2)
# -*- coding: utf-8 -*-
"""
@project ensepro
@since 25/02/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
from string import Template
from chatterbot import ChatBot
from ensepro import configuracoes
from ensepro.cln.tipo_frases import TipoFrase
from ensepro.constantes import ChaterbotConstantes, LoggerConstantes
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_CHATTERBOT_HELPER)
chatter_bot = None
# termos_relevantes = Lista de palavras que devem ser consideradas para obtenção do tipo da frase
attention_termos_relevantes = {}
PALAVRAS_CHAVE = {
"termo_relevante": "#"
}
def get_tipo(frase):
if not chatter_bot:
criar_chatterbot()
iniciar_treinamento()
logger.debug("termos_relevantes: %s", attention_termos_relevantes)
logger.info("Obtendo tipo da frase: %s", frase)
# -*- coding: utf-8 -*-
"""
@project ensepro
@since 25/02/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
import requests
from requests import HTTPError
import ensepro.configuracoes as configuracoes
from ensepro.constantes import PalavrasServidorConstantes as ps_consts, LoggerConstantes as logger_consts
logger = logger_consts.get_logger(logger_consts.MODULO_PALAVRAS_SERVICE)
endpoint = configuracoes.get_config(ps_consts.ENDPOINT)
porta = configuracoes.get_config(ps_consts.PORTA)
servico_analisar_frase = configuracoes.get_config(
ps_consts.SERVICO_ANALISAR_FRASE)
# TODO verificar a necessidade de uma classe de Request e Response
# TODO 2. futuro: implementar no PalavrasService um serviço que recebe uma lista de frase
# e faz a analise delas e retorna tudo de uma vez... (acho que fica melhor do que ficar chamando toda hora...)
def analisar_frase(frase: str):
logger.info("Analisando frase: [frase=%s]", frase)
url = __build_url([endpoint, ":", porta, servico_analisar_frase])
params = {"frase": frase.replace("(", "").replace(")", "")}
logger.debug("Executando request [url=%s, params=%s]", url, params)
"""
@project ensepro
@since 10/04/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
import requests
from ensepro.servicos.request import KnowledgeGraphSearchRequest
from ensepro.servicos.response import KnowledgeGraphSearchResponse
import ensepro.configuracoes as configuracoes
from ensepro.constantes import LoggerConstantes, KnowledgeGraphSearchConstantes
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_KNOWLEDGE_GRAPH_SEARCH_SERVICE)
endpoint = configuracoes.get_config(KnowledgeGraphSearchConstantes.ENDPOINT)
search_service = configuracoes.get_config(KnowledgeGraphSearchConstantes.SEARCH_SERVICE)
api_key = ""
try:
api_key = open(configuracoes.get_config(KnowledgeGraphSearchConstantes.API_KEY)).read()
except Exception as ex:
logger.info("Erro ao carregar arquivo com key de autenticação com GoogleKnowledgeGraph. ")
logger.exception(ex)
def search(request: KnowledgeGraphSearchRequest) -> KnowledgeGraphSearchResponse:
logger.info("Service Knowledge Graph Search request: [request=%s]", request)
url = __build_url([endpoint, search_service])
params = request.__dict__
"""
@project ensepro
@since 09/03/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
from ensepro.constantes import LoggerConstantes
from ensepro.elasticsearch import connection
from ensepro.elasticsearch.queries import Query, QueryStringSearch, QueryTermSearch, QueryTermsSearch
from .search import execute_search
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_ES_CONSULTA)
def simple_query_string_search(field, value):
query_string = QueryStringSearch()
query_string.add_field(field)
query_string.add_value(value)
query = Query.build_default(query_string.build_query())
logger.info("Criando QueryString")
return execute_search(connection(), query)
def simple_query_term_search(field, value):
query_term = QueryTermSearch(field, value)
query = Query.build_default(query_term.build_query())
logger.info("Criando QueryTerm")
return execute_search(connection(), query)
def simple_query_terms_search(field, values):
"""
@project ensepro
@since 04/03/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
import re
import json
from ensepro.servicos.palavras_service import analisar_frase
from ensepro.constantes import LoggerConstantes, StringConstantes
from ensepro.elasticsearch import helpers, loaders
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_ES_DATASET)
def carregar_dataset(es_client, index_name, index_type, index_settings,
dataset_file, delete_index_before=False):
helpers.create_index(es_client, index_name, index_settings, delete_index_before=delete_index_before)
linhas_dataset = open(dataset_file,
StringConstantes.FILE_READ_ONLY,
encoding=StringConstantes.UTF_8).read().split(StringConstantes.BREAK_LINE)
acoes_insercao = __converter_para_insert_actions(index_name, index_type, linhas_dataset)
print(json.dumps(acoes_insercao, indent=4, sort_keys=False))
def __converter_para_insert_actions(index_name, index_type, linhas_dataset):
acoes = []
for linha in linhas_dataset:
# -*- coding: utf-8 -*-
"""
@project ensepro
@since 25/02/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
from nltk.tree import Tree
from ensepro.constantes import LoggerConstantes
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_ARVORE)
class Arvore:
def __init__(self):
self.__nodes = {}
@property
def nodes(self):
return self.__nodes
@property
def roots(self):
"""
A(s) raiz(es) da árvore são os nodes que não possuem pais.
:return: Todos os nodos que são raizes.
"""
return [node for node in self.nodes.values() if not node.pai]
def adicionar_node(self, id, value, id_pai=None):
# -*- coding: utf-8 -*-
"""
@project ensepro
@since 25/02/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
from ensepro.constantes import LoggerConstantes
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_LOCUCAO_VERBAL)
def get(frase):
logger.info("Buscando locuções verbais: [%s]", frase)
palavras = frase.get_palavras(__condicao_palavra_original_nao_vazia)
logger.debug("Palavras com palavra original não vazia: [%s]", palavras)
numero_palavras = len(palavras)
locucoes = []
map_locucao_atual = {}
palavra_anterior = None
for index in range(numero_palavras):
palavra_atual = palavras[index]
# Se a palavra anterior e a palavra atual forem verbos, existe um locução verbal
if palavra_anterior and palavra_anterior.is_verbo() and palavra_atual.is_verbo():
map_locucao_atual[palavra_anterior.id] = palavra_anterior
map_locucao_atual[palavra_atual.id] = palavra_atual
logger.debug("Locução encontrada: [palavra_atual=%s, palavra_anterior=%s]", palavra_atual, palavra_anterior)
"""
@project ensepro
@since 04/03/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
from ensepro.constantes import LoggerConstantes
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_ES_HELPERS)
def create_index(es_client, index_name, index_settings, delete_index_before=False):
if delete_index_before:
delete_index(es_client, index_name)
logger.info("Criando índice {}".format(index_name))
es_client.indices.create(index=index_name, body=index_settings)
def delete_index(es_client, index_name):
logger.debug("Removendo índice '{}'".format(index_name))
es_client.indices.delete(index=index_name, ignore=[400, 404])
# -*- coding: utf-8 -*-
"""
@project ensepro
@since 20/09/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
import json
from ensepro import configuracoes
from ensepro.constantes import ConfiguracoesConstantes, StringConstantes, LoggerConstantes
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_NOMINALIZACAO)
nominalizacoes = json.loads(open(
file=ConfiguracoesConstantes.ENSEPRO_PATH + configuracoes.get_config(ConfiguracoesConstantes.ARQUIVO_NOMINALIZACAO),
mode=StringConstantes.FILE_READ_ONLY,
encoding=StringConstantes.UTF_8
).read())
def get(verbo: str):
logger.info("Obtendo nominalização do verbo: %s", verbo)
result = nominalizacoes.get(verbo, [])
logger.debug("Nominalizações: %s", str(result))
return result
"""
@project ensepro
@since 04/03/2018
@author Alencar Rodrigo Hentges <*****@*****.**>
"""
from ensepro import configuracoes
from elasticsearch import Elasticsearch
from ensepro.constantes import ElasticSearchConstantes, LoggerConstantes
logger = LoggerConstantes.get_logger(LoggerConstantes.MODULO_ES_CONNECTION)
__connection = None
def connection():
global __connection
if __connection:
return __connection
es_host = configuracoes.get_config(ElasticSearchConstantes.ENDPOINT)
es_porta = configuracoes.get_config(ElasticSearchConstantes.PORTA)
es_username = configuracoes.get_config(ElasticSearchConstantes.USERNAME)
es_password = configuracoes.get_config(ElasticSearchConstantes.PASSWORD)
endpoint = [{"host": es_host, "port": es_porta}]
es_auth = None
if es_username:
es_auth = (es_username, es_password)
logger.debug("Iniciando conexão com ElasticSeach[{}:{}]".format(
