प्लेराइट: वेब स्क्रैपिंग और टेस्टिंग

टेस्टिंग और स्क्रैपिंग के लिए ब्राउज़र ऑटोमेशन मास्टर करें

Page content

Playwright एक शक्तिशाली, आधुनिक ब्राउज़र ऑटोमेशन फ्रेमवर्क है जो वेब स्क्रैपिंग और एंड-टू-एंड टेस्टिंग को क्रांतिकारी बनाता है।

माइक्रोसॉफ्ट द्वारा विकसित, यह क्रोमियम, फायरफॉक्स, और वेबकिट ब्राउज़रों को ऑटोमेट करने के लिए एक एकीकृत API प्रदान करता है, जो अप्रतिम विश्वसनीयता और गति के साथ।

playwright ui

Playwright क्या है?

Playwright एक ओपन-सोर्स ब्राउज़र ऑटोमेशन फ्रेमवर्क है जो डेवलपर्स को विश्वसनीय एंड-टू-एंड टेस्ट लिखने और उन्नत वेब स्क्रैपिंग समाधान बनाने की अनुमति देता है। पारंपरिक ऑटोमेशन टूल्स के विपरीत, Playwright को आधुनिक वेब एप्लिकेशन्स, डायनामिक कंटेंट, सिंगल-पेज एप्लिकेशन्स (SPAs), और जटिल जावास्क्रिप्ट फ्रेमवर्क्स को संभालने के लिए बुनियादी स्तर से बनाया गया है।

फ्रेमवर्क उस कोर समस्या को संबोधित करता है जो पिछले ऑटोमेशन टूल्स को परेशान करती थी: फ्लेक्सिबिलिटी। Playwright ऑटो-वेटिंग मेकेनिज्म पेश करता है जो तत्वों को एक्शन करने योग्य होने के लिए स्वचालित रूप से इंतजार करते हैं, जिससे किसी भी कार्रवाई करने से पहले अनिश्चित समय सीमाएं या स्लीप स्टेटमेंट्स की आवश्यकता समाप्त हो जाती हैं जो टेस्ट्स को अविश्वसनीय बनाते थे।

मुख्य विशेषताएं

क्रॉस-ब्राउज़र समर्थन: Playwright सभी प्रमुख ब्राउज़र इंजनों - क्रोमियम (जिसमें क्रोम और एज शामिल हैं), फायरफॉक्स, और वेबकिट (सफारी) का समर्थन करता है। इसका मतलब है कि आप अपना ऑटोमेशन स्क्रिप्ट एक बार लिख सकते हैं और विभिन्न ब्राउज़रों पर बिना किसी संशोधन के चलाए सकते हैं, जिससे सुनिश्चित होता है कि आपके वेब एप्लिकेशन्स हर जगह समान रूप से काम करते हैं।

ऑटो-वेटिंग: Playwright की सबसे शक्तिशाली विशेषताओं में से एक इसका बिल्ट-इन ऑटो-वेटिंग मेकेनिज्म है। किसी भी कार्रवाई करने से पहले, Playwright स्वचालित रूप से तत्वों के लिए इंतजार करता है कि वे दृश्यमान, सक्षम, स्थिर, और अवरुद्ध न हों। यह रेस कंडीशन्स को समाप्त करता है और सिलेनियम जैसे टूल्स की तुलना में टेस्ट्स को बहुत अधिक विश्वसनीय बनाता है जहां स्पष्ट वेट्स अक्सर आवश्यक होते हैं।

नेटवर्क इंटरसेप्शन: Playwright आपको नेटवर्क रिक्वेस्ट्स और रिस्पॉन्स्स को इंटरसेप्ट, मॉडिफाई, और मॉक करने की अनुमति देता है। यह वेब स्क्रैपिंग के दौरान अनावश्यक संसाधनों को ब्लॉक करने, एपीआई रिस्पॉन्स्स को मॉक करने के लिए बैकएंड की आवश्यकता के बिना, या एज केसों को टेस्ट करने और धीमी नेटवर्क्स को सिमुलेट करने के लिए अमूल्य है।

