Na era digital de hoje, as informações são abundantes, mas encontrar os dados certos pode ser um desafio. Um mecanismo de metabusca agrega resultados de vários mecanismos de busca, fornecendo uma visão mais abrangente das informações disponíveis. Nesta postagem do blog, percorreremos o processo de construção de um mecanismo de metabusca simples em Python, completo com tratamento de erros, limitação de taxa e recursos de privacidade.

O que é um mecanismo de metabusca?

Um mecanismo de metabusca não mantém seu próprio banco de dados de páginas indexadas. Em vez disso, ele envia as consultas dos usuários a vários mecanismos de pesquisa, coleta os resultados e os apresenta em um formato unificado. Essa abordagem permite que os usuários acessem uma gama mais ampla de informações sem precisar pesquisar cada mecanismo individualmente.

Pré-requisitos

Para acompanhar este tutorial, você precisará de:

• Python instalado em sua máquina (de preferência Python 3.6 ou superior).
• Conhecimento básico de programação Python.
• Uma chave de API para o Bing Search (você pode se inscrever para um nível gratuito).

Etapa 1: configure seu ambiente

Primeiro, certifique-se de ter as bibliotecas necessárias instaladas. Usaremos requests para fazer solicitações HTTP e json para lidar com dados JSON.

Você pode instalar a biblioteca de solicitações usando pip:

pip install requests

Etapa 2: Defina seus mecanismos de pesquisa

Crie um novo arquivo Python chamado meta_search_engine.py e comece definindo os mecanismos de pesquisa que deseja consultar. Para este exemplo, usaremos DuckDuckGo e Bing.

import requests
import json
import os
import time

# Define your search engines
SEARCH_ENGINES = {
    "DuckDuckGo": "https://api.duckduckgo.com/?q={}&format=json",
    "Bing": "https://api.bing.microsoft.com/v7.0/search?q={}&count=10",
}

BING_API_KEY = "YOUR_BING_API_KEY"  # Replace with your Bing API Key

Etapa 3: implementar a função de consulta

Em seguida, crie uma função para consultar os mecanismos de pesquisa e recuperar os resultados. Também implementaremos o tratamento de erros para gerenciar problemas de rede normalmente.

def search(query):
    results = []

    # Query DuckDuckGo
    ddg_url = SEARCH_ENGINES["DuckDuckGo"].format(query)
    try:
        response = requests.get(ddg_url)
        response.raise_for_status()  # Raise an error for bad responses
        data = response.json()
        for item in data.get("RelatedTopics", []):
            if 'Text' in item and 'FirstURL' in item:
                results.append({
                    'title': item['Text'],
                    'url': item['FirstURL']
                })
    except requests.exceptions.RequestException as e:
        print(f"Error querying DuckDuckGo: {e}")

    # Query Bing
    bing_url = SEARCH_ENGINES["Bing"].format(query)
    headers = {"Ocp-Apim-Subscription-Key": BING_API_KEY}
    try:
        response = requests.get(bing_url, headers=headers)
        response.raise_for_status()  # Raise an error for bad responses
        data = response.json()
        for item in data.get("webPages", {}).get("value", []):
            results.append({
                'title': item['name'],
                'url': item['url']
            })
    except requests.exceptions.RequestException as e:
        print(f"Error querying Bing: {e}")

    return results

Etapa 4: implementar limitação de taxa

Para evitar atingir os limites de taxa da API, implementaremos um limitador de taxa simples usando time.sleep().

# Rate limit settings
RATE_LIMIT = 1  # seconds between requests

def rate_limited_search(query):
    time.sleep(RATE_LIMIT)  # Wait before making the next request
    return search(query)

Etapa 5: adicionar recursos de privacidade

Para aumentar a privacidade do usuário, evitaremos registrar as consultas dos usuários e implementaremos um mecanismo de cache para armazenar resultados temporariamente.

CACHE_FILE = 'cache.json'

def load_cache():
    if os.path.exists(CACHE_FILE):
        with open(CACHE_FILE, 'r') as f:
            return json.load(f)
    return {}

def save_cache(results):
    with open(CACHE_FILE, 'w') as f:
        json.dump(results, f)

