# Docker Compose का उपयोग करें
git clone https://github.com/crawlab-team/crawlab.git
cd crawlab
docker-compose up -d

# Python निर्भरता
pip install selenium requests

"""
Crawlab + CapSolver: reCAPTCHA v2 सॉल्वर
Selenium के साथ reCAPTCHA v2 चुनौतियों के लिए पूर्ण स्क्रिप्ट
"""

import os
import time
import json
import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# कॉन्फ़िगरेशन
CAPSOLVER_API_KEY = os.getenv('CAPSOLVER_API_KEY', 'YOUR_CAPSOLVER_API_KEY')
CAPSOLVER_API = 'https://api.capsolver.com'


class CapsolverClient:
    """reCAPTCHA v2 के लिए CapSolver API क्लाइंट"""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.session = requests.Session()

    def create_task(self, task: dict) -> str:
        """CAPTCHA हल करने के लिए कार्य बनाएं"""
        payload = {
            "clientKey": self.api_key,
            "task": task
        }
        response = self.session.post(
            f"{CAPSOLVER_API}/createTask",
            json=payload
        )
        result = response.json()

        if result.get('errorId', 0) != 0:
            raise Exception(f"CapSolver त्रुटि: {result.get('errorDescription')}")

        return result['taskId']

    def get_task_result(self, task_id: str, timeout: int = 120) -> dict:
        """कार्य परिणाम के लिए पॉल करें"""
        for _ in range(timeout):
            payload = {
                "clientKey": self.api_key,
                "taskId": task_id
            }
            response = self.session.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json=payload
            )
            result = response.json()

            if result.get('status') == 'ready':
                return result['solution']

            if result.get('status') == 'failed':
                raise Exception("CAPTCHA हल नहीं हो सका")

            time.sleep(1)

        raise Exception("समाधान की प्रतीक्षा में समय सीमा समाप्त हो गई")

    def solve_recaptcha_v2(self, website_url: str, site_key: str) -> str:
        """reCAPTCHA v2 हल करें और टोकन लौटाएं"""
        task = {
            "type": "ReCaptchaV2TaskProxyLess",
            "websiteURL": website_url,
            "websiteKey": site_key
        }

        print(f"{website_url} के लिए कार्य बनाया जा रहा है...")
        task_id = self.create_task(task)
        print(f"कार्य बनाया गया: {task_id}")

        print("समाधान की प्रतीक्षा कर रहे हैं...")
        solution = self.get_task_result(task_id)
        return solution['gRecaptchaResponse']

    def get_balance(self) -> float:
        """खाता शेष प्राप्त करें"""
        response = self.session.post(
            f"{CAPSOLVER_API}/getBalance",
            json={"clientKey": self.api_key}
        )
        return response.json().get('balance', 0)


class RecaptchaV2Crawler:
    """reCAPTCHA v2 समर्थन के साथ Selenium क्रॉलर"""

    def __init__(self, headless: bool = True):
        self.headless = headless
        self.driver = None
        self.capsolver = CapsolverClient(CAPSOLVER_API_KEY)

    def start(self):
        """ब्राउज़र की शुरुआत करें"""
        options = Options()
        if self.headless:
            options.add_argument("--headless=new")
        options.add_argument("--no-sandbox")
        options.add_argument("--disable-dev-shm-usage")
        options.add_argument("--window-size=1920,1080")

        self.driver = webdriver.Chrome(options=options)
        print("ब्राउज़र शुरू किया गया")

    def stop(self):
        """ब्राउज़र बंद करें"""
        if self.driver:
            self.driver.quit()
            print("ब्राउज़र बंद किया गया")

    def detect_recaptcha(self) -> str:
        """reCAPTCHA का पता लगाएं और site key लौटाएं"""
        try:
            element = self.driver.find_element(By.CLASS_NAME, "g-recaptcha")
            return element.get_attribute("data-sitekey")
        except:
            return None

    def inject_token(self, token: str):
        """हल किया गया टोकन पृष्ठ में डालें"""
        self.driver.execute_script(f"""
            // g-recaptcha-response टेक्सटएरिया सेट करें
            var responseField = document.getElementById('g-recaptcha-response');
            if (responseField) {{
                responseField.style.display = 'block';
                responseField.value = '{token}';
            }}

            // सभी छिपे हुए उत्तर क्षेत्रों को सेट करें
            var textareas = document.querySelectorAll('textarea[name="g-recaptcha-response"]');
            for (var i = 0; i < textareas.length; i++) {{
                textareas[i].value = '{token}';
            }}
        """)
        print("टोकन डाल दिया गया")

    def submit_form(self):
        """फॉर्म जमा करें"""
        try:
            submit = self.driver.find_element(
                By.CSS_SELECTOR,
                'button[type="submit"], input[type="submit"]'
            )
            submit.click()
            print("फॉर्म जमा किया गया")
        except Exception as e:
            print(f"फॉर्म जमा नहीं किया जा सका: {e}")

    def crawl(self, url: str) -> dict:
        """reCAPTCHA v2 निपटान के साथ URL क्रॉल करें"""
        result = {
            'url': url,
            'success': False,
            'captcha_solved': False
        }

        try:
            print(f"जाएं: {url}")
            self.driver.get(url)
            time.sleep(2)

            # reCAPTCHA का पता लगाएं
            site_key = self.detect_recaptcha()

            if site_key:
                print(f"reCAPTCHA v2 पाया गया! site key: {site_key}")

                # CAPTCHA हल करें
                token = self.capsolver.solve_recaptcha_v2(url, site_key)
                print(f"टोकन प्राप्त: {token[:50]}...")

                # टोकन डालें
                self.inject_token(token)
                result['captcha_solved'] = True

                # फॉर्म जमा करें
                self.submit_form()
                time.sleep(2)

            result['success'] = True
            result['title'] = self.driver.title

        except Exception as e:
            result['error'] = str(e)
            print(f"त्रुटि: {e}")

        return result