मोबाइल एमुलेशन: विभिन्न मोबाइल डिवाइसों के साथ विशिष्ट व्यूपोर्ट साइज, यूजर एजेंट्स, और टच इवेंट्स के साथ मोबाइल वेब एप्लिकेशन्स को टेस्ट करें। Playwright में लोकप्रिय फोन और टैबलेट्स के लिए डिवाइस डिस्क्रिप्टर्स शामिल हैं।

शक्तिशाली सेलेक्टर्स: सीएसएस और एक्सपाथ सेलेक्टर्स के अलावा, Playwright टेक्स्ट सेलेक्टर्स, एक्सेसिबिलिटी टेस्टिंग के लिए रोल-आधारित सेलेक्टर्स, और यहां तक कि रिएक्ट और व्यू के लिए प्रयोगात्मक सेलेक्टर्स के लिए कम्पोनेंट-आधारित फ्रेमवर्क्स का समर्थन करता है।

इंस्टॉलेशन और सेटअप

Playwright को विभिन्न प्रोग्रामिंग भाषाओं में सेटअप करना सरल है।

पाइथन इंस्टॉलेशन

पाइथन प्रोजेक्ट्स के लिए, Playwright को pip के माध्यम से इंस्टॉल किया जा सकता है और इसमें सिंक्रोनस और एसिंक्रोनस एपीआई दोनों शामिल हैं। अगर आप एक तेज़, आधुनिक पाइथन पैकेज मैनेजर की तलाश कर रहे हैं, तो हमारी गाइड पर देखें uv - पाइथन पैकेज, प्रोजेक्ट, और एन्वायरनमेंट मैनेजर:

# Playwright पैकेज इंस्टॉल करें
pip install playwright

# ब्राउज़र्स इंस्टॉल करें (क्रोमियम, फायरफॉक्स, वेबकिट)
playwright install

# केवल विशिष्ट ब्राउज़र के लिए
playwright install chromium

प्लेवीथ के साथ काम करते समय पाइथन सिंटैक्स और आमतौर पर उपयोग किए जाने वाले कमांड्स के लिए एक व्यापक संदर्भ के लिए, हमारी पाइथन चीटशीट पर संदर्भ लें।

जावास्क्रिप्ट/टाइपस्क्रिप्ट इंस्टॉलेशन

नोड.जेएस प्रोजेक्ट्स के लिए, प्लेवीथ को npm या yarn के माध्यम से इंस्टॉल करें:

# npm का उपयोग करके
npm init playwright@latest

# yarn का उपयोग करके
yarn create playwright

# मैनुअल इंस्टॉलेशन
npm install -D @playwright/test
npx playwright install

npm init playwright कमांड एक इंटरैक्टिव सेटअप प्रदान करता है जो आपकी प्रोजेक्ट को उदाहरण टेस्ट्स, कॉन्फ़िगरेशन फाइल्स, और गिटहब एक्शन्स वर्कफ्लो के साथ कॉन्फ़िगर करता है।

बेसिक कॉन्फ़िगरेशन

एक playwright.config.ts (टाइपस्क्रिप्ट) या playwright.config.js (जावास्क्रिप्ट) फाइल बनाएं:

import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  timeout: 30000,
  retries: 2,
  workers: 4,
  use: {
    headless: true,
    viewport: { width: 1280, height: 720 },
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
  },
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
    },
    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] },
    },
    {
      name: 'webkit',
      use: { ...devices['Desktop Safari'] },
    },
  ],
});

Playwright के साथ वेब स्क्रैपिंग

Playwright पारंपरिक स्क्रैपिंग लाइब्रेरीज के साथ संघर्ष करने वाले आधुनिक वेबसाइट्स के साथ वेब स्क्रैपिंग में उत्कृष्ट है, जिनमें डायनामिक कंटेंट होता है।

बेसिक स्क्रैपिंग उदाहरण

यहाँ एक व्यापक पाइथन उदाहरण है जो कोर स्क्रैपिंग अवधारणाओं को प्रदर्शित करता है:

