py4quality 0.1.0__py3-none-any.whl

py4quality-0.1.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: py4quality
+Version: 0.1.0
+Summary: A highly user-friendly, kid-friendly automation framework using Chrome DevTools Protocol (CDP).
+Author: Venkata Santosh Tharigoppala
+License: MIT
+Project-URL: Homepage, https://github.com/santoshtvk-new/Pyquality
+Project-URL: Bug Tracker, https://github.com/santoshtvk-new/Pyquality/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: websocket-client>=1.6.1
+Requires-Dist: requests>=2.31.0
+
+# pyquality 🎈
+
+A kid-friendly, yet exceptionally powerful automation framework for Python driven directly by the Chrome DevTools Protocol (CDP).
+
+`pyquality` is designed to be as simple as possible. Want to close the browser? Just call `b.bye()`. Want to navigate? `b.go_to("https://...")`
+
+Under the hood, it retains uncompromising power. Advanced users have **unfiltered access** to all 40+ raw Chromium DevTools domains (DOM, Network, Page, etc.) auto-generated from the official Google spec!
+
+---
+
+## 🚀 Installation (Source)
+If you are developing locally:
+```bash
+git clone https://github.com/santoshtvk-new/Pyquality.git
+cd pyquality
+pip install -e .
+```
+
+## 🛠️ Installation (PIP)
+*(When published to PyPi)*
+```bash
+pip install pyquality
+```
+
+---
+
+## 📖 Quick Start
+
+```python
+from pyquality.browser import Browser
+
+# 1. Start it up
+b = Browser(headless=False)
+
+# 2. Go somewhere
+b.go_to("https://example.com")
+
+# 3. Validation is easy
+b.should_be_seen("h1")
+
+# 4. Say goodbye
+b.bye()
+```
+
+## ✨ The Kid-Friendly Aliases
+
+`pyquality` dynamically binds methods defined in `METHOD_ALIASES.yml` so you can use vocabulary that makes sense to you.
+
+### Navigation
+- `navigate(url)` -> `go_to`, `open_website`
+- `reload()` -> `refresh`, `reload_page`
+- `close()` -> `close_browser`, `bye`
+- `go_back()` -> `step_back`, `previous_page`
+- `go_forward()` -> `step_forward`, `next_page`
+
+### Interaction
+- `click_element(selector)` -> `click_this`, `tap`
+- `type_text(selector, text)` -> `type_in`, `write_this`
+- `hover_element(selector)` -> `point_at`, `hover_over`
+
+### APIs & Data
+- `API.get(endpoint)` -> `fetch_data`, `grab`
+- `API.post(endpoint, json)` -> `create_data`, `send_new`
+
+---
+
+## ⚡ Raw CDP Power (Advanced)
+
+If you need capabilities beyond the simple wrappers, `pyquality` has raw auto-generated bindings for **EVERY** CDP Domain. They are attached natively to the browser instance:
+
+```python
+from pyquality.browser import Browser
+b = Browser()
+
+# Use raw 'Page' domain to capture a PDF
+b.page.printToPDF()
+
+# Use raw 'Network' domain to throttle connection
+b.network.emulateNetworkConditions(
+    offline=False, 
+    latency=200, 
+    downloadThroughput=1000, 
+    uploadThroughput=1000
+)
+
+# Use raw 'DOM' domain to get node information
+b.dom.getDocument(depth=-1)
+```
+
+## 📦 Deploying Initial PIP Package
+
+To package this framework and upload it to PyPi:
+
+1. **Install build tools:**
+   ```bash
+   pip install build twine
+   ```
+
+2. **Generate Native Wrappers:**
+   Ensure your CDP protocol bindings are up-to-date:
+   ```bash
+   python src/pyquality/generate_cdp_wrappers.py
+   ```
+
+3. **Build wheels:**
+   ```bash
+   python -m build
+   ```
+   *This generates `.tar.gz` and `.whl` files in the `/dist` folder.*
+
+4. **Upload to PyPi (Requires Account):**
+   ```bash
+   python -m twine upload dist/*
+   ```
+
+5. **Done!** Users can now run `pip install pyquality`.

py4quality-0.1.0.dist-info/RECORD