def search_with_cache(query):
    cache = load_cache()
    if query in cache:
        print("Returning cached results.")
        return cache[query]

    results = rate_limited_search(query)
    save_cache({query: results})
    return results

Etapa 6: remover duplicatas

Para garantir que os resultados sejam únicos, implementaremos uma função para remover duplicatas com base no URL.

def remove_duplicates(results):
    seen = set()
    unique_results = []
    for result in results:
        if result['url'] not in seen:
            seen.add(result['url'])
            unique_results.append(result)
    return unique_results

Etapa 7: exibir resultados

Crie uma função para exibir os resultados da pesquisa em um formato amigável.

def display_results(results):
    for idx, result in enumerate(results, start=1):
        print(f"{idx}. {result['title']}\n   {result['url']}\n")

Etapa 8: Função Principal

Finalmente, integre tudo em uma função principal que executa o mecanismo de metabusca.

def main():
    query = input("Enter your search query: ")
    results = search_with_cache(query)
    unique_results = remove_duplicates(results)
    display_results(unique_results)

if __name__ == "__main__":
    main()

Código Completo

Aqui está o código completo do seu metabuscador:

import requests
import json
import os
import time

# Define your search engines
SEARCH_ENGINES = {
    "DuckDuckGo": "https://api.duckduckgo.com/?q={}&format=json",
    "Bing": "https://api.bing.microsoft.com/v7.0/search?q={}&count=10",
}

BING_API_KEY = "YOUR_BING_API_KEY"  # Replace with your Bing API Key

# Rate limit settings
RATE_LIMIT = 1  # seconds between requests

def search(query):
    results = []

    # Query DuckDuckGo
    ddg_url = SEARCH_ENGINES["DuckDuckGo"].format(query)
    try:
        response = requests.get(ddg_url)
        response.raise_for_status()
        data = response.json()
        for item in data.get("RelatedTopics", []):
            if 'Text' in item and 'FirstURL' in item:
                results.append({
                    'title': item['Text'],
                    'url': item['FirstURL']
                })
    except requests.exceptions.RequestException as e:
        print(f"Error querying DuckDuckGo: {e}")

    # Query Bing
    bing_url = SEARCH_ENGINES["Bing"].format(query)
    headers = {"Ocp-Apim-Subscription-Key": BING_API_KEY}
    try:
        response = requests.get(bing_url, headers=headers)
        response.raise_for_status()
        data = response.json()
        for item in data.get("webPages", {}).get("value", []):
            results.append({
                'title': item['name'],
                'url': item['url']
            })
    except requests.exceptions.RequestException as e:
        print(f"Error querying Bing: {e}")

    return results

def rate_limited_search(query):
    time.sleep(RATE_LIMIT)
    return search(query)

CACHE_FILE = 'cache.json'

def load_cache():
    if os.path.exists(CACHE_FILE):
        with open(CACHE_FILE, 'r') as f:
            return json.load(f)
    return {}

def save_cache(results):
    with open(CACHE_FILE, 'w') as f:
        json.dump(results, f)

def search_with_cache(query):
    cache = load_cache()
    if query in cache:
        print("Returning cached results.")
        return cache[query]

    results = rate_limited_search(query)
    save_cache({query: results})
    return results

def remove_duplicates(results):
    seen = set()
    unique_results = []
    for result in results:
        if result['url'] not in seen:
            seen.add(result['url'])
            unique_results.append(result)
    return unique_results

def display_results(results):
    for idx, result in enumerate(results, start=1):
        print(f"{idx}. {result['title']}\n   {result['url']}\n")

def main():
    query = input("Enter your search query: ")
    results = search_with_cache(query)
    unique_results = remove_duplicates(results)
    display_results(unique_results)

if __name__ == "__main__":
    main()

Conclusão

Parabéns! Você construiu um mecanismo de metabusca simples, mas funcional em Python. Este projeto não apenas demonstra como agregar resultados de pesquisa de múltiplas fontes, mas também enfatiza a importância do tratamento de erros, da limitação de taxas e da privacidade do usuário. Você pode aprimorar ainda mais esse mecanismo adicionando mais mecanismos de pesquisa, implementando uma interface web ou até mesmo integrando aprendizado de máquina para melhorar a classificação dos resultados. Boa codificação!