Пример #1
0
    def buscar_frame_principal(self, termo):
        try:
            page = requests.get(self.url_base_defs+'/'+termo)
            print(self.url_base_defs+'/'+termo)
        except:
            print("\nExcecao no metodo buscar_frame_principal() para o termo '%s'\n\n"%termo)

            palavra_sing = Util.singularize(termo)

            if palavra_sing != termo:
                return self.buscar_frame_principal(palavra_sing)
            else:
                print("\nExcecao no metodo buscar_frame_principal() para o termo '%s'\n\n"%termo)
                return None

        tree = html.fromstring(page.content)

        try:
            requests.session().cookies.clear()
        except: pass

        path = "//*[@id='content']/div[1]/div[2]/div/div/div/div[1]/section[@class='gramb']"
        principal = tree.xpath(path)

        return principal
Пример #2
0
    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