from playwright.sync_api import sync_playwright
import json

def scrape_website():
    with sync_playwright() as p:
        # ब्राउज़र लॉन्च करें
        browser = p.chromium.launch(headless=True)

        # आइसोलेशन के लिए कॉन्टेक्स्ट बनाएं
        context = browser.new_context(
            viewport={'width': 1920, 'height': 1080},
            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64)'
        )

        # नया पेज खोलें
        page = context.new_page()

        # URL पर नेविगेट करें
        page.goto('https://example.com/products')

        # कंटेंट लोड होने का इंतजार करें
        page.wait_for_selector('.product-item')

        # डेटा निकालें
        products = page.query_selector_all('.product-item')

        data = []
        for product in products:
            title = product.query_selector('h2').inner_text()
            price = product.query_selector('.price').inner_text()
            url = product.query_selector('a').get_attribute('href')

            data.append({
                'title': title,
                'price': price,
                'url': url
            })

        # क्लीनअप करें
        browser.close()

        return data

# स्क्रैपर चलाएं
results = scrape_website()
print(json.dumps(results, indent=2))

डायनामिक कंटेंट का हैंडलिंग

आधुनिक वेबसाइट्स अक्सर जावास्क्रिप्ट के माध्यम से कंटेंट को डायनामिक रूप से लोड करती हैं। Playwright इसे बिना किसी समस्या के संभालता है:

async def scrape_dynamic_content():
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()

        await page.goto('https://example.com/infinite-scroll')

        # और कंटेंट लोड करने के लिए स्क्रोल करें
        for _ in range(5):
            await page.evaluate('window.scrollTo(0, document.body.scrollHeight)')
            await page.wait_for_timeout(2000)

        # नेटवर्क को आइडल होने का इंतजार करें
        await page.wait_for_load_state('networkidle')

        # सभी लोड किए गए आइटम्स निकालें
        items = await page.query_selector_all('.item')

        await browser.close()

स्क्रैप किए गए कंटेंट को मार्कडाउन में बदलना

Playwright के साथ HTML कंटेंट निकालने के बाद, आपको अक्सर इसे एक अधिक उपयोगी फॉर्मेट में बदलने की आवश्यकता होती है। HTML को मार्कडाउन में बदलने के लिए व्यापक गाइड्स के लिए, हमारी लेखों पर देखें पाइथन में HTML को मार्कडाउन में बदलना: एक व्यापक गाइड जो छह अलग-अलग पाइथन लाइब्रेरीज की तुलना करता है, और LLM और Ollama का उपयोग करके HTML कंटेंट को मार्कडाउन में बदलना AI-सक्षम परिवर्तन के लिए। अगर आप वर्ड दस्तावेज़ों के साथ काम कर रहे हैं, तो हमारी गाइड पर देखें वर्ड दस्तावेज़ों को मार्कडाउन में बदलना.

ऑथेंटिकेशन और सेशन मैनेजमेंट

जब स्क्रैपिंग में ऑथेंटिकेशन की आवश्यकता होती है, तो Playwright ब्राउज़र स्टेट को सहेजने और पुनः उपयोग करने को आसान बनाता है:

def login_and_save_session():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        context = browser.new_context()
        page = context.new_page()

        # लॉगिन करें
        page.goto('https://example.com/login')
        page.fill('input[name="username"]', 'your_username')
        page.fill('input[name="password"]', 'your_password')
        page.click('button[type="submit"]')

        # लॉगिन के बाद नेविगेशन का इंतजार करें
        page.wait_for_url('**/dashboard')

        # ऑथेंटिकेटेड स्टेट सहेजें
        context.storage_state(path='auth_state.json')

        browser.close()

def scrape_with_saved_session():
    with sync_playwright() as p:
        browser = p.chromium.launch()
        # सहेजे गए ऑथेंटिकेशन स्टेट का पुनः उपयोग करें
        context = browser.new_context(storage_state='auth_state.json')
        page = context.new_page()

        # पहले से ऑथेंटिकेटेड!
        page.goto('https://example.com/protected-data')
        # ... प्रोटेक्टेड कंटेंट स्क्रैप करें

        browser.close()