@@ -0,0 +1,59 @@
+pyquality/__init__.py,sha256=HHsujZB71SvZ6QlCT31aQqoCsPFVPmst04O2k7s1Wi4,416
+pyquality/api.py,sha256=Nvn9anJpojGKgY-K9nxDAE1_PhRFtl9gYgY0Tm3rCuU,2272
+pyquality/browser.py,sha256=IcPp2bI0df7QvRct67lZfucGHsX5XIZ8gqKcwSBEPOs,7144
+pyquality/cdp_driver.py,sha256=akVj_sjzqKsmFaV7xBB8641Z3LoE3PrfrpLB7RNetJg,4097
+pyquality/generate_cdp_wrappers.py,sha256=evf7QgYjZpPhMaegZ1h2mq_dujSGvBgoXhwSTD8-DSA,3087
+pyquality/domains/__init__.py,sha256=0gsq3rF99-4uvgjRwdXxiTsaawEVMuBaAI1v4se-yEg,1992
+pyquality/domains/accessibility.py,sha256=WgpLadf9olN5W0nwsGb3xxk2RcilkJstq1CJnwAL5Nw,5674
+pyquality/domains/animation.py,sha256=QgY4iAVmvZe-FeK_s6SfT5jVnqWTIH5-I2CWP2gu7BQ,3428
+pyquality/domains/audits.py,sha256=cEq8azHFw0FQE-5atj-zjXSWmNE8oIWjYEbhVvqKiV8,1731
+pyquality/domains/autofill.py,sha256=PEHOpaEDsQk9XbomFlcecD1AtRB1yeAlyhv_bMvkDwo,1777
+pyquality/domains/backgroundservice.py,sha256=CPfqpUnU6weiDeSIuSkgfhuAfFKRjmIt1DM3pKD0LMo,1346
+pyquality/domains/bluetoothemulation.py,sha256=x39bOCFAYX2OGw44MvOt0ELjlJ1y8anTl90KcbItCNU,7369
+pyquality/domains/browser.py,sha256=UiYFvDyU7q128bE0mPHei6sybexXBxWOeOHlCMhRMec,10732
+pyquality/domains/cachestorage.py,sha256=fh-cYMbAvJgg9EATy48995m_sXBiVzic_7Pk9flJdz4,2963
+pyquality/domains/cast.py,sha256=uET2TgiHgib-Axs4cNv_SDyZV2sm3UQmHso-BvZybhg,2118
+pyquality/domains/css.py,sha256=nyUOq6WXhjyY41w2IMbJHAaKGjnZ0UBxOpTmPC00ZWg,18042
+pyquality/domains/deviceaccess.py,sha256=Re_OieoKFAfbYGk1C-M-amaCkrfUuKi0AakQ-mbUc8Q,1144
+pyquality/domains/deviceorientation.py,sha256=4Med9HC--h4BVIsCCK7jhSioB5i8djliXGxYkj5iAIo,818
+pyquality/domains/dom.py,sha256=1gXgLS1tdeGW1q88dFD6rIHSGVzq8kc_CIqR2KTkffU,28498
+pyquality/domains/domdebugger.py,sha256=IkvlRlll_Y-IBDDPoyEIR-tzceb4IMqewy0-IfA4Wmc,4733
+pyquality/domains/domsnapshot.py,sha256=4Fr5QrxjfwldqoSBMlAhLqfE2p4zV6HgbdOre7hRcVk,3907
+pyquality/domains/domstorage.py,sha256=oky4QBdftbV6f9mBWwAVev7_-_83lObruyXDAQUTQaw,1894
+pyquality/domains/emulation.py,sha256=0ks1WIVNQKW00Az9wm8s-QEoOFtjABahjseyegj2aTs,29839
+pyquality/domains/eventbreakpoints.py,sha256=KrP66M00M5rw0bX0F9prbNyVAZnQKM_PlwP6UJxNnJk,1022
+pyquality/domains/extensions.py,sha256=xReADdABrXOpaemW3CHeLZtuX23AyNMDsCWDgoKxdTE,4285
+pyquality/domains/fedcm.py,sha256=Q6wPtAgARce8V1u50Xx2Xv7rjRh770mrPCYOtvdPGzY,2720
+pyquality/domains/fetch.py,sha256=jq1W9AZQyTZINzzd25j5PB7aMJQruI1yb-CHY56BUWU,8677
+pyquality/domains/filesystem.py,sha256=DkKcf7blP5HsqRX2cB3CNAQuQh1aDMSWfzi8gkK3Tnw,423
+pyquality/domains/headlessexperimental.py,sha256=L5Nq0FNIvGYkDZA5DO4knrg5VjHNwaGvZzzYhQ34NVQ,2391
+pyquality/domains/indexeddb.py,sha256=6BBCAlJZlh5i2tni96ybmQGcLnshaFlKTakwPdrmI6U,8036
+pyquality/domains/input.py,sha256=wAJrOZNs2dpoPDxi9sYYffKo_op8VTKzPRefvMJ-f4Q,17963
+pyquality/domains/inspector.py,sha256=XV0paJ_oowB8r3NZmGndoOr7TUwCVDSD1l0JsFPbrzM,480
+pyquality/domains/io.py,sha256=CrDgCBmfskWESloabCLSylX99T7EHqo4kUQsw_hapY4,1446
+pyquality/domains/layertree.py,sha256=bp6oqTz0_cpRrlN0xQ6wPy842ufJ76kqsWlN6IDIh1Q,3940
+pyquality/domains/log.py,sha256=PkexU_T_FUHw887KxAoaiR8cZ1TeazFiESU4jwHLMmg,1247
+pyquality/domains/media.py,sha256=w8G38lEZh1qhjGzzAf4e2Eskvm0n8U8wstxfalvrrKk,439
+pyquality/domains/memory.py,sha256=BPeksrnBFBcSp2z5h6XLB6-hpi0BNZn5eajcVvp3Iew,3566
+pyquality/domains/network.py,sha256=-dQs_YDwpd_a11HY742VJvPLuC_rFF5yaYr1tXkl5Lk,26817
+pyquality/domains/overlay.py,sha256=sZvHRb1cXbbZW26BEUouv6xNIdwVzQhcU52ambKCOVY,14918
+pyquality/domains/page.py,sha256=kPiVD9L3rObkWcA4S1RCuZWUl0s7oQOseiHgLcI9Gv0,33744
+pyquality/domains/performance.py,sha256=y6A1HgEEZRJBXUQXW0oPzi4Zq0pW2FPc0uhBVZlp4lc,1375
+pyquality/domains/performancetimeline.py,sha256=GPtXkjdgVnsRIHPLBoOI1dw3Md_nDODDxNufdsbQNtk,742
+pyquality/domains/preload.py,sha256=XaZeI9JAvojjnYFElBcSrKdQWswRH-6gbT3Pxx-ZbPM,434
+pyquality/domains/pwa.py,sha256=Redp4yZSbFrM4dz4uJ2bjSTSSwSLrjuUSz9i73MC5Zw,5971
+pyquality/domains/security.py,sha256=a9i2beL_Q-d-dQdYol99eUCPDDLAIyunoT46aooVMh4,1835
+pyquality/domains/serviceworker.py,sha256=0s0PQrGY1ddHqDebHdXcsl4yKOIFxVKsPtLoKoK2ebE,3927
+pyquality/domains/smartcardemulation.py,sha256=ktRgNAMeq2ISxsqV2bHaT4PPyo9Meq4_Zf1wVGMCeaM,8136
+pyquality/domains/storage.py,sha256=B1QzqZPAUt7BP5PSM2XtiKDCzleImz7OGROcndC5Mc8,15233
+pyquality/domains/systeminfo.py,sha256=Lh93Ndor1h6NygtFGdSkoqc6tNlIuxGebZ6IlD4uzEk,819
+pyquality/domains/target.py,sha256=QcBHgJJdm4oXlYq71zh8TDeg_oIa57gn-uXqOFmDDMM,14564
+pyquality/domains/tethering.py,sha256=Lw9zOYAHC3dna0yBDpgv2iAU6nc2wrvYA69fCDEWmW0,627
+pyquality/domains/tracing.py,sha256=VXo1Qp_861RkFyc25wMH2aihHCDWhaO5Wypf3UjSCjM,3908
+pyquality/domains/webaudio.py,sha256=wJGBgK3mPsRdJbI_kWly03odOQC4P34cEVXdFbLSWIk,804
+pyquality/domains/webauthn.py,sha256=euR3K3EDQRyhS4_khiOJYosoiWhE0x8qb3yrEkt8AHE,6487
+pyquality/domains/webmcp.py,sha256=LwopI6ctyDGwjfigaHH-vq6URQQiaR5PwNHPbAJ2L_c,380
+py4quality-0.1.0.dist-info/METADATA,sha256=odRepNz5yaegFHhPoJx2Seqc4Tga4HdUevIgOYVBwgo,3514
+py4quality-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+py4quality-0.1.0.dist-info/top_level.txt,sha256=Ee7HP6bjyNHs6rDI1Pp21yQ8sBDrr47snG9LhORbtuk,10
+py4quality-0.1.0.dist-info/RECORD,,

