सक्रेपलेस और गूगल जेमिनी के साथ बुद्धिमान खोज विश्लेषिकी कैसे बनाएं

# वर्चुअल वातावरण बनाएं
python -m venv scrapeless-gemini-env

# वातावरण सक्रिय करें
scrapeless-gemini-env\Scripts\activate

# वर्चुअल वातावरण बनाएं
python3 -m venv scrapeless-gemini-env

# वातावरण सक्रिय करें
source scrapeless-gemini-env/bin/activate

# वर्चुअल वातावरण बनाएं
python3 -m venv scrapeless-gemini-env

# वातावरण सक्रिय करें
source scrapeless-gemini-env/bin/activate

pip install requests google-generativeai python-dotenv pandas

SCRAPELESS_API_TOKEN=your_token_here
GEMINI_API_KEY=your_gemini_key_here

import json
import requests
import os
from dotenv import load_dotenv

load_dotenv()

class ScrapelessClient:
    def __init__(self):
        self.token = os.getenv('SCRAPELESS_API_TOKEN')
        self.host = "api.scrapeless.com"
        self.url = f"https://{self.host}/api/v1/scraper/request"
        self.headers = {"x-api-token": self.token}
    
    def search_google(self, query, **kwargs):
        """Scrapeless का उपयोग करके Google खोज करें"""
        payload = {
            "actor": "scraper.google.search",
            "input": {
                "q": query,
                "gl": kwargs.get("gl", "us"),
                "hl": kwargs.get("hl", "en"),
                "google_domain": kwargs.get("google_domain", "google.com"),
                "location": kwargs.get("location", ""),
                "tbs": kwargs.get("tbs", ""),
                "start": str(kwargs.get("start", 0)),
                "num": str(kwargs.get("num", 10))
            }
        }
        
        response = requests.post(
            self.url, 
            headers=self.headers, 
            data=json.dumps(payload)
        )
        
        if response.status_code != 200:
            print(f"त्रुटि: {response.status_code} - {response.text}")
            return None
            
        return response.json()

import google.generativeai as genai

class SearchAnalyzer:
    def __init__(self):
        genai.configure(api_key=os.getenv('GEMINI_API_KEY'))
        self.model = genai.GenerativeModel('gemini-1.5-flash')
        self.scraper = ScrapelessClient()
    
    def analyze_topic(self, topic):
        """किसी विषय की खोज और विश्लेषण करें"""
        # चरण 1: खोज परिणाम प्राप्त करें
        print(f"खोज करने के लिए: {topic}")
        search_results = self.scraper.search_google(topic, num=20)
        
        if not search_results:
            return None
        
        # चरण 2: प्रमुख जानकारी निकालें
        extracted_data = self._extract_results(search_results)
        
        # चरण 3: जेमिनी के साथ विश्लेषण करें
        prompt = f"""
        इन खोज परिणामों का विश्लेषण करें जो "{topic}" के बारे में हैं:
        
        {json.dumps(extracted_data, indent=2)}
        
        प्रदान करें:
        1. प्रमुख विषय और रुझान
        2. जानकारी के मुख्य स्रोत
        3. उल्लेखनीय अंतर्दृष्टियाँ
        4. अनुशंसित कार्रवाई
        
        अपनी प्रतिक्रिया को स्पष्ट, कार्यात्मक रिपोर्ट के रूप में फ़ॉर्मेट करें।
        """
        
        response = self.model.generate_content(prompt)
        
        return {
            "topic": topic,
            "search_data": extracted_data,
            "analysis": response.text
        }