यह दृष्टिकोण विशेष रूप से APIs के साथ काम करने या AI इंटीग्रेशन के लिए MCP सर्वर बनाने के लिए उपयोगी है। AI टूल इंटीग्रेशन में वेब स्क्रैपिंग को लागू करने के लिए एक पूर्ण गाइड के लिए, हमारी लेख पर देखें पाइथन में MCP सर्वर बनाना: वेबसर्च और स्क्रैप.

एंड-टू-एंड टेस्टिंग

प्लेवराइट का प्राथमिक उपयोग वेब एप्लिकेशन्स के लिए मजबूत एंड-टू-एंड टेस्ट लिखना है।

अपना पहला टेस्ट लिखना

टाइपस्क्रिप्ट में एक पूर्ण टेस्ट उदाहरण यहां दिया गया है:

import { test, expect } from '@playwright/test';

test('उपयोगकर्ता कार्ट में आइटम जोड़ सकता है', async ({ page }) => {
  // होमपेज पर नेविगेट करें
  await page.goto('https://example-shop.com');

  // उत्पाद खोजें
  await page.fill('[data-testid="search-input"]', 'लैपटॉप');
  await page.press('[data-testid="search-input"]', 'Enter');

  // खोज परिणामों का इंतजार करें
  await expect(page.locator('.product-card')).toBeVisible();

  // पहला उत्पाद क्लिक करें
  await page.locator('.product-card').first().click();

  // उत्पाद पेज लोड हुआ है इसका सत्यापन करें
  await expect(page).toHaveURL(/\/product\/.+/);

  // कार्ट में जोड़ें
  await page.click('[data-testid="add-to-cart"]');

  // कार्ट अपडेट हुआ है इसका सत्यापन करें
  const cartCount = page.locator('[data-testid="cart-count"]');
  await expect(cartCount).toHaveText('1');
});

पेज ऑब्जेक्ट मॉडल

बड़े टेस्ट सूट्स के लिए, पेज ऑब्जेक्ट मॉडल पैटर्न का उपयोग करें ताकि रखरखाव सुधारा जा सके:

// pages/LoginPage.ts
export class LoginPage {
  constructor(private page: Page) {}

  async navigate() {
    await this.page.goto('/login');
  }

  async login(username: string, password: string) {
    await this.page.fill('[name="username"]', username);
    await this.page.fill('[name="password"]', password);
    await this.page.click('button[type="submit"]');
  }

  async getErrorMessage() {
    return await this.page.locator('.error-message').textContent();
  }
}

// tests/login.spec.ts
import { test, expect } from '@playwright/test';
import { LoginPage } from '../pages/LoginPage';

test('अवैध क्रेडेंशियल्स के साथ लॉगिन त्रुटि संदेश दिखाता है', async ({ page }) => {
  const loginPage = new LoginPage(page);
  await loginPage.navigate();
  await loginPage.login('invalid@email.com', 'wrongpass');

  const error = await loginPage.getErrorMessage();
  expect(error).toContain('Invalid credentials');
});

उन्नत विशेषताएं

कोडजेन - स्वचालित टेस्ट जनरेशन

प्लेवराइट का कोडजेन टूल वेब पेज के साथ आपकी इंटरैक्शन को रिकॉर्ड करके टेस्ट जनरेट करता है:

# कोडजेन ओपन करें
playwright codegen example.com

# विशिष्ट ब्राउज़र के साथ
playwright codegen --browser firefox example.com

# सेव्ड ऑथेंटिकेशन स्टेट के साथ
playwright codegen --load-storage=auth.json example.com

जैसे-जैसे आप पेज के साथ इंटरैक्ट करते हैं, कोडजेन रियल-टाइम में कोड जनरेट करता है। यह टेस्ट प्रोटोटाइपिंग या प्लेवराइट के सेलेक्टर सिंटैक्स सीखने के लिए बेहद उपयोगी है।

