def __init__(self, configs):
configs_oxford = configs['oxford']
self.configs = configs
self.url_base = configs_oxford['url_base']
self.app_id = configs_oxford['app_id']
self.chave = configs_oxford['app_key']
self.headers = {
'app_id' : self.app_id,
'app_key': self.chave
}
dir_bases = self.configs['caminho_bases']
cfg_cache = configs['oxford']['cache']
self.dir_urls_invalidas_sinonimos = dir_bases+'/'+cfg_cache['obj_urls_invalidas_sinonimos']
self.obj_urls_invalidas_sinonimos = Util.abrir_json(self.dir_urls_invalidas_sinonimos)
self.dir_urls_invalidas_definicoes = dir_bases+'/'+cfg_cache['obj_urls_invalidas_definicoes']
self.obj_urls_invalidas_definicoes = Util.abrir_json(self.dir_urls_invalidas_definicoes)
if None == self.obj_urls_invalidas_sinonimos:
self.obj_urls_invalidas_sinonimos = dict()
if None == self.obj_urls_invalidas_definicoes:
self.obj_urls_invalidas_definicoes = dict()
def desambiguar(self, ctx, ambigua, pos, nbest=True,\
lematizar=True, stem=True, stop=True,\
usar_ontologia=False, usr_ex=False,\
busca_ampla=False, med_sim='cosine', cands=[ ]):
# Para gerar chave do CACHE
vars_locais = dict(locals())
dir_cache_tmp = None
dir_bases = self.cfgs['caminho_bases']
self.usar_cache = False
if self.usar_cache:
obj_dir_cache_des = dir_bases + '/' + self.cfgs['oxford']['cache'][
'desambiguador']
del vars_locais['self']
del vars_locais['ambigua']
k_vars = self.construir_chave_cache(vars_locais)
dir_completo_obj = "%s/%s.json" % (obj_dir_cache_des, ambigua)
Util.abrir_json(dir_completo_obj, criarsenaoexiste=True)
if k_vars in obj_cache:
return obj_cache[k_vars]
if len(pos) == 1:
pos = Util.cvrsr_pos_wn_oxford(pos)
lem, st = (med_sim == 'cosine'), (med_sim == 'cosine')
todas_assinaturas = []
try:
todas_assinaturas = self.assinatura_significado(
ambigua, usar_exemplos=usr_ex, lematizar=lem, stem=st)
for candidato_iter in cands:
todas_assinaturas += self.assinatura_significado(
candidato_iter,
usar_exemplos=usr_ex,
lematizar=lem,
stem=st)
todas_assinaturas = [
assi for assi in todas_assinaturas
if pos == assi[0].split('.')[1]
]
# Tirando palavras de tamanho 1
ctx = [p for p in Util.tokenize(ctx.lower()) if len(p) > 1]
ctx = Util.normalizar_ctx(ctx, stop=stop, lematizar=lem, stem=st)
except KeyboardInterrupt, ke:
pass
def iniciar_coleta(self, palavra):
if palavra in ExtWeb.cache_objetos_coletados:
return ExtWeb.cache_objetos_coletados[palavra]
dir_cache_obj = "%s/%s.json"%(self.dir_cache, palavra)
obj = Util.abrir_json(dir_cache_obj)
if obj != None: return obj
resultado = { }
conjunto_frames = self.buscar_frame_principal(palavra)
if not conjunto_frames:
ExtWeb.cache_objetos_coletados[palavra] = None
return None
for frame in conjunto_frames:
print(frame)
try:
res_tmp = self.scrap_frame_definicoes(frame, palavra)
except Exception, e:
res_tmp = dict()
try:
# lista com UM elemento apenas
pos = res_tmp.keys()[0]
if not pos in resultado:
resultado[pos] = dict()
for def_primaria in res_tmp[pos]:
resultado[pos][def_primaria] = res_tmp[pos][def_primaria]
except Exception, e:
pass
def obter_sinonimos(self, palavra):
if palavra in self.obj_urls_invalidas_sinonimos:
Util.print_formatado('\tClienteOxford: URL evitada: ' + palavra)
return None
dir_bases = self.configs['caminho_bases']
dir_cache_oxford = dir_bases+'/'+self.configs['oxford']['cache']['sinonimos']
dir_obj_json = dir_cache_oxford+'/'+palavra+'.json'
if os.path.isfile(dir_obj_json):
obj_tmp = Util.abrir_json(dir_obj_json)
if obj_tmp != None and obj_tmp != { }:
return obj_tmp
try:
url = self.url_base+"/thesaurus/en/"+palavra
obj = Util.requisicao_http(url, self.headers, admite_404=True).json()
obj_json = { }
try:
for entry in obj['results'][0]['lexicalEntries']:
pos = entry['lexicalCategory']
if not pos in obj_json:
obj_json[pos] = [ ]
for sense in entry['entries'][0]['senses']:
obj_json[pos].append(sense)
except Exception, e:
if "error" in obj_json:
if "No entries were found" in obj_json['error']:
raise Exception(obj_json['error'])
print('Salvando em cache: ' + str(Util.salvar_json(dir_obj_json, obj_json)))
return obj_json
def obter_sinonimos(self, palavra):
if palavra in self.obj_urls_invalidas_sinonimos:
Util.print_formatado('\tClienteOxford: URL evitada: ' + palavra)
return None
dir_bases = self.configs['caminho_bases']
dir_cache_oxford = dir_bases + '/' + self.configs['oxford']['cache'][
'sinonimos']
dir_obj_json = dir_cache_oxford + '/' + palavra + '.json'
if os.path.isfile(dir_obj_json):
return Util.abrir_json(dir_obj_json)
try:
url = self.url_base + "/entries/en/" + palavra + "/synonyms"
obj = Util.requisicao_http(url, self.headers).json()
obj_json = {}
for entry in obj['results'][0]['lexicalEntries']:
pos = entry['lexicalCategory']
if not pos in obj_json:
obj_json[pos] = []
for sense in entry['entries'][0]['senses']:
obj_json[pos].append(sense)
print('Salvando em cache: ' +
str(Util.salvar_json(dir_obj_json, obj_json)))
return obj_json
except:
self.obj_urls_invalidas_sinonimos[palavra] = ""
#print('URL ERRADA: ' + url)
return None
def __init__(self, configs):
self.configs = configs
# self.configs['dir_base_casada_manualmente']
self.diretorio_base_casada_manualmente = self.configs[
'dir_base_casada_manualmente']
self.base_casada_manualmente = Util.abrir_json(
self.diretorio_base_casada_manualmente)
self.base_ox = BaseOx(self.configs)
if self.base_casada_manualmente == None:
self.base_casada_manualmente = {}
def iniciar_coleta_original(self, palavra):
if palavra in ExtWeb.cache_objetos_coletados:
return ExtWeb.cache_objetos_coletados[palavra]
dir_cache_obj = "%s/%s.json"%(self.dir_cache, palavra)
obj = Util.abrir_json(dir_cache_obj)
if obj != None: return obj
resultado = { }
conjunto_frames = self.buscar_frame_principal(palavra)
if not conjunto_frames:
ExtWeb.cache_objetos_coletados[palavra] = None
return None
for frame in conjunto_frames:
res_tmp = self.scrap_frame_definicoes(frame, palavra)
# Se nao consegue sequer obter as POS, nao tem porque usar
if res_tmp == None:
ExtWeb.cache_objetos_coletados[palavra] = None
return None
# lista com UM elemento apenas
pos = res_tmp.keys()[0]
if not pos in resultado:
resultado[pos] = dict()
for def_primaria in res_tmp[pos]:
try:
resultado[pos][def_primaria] = res_tmp[pos][def_primaria]
except: pass
obj = json.loads(json.dumps(resultado))
Util.salvar_json(dir_cache_obj, obj)
ExtWeb.cache_objetos_coletados[palavra] = obj
return obj
def obter_frequencia(self, palavra):
dir_cache = self.configs['caminho_bases']+'/'+self.configs['oxford']['cache']['frequencias']
todos_arquivos_cache = Util.list_arqs(dir_cache)
todos_arquivos_cache = [c.split("/")[-1] for c in todos_arquivos_cache]
if palavra + ".json" in todos_arquivos_cache:
path = dir_cache+'/'+palavra + '.json'
obj = Util.abrir_json(path)
return obj['result']['frequency']
else:
url = self.url_base + '/stats/frequency/word/en/?corpus=nmc&lemma=' + palavra
obj_req = Util.requisicao_http(url, self.headers)
path = dir_cache+'/'+palavra + '.json'
Util.salvar_json(path, obj_req.json())
try:
return obj_req.json()['result']['frequency']
except Exception, e:
return 0
def obter_definicoes(self, palavra, lematizar=True):
if palavra in self.obj_urls_invalidas_definicoes:
return None
dir_bases = self.configs['caminho_bases']
dir_cache_oxford = dir_bases + '/' + self.configs['oxford']['cache'][
'definicoes']
dir_obj_json = dir_cache_oxford + '/' + palavra + '.json'
if os.path.isfile(dir_obj_json):
return Util.abrir_json(dir_obj_json)
try:
url = self.url_base + "/entries/en/" + palavra
#Util.print_formatado('\nRequerindo URL %s' % url)
obj = Util.requisicao_http(url, self.headers).json()
saida_tmp = []
saida = {}
for e in obj['results'][0]['lexicalEntries']:
saida_tmp.append(e)
for entry in saida_tmp:
if not entry['lexicalCategory'] in saida:
saida[entry['lexicalCategory']] = []
for sense in entry['entries'][0]['senses']:
saida[entry['lexicalCategory']].append(sense)
print('\tClienteOxford URL certa: ' + url)
print('\tClienteOxford: Salvando em cache: ' +
str(Util.salvar_json(dir_obj_json, saida)))
return saida
except Exception, e:
self.obj_urls_invalidas_definicoes[palavra] = ""
Util.print_formatado('\tClienteOxford: URL errada: ' + palavra,
visivel=False)
return None
def construir_objeto_unificado(self, palavra):
palavra_sing = Util.singularize(palavra)
if palavra in BaseOx.objs_unificados:
return BaseOx.objs_unificados[palavra]
dir_bases = self.cfgs['caminho_bases']
dir_cache_oxford = self.cfgs['oxford']['cache']
nome_arq = palavra + '.json'
dir_obj_definicoes = dir_bases+'/'+dir_cache_oxford['definicoes']+'/'+nome_arq
dir_obj_extrator = dir_bases+'/'+dir_cache_oxford['extrator_web']+'/'+nome_arq
dir_obj_sinonimos = dir_bases+'/'+dir_cache_oxford['sinonimos']+'/'+nome_arq
obj_definicoes = Util.abrir_json(dir_obj_definicoes, criarsenaoexiste=False)
obj_extrator = Util.abrir_json(dir_obj_extrator, criarsenaoexiste=False)
if obj_definicoes == None or obj_definicoes == { }:
obj_definicoes = CliOxAPI.obter_definicoes(CliOxAPI.CLI, palavra)
Util.salvar_json(dir_obj_definicoes, obj_definicoes)
if not dir_obj_sinonimos in BaseOx.objs_sinonimos_inatingiveis:
obj_sinonimos = Util.abrir_json(dir_obj_sinonimos, criarsenaoexiste=False)
if obj_sinonimos in [None, { }]:
obj_sinonimos = self.cli_api_ox.obter_sinonimos(palavra)
if obj_sinonimos in [None, { }] and palavra_sing != palavra:
obj_sinonimos = self.cli_api_ox.obter_sinonimos(palavra_sing)
if obj_sinonimos:
Util.salvar_json(dir_obj_sinonimos, obj_sinonimos)
if palavra_sing != palavra:
dir_obj_sinonimos = dir_bases+'/'+dir_cache_oxford['sinonimos']+'/'+palavra_sing + '.json'
Util.salvar_json(dir_obj_sinonimos, obj_sinonimos)
else:
BaseOx.objs_sinonimos_inatingiveis.add(palavra)
BaseOx.objs_sinonimos_inatingiveis.add(palavra_sing)
if obj_extrator == None:
obj_extrator = self.extrator_web_ox.iniciar_coleta(palavra)
if obj_extrator != None and obj_extrator != { }:
Util.salvar_json(dir_obj_extrator, obj_extrator)
dir_obj_extrator_sing = dir_bases+'/'+dir_cache_oxford['extrator_web']+'/'+palavra_sing+'.json'
if dir_obj_extrator_sing != dir_obj_extrator:
Util.salvar_json(dir_obj_extrator_sing, obj_extrator)
return obj_extrator
else:
obj_extrator = self.extrator_web_ox.iniciar_coleta(palavra_sing)
if obj_extrator != None and obj_extrator != { }:
Util.salvar_json(dir_obj_extrator, obj_extrator)
dir_obj_extrator_sing = dir_bases+'/'+dir_cache_oxford['extrator_web']+'/'+palavra_sing+'.json'
if dir_obj_extrator_sing != dir_obj_extrator:
Util.salvar_json(dir_obj_extrator_sing, obj_extrator)
return obj_extrator
return { }
# Processando definicoes
obj_join_definicoes = { }
# Processando definicoes extrator
obj_join_extrator = { }
for pos in obj_extrator:
for def_prim in obj_extrator[pos]:
k_reg = pos + self.cfgs['separador'] + def_prim[:-1].lower()
obj_join_extrator[k_reg] = obj_extrator[pos][def_prim]['exemplos']
for def_sec in obj_extrator[pos][def_prim]['def_secs']:
k_reg = pos + self.cfgs['separador'] + def_sec[:-1].lower()
obj_join_extrator[k_reg] = obj_extrator[pos][def_prim]['def_secs'][def_sec]['exemplos']
if not obj_definicoes or not obj_sinonimos:
return obj_extrator
for pos in obj_definicoes:
for reg in obj_definicoes[pos]:
if 'thesaurusLinks' in reg:
k_reg = pos + self.cfgs['separador'] + reg['thesaurusLinks'][0]['sense_id']
if 'definitions' in reg:
obj_join_definicoes[k_reg] = reg['definitions']
if 'subsenses' in reg:
for reg_sub in reg['subsenses']:
try:
k_reg = pos + self.cfgs['separador'] + reg_sub['thesaurusLinks'][0]['sense_id']
except:
k_reg = pos + self.cfgs['separador'] + reg_sub['id']
try:
obj_join_definicoes[k_reg] = reg_sub['definitions']
except: pass
try:
k_reg = pos + self.cfgs['separador'] + reg['thesaurusLinks'][0]['sense_id']
if k_reg in obj_join_definicoes:
obj_join_definicoes[k_reg] += reg_sub['definitions']
else:
obj_join_definicoes[k_reg] = reg_sub['definitions']
except: pass
else: pass
else: pass
obj_unificado = dict(obj_extrator)
# Processando sinonimos
obj_join_sinonimos = { }
for pos in obj_sinonimos:
for reg in obj_sinonimos[pos]:
k_reg = pos + self.cfgs['separador'] + reg['id']
try: sins_tmp = [r['text'] for r in reg['synonyms']]
except: sins_tmp = [ ]
obj_join_sinonimos[k_reg] = sins_tmp
if 'subsenses' in reg:
for reg_sub in reg['subsenses']:
k_reg = pos + self.cfgs['separador'] + reg_sub['id']
try: sins_tmp = [r['text'] for r in reg_sub['synonyms']]
except: sins_tmp = [ ]
obj_join_sinonimos[k_reg] = sins_tmp
# Realizando juncao de sinonimos
obj_join_sinonimos_tmp = { }
for k_reg in obj_join_sinonimos:
if k_reg in obj_join_definicoes:
for k_reg_defs in obj_join_definicoes[k_reg]:
if len(obj_join_definicoes[k_reg]) == 1:
obj_join_sinonimos_tmp[k_reg_defs] = obj_join_sinonimos[k_reg]
for k_reg in obj_join_sinonimos:
if k_reg in obj_join_definicoes:
for k_reg_defs in obj_join_definicoes[k_reg]:
if not k_reg_defs in obj_join_sinonimos_tmp:
obj_join_sinonimos_tmp[k_reg_defs] = obj_join_sinonimos[k_reg]
for pos in obj_extrator:
for def_prim in obj_extrator[pos]:
if def_prim[:-1].lower() in obj_join_sinonimos_tmp: chave = def_prim[:-1].lower()
elif def_prim.lower() in obj_join_sinonimos_tmp: chave = def_prim.lower()
else: chave = None
if chave:
sins = obj_join_sinonimos_tmp[chave]
obj_unificado[pos][def_prim]['sinonimos'] = sins
for def_sec in obj_extrator[pos][def_prim]['def_secs']:
if def_sec[:-1].lower() in obj_join_sinonimos_tmp: chave = def_sec[:-1].lower()
elif def_sec.lower() in obj_join_sinonimos_tmp: chave = def_sec.lower()
else: chave = None
if chave:
sins = obj_join_sinonimos_tmp[chave]
obj_unificado[pos][def_prim]['def_secs'][def_sec]['sinonimos'] = sins
obj_join_sinonimos_tmp = None
obj_join_definicoes = None
obj_join_extrator = None
obj_join_sinonimos = None
obj_definicoes = None
obj_sinonimos = None
obj_extrator = None
BaseOx.objs_unificados[palavra] = obj_unificado
for pos_excluir in set(obj_unificado.keys())-set(self.cfgs['oxford']['pos']):
if pos_excluir in obj_unificado:
del obj_unificado[pos_excluir]
if obj_unificado == None or obj_unificado == { }:
print("O objeto da palavra %s deu errado!"%palavra)
return obj_unificado
def des_exemplos(self, ctx,\
ambigua, pos, nbest=True,\
lematizar=True, stem=True, stop=True,\
normalizar_pont=True):
cfgs = self.cfgs
dir_bases = self.cfgs['caminho_bases']
base_ox = self.base_ox
rep_vet = self.rep_vetorial
alvaro = Alvaro.Alvaro.INSTANCE
dir_cache_rel_sinonimia = cfgs['caminho_bases'] + '/' + cfgs['oxford'][
'cache']['sinonimia']
chave_cache_relacao_sin = "%s-%s.json" % (ambigua, pos)
dir_obj = dir_cache_rel_sinonimia + '/' + chave_cache_relacao_sin
if not chave_cache_relacao_sin in Util.list_arqs(
dir_cache_rel_sinonimia):
rel_definicoes = alvaro.construir_relacao_definicoes(
ambigua, pos, fontes='oxford')
Util.salvar_json(dir_obj, rel_definicoes)
else:
rel_definicoes = Util.abrir_json(dir_obj, criarsenaoexiste=False)
res_des_tmp = []
pontuacao_somada = 0.00
for def_ambigua in rel_definicoes:
uniao_palavras_sem_duplicatas = set()
uniao_palavras_com_duplicatas = list()
exemplos_blob = []
palavras_tf = {}
try:
maximo_exemplos = self.cfgs['params_exps']['qtde_exemplos'][0]
lista_exemplos = BaseOx.obter_atributo(ambigua, pos,
def_ambigua, 'exemplos')
# Adicionando lemas
lista_exemplos.append(" ".join(
BaseOx.obter_sins(ambigua, def_ambigua, pos)))
# Adicionando definicao
lista_exemplos.append(def_ambigua)
for ex in lista_exemplos[:maximo_exemplos]:
ex_blob = TextBlob(ex)
exemplos_blob.append(ex_blob)
for token in ex_blob.words:
if Util.is_stop_word(token.lower()) == False:
token_lematizado = lemmatize(token)
uniao_palavras_sem_duplicatas.add(token_lematizado)
uniao_palavras_com_duplicatas.append(
token_lematizado)
except Exception, caminho:
exemplos = []
textblob_vocab = TextBlob(" ".join(uniao_palavras_com_duplicatas))
palavras_latentes = []
for p in textblob_vocab.word_counts:
if textblob_vocab.word_counts[p] > 1:
palavras_latentes.append(p)
palavras_derivadas = []
for p in uniao_palavras_sem_duplicatas:
tf = alvaro.tf(p, textblob_vocab)
palavras_tf[p] = tf
pontuacao = 0.00
for t in Util.tokenize(Util.resolver_en(ctx).lower()):
try:
pontuacao += palavras_tf[t]
except:
pontuacao += 0.00
pontuacao_somada += pontuacao
try:
if normalizar_pont:
reg_pont = pontuacao / sum(palavras_tf.values())
else:
reg_pont = pontuacao
except ZeroDivisionError, zde:
reg_pont = 0.00
def iniciar_indexacao_signalmedia(dir_lista_arquivos, arquivos_duplicados):
arquivos_duplicados = Util.abrir_json(arquivos_duplicados,
criarsenaoexiste=False)
arquivos_duplicados_set = set()
for reg_str in arquivos_duplicados:
path, _id_ = eval(reg_str)
arquivos_duplicados_set.add(_id_)
Whoosh.DIR_INDEXES = raw_input("Diretorio indexes: ")
if not os.path.exists(Whoosh.DIR_INDEXES):
os.mkdir(Whoosh.DIR_INDEXES)
indexer = create_in(Whoosh.DIR_INDEXES, Whoosh.SCHEMA_CORPORA)
else:
indexer = whoosh.index.open_dir(Whoosh.DIR_INDEXES)
writer = indexer.writer()
arquivo_lista = open(dir_lista_arquivos, 'r')
todos_arquivos = [
e.replace('\n', '') for e in arquivo_lista.readlines()
]
arquivo_lista.close()
indice_arquivo = 1
for _arquivo_ in todos_arquivos:
if writer.is_closed:
writer = None
writer = indexer.writer()
indice_linha = 1
arquivo = "./Bases/Corpora/SignalMedia/" + _arquivo_
print('\tArquivo %d' % (indice_arquivo))
with open(arquivo) as _arq_:
for linha_tmp in _arq_:
try:
obj_json = json.loads(linha_tmp)
if not obj_json["id"] in arquivos_duplicados_set:
titulo_doc_sm = obj_json["title"]
arq = obj_json["content"]
arq.replace(". \n\n", ". ")
arq.replace("? \n\n", "? ")
arq.replace("! \n\n", "! ")
arq.replace(". \n \n", ". ")
arq.replace("? \n \n", "? ")
arq.replace("! \n \n", "! ")
arq = re.split('[.?!]', arq)
arq = [l for l in arq if l.strip() != '']
else:
arq = []
except:
arq = []
for linha_arq in arq:
try:
#conteudo = unicode(str(linha_arq).decode('utf-8'))
#conteudo = re.sub(r'[^\x00-\x7F]+',' ', conteudo)
conteudo = str(linha_arq)
conteudo = "".join(
[i if ord(i) < 128 else " " for i in conteudo])
import random
nome_arquivo = arquivo + '-' + \
str(Util.md5sum_string(conteudo))
title = unicode(nome_arquivo)
path = unicode(nome_arquivo)
content = unicode(conteudo)
try:
if content.strip(" ") != "":
if writer.is_closed:
writer = indexer.writer()
if writer.is_closed == False:
raw_input("Deu certo!")
else:
raw_input("Deu errado!")
writer.add_document(title=title,
path=path,
content=content)
except Exception, e:
print("Content: " +
str((content, title, path)))
import traceback
traceback.print_stack()
raw_input("\nExcecao aqui: %s\n" % str(e))
except Exception, e:
import traceback
traceback.print_stack()
print("\nException: " + str(e) + "\n")
#"""print('\tArquivo %d - Linha %d' % (indice_arquivo, indice_linha))"""
indice_linha += 1
indice_arquivo += 1
print('Realizando commit. Vai gastar um bom tempo!')
try:
if writer.is_closed:
raw_input("\nWriter estava fechado na hora do commit!\n")
writer.commit()
print("@@@ " + _arquivo_)
print('Commit realizado...')
except Exception, e:
import traceback
print("@@@ " + _arquivo_)
print("\nException: " + str(e) + "\n")
print('Commit NAO realizado...')
traceback.print_stack()
print("===============================")