```python
def _extract_results(self, search_data):
        """खोज परिणामों से संबंधित डेटा निकालें"""
        results = []
        
        if "organic_results" in search_data:
            for item in search_data["organic_results"][:10]:
                results.append({
                    "title": item.get("title", ""),
                    "snippet": item.get("snippet", ""),
                    "link": item.get("link", ""),
                    "source": item.get("displayed_link", "")
                })
        
        return results

class CompetitorMonitor:
    def __init__(self):
        self.analyzer = SearchAnalyzer()
    
    def analyze_competitors(self, company_name, competitors):
        """किसी कंपनी का प्रतिस्पर्धियों के खिलाफ विश्लेषण करें"""
        all_data = {}
        
        # प्रत्येक कंपनी की खोज करें
        for comp in [company_name] + competitors:
            print(f"\nविश्लेषण कर रहे हैं: {comp}")
            
            # हाल के समाचार और अपडेट के लिए खोजें
            news_query = f"{comp} नवीनतम समाचार अपडेट 2025"
            data = self.analyzer.analyze_topic(news_query)
            
            if data:
                all_data[comp] = data
        
        # तुलनात्मक विश्लेषण उत्पन्न करें
        comparative_prompt = f"""
        इस डेटा के आधार पर {company_name} और प्रतिस्पर्धियों की तुलना करें:
        
        {json.dumps(all_data, indent=2)}
        
        प्रदान करें:
        1. प्रतिस्पर्धी स्थिति
        2. प्रत्येक कंपनी की अनूठी ताकत
        3. बाजार के अवसर
        4. {company_name} के लिए रणनीतिक सिफारिशें
        """
        
        response = self.analyzer.model.generate_content(comparative_prompt)
        
        return {
            "company": company_name,
            "competitors": competitors,
            "analysis": response.text,
            "raw_data": all_data
        }

class TrendMonitor:
    def __init__(self):
        self.analyzer = SearchAnalyzer()
        self.scraper = ScrapelessClient()
    
    def monitor_trend(self, keyword, time_range="d"):
        """एक कीवर्ड के लिए प्रवृत्तियों की निगरानी करें"""
        # समय रेंज को गूगल के tbs पैरामीटर से मैप करें
        time_map = {
            "h": "qdr:h",  # पिछले घंटे
            "d": "qdr:d",  # पिछले दिन
            "w": "qdr:w",  # पिछले सप्ताह
            "m": "qdr:m"   # पिछले महीने
        }
        
        # समय फ़िल्टर के साथ खोजें
        results = self.scraper.search_google(
            keyword, 
            tbs=time_map.get(time_range, "qdr:d"),
            num=30
        )
        
        if not results:
            return None
        
        # प्रवृत्तियों का विश्लेषण करें
        prompt = f"""
        हाल के खोज परिणामों के आधार पर "{keyword}" के लिए प्रवृत्तियों का विश्लेषण करें:
        
        {json.dumps(results.get("organic_results", [])[:15], indent=2)}
        
        पहचानें:
        1. उभरते पैटर्न
        2. प्रमुख विकास
        3. मनोवृत्ति (सकारात्मक/नकारात्मक/तटस्थ)
        4. भविष्यवाणियाँ
        5. कार्रवाई योग्य insights
        """
        
        response = self.analyzer.model.generate_content(prompt)
        
        return {
            "keyword": keyword,
            "time_range": time_range,
            "analysis": response.text,
            "result_count": len(results.get("organic_results", []))
        }

def main():
    # घटकों को प्रारंभ करें
    competitor_monitor = CompetitorMonitor()
    trend_monitor = TrendMonitor()
    
    # उदाहरण 1: प्रतिस्पर्धी विश्लेषण
    # महत्वपूर्ण: इन उदाहरण कंपनियों को अपनी वास्तविक कंपनी और प्रतिस्पर्धियों से बदलें
    print("=== प्रतिस्पर्धी विश्लेषण ===")
    analysis = competitor_monitor.analyze_competitors(
        company_name="OpenAI",  # अपनी कंपनी का नाम बदलें
        competitors=["Anthropic", "Google AI", "Meta AI"]  # अपने प्रतिस्पर्धियों से बदलें
    )
    
    print("\nप्रतिस्पर्धी विश्लेषण परिणाम:")
    print(analysis["analysis"])
    
    # परिणाम सहेजें
    with open("competitor_analysis.json", "w") as f:
        json.dump(analysis, f, indent=2)
    
    # उदाहरण 2: प्रवृत्ति मॉनिटरिंग
    # महत्वपूर्ण: कीवर्ड को अपने उद्योग-विशिष्ट शर्तों से बदलें
    print("\n\n=== प्रवृत्ति मॉनिटरिंग ===")
    trends = trend_monitor.monitor_trend(
        keyword="कृत्रिम बुद्धिमत्ता विनियमन",  # अपने कीवर्ड से बदलें
        time_range="w"  # पिछले सप्ताह
    )
    
    print("\nप्रवृत्ति विश्लेषण परिणाम:")
    print(trends["analysis"])
    
    # उदाहरण 3: बहु-थीम विश्लेषण
    # महत्वपूर्ण: इन विषयों को अपने उद्योग-विशिष्ट विषयों से बदलें
    print("\n\n=== बहु-थीम विश्लेषण ===")
    topics = [
        "जनरेटिव एआई व्यावसायिक अनुप्रयोग",  # अपने विषयों से बदलें
        "एआई साइबरसिक्योरिटी खतरे",

    # चरण 2: कुंजी सूचना निकालें
    निकाले गए डेटा = self._extract_results(खोज परिणाम)
    
    # चरण 3: जेमिनी के साथ विश्लेषण करें
    संकेत = f"""
    इन खोज परिणामों का विश्लेषण करें "{विषय}":
    
    {json.dumps(nikale_gaye_data, indent=2)}
    
    प्रदान करें:
    1. प्रमुख विषय और प्रवृत्तियाँ
    2. जानकारी के मुख्य स्रोत
    3. उल्लेखनीय अंतर्दृष्टियाँ
    4. अनुशंसित कार्य
    
    अपनी प्रतिक्रिया को एक स्पष्ट, कार्यात्मक रिपोर्ट के रूप में स्वरूपित करें।
    """
    
    प्रतिक्रिया = self.model.generate_content(संकेत)
    
    लौटाएँ {
        "विषय": विषय,
        "खोज डेटा": निकाले गए डेटा,
        "विश्लेषण": प्रतिक्रिया.text
    }

def _extract_results(self, खोज डेटा):
    """खोज परिणामों से प्रासंगिक डेटा निकालें"""
    परिणाम = []
    
    यदि "कार्बनिक_परिणाम" खोज डेटा में है:
        के लिए आइटम में खोज डेटा["कार्बनिक_परिणाम"][:10]:
            परिणाम.append({
                "शीर्षक": आइटम.get("शीर्षक", ""),
                "संक्षिप्त": आइटम.get("संक्षिप्त", ""),
                "लिंक": आइटम.get("लिंक", ""),
                "स्रोत": आइटम.get("प्रदर्शित_link", "")
            })
    
    लौटाएँ परिणाम

def analyze_competitors(self, कंपनी का नाम, प्रतिस्पर्धियों):
    """एक कंपनी का उसके प्रतिस्पर्धियों की तुलना करें"""
    सभी डेटा = {}
    
    # प्रत्येक कंपनी के लिए खोजें
    के लिए comp में [कंपनी का नाम] + प्रतिस्पर्धियों:
        print(f"\nविश्लेषण कर रहे हैं: {comp}")
        
        # हाल की समाचार और अपडेट के लिए खोजें
        समाचार_प्रश्न = f"{comp} नवीनतम समाचार अपडेट 2025"
        डेटा = self.analyzer.analyze_topic(समाचार_प्रश्न)
        
        यदि डेटा:
            सभी डेटा[comp] = डेटा
        
        # अनुरोधों के बीच विलंब जोड़ें
        समय.sleep(2)
    
    # तुलनात्मक विश्लेषण उत्पन्न करें
    तुलनात्मक_संकेत = f"""
    {कंपनी का नाम} की तुलना प्रतिस्पर्धियों से इस डेटा के आधार पर करें:
    
    {json.dumps(सभी डेटा, indent=2)}
    
    प्रदान करें:
    1. प्रतिस्पर्धात्मक स्थिति
    2. प्रत्येक कंपनी की अद्वितीय ताकत
    3. बाजार के अवसर
    4. {कंपनी का नाम} के लिए रणनीतिक अनुशंसाएँ
    """
    
    प्रतिक्रिया = self.analyzer.model.generate_content(tulsnativ_prompt)
    
    लौटाएँ {
        "कंपनी": कंपनी का नाम,
        "प्रतिस्पर्धी": प्रतिस्पर्धियों,
        "विश्लेषण": प्रतिक्रिया.text,
        "कच्चा डेटा": सभी डेटा
    }

def monitor_trend(self, कीवर्ड, समय सीमा="d"):
    """एक कीवर्ड के लिए प्रवृत्तियों की निगरानी करें"""
    # समय सीमाओं को Google के tbs पैरामीटर के लिए मैप करें
    समय_मानचित्र = {
        "घ": "qdr:h",  # पिछले घंटा
        "घ": "qdr:d",  # पिछले दिन
        "w": "qdr:w",  # पिछले सप्ताह
        "m": "qdr:m"   # पिछले महीने
    }
    
    # समय फ़िल्टर के साथ खोजें
    परिणाम = self.scraper.search_google(
        कीवर्ड, 
        tbs=समय_मानचित्र.get(समय सीमा, "qdr:d"),
        num=30
    )
    
    यदि परिणाम नहीं हैं:
        कुछ नहीं लौटाएँ
    
    # प्रवृत्तियों का विश्लेषण करें
    संकेत = f"""
    हाल की खोज परिणामों के आधार पर "{कीवर्ड}" के लिए प्रवृत्तियों का विश्लेषण करें:
    
    {json.dumps(परिणाम.get("कार्बनिक_परिणाम", [])[:15], indent=2)}
    
    पहचानें:
    1. उभरते पैटर्न
    2. प्रमुख विकास
    3. भावना (सकारात्मक/नकारात्मक/तटस्थ)
    4. भविष्यवाणियाँ
    5. कार्यात्मक अंतर्दृष्टियाँ
    """
    
    प्रतिक्रिया = self.analyzer.model.generate_content(संकेत)
    
    लौटाएँ {
        "कीवर्ड": कीवर्ड,
        "समय सीमा": समय सीमा,
        "विश्लेषण": प्रतिक्रिया.text,
        "परिणाम संख्या": len(परिणाम.get("कार्बनिक_परिणाम", []))
    }

    # डेटा संरचना को समतल करें
    पंक्तियाँ = []
    के लिए आइटम में डेटा:
        यदि isinstance(आइटम, dict) और "खोज डेटा" में आइटम:
            के लिए परिणाम में आइटम["खोज डेटा"]:
                पंक्तियाँ.append({
                    "विषय": आइटम.get("विषय", ""),
                    "शीर्षक": परिणाम.get("शीर्षक", ""),
                    "संक्षिप्त": परिणाम.get("संक्षिप्त", ""),
                    "लिंक": परिणाम.get("लिंक", ""),
                    "स्रोत": परिणाम.get("स्रोत", "")
                })
    
    df = pd.DataFrame(पंक्तियाँ)

df.to_csv(filename, index=False)
        print(f"डेटा {filename} में निर्यातित किया गया")

        return filename

    @staticmethod
    def create_html_report(analysis_data, filename="report.html"):
        """विश्लेषण डेटा से एक एचटीएमएल रिपोर्ट बनाएँ"""
        html = f"""
        <!DOCTYPE html>
        <html>
        <head>
            <title>सर्च एनालिटिक्स रिपोर्ट</title>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 40px; }}
                .section {{ margin-bottom: 30px; padding: 20px; 
                           background-color: #f5f5f5; border-radius: 8px; }}
                h1 {{ color: #333; }}
                h2 {{ color: #666; }}
                pre {{ white-space: pre-wrap; word-wrap: break-word; }}
            </style>
        </head>
        <body>
            <h1>सर्च एनालिटिक्स रिपोर्ट</h1>
            <p>जेनरेट किया गया: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
            
            <div class="section">
                <h2>विश्लेषण परिणाम</h2>
                <pre>{analysis_data.get('analysis', 'कोई विश्लेषण उपलब्ध नहीं')}</pre>
            </div>
            
            <div class="section">
                <h2>डेटा सारांश</h2>
                <p>विषय: {analysis_data.get('topic', 'N/A')}</p>
                <p>विश्लेषित परिणाम: {len(analysis_data.get('search_data', []))}</p>
            </div>
        </body>
        </html>
        """
        
        with open(filename, 'w') as f:
            f.write(html)
        
        print(f"एचटीएमएल रिपोर्ट बनाई गई: {filename}")

def main():
    # घटकों को शुरू करें
    competitor_monitor = CompetitorMonitor()
    trend_monitor = TrendMonitor()
    exporter = DataExporter()
    
    # उदाहरण 1: प्रतिस्पर्धी विश्लेषण
    print("=== प्रतिस्पर्धी ANALYSIS ===")
    analysis = competitor_monitor.analyze_competitors(
        company_name="OpenAI",
        competitors=["Anthropic", "Google AI", "Meta AI"]
    )
    
    print("\nप्रतिस्पर्धी विश्लेषण परिणाम:")
    print(analysis["analysis"])
    
    # परिणाम सहेजें
    with open("competitor_analysis.json", "w") as f:
        json.dump(analysis, f, indent=2)
    
    # उदाहरण 2: प्रवृत्ति निगरानी
    print("\n\n=== प्रवृत्ति निगरानी ===")
    trends = trend_monitor.monitor_trend(
        keyword="कृत्रिम बुद्धिमत्ता विनियमन",
        time_range="w"  # पिछले सप्ताह
    )
    
    print("\nप्रवृत्ति विश्लेषण परिणाम:")
    print(trends["analysis"])
    
    # उदाहरण 3: मल्टी-टॉपिक विश्लेषण
    print("\n\n=== मल्टी-टॉपिक विश्लेषण ===")
    topics = [
        "जनरेटिव एआई व्यापार अनुप्रयोग",
        "एआई साइबर सुरक्षा खतरें",
        "मशीन सीखने की स्वास्थ्य देखभाल"
    ]
    
    analyzer = SearchAnalyzer()
    all_results = []
    
    for topic in topics:
        print(f"\nविश्लेषण कर रहे हैं: {topic}")
        result = analyzer.analyze_topic(topic)
        
        if result:
            all_results.append(result)
            # व्यक्तिगत विश्लेषण सहेजें
            filename = f"{topic.replace(' ', '_')}_analysis.txt"
            with open(filename, "w") as f:
                f.write(result["analysis"])
            print(f"विश्लेषण {filename} में सहेजा गया")
        
        # अनुरोधों के बीच देरी
        time.sleep(2)
    
    # सभी परिणामों को CSV में निर्यात करें
    if all_results:
        csv_file = exporter.export_to_csv(all_results)
        print(f"\nसभी परिणाम निर्यात किए गए: {csv_file}")
        
        # पहले परिणाम के लिए एचटीएमएल रिपोर्ट बनाएं
        if all_results[0]:
            exporter.create_html_report(all_results[0])

if __name__ == "__main__":
    main()