डिबगिंग के लिए ट्रेस व्यूअर

जब टेस्ट फेल होते हैं, तो समझने में चुनौती आ सकती है। प्लेवराइट का ट्रेस व्यूअर टेस्ट एक्सीक्यूशन का टाइमलाइन व्यू प्रदान करता है:

// कॉन्फिग में ट्रेसिंग सक्षम करें
use: {
  trace: 'on-first-retry',
}

टेस्ट फेल होने और रिट्री करने के बाद, ट्रेस देखें:

playwright show-trace trace.zip

ट्रेस व्यूअर हर एक्शन पर स्क्रीनशॉट्स, नेटवर्क गतिविधि, कंसोल लॉग्स, और DOM स्नैपशॉट्स दिखाता है, जिससे डिबगिंग सरल हो जाती है।

नेटवर्क इंटरसेप्शन और मॉकिंग

एज केस टेस्टिंग के लिए नेटवर्क ट्रैफिक को इंटरसेप्ट और मॉडिफाई करें:

def test_with_mocked_api():
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()

        # मॉक API रिस्पॉन्स
        def handle_route(route):
            if 'api/products' in route.request.url:
                route.fulfill(
                    status=200,
                    body=json.dumps({
                        'products': [
                            {'id': 1, 'name': 'Test Product', 'price': 99.99}
                        ]
                    })
                )
            else:
                route.continue_()

        page.route('**/*', handle_route)

        page.goto('https://example.com')
        # पेज अब मॉक्ड डेटा का उपयोग करता है

        browser.close()

मोबाइल टेस्टिंग

अपने रिस्पॉन्सिव डिजाइन्स को विभिन्न डिवाइस पर टेस्ट करें:

from playwright.sync_api import sync_playwright

def test_mobile():
    with sync_playwright() as p:
        # डिवाइस डिस्क्रिप्टर का उपयोग करें
        iphone_13 = p.devices['iPhone 13']

        browser = p.webkit.launch()
        context = browser.new_context(**iphone_13)
        page = context.new_page()

        page.goto('https://example.com')

        # मोबाइल उपयोगकर्ता के रूप में इंटरैक्ट करें
        page.locator('#mobile-menu-button').click()

        browser.close()

सर्वोत्तम प्रथाएं

वेब स्क्रैपिंग के लिए

  1. प्रोडक्शन में हेडलेस मोड का उपयोग करें: हेडलेस ब्राउज़िंग तेज़ है और कम संसाधनों का उपयोग करता है
  2. रेट लिमिटिंग लागू करें: रिक्वेस्ट्स के बीच देरी डालकर टारगेट वेबसाइट्स का सम्मान करें
  3. त्रुटियों को ग्रेसफुल रूप से हैंडल करें: नेटवर्क समस्याएं, टाइमआउट्स, और सेलेक्टर बदलाव होते हैं
  4. यूजर एजेंट्स को रोटेट करें: ब्राउज़र फिंगरप्रिंट्स को बदलकर पता चलने से बचें
  5. रोबोट्स.टेक्स्ट का सम्मान करें: वेबसाइट स्क्रैपिंग नीतियों की जांच करें और उनका पालन करें
  6. कॉन्टेक्स्ट आइसोलेशन का उपयोग करें: पैरालेल स्क्रैपिंग के लिए अलग ब्राउज़र कॉन्टेक्स्ट बनाएं

स्क्रैप्ड सामग्री को मार्कडाउन फॉर्मेट में बदलते समय, LLM-आधारित कन्वर्जन टूल्स या HTML-to-Markdown कन्वर्जन के लिए विशेषीकृत Python लाइब्रेरीज का उपयोग करने पर विचार करें।

टेस्टिंग के लिए

  1. डेटा-टेस्टिड एट्रिब्यूट्स का उपयोग करें: CSS क्लासेस से अधिक स्थिर होते हैं जो अक्सर बदलते हैं
  2. हार्ड वेट्स से बचें: sleep() के बजाय प्लेवराइट के बिल्ट-इन वेटिंग मेकेनिज्म का उपयोग करें
  3. टेस्ट्स स्वतंत्र रखें: हर टेस्ट को अलग-अलग चलाने में सक्षम होना चाहिए
  4. फिक्स्चर्स का उपयोग करें: टेस्ट्स के बीच सेटअप कोड साझा करें
  5. टेस्ट्स को पैरालेल चलाएं: प्लेवराइट के वर्कर थ्रेड्स का उपयोग करें
  6. फेल होने पर ट्रेस रिकॉर्ड करें: आसान डिबगिंग के लिए ट्रेस रिकॉर्डिंग सक्षम करें

प्रदर्शन अनुकूलन

# अनावश्यक संसाधनों को निष्क्रिय करें
def fast_scraping():
    with sync_playwright() as p:
        browser = p.chromium.launch()
        context = browser.new_context()
        page = context.new_page()

        # स्क्रैपिंग को तेज़ करने के लिए छवियां और स्टाइलशीट्स को ब्लॉक करें
        async def block_resources(route):
            if route.request.resource_type in ['image', 'stylesheet', 'font']:
                await route.abort()
            else:
                await route.continue_()

        page.route('**/*', block_resources)
        page.goto('https://example.com')

        browser.close()

प्लेवराइट को विकल्पों से तुलना करना

प्लेवराइट बनाम सेलेनियम

प्लेवराइट के फायदे:

  • बिल्ट-इन ऑटो-वेटिंग फ्लेकी टेस्ट्स को समाप्त करता है
  • आधुनिक आर्किटेक्चर के कारण तेज़ एक्सीक्यूशन
  • बेहतर नेटवर्क इंटरसेप्शन और मॉकिंग
  • उत्कृष्ट डिबगिंग टूल्स (ट्रेस व्यूअर)
  • कम बॉयलरप्लेट के साथ सरल API
  • एक ही इंस्टॉलेशन के साथ कई ब्राउज़र्स

सेलेनियम के फायदे:

  • अधिक परिपक्व इकोसिस्टम के साथ व्यापक समुदाय
  • अधिक प्रोग्रामिंग भाषाओं का समर्थन
  • पुराने संस्करणों सहित अधिक ब्राउज़र संगतता

प्लेवराइट बनाम पपेटियर

प्लेवराइट के फायदे:

  • सच्चा क्रॉस-ब्राउज़र समर्थन (फायरफॉक्स, वेबकिट, क्रोमियम)
  • पपेटियर के पाठों पर आधारित बेहतर API डिजाइन
  • अधिक शक्तिशाली डिबगिंग टूल्स
  • माइक्रोसॉफ्ट का समर्थन और सक्रिय विकास

पपेटियर के फायदे:

  • थोड़ा छोटा फुटप्रिंट
  • क्रोम डेवटूल्स प्रोटोकॉल में विशेषज्ञता

अधिकांश नए प्रोजेक्ट्स के लिए, प्लेवराइट को आधुनिक आर्किटेक्चर और व्यापक फीचर सेट के कारण अनुशंसित किया जाता है। यदि आप Go के बजाय Python या JavaScript का उपयोग कर रहे हैं और वेब स्क्रैपिंग क्षमताओं की आवश्यकता है, तो Go इकोसिस्टम में तुलनीय स्क्रैपिंग टूल्स के लिए हमारा गाइड देखें Beautiful Soup Alternatives for Go.

सामान्य उपयोग मामले

AI/LLM एप्लिकेशन्स के लिए डेटा एक्सट्रैक्शन

प्लेवराइट AI मॉडल्स के लिए ट्रेनिंग डेटा इकट्ठा करने या वेब सर्च क्षमताओं को बनाने के लिए उत्कृष्ट है। MCP (मॉडल कॉन्टेक्स्ट प्रोटोकॉल) सर्वर बनाते समय, प्लेवराइट वेब स्क्रैपिंग घटक का प्रबंधन कर सकता है जबकि LLMs एक्सट्रैक्टेड सामग्री को प्रोसेस करते हैं।

CI/CD में स्वचालित टेस्टिंग

प्लेवराइट टेस्ट्स को अपने कंटीन्यूअस इंटीग्रेशन पाइपलाइन में एकीकृत करें:

# .github/workflows/playwright.yml
name: Playwright Tests
on:
  push:
    branches: [ main, master ]
  pull_request:
    branches: [ main, master ]
jobs:
  test:
    timeout-minutes: 60
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: actions/setup-node@v3
      with:
        node-version: 18
    - name: Install dependencies
      run: npm ci
    - name: Install Playwright Browsers
      run: npx playwright install --with-deps
    - name: Run Playwright tests
      run: npx playwright test
    - uses: actions/upload-artifact@v3
      if: always()
      with:
        name: playwright-report
        path: playwright-report/
        retention-days: 30

वेबसाइट मॉनिटरिंग

अपने प्रोडक्शन वेबसाइट्स को अपटाइम और फंक्शनलिटी के लिए मॉनिटर करें:

import schedule
import time

def monitor_website():
    with sync_playwright() as p:
        try:
            browser = p.chromium.launch()
            page = browser.new_page()
            page.goto('https://your-site.com', timeout=30000)

            # महत्वपूर्ण तत्वों की जांच करें
            assert page.is_visible('.header')
            assert page.is_visible('#main-content')

            print("✓ वेबसाइट स्वस्थ है")
        except Exception as e:
            print(f"✗ वेबसाइट समस्या पता चली: {e}")
            # अलर्ट भेजें
        finally:
            browser.close()

# हर 5 मिनट में चलाएं
schedule.every(5).minutes.do(monitor_website)

while True:
    schedule.run_pending()
    time.sleep(1)

सामान्य समस्याओं का समाधान

ब्राउज़र इंस्टॉलेशन समस्याएं

अगर ब्राउज़र्स डाउनलोड नहीं होते हैं:

# कस्टम डाउनलोड लोकेशन सेट करें
PLAYWRIGHT_BROWSERS_PATH=/custom/path playwright install

# कैश क्लियर करें और पुनः इंस्टॉल करें
playwright uninstall
playwright install

टाइमआउट त्रुटियां

धीमी नेटवर्क या जटिल पेजों के लिए टाइमआउट बढ़ाएं:

page.goto('https://slow-site.com', timeout=60000)  # 60 सेकंड
page.wait_for_selector('.element', timeout=30000)  # 30 सेकंड

सेलेक्टर नहीं मिला

प्लेवराइट इंस्पेक्टर का उपयोग करें सही सेलेक्टर पहचानने के लिए:

PWDEBUG=1 pytest test_file.py

यह इंस्पेक्टर ओपन करता है जहां आप तत्वों पर हॉवर कर सकते हैं और उनके सेलेक्टर देख सकते हैं।

निष्कर्ष

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

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

पाइथन डेवलपर्स जो डेटा पाइपलाइन या वेब स्क्रैपिंग परियोजनाओं पर काम कर रहे हैं, उनके लिए प्लेवराइट आधुनिक पैकेज मैनेजर के साथ आसानी से एकीकृत होता है और पांडास, रिक्वेस्ट्स और अन्य डेटा साइंस टूल्स के साथ उत्कृष्ट रूप से काम करता है। जटिल आधुनिक वेबसाइट्स से संरचित डेटा निकालने की क्षमता इसे AI अनुप्रयोगों, अनुसंधान परियोजनाओं और बिजनेस इंटेलिजेंस के लिए अमूल्य बनाती है। जब इसे HTML-to-Markdown कन्वर्जन टूल्स और उचित सामग्री प्रसंस्करण के साथ मिलाया जाता है, तो प्लेवराइट वेब डेटा को बड़े पैमाने पर निकालने, परिवर्तित करने और उपयोग करने के लिए एक पूर्ण समाधान बन जाता है।

उपयोगी लिंक

अन्य संदर्भ