py4quality-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

py4quality-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyquality

pyquality/__init__.py

@@ -0,0 +1,15 @@
+import yaml
+import os
+
+def load_aliases():
+    alias_path = os.path.join(os.path.dirname(__file__), "..", "..", "METHOD_ALIASES.yml")
+    if not os.path.exists(alias_path):
+        return {}
+    with open(alias_path, 'r') as f:
+        return yaml.safe_load(f)
+
+# The loaded aliases can be used by the browser instance to dynamically map methods.
+ALIASES = load_aliases()
+
+from .api import API
+__version__ = "0.1.0"

pyquality/api.py

@@ -0,0 +1,59 @@
+import requests
+
+class API:
+    """
+    Kid-friendly wrapper for REST API calls.
+    """
+    def __init__(self, base_url=""):
+        self.base_url = base_url
+        self.session = requests.Session()
+        self._apply_aliases()
+
+    def _apply_aliases(self):
+        """Bind kid-friendly aliases to instance methods dynamically."""
+        from .__init__ import ALIASES
+        if "api" in ALIASES:
+            for method_name, aliases in ALIASES["api"].items():
+                if hasattr(self, method_name):
+                    func = getattr(self, method_name)
+                    for alias in aliases:
+                        setattr(self, alias, func)
+
+    def _build_url(self, endpoint):
+        if endpoint.startswith("http"):
+            return endpoint
+        return f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
+
+    def set_header(self, key, value):
+        """Set a header for subsequent requests."""
+        self.session.headers.update({key: value})
+
+    def use_token(self, token):
+        """Authenticate with a Bearer token."""
+        self.set_header("Authorization", f"Bearer {token}")
+
+    def get(self, endpoint, **kwargs):
+        """Send a GET request."""
+        return self.session.get(self._build_url(endpoint), **kwargs)
+
+    def post(self, endpoint, json=None, data=None, **kwargs):
+        """Send a POST request."""
+        return self.session.post(self._build_url(endpoint), json=json, data=data, **kwargs)
+
+    def put(self, endpoint, json=None, data=None, **kwargs):
+        """Send a PUT request."""
+        return self.session.put(self._build_url(endpoint), json=json, data=data, **kwargs)
+
+    def delete(self, endpoint, **kwargs):
+        """Send a DELETE request."""
+        return self.session.delete(self._build_url(endpoint), **kwargs)
+
+    def patch(self, endpoint, json=None, data=None, **kwargs):
+        """Send a PATCH request."""
+        return self.session.patch(self._build_url(endpoint), json=json, data=data, **kwargs)
+
+    def should_be_status(self, response, expected_status):
+        """Kid-friendly assertion for status codes."""
+        if response.status_code != expected_status:
+            raise AssertionError(f"Expected status {expected_status}, but got {response.status_code}.")
+        return True

pyquality/browser.py

@@ -0,0 +1,179 @@
+from .cdp_driver import CDPDriver
+from .__init__ import ALIASES
+from . import domains
+
+class Browser:
+    """
+    Kid-friendly wrapper around CDPDriver.
+    This class can dynamically expose methods mapped by aliases.
+    """
+    def __init__(self, headless=False):
+        self.driver = CDPDriver()
+        self.driver.start_chrome(headless=headless)
+        self.driver.connect()
+        # Enable network tracking
+        self.driver.execute_and_wait("Network.enable")
+        
+        # Initialize native CDP domains dynamically
+        for attr_name in dir(domains):
+            if attr_name.endswith("Domain"):
+                domain_class = getattr(domains, attr_name)
+                # Ensure the property name doesn't collide with existing class/instance vars like `browser` -> `cdp_browser`
+                prop_name = attr_name[:-6].lower()
+                if prop_name == "browser":
+                    prop_name = "cdp_browser"
+                    
+                setattr(self, prop_name, domain_class(self.driver))
+                
+        self._apply_aliases()
+
+    def _apply_aliases(self):
+        """Bind kid-friendly aliases to instance methods dynamically."""
+        for category, methods in ALIASES.items():
+            for method_name, aliases in methods.items():
+                if hasattr(self, method_name):
+                    func = getattr(self, method_name)
+                    for alias in aliases:
+                        setattr(self, alias, func)
+
+    # ===============
+    # CORE METHODS
+    # ===============
+    def navigate(self, url):
+        """Navigate to a URL."""
+        response = self.driver.execute_and_wait("Page.navigate", {"url": url})
+        return response
+        
+    def reload(self):
+        """Reload the current page using raw CDP."""
+        return self.page.reload()
+
+    def go_back(self):
+        """Navigate backward in history."""
+        return self.evaluate_js("window.history.back()")
+
+    def go_forward(self):
+        """Navigate forward in history."""
+        return self.evaluate_js("window.history.forward()")
+
+    def get_title(self):
+        """Get page title."""
+        res = self.evaluate_js("document.title")
+        return res.get('result', {}).get('result', {}).get('value', '')
+
+    def get_url(self):
+        """Get current URL."""
+        res = self.evaluate_js("window.location.href")
+        return res.get('result', {}).get('result', {}).get('value', '')
+
+    def evaluate_js(self, expression):
+        """Evaluate JS in the browser."""
+        response = self.driver.execute_and_wait("Runtime.evaluate", {
+            "expression": expression,
+            "returnByValue": True
+        })
+        return response
+
+    def find_element(self, selector):
+        """Check if element exists."""
+        res = self.evaluate_js(f"document.querySelector('{selector}') !== null")
+        return res.get('result', {}).get('result', {}).get('value', False)
+
+    def click_element(self, selector):
+        """Click an element using JS."""
+        return self.evaluate_js(f"document.querySelector('{selector}').click()")
+
+    def type_text(self, selector, text):
+        """Type text into an input."""
+        # Escape quotes in text
+        safe_text = text.replace("'", "\\'").replace('"', '\\"')
+        return self.evaluate_js(
+            f"document.querySelector('{selector}').value = '{safe_text}';"
+            f"document.querySelector('{selector}').dispatchEvent(new Event('input'));"
+        )
+
+    def hover_element(self, selector):
+        """Hover over an element (dispatches mouseover/mouseenter events)."""
+        return self.evaluate_js(
+            f"var el = document.querySelector('{selector}');"
+            f"if (el) {{ el.dispatchEvent(new MouseEvent('mouseenter', {{bubbles: true}}));"
+            f"el.dispatchEvent(new MouseEvent('mouseover', {{bubbles: true}})); }}"
+        )
+
+    # ===============
+    # DISCOVERY & VALIDATION
+    # ===============
+    def wait_for_selector(self, selector, timeout=10):
+        """Wait until an element appears in the DOM."""
+        import time
+        start = time.time()
+        while time.time() - start < timeout:
+            if self.find_element(selector):
+                return True
+            time.sleep(0.5)
+        raise Exception(f"Timeout waiting for selector: {selector}")
+
+    def assert_visible(self, selector):
+        """Check if an element is visible (naive check for presence and display structure)."""
+        res = self.evaluate_js(
+            f"var el = document.querySelector('{selector}');"
+            f"el ? (el.offsetWidth > 0 && el.offsetHeight > 0 && getComputedStyle(el).display !== 'none') : false"
+        )
+        is_vis = res.get('result', {}).get('result', {}).get('value', False)
+        if not is_vis:
+            raise AssertionError(f"Element {selector} is not visible.")
+        return True
+
+    def assert_text(self, selector, expected_text):
+        """Check if an element contains expected text."""
+        res = self.evaluate_js(f"var el = document.querySelector('{selector}'); el ? el.innerText : ''")
+        actual_text = res.get('result', {}).get('result', {}).get('value', '')
+        if expected_text not in actual_text:
+            raise AssertionError(f"Expected text '{expected_text}' not found in '{actual_text}'.")
+        return True
+
+    # ===============
+    # ADVANCED
+    # ===============
+    def take_screenshot(self, filename="screenshot.png"):
+        """Take a full page screenshot."""
+        import base64
+        response = self.driver.execute_and_wait("Page.captureScreenshot")
+        data = response.get('result', {}).get('data', '')
+        if data:
+            with open(filename, "wb") as f:
+                f.write(base64.b64decode(data))
+        return filename
+
+    def get_network_logs(self):
+        """Return all network events captured."""
+        return self.driver.events
+
+    def get_accessibility_tree(self):
+        """Fetch the accessibility tree for the page."""
+        response = self.driver.execute_and_wait("Accessibility.getFullAXTree")
+        return response.get('result', {}).get('nodes', [])
+        
+    def get_cookies(self):
+        """Get all browser cookies via Network domain."""
+        return self.network.getCookies().get('result', {}).get('cookies', [])
+
+    def clear_cookies(self):
+        """Clear all browser cookies via Network domain."""
+        return self.network.clearBrowserCookies()
+
+    def set_viewport(self, width, height, is_mobile=False):
+        """Emulate device metrics / viewport."""
+        return self.emulation.setDeviceMetricsOverride(width=width, height=height, deviceScaleFactor=3 if is_mobile else 1, mobile=is_mobile)
+
+    def act_like_phone(self):
+        """Emulate a generic phone viewport."""
+        return self.set_viewport(375, 812, is_mobile=True)
+
+    def set_location(self, latitude, longitude, accuracy=100):
+        """Emulate geographical location."""
+        return self.emulation.setGeolocationOverride(latitude=latitude, longitude=longitude, accuracy=accuracy)
+
+    def close(self):
+        """Close the browser."""
+        self.driver.stop_chrome()

pyquality/cdp_driver.py

@@ -0,0 +1,126 @@
+import json
+import websocket
+import threading
+import time
+import requests
+import subprocess
+import os
+import signal
+
+class CDPDriver:
+    """
+    Direct websocket communicator for Chrome DevTools Protocol.
+    This avoids relying on heavy CDP wrapper dependencies.
+    """
+    def __init__(self, port=9222):
+        self.port = port
+        self.ws = None
+        self.msg_id = 1
+        self.responses = {}
+        self.events = []
+        self._browser_process = None
+        self.connected_event = threading.Event()
+
+    def start_chrome(self, headless=False):
+        # We need a robust way to find/start Chrome across platforms.
+        # For Windows, typically it's in Program Files.
+        chrome_path = r"C:\Program Files\Google\Chrome\Application\chrome.exe"
+        if not os.path.exists(chrome_path):
+            chrome_path = r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"
+        
+        args = [
+            chrome_path,
+            f"--remote-debugging-port={self.port}",
+            "--remote-allow-origins=*",
+            "--user-data-dir=C:\\Temp\\pyquality_profile" # Temporary profile
+        ]
+        
+        if headless:
+            args.append("--headless")
+            args.append("--disable-gpu")
+            args.append("--no-sandbox")
+        
+        self._browser_process = subprocess.Popen(args)
+        time.sleep(2) # Give it time to start
+
+    def stop_chrome(self):
+        if self._browser_process:
+            self._browser_process.send_signal(signal.SIGTERM)
+            
+    def _on_open(self, ws):
+        self.connected_event.set()
+
+    def _on_error(self, ws, error):
+        print(f"WebSocket Error: {error}")
+
+    def _on_close(self, ws, close_status_code, close_msg):
+        print("WebSocket Closed")
+
+    def connect(self):
+        # Fetch the websocket debugger URL
+        url = f"http://127.0.0.1:{self.port}/json"
+        
+        # Add a retry logic in case Chrome takes time to open the port
+        response = None
+        for _ in range(5):
+            try:
+                response = requests.get(url).json()
+                break
+            except Exception:
+                time.sleep(1)
+                
+        # We just grab the first page
+        if not response:
+            raise Exception("No active pages found or CDP port not responding!")
+            
+        page_ws_url = response[0]['webSocketDebuggerUrl']
+        self.ws = websocket.WebSocketApp(
+            page_ws_url,
+            on_message=self._on_message,
+            on_open=self._on_open,
+            on_error=self._on_error,
+            on_close=self._on_close
+        )
+        
+        # Start receiver thread
+        self.connected_event.clear()
+        self._thread = threading.Thread(target=self.ws.run_forever, kwargs={"suppress_origin": True})
+        self._thread.daemon = True
+        self._thread.start()
+        
+        # Wait up to 5 seconds for the connection to establish
+        if not self.connected_event.wait(5):
+            raise Exception("Failed to connect to browser websocket within 5 seconds")
+
+    def _on_message(self, ws, message):
+        data = json.loads(message)
+        if 'id' in data:
+            self.responses[data['id']] = data
+        else:
+            self.events.append(data)
+
+    def send_command(self, method, params=None):
+        if params is None:
+            params = {}
+        
+        cmd = {
+            "id": self.msg_id,
+            "method": method,
+            "params": params
+        }
+        self.ws.send(json.dumps(cmd))
+        current_id = self.msg_id
+        self.msg_id += 1
+        return current_id
+        
+    def wait_for_response(self, msg_id, timeout=5):
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if msg_id in self.responses:
+                return self.responses.pop(msg_id)
+            time.sleep(0.01)
+        raise TimeoutError(f"No response for message {msg_id}")
+
+    def execute_and_wait(self, method, params=None):
+        msg_id = self.send_command(method, params)
+        return self.wait_for_response(msg_id)

pyquality/domains/__init__.py

@@ -0,0 +1,50 @@
+# Auto-generated CDP Domains
+from .accessibility import AccessibilityDomain
+from .animation import AnimationDomain
+from .audits import AuditsDomain
+from .autofill import AutofillDomain
+from .backgroundservice import BackgroundServiceDomain
+from .bluetoothemulation import BluetoothEmulationDomain
+from .browser import BrowserDomain
+from .css import CSSDomain
+from .cachestorage import CacheStorageDomain
+from .cast import CastDomain
+from .dom import DOMDomain
+from .domdebugger import DOMDebuggerDomain
+from .domsnapshot import DOMSnapshotDomain
+from .domstorage import DOMStorageDomain
+from .deviceaccess import DeviceAccessDomain
+from .deviceorientation import DeviceOrientationDomain
+from .emulation import EmulationDomain
+from .eventbreakpoints import EventBreakpointsDomain
+from .extensions import ExtensionsDomain
+from .fedcm import FedCmDomain
+from .fetch import FetchDomain
+from .filesystem import FileSystemDomain
+from .headlessexperimental import HeadlessExperimentalDomain
+from .io import IODomain
+from .indexeddb import IndexedDBDomain
+from .input import InputDomain
+from .inspector import InspectorDomain
+from .layertree import LayerTreeDomain
+from .log import LogDomain
+from .media import MediaDomain
+from .memory import MemoryDomain
+from .network import NetworkDomain
+from .overlay import OverlayDomain
+from .pwa import PWADomain
+from .page import PageDomain
+from .performance import PerformanceDomain
+from .performancetimeline import PerformanceTimelineDomain
+from .preload import PreloadDomain
+from .security import SecurityDomain
+from .serviceworker import ServiceWorkerDomain
+from .smartcardemulation import SmartCardEmulationDomain
+from .storage import StorageDomain
+from .systeminfo import SystemInfoDomain
+from .target import TargetDomain
+from .tethering import TetheringDomain
+from .tracing import TracingDomain
+from .webaudio import WebAudioDomain
+from .webauthn import WebAuthnDomain
+from .webmcp import WebMCPDomain