def main():
    """मुख्य प्रवेश बिंदु"""
    # बैलेंस जांचें
    client = CapsolverClient(CAPSOLVER_API_KEY)
    print(f"CapSolver बैलेंस: ${client.get_balance():.2f}")

    # क्रॉलर बनाएं
    crawler = RecaptchaV2Crawler(headless=True)

    try:
        crawler.start()

        # लक्ष्य URL क्रॉल करें (अपने लक्ष्य से बदलें)
        result = crawler.crawl("https://example.com/protected-page")

        print("\n" + "=" * 50)
        print("परिणाम:")
        print(json.dumps(result, indent=2))

    finally:
        crawler.stop()


if __name__ == "__main__":
    main()

"""
Crawlab + CapSolver: Cloudflare Turnstile सॉल्वर
Turnstile चुनौतियों के लिए पूर्ण स्क्रिप्ट
"""

import os
import time
import json
import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options
from selenium.common.exceptions import NoSuchElementException

# कॉन्फ़िगरेशन
CAPSOLVER_API_KEY = os.getenv('CAPSOLVER_API_KEY', 'YOUR_CAPSOLVER_API_KEY')
CAPSOLVER_API = 'https://api.capsolver.com'


class TurnstileSolver:
    """Turnstile के लिए CapSolver क्लाइंट"""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.session = requests.Session()

    def solve(self, website_url: str, site_key: str) -> str:
        """Turnstile CAPTCHA हल करें"""
        print(f"{website_url} के लिए Turnstile हल कर रहे हैं")
        print(f"site key: {site_key}")

        # कार्य बनाएं
        task_data = {
            "clientKey": self.api_key,
            "task": {
                "type": "AntiTurnstileTaskProxyLess",
                "websiteURL": website_url,
                "websiteKey": site_key
            }
        }

        response = self.session.post(f"{CAPSOLVER_API}/createTask", json=task_data)
        result = response.json()

        if result.get('errorId', 0) != 0:
            raise Exception(f"CapSolver त्रुटि: {result.get('errorDescription')}")

        task_id = result['taskId']
        print(f"कार्य बनाया गया: {task_id}")

        # परिणाम के लिए पॉल करें
        for i in range(120):
            result_data = {
                "clientKey": self.api_key,
                "taskId": task_id
            }

            response = self.session.post(f"{CAPSOLVER_API}/getTaskResult", json=result_data)
            result = response.json()

            if result.get('status') == 'ready':
                token = result['solution']['token']
                print("Turnstile हल कर दिया गया!")
                return token

            if result.get('status') == 'failed':
                raise Exception("Turnstile हल नहीं हो सका")

            time.sleep(1)

        raise Exception("समाधान की प्रतीक्षा में समय सीमा समाप्त हो गई")


class TurnstileCrawler:
    """Turnstile समर्थन के साथ Selenium क्रॉलर"""

    def __init__(self, headless: bool = True):
        self.headless = headless
        self.driver = None
        self.solver = TurnstileSolver(CAPSOLVER_API_KEY)

    def start(self):
        """ब्राउज़र की शुरुआत करें"""
        options = Options()
        if self.headless:
            options.add_argument("--headless=new")
        options.add_argument("--no-sandbox")
        options.add_argument("--disable-dev-shm-usage")

        self.driver = webdriver.Chrome(options=options)

    def stop(self):
        """ब्राउज़र बंद करें"""
        if self.driver:
            self.driver.quit()

    def detect_turnstile(self) -> str:
        """Turnstile का पता लगाएं और site key लौटाएं"""
        try:
            turnstile = self.driver.find_element(By.CLASS_NAME, "cf-turnstile")
            return turnstile.get_attribute("data-sitekey")
        except NoSuchElementException:
            return None

    def inject_token(self, token: str):
        """Turnstile टोकन डालें"""
        self.driver.execute_script(f"""
            var token = '{token}';

            // cf-turnstile-response क्षेत्र खोजें
            var field = document.querySelector('[name="cf-turnstile-response"]');
            if (field) {{
                field.value = token;
            }}

            // सभी Turnstile इनपुट खोजें
            var inputs = document.querySelectorAll('input[name*="turnstile"]');
            for (var i = 0; i < inputs.length; i++) {{
                inputs[i].value = token;
            }}
        """)
        print("टोकन डाल दिया!")

    def crawl(self, url: str) -> dict:
        """Turnstile निपटान के साथ URL क्रॉल करें"""
        result = {
            'url': url,
            'success': False,
            'captcha_solved': False,
            'captcha_type': None
        }

        try:
            print(f"जाएं: {url}")
            self.driver.get(url)
            time.sleep(3)

            # Turnstile का पता लगाएं
            site_key = self.detect_turnstile()

            if site_key:
                result['captcha_type'] = 'turnstile'
                print(f"Turnstile पाया गया! site key: {site_key}")

                # हल करें
                token = self.solver.solve(url, site_key)

                # डालें
                self.inject_token(token)
                result['captcha_solved'] = True

                time.sleep(2)

            result['success'] = True
            result['title'] = self.driver.title

        except Exception as e:
            print(f"त्रुटि: {e}")
            result['error'] = str(e)

        return result


def main():
    """मुख्य प्रवेश बिंदु"""
    crawler = TurnstileCrawler(headless=True)

    try:
        crawler.start()

        # लक्ष्य (अपने लक्ष्य URL से बदलें)
        result = crawler.crawl("https://example.com/turnstile-protected")

        print("\n" + "=" * 50)
        print("परिणाम:")
        print(json.dumps(result, indent=2))

    finally:
        crawler.stop()


if __name__ == "__main__":
    main()

"""
Crawlab + CapSolver: Scrapy स्पाइडर
CAPTCHA हल करने वाले मिडलवेयर के साथ पूर्ण Scrapy स्पाइडर
"""

import scrapy
import requests
import time
import os

CAPSOLVER_API_KEY = os.getenv('CAPSOLVER_API_KEY', 'YOUR_CAPSOLVER_API_KEY')
CAPSOLVER_API = 'https://api.capsolver.com'


class CapsolverMiddleware:
    """CAPTCHA हल करने के लिए Scrapy मिडलवेयर"""

    def __init__(self):
        self.api_key = CAPSOLVER_API_KEY

    def solve_recaptcha_v2(self, url: str, site_key: str) -> str:
        """reCAPTCHA v2 हल करें"""

    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": self.api_key,
            "task": {
                "type": "ReCaptchaV2TaskProxyLess",
                "websiteURL": url,
                "websiteKey": site_key
            }
        }
    )
    task_id = response.json()['taskId']

    # परिणाम के लिए पॉल
    for _ in range(120):
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={"clientKey": self.api_key, "taskId": task_id}
        ).json()

        if result.get('status') == 'ready':
            return result['solution']['gRecaptchaResponse']

        time.sleep(1)

    raise Exception("समय सीमा समाप्त")

name = "captcha_spider"
start_urls = ["https://example.com/protected"]

custom_settings = {
    'DOWNLOAD_DELAY': 2,
    'CONCURRENT_REQUESTS': 1,
}

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.capsolver = CapsolverMiddleware()

def parse(self, response):
    # reCAPTCHA की जांच करें
    site_key = response.css('.g-recaptcha::attr(data-sitekey)').get()

    if site_key:
        self.logger.info(f"reCAPTCHA पाया गया: {site_key}")

        # कैप्चा हल करें
        token = self.capsolver.solve_recaptcha_v2(response.url, site_key)

        # टोकन के साथ फॉर्म जमा करें
        yield scrapy.FormRequest.from_response(
            response,
            formdata={'g-recaptcha-response': token},
            callback=self.after_captcha
        )
    else:
        yield from self.extract_data(response)

def after_captcha(self, response):
    """कैप्चा के बाद पृष्ठ का प्रसंस्करण"""
    yield from self.extract_data(response)

def extract_data(self, response):
    """पृष्ठ से डेटा निकालें"""
    yield {
        'title': response.css('title::text').get(),
        'url': response.url,
    }

---

## Node.js/Puppeteer एकीकरण

कैप्चा हल करने के लिए पूर्ण Node.js स्क्रिप्ट:

```javascript
/**
 * Crawlab + Capsolver: Puppeteer स्पाइडर
 * कैप्चा हल करने के लिए पूर्ण Node.js स्क्रिप्ट
 */

const puppeteer = require('puppeteer');

const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY || 'YOUR_CAPSOLVER_API_KEY';
const CAPSOLVER_API = 'https://api.capsolver.com';

/**
 * Capsolver क्लाइंट
 */
class Capsolver {
    constructor(apiKey) {
        this.apiKey = apiKey;
    }

    async createTask(task) {
        const response = await fetch(`${CAPSOLVER_API}/createTask`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                clientKey: this.apiKey,
                task: task
            })
        });
        const result = await response.json();

        if (result.errorId !== 0) {
            throw new Error(result.errorDescription);
        }

        return result.taskId;
    }

    async getTaskResult(taskId, timeout = 120) {
        for (let i = 0; i < timeout; i++) {
            const response = await fetch(`${CAPSOLVER_API}/getTaskResult`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    clientKey: this.apiKey,
                    taskId: taskId
                })
            });
            const result = await response.json();

            if (result.status === 'ready') {
                return result.solution;
            }

            if (result.status === 'failed') {
                throw new Error('कार्य विफल');
            }

            await new Promise(r => setTimeout(r, 1000));
        }

        throw new Error('समय सीमा समाप्त');
    }

    async solveRecaptchaV2(url, siteKey) {
        const taskId = await this.createTask({
            type: 'ReCaptchaV2TaskProxyLess',
            websiteURL: url,
            websiteKey: siteKey
        });

        const solution = await this.getTaskResult(taskId);
        return solution.gRecaptchaResponse;
    }

    async solveTurnstile(url, siteKey) {
        const taskId = await this.createTask({
            type: 'AntiTurnstileTaskProxyLess',
            websiteURL: url,
            websiteKey: siteKey
        });

        const solution = await this.getTaskResult(taskId);
        return solution.token;
    }
}

/**
 * मुख्य ड्रॉलिंग कार्य
 */
async function crawlWithCaptcha(url) {
    const capsolver = new Capsolver(CAPSOLVER_API_KEY);

    const browser = await puppeteer.launch({
        headless: true,
        args: ['--no-sandbox', '--disable-setuid-sandbox']
    });

    const page = await browser.newPage();

    try {
        console.log(`ड्रॉलिंग: ${url}`);
        await page.goto(url, { waitUntil: 'networkidle2' });

        // कैप्चा प्रकार की पहचान करें
        const captchaInfo = await page.evaluate(() => {
            const recaptcha = document.querySelector('.g-recaptcha');
            if (recaptcha) {
                return {
                    type: 'recaptcha',
                    siteKey: recaptcha.dataset.sitekey
                };
            }

            const turnstile = document.querySelector('.cf-turnstile');
            if (turnstile) {
                return {
                    type: 'turnstile',
                    siteKey: turnstile.dataset.sitekey
                };
            }

            return null;
        });

        if (captchaInfo) {
            console.log(`${captchaInfo.type} पाया गया!`);

            let token;

            if (captchaInfo.type === 'recaptcha') {
                token = await capsolver.solveRecaptchaV2(url, captchaInfo.siteKey);

                // टोकन डालें
                await page.evaluate((t) => {
                    const field = document.getElementById('g-recaptcha-response');
                    if (field) field.value = t;

                    document.querySelectorAll('textarea[name="g-recaptcha-response"]')
                        .forEach(el => el.value = t);
                }, token);

            } else if (captchaInfo.type === 'turnstile') {
                token = await capsolver.solveTurnstile(url, captchaInfo.siteKey);

                // टोकन डालें
                await page.evaluate((t) => {
                    const field = document.querySelector('[name="cf-turnstile-response"]');
                    if (field) field.value = t;
                }, token);
            }

            console.log('कैप्चा हल कर दिया गया और डाल दिया गया!');
        }

        // डेटा निकालें
        const data = await page.evaluate(() => ({
            title: document.title,
            url: window.location.href
        }));

        return data;

    } finally {
        await browser.close();
    }
}

// मुख्य निष्पादन
const targetUrl = process.argv[2] || 'https://example.com';

crawlWithCaptcha(targetUrl)
    .then(result => {
        console.log('\nपरिणाम:');
        console.log(JSON.stringify(result, null, 2));
    })
    .catch(console.error);

def solve_with_retry(solver, url, site_key, max_retries=3):
    """कैप्चा हल करें पुन: प्रयास के साथ"""
    for attempt in range(max_retries):
        try:
            return solver.solve(url, site_key)
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            print(f"प्रयास {attempt + 1} विफल: {e}")
            time.sleep(2 ** attempt)  # एक्स्पोनेंशियल बैकऑफ

# Scrapy सेटिंग्स
DOWNLOAD_DELAY = 3
CONCURRENT_REQUESTS_PER_DOMAIN = 1

export CAPSOLVER_API_KEY="आपका-एपी-कुंजी-यहां"