आज के डिजिटल युग में जानकारी प्रचुर है, लेकिन सही डेटा ढूंढना एक चुनौती हो सकती है। एक मेटा सर्च इंजन कई खोज इंजनों से परिणाम एकत्र करता है, जो उपलब्ध जानकारी का अधिक व्यापक दृश्य प्रदान करता है। इस ब्लॉग पोस्ट में, हम त्रुटि प्रबंधन, दर सीमित करने और गोपनीयता सुविधाओं के साथ पायथन में एक सरल मेटा सर्च इंजन बनाने की प्रक्रिया से गुजरेंगे।

मेटा सर्च इंजन क्या है?

एक मेटा सर्च इंजन अनुक्रमित पृष्ठों का अपना डेटाबेस नहीं रखता है। इसके बजाय, यह उपयोगकर्ता के प्रश्नों को कई खोज इंजनों को भेजता है, परिणाम एकत्र करता है, और उन्हें एक एकीकृत प्रारूप में प्रस्तुत करता है। यह दृष्टिकोण उपयोगकर्ताओं को प्रत्येक इंजन को व्यक्तिगत रूप से खोजे बिना जानकारी की विस्तृत श्रृंखला तक पहुंचने की अनुमति देता है।

आवश्यक शर्तें

इस ट्यूटोरियल का अनुसरण करने के लिए, आपको इसकी आवश्यकता होगी:

• आपकी मशीन पर पायथन स्थापित है (अधिमानतः पायथन 3.6 या उच्चतर)।
• पायथन प्रोग्रामिंग का बुनियादी ज्ञान।
• बिंग सर्च के लिए एक एपीआई कुंजी (आप एक निःशुल्क टियर के लिए साइन अप कर सकते हैं)।

चरण 1: अपना वातावरण स्थापित करें

सबसे पहले, सुनिश्चित करें कि आपके पास आवश्यक पुस्तकालय स्थापित हैं। हम HTTP अनुरोध करने के लिए अनुरोधों का उपयोग करेंगे और JSON डेटा को संभालने के लिए json का उपयोग करेंगे।

आप पिप का उपयोग करके अनुरोध लाइब्रेरी स्थापित कर सकते हैं:

pip install requests

चरण 2: अपने खोज इंजन को परिभाषित करें

meta_search_engine.py नामक एक नई पायथन फ़ाइल बनाएं और उन खोज इंजनों को परिभाषित करके प्रारंभ करें जिन्हें आप क्वेरी करना चाहते हैं। इस उदाहरण के लिए, हम डकडकगो और बिंग का उपयोग करेंगे।

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

चरण 3: क्वेरी फ़ंक्शन लागू करें

इसके बाद, खोज इंजनों से पूछताछ करने और परिणाम प्राप्त करने के लिए एक फ़ंक्शन बनाएं। हम नेटवर्क समस्याओं को शालीनता से प्रबंधित करने के लिए त्रुटि प्रबंधन भी लागू करेंगे।

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

चरण 4: दर सीमित लागू करें

एपीआई दर सीमा को रोकने के लिए, हम 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)

चरण 5: गोपनीयता सुविधाएँ जोड़ें

उपयोगकर्ता की गोपनीयता बढ़ाने के लिए, हम उपयोगकर्ता प्रश्नों को लॉग करने से बचेंगे और परिणामों को अस्थायी रूप से संग्रहीत करने के लिए एक कैशिंग तंत्र लागू करेंगे।

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

चरण 6: डुप्लिकेट हटाएँ

यह सुनिश्चित करने के लिए कि परिणाम अद्वितीय हैं, हम यूआरएल के आधार पर डुप्लिकेट को हटाने के लिए एक फ़ंक्शन लागू करेंगे।

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

चरण 7: परिणाम प्रदर्शित करें

खोज परिणामों को उपयोगकर्ता के अनुकूल प्रारूप में प्रदर्शित करने के लिए एक फ़ंक्शन बनाएं।

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

चरण 8: मुख्य कार्य

अंत में, मेटा सर्च इंजन चलाने वाले मुख्य फ़ंक्शन में सब कुछ एकीकृत करें।

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

पूरा कोड

यहां आपके मेटा सर्च इंजन के लिए पूरा कोड है:

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

निष्कर्ष

बधाई हो! आपने पायथन में एक सरल लेकिन कार्यात्मक मेटा सर्च इंजन बनाया है। यह परियोजना न केवल दर्शाती है कि एकाधिक स्रोतों से खोज परिणामों को कैसे एकत्रित किया जाए बल्कि त्रुटि प्रबंधन, दर सीमित करने और उपयोगकर्ता गोपनीयता के महत्व पर भी जोर दिया गया है। आप अधिक खोज इंजन जोड़कर, वेब इंटरफ़ेस लागू करके, या बेहतर परिणाम रैंकिंग के लिए मशीन लर्निंग को एकीकृत करके इस इंजन को और बढ़ा सकते हैं। हैप्पी कोडिंग!