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("===============================")