À l’ère numérique d’aujourd’hui, les informations sont abondantes, mais trouver les bonnes données peut être un défi. Un métamoteur de recherche regroupe les résultats de plusieurs moteurs de recherche, offrant une vue plus complète des informations disponibles. Dans cet article de blog, nous expliquerons le processus de création d'un méta-moteur de recherche simple en Python, doté de fonctionnalités de gestion des erreurs, de limitation de débit et de confidentialité.

Qu’est-ce qu’un métamoteur de recherche ?

Un métamoteur de recherche ne gère pas sa propre base de données de pages indexées. Au lieu de cela, il envoie les requêtes des utilisateurs à plusieurs moteurs de recherche, collecte les résultats et les présente dans un format unifié. Cette approche permet aux utilisateurs d'accéder à un plus large éventail d'informations sans avoir à rechercher chaque moteur individuellement.

Conditions préalables

Pour suivre ce didacticiel, vous aurez besoin de :

• Python installé sur votre machine (de préférence Python 3.6 ou supérieur).
• Connaissance de base de la programmation Python.
• Une clé API pour Bing Search (vous pouvez vous inscrire pour un niveau gratuit).

Étape 1 : Configurez votre environnement

Tout d’abord, assurez-vous que les bibliothèques nécessaires sont installées. Nous utiliserons des requêtes pour effectuer des requêtes HTTP et json pour gérer les données JSON.

Vous pouvez installer la bibliothèque de requêtes en utilisant pip :

pip install requests

Étape 2 : définissez vos moteurs de recherche

Créez un nouveau fichier Python nommé meta_search_engine.py et commencez par définir les moteurs de recherche que vous souhaitez interroger. Pour cet exemple, nous utiliserons DuckDuckGo et 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

Étape 3 : implémenter la fonction de requête

Ensuite, créez une fonction pour interroger les moteurs de recherche et récupérer les résultats. Nous mettrons également en œuvre la gestion des erreurs pour gérer les problèmes de réseau avec élégance.

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

Étape 4 : implémenter la limitation du débit

Pour éviter d'atteindre les limites de débit de l'API, nous allons implémenter un simple limiteur de débit à l'aide de 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)

Étape 5 : ajouter des fonctionnalités de confidentialité

Pour améliorer la confidentialité des utilisateurs, nous éviterons de consigner les requêtes des utilisateurs et mettrons en œuvre un mécanisme de mise en cache pour stocker temporairement les résultats.

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

Étape 6 : Supprimer les doublons

Pour garantir l'unicité des résultats, nous mettrons en œuvre une fonction permettant de supprimer les doublons en fonction de l'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

Étape 7 : Afficher les résultats

Créez une fonction pour afficher les résultats de la recherche dans un format convivial.

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

Étape 8 : Fonction principale

Enfin, intégrez le tout dans une fonction principale qui exécute le méta-moteur de recherche.

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

Code complet

Voici le code complet de votre méta-moteur de recherche :

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

Conclusion

Félicitations! Vous avez créé un méta-moteur de recherche simple mais fonctionnel en Python. Ce projet montre non seulement comment agréger les résultats de recherche provenant de plusieurs sources, mais souligne également l'importance de la gestion des erreurs, de la limitation du débit et de la confidentialité des utilisateurs. Vous pouvez encore améliorer ce moteur en ajoutant davantage de moteurs de recherche, en implémentant une interface Web ou même en intégrant l'apprentissage automatique pour un meilleur classement des résultats. Bon codage !