En la era digital actual, la información abunda, pero encontrar los datos correctos puede ser un desafío. Un metamotor de búsqueda agrega resultados de múltiples motores de búsqueda, proporcionando una vista más completa de la información disponible. En esta publicación de blog, recorreremos el proceso de creación de un metamotor de metabúsqueda simple en Python, completo con manejo de errores, limitación de velocidad y funciones de privacidad.

¿Qué es un metabuscador?

Un metabuscador no mantiene su propia base de datos de páginas indexadas. En cambio, envía consultas de los usuarios a múltiples motores de búsqueda, recopila los resultados y los presenta en un formato unificado. Este enfoque permite a los usuarios acceder a una gama más amplia de información sin tener que buscar en cada motor individualmente.

Requisitos previos

Para seguir este tutorial, necesitarás:

• Python instalado en su máquina (preferiblemente Python 3.6 o superior).
• Conocimientos básicos de programación en Python.
• Una clave API para Bing Search (puedes registrarte para obtener un nivel gratuito).

Paso 1: configure su entorno

Primero, asegúrese de tener instaladas las bibliotecas necesarias. Usaremos solicitudes para realizar solicitudes HTTP y json para manejar datos JSON.

Puedes instalar la biblioteca de solicitudes usando pip:

pip install requests

Paso 2: Defina sus motores de búsqueda

Cree un nuevo archivo Python llamado meta_search_engine.py y comience definiendo los motores de búsqueda que desea consultar. Para este ejemplo, usaremos DuckDuckGo y 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

Paso 3: implementar la función de consulta

A continuación, cree una función para consultar los motores de búsqueda y recuperar resultados. También implementaremos un manejo de errores para gestionar los problemas de red de manera elegante.

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

Paso 4: implementar la limitación de velocidad

Para evitar alcanzar los límites de tasa de API, implementaremos un limitador de tasa simple 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)

Paso 5: agregue funciones de privacidad

Para mejorar la privacidad del usuario, evitaremos registrar las consultas de los usuarios e implementaremos un mecanismo de almacenamiento en caché para almacenar temporalmente los resultados.

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

Paso 6: eliminar duplicados

Para garantizar que los resultados sean únicos, implementaremos una función para eliminar duplicados según la 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

Paso 7: Mostrar resultados

Cree una función para mostrar los resultados de la búsqueda en un formato fácil de usar.

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

Paso 8: Función principal

Finalmente, integra todo en una función principal que ejecuta el metabuscador.

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

Aquí está el código completo de tu 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()

Conclusión

¡Felicidades! Ha creado un metamotor de búsqueda simple pero funcional en Python. Este proyecto no sólo demuestra cómo agregar resultados de búsqueda de múltiples fuentes, sino que también enfatiza la importancia del manejo de errores, la limitación de tasas y la privacidad del usuario. Puede mejorar aún más este motor agregando más motores de búsqueda, implementando una interfaz web o incluso integrando el aprendizaje automático para mejorar la clasificación de los resultados. ¡Feliz codificación!