def iniciar_casamento(self, termo, pos, corrigir=False):
if corrigir:
del self.base_casada_manualmente[termo]
if not termo in self.base_casada_manualmente:
self.base_casada_manualmente[termo] = {}
if not wn.synsets(
unicode(termo),
pos)[0].name() in self.base_casada_manualmente[termo]:
obj_oxford = BaseOx.construir_objeto_unificado(termo)
pos_oxford = Util.cvrsr_pos_wn_oxford(pos)
try:
obj_oxford = obj_oxford[pos_oxford]
except TypeError:
print('A POS %s para o termo %s nao foi encontrada!' %
(pos_oxford, termo))
return
for synset in wn.synsets(unicode(termo), pos):
self.base_casada_manualmente[termo][synset.name()] = []
print('\n\n')
print('\t' + str((str(termo), str(pos))))
print('\t' + synset.definition().upper() + '\n')
indice = 1
definicoes_indexadas = []
for definicao in obj_oxford:
definicoes_indexadas.append(definicao)
print('\n\t\t' + str(indice) + ' - ' + repr(definicao) +
'\n')
indice += 1
for def_sec_iter in obj_oxford[definicao]['def_secs']:
def_sec = def_sec_iter.encode('utf8')
definicoes_indexadas.append(def_sec)
print('\t\t' + str(indice) + ' - ' + repr(def_sec))
indice += 1
valores = self.ler_inteiros('\n\tINDICES: ')
print('\tAnotacao > ' + str(valores))
print('\n\n')
for v in valores:
try:
self.base_casada_manualmente[termo][
synset.name()].append(definicoes_indexadas[v - 1])
except IndexError:
pass
dir_saida = self.diretorio_base_casada_manualmente
Util.salvar_json(dir_saida, self.base_casada_manualmente)
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 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 persistir_urls_invalidas(self):
Util.salvar_json(self.dir_urls_invalidas_sinonimos, self.obj_urls_invalidas_sinonimos)
Util.salvar_json(self.dir_urls_invalidas_definicoes, self.obj_urls_invalidas_definicoes)
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
# Se nao consegue sequer obter as POS, nao tem porque usar
if resultado in [dict(), None]:
ExtWeb.cache_objetos_coletados[palavra] = None
return None
obj = json.loads(json.dumps(resultado))
Util.salvar_json(dir_cache_obj, obj)
ExtWeb.cache_objetos_coletados[palavra] = obj
return obj
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 = { }
class DesOx(object):
INSTANCE = None
cache_objs_json = {}
def __init__(self, cfgs, base_ox, rep_vetorial=None):
self.cfgs = cfgs
self.base_ox = base_ox
self.rep_conceitos = None
self.rep_vetorial = rep_vetorial
self.usar_cache = True
self.dir_cache = cfgs['oxford']['cache']['desambiguador']
self.tam_max_ngram = 4
def assinatura_significado_aux(self, lema, pos, definicao, lista_exemplos):
retornar_valida = Util.retornar_valida_pra_indexar
assinatura = retornar_valida(definicao.replace('.', '')).lower()
assinatura = [
p for p in Util.tokenize(assinatura) if not p in [',', ';', '.']
]
if lista_exemplos:
assinatura += list(
itertools.chain(
*[retornar_valida(ex).split() for ex in lista_exemplos]))
assinatura += lema
assinatura = [p for p in assinatura if len(p) > 1]
return assinatura
# "lematizar,True::nbest,True::stop,True::ctx,frase.::pos,r::usar_ontologia,False::
# stem,True::usar_exemplos,True::busca_ampla,False"
def construir_chave_cache(self, vars):
vars = [
",".join((unicode(k), unicode(v))) for k, v in vars.iteritems()
]
return "::".join(vars)
# Metodo Cosseno feito para o dicionario de Oxford
# Retorna dados ordenados de forma decrescente
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
pontuacao = []
for assi in todas_assinaturas:
ass_definicao = Util.normalizar_ctx(assi[3],
stop=stop,
lematizar=lematizar,
stem=stem)
label_def, desc_def, frase_def, ass_def = assi
reg_def = (label_def, desc_def, frase_def)
if med_sim == 'cosine':
func_sim = cos_sim
elif med_sim == 'word_move_distance':
func_sim = self.rep_vetorial.word_move_distance
dist_simi = func_sim(" ".join(ctx), " ".join(ass_definicao))
# Colocando valor infinito
if dist_simi == float('inf'):
dist_simi = float(Util.MAX_WMD)
if dist_simi == 'cosine' and dist_simi == 0.00:
pass
else:
pontuacao.append((dist_simi, reg_def))
# Ordenacao da saida do desambiguador (cosine=decrescente, wmd=crescente)
ordem_crescente = (med_sim == 'cosine')
res_des = [(s, p)
for p, s in sorted(pontuacao, reverse=ordem_crescente)]
if self.usar_cache:
obj_cache[k_vars] = res_des
Util.salvar_json(dir_completo_obj, obj_cache)
return res_des
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
