phantomfetch 0.4.7__tar.gz → 0.4.9__tar.gz

{phantomfetch-0.4.7 → phantomfetch-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: phantomfetch
-Version: 0.4.7
+Version: 0.4.9
 Summary: High-performance agentic web scraping library combining curl-cffi speed with Playwright browser capabilities
 Keywords: web-scraping,playwright,curl-cffi,async,browser-automation,http-client,agentic,anti-detection
 Author: CosmicBull
@@ -25,12 +25,20 @@ Requires-Dist: opentelemetry-api>=1.38.0
 Requires-Dist: opentelemetry-sdk>=1.38.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: beautifulsoup4>=4.14.3
+Requires-Dist: cloakbrowser>=0.3.0 ; extra == 'all'
+Requires-Dist: maxminddb>=2.0.0 ; extra == 'all'
+Requires-Dist: cloakbrowser>=0.3.0 ; extra == 'cloakbrowser'
+Requires-Dist: cloakbrowser[geoip]>=0.3.0 ; extra == 'geoip'
+Requires-Dist: maxminddb>=2.0.0 ; extra == 'geoip'
 Requires-Python: >=3.13
 Project-URL: Homepage, https://github.com/iristech-systems/PhantomFetch
 Project-URL: Documentation, https://github.com/iristech-systems/PhantomFetch#readme
 Project-URL: Repository, https://github.com/iristech-systems/PhantomFetch
 Project-URL: Issues, https://github.com/iristech-systems/PhantomFetch/issues
 Project-URL: Changelog, https://github.com/iristech-systems/PhantomFetch/blob/main/CHANGELOG.md
+Provides-Extra: all
+Provides-Extra: cloakbrowser
+Provides-Extra: geoip
 Description-Content-Type: text/markdown
 
 # PhantomFetch

{phantomfetch-0.4.7 → phantomfetch-0.4.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "phantomfetch"
-version = "0.4.7"
+version = "0.4.9"
 description = "High-performance agentic web scraping library combining curl-cffi speed with Playwright browser capabilities"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -42,6 +42,11 @@ dependencies = [
     "beautifulsoup4>=4.14.3",
 ]
 
+[project.optional-dependencies]
+cloakbrowser = ["cloakbrowser>=0.3.0"]
+geoip = ["cloakbrowser[geoip]>=0.3.0", "maxminddb>=2.0.0"]
+all = ["cloakbrowser>=0.3.0", "maxminddb>=2.0.0"]
+
 [project.urls]
 Homepage = "https://github.com/iristech-systems/PhantomFetch"
 Documentation = "https://github.com/iristech-systems/PhantomFetch#readme"

{phantomfetch-0.4.7 → phantomfetch-0.4.9}/src/phantomfetch/engines/browser/cdp.py

@@ -1,11 +1,12 @@
 import asyncio
 import re
 import time
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, Literal, Optional
 from urllib.parse import urlparse
 
 from browserforge.fingerprints import FingerprintGenerator, Screen
 from browserforge.injectors.playwright import AsyncNewContext
+from browserforge.injectors.utils import InjectFunction, only_injectable_headers
 from loguru import logger
 from opentelemetry import context
 from undetected_playwright import stealth_async
@@ -73,6 +74,13 @@ class CDPEngine:
         launch_args: list[str] | None = None,
         browser_type: str = "chromium",
         cdp_connection_type: str = "cdp",
+        backend: Literal["rebrowser", "playwright", "patchright"] = "rebrowser",
+        cloak_browser: bool = False,
+        cloak_browser_humanize: bool = False,
+        cloak_browser_human_preset: str = "default",
+        cloak_browser_geoip: bool = False,
+        cloak_binary_path: str | None = None,
+        persistent_context_dir: str | None = None,
     ):
         """
         Args:
@@ -87,6 +95,7 @@ class CDPEngine:
             fingerprint: Enable BrowserForge fingerprint injection (default: True).
                          Injects a realistic Canvas, WebGL, navigator, and screen
                          fingerprint into every new browser context.
+                         Automatically disabled when cloak_browser=True (binary handles it).
             fingerprint_options: Optional constraints forwarded to FingerprintGenerator
                                  (e.g. {"browser": "chrome", "os": "windows"}).
             launch_args: Additional Chromium launch flags for local browser launches
@@ -98,6 +107,23 @@ class CDPEngine:
                                 (connect_over_cdp) or "playwright" for Playwright wire protocol (connect).
                                 Defaults to "cdp". Use "playwright" for services like
                                 playwright run-server or Scrapeless recording.
+            backend: Which Playwright variant to use: "rebrowser" (rebrowser_playwright, default),
+                                "playwright" (stock playwright), or "patchright" (patchright).
+                                CloakBrowser integration requires "playwright" or "patchright".
+            cloak_browser: Use CloakBrowser's stealth Chromium binary instead of stock browser.
+                           When True, fingerprint and stealth params are ignored (binary handles them).
+                           Requires: pip install phantomfetch[cloakbrowser]
+            cloak_browser_humanize: Enable human-like mouse, keyboard, and scroll behavior
+                                    when using CloakBrowser. Adds Bezier curve mouse movement,
+                                    realistic typing delays, and scroll micro-steps.
+            cloak_browser_human_preset: Humanize preset — "default" (normal speed) or "careful" (slower).
+            cloak_browser_geoip: Auto-detect timezone and locale from proxy IP using MaxMind GeoIP.
+                                  Requires: pip install phantomfetch[cloakbrowser,geoip]
+            cloak_binary_path: Path to CloakBrowser binary. If None, uses CloakBrowser's
+                               ensure_binary() to download/find it.
+            persistent_context_dir: Directory for persistent browser profile (cookies/localStorage
+                                   persist across sessions). When set, uses CloakBrowser's
+                                   persistent context API. Enables incognito bypass.
         """
         self.cdp_endpoint = cdp_endpoint
         self.headless = headless
@@ -111,6 +137,17 @@ class CDPEngine:
         self.launch_args = launch_args or []
         self.browser_type = browser_type
         self.cdp_connection_type = cdp_connection_type
+        self.backend = backend
+        self.cloak_browser = cloak_browser
+        self.cloak_browser_humanize = cloak_browser_humanize
+        self.cloak_browser_human_preset = cloak_browser_human_preset
+        self.cloak_browser_geoip = cloak_browser_geoip
+        self.cloak_binary_path = cloak_binary_path
+        self.persistent_context_dir = persistent_context_dir
+
+        self._cloak_browser_available = False
+        self._cloak_context: Any = None
+        self._cloak_human_config: Any = None
 
         # Map playwright browser type to BrowserForge constraint
         if "browser" not in self.fingerprint_options and self.browser_type in (
@@ -126,7 +163,8 @@ class CDPEngine:
             self.fingerprint_options["device"] = "desktop"
 
         # BrowserForge fingerprint generator — instantiated once, generate() per request
-        if fingerprint:
+        # Disabled when using CloakBrowser (binary handles fingerprints natively)
+        if fingerprint and not cloak_browser:
             screen = Screen(
                 min_width=1280, max_width=1920, min_height=720, max_height=1080
             )
@@ -144,14 +182,83 @@ class CDPEngine:
 
     async def connect(self) -> None:
         """Initialize Playwright and connect to browser."""
+        if self.cloak_browser:
+            await self._connect_cloakbrowser()
+        else:
+            await self._connect_playwright()
+
+    async def _connect_cloakbrowser(self) -> None:
+        """Connect using CloakBrowser's stealth Chromium binary.
+
+        Uses cloakbrowser.launch_async() + browser.new_context() for non-persistent,
+        or launch_persistent_context_async() for persistent. These handle binary
+        management, stealth args, geoip, and humanize patches internally.
+        """
+        try:
+            from cloakbrowser import launch_async, launch_persistent_context_async
+        except ImportError:
+            raise ImportError(
+                "cloakbrowser is not installed. "
+                "Install it with: pip install phantomfetch[cloakbrowser]"
+            )
+
+        logger.info(
+            f"[cdp] Connecting via CloakBrowser "
+            f"(humanize={self.cloak_browser_humanize}, "
+            f"persistent={bool(self.persistent_context_dir)})"
+        )
+
+        if self.persistent_context_dir:
+            logger.debug(
+                f"[cdp] CloakBrowser persistent context: {self.persistent_context_dir}"
+            )
+            launch_kwargs: dict[str, Any] = {
+                "headless": self.headless,
+                "user_agent": self.user_agent,
+                "viewport": self.viewport,
+                "stealth_args": False,
+                "humanize": self.cloak_browser_humanize,
+                "human_preset": self.cloak_browser_human_preset,
+                "backend": self.backend,
+                "geoip": self.cloak_browser_geoip,
+            }
+            self._cloak_context = await launch_persistent_context_async(
+                self.persistent_context_dir,
+                **launch_kwargs,
+            )
+            self._browser: Any = None
+        else:
+            logger.debug(
+                "[cdp] CloakBrowser non-persistent — browser created per fetch"
+            )
+            self._browser = await launch_async(
+                headless=self.headless,
+                stealth_args=False,
+                humanize=self.cloak_browser_humanize,
+                human_preset=self.cloak_browser_human_preset,
+                backend=self.backend,
+                geoip=self.cloak_browser_geoip,
+            )
+            self._cloak_context = None
 
-        from playwright.async_api import async_playwright
+        self._cloak_browser_available = True
+
+    async def _connect_playwright(self) -> None:
+        """Connect using standard Playwright (rebrowser, stock, or patchright)."""
+        backend = self.backend
+        if backend == "rebrowser":
+            from rebrowser_playwright.async_api import async_playwright
+        elif backend == "patchright":
+            from patchright.async_api import async_playwright
+        else:
+            from playwright.async_api import async_playwright
 
         self._playwright = await async_playwright().start()
         try:
             if self.cdp_endpoint:
                 logger.info(
-                    f"[cdp] Connecting to: {self.cdp_endpoint} (type={self.cdp_connection_type})"
+                    f"[cdp] Connecting to: {self.cdp_endpoint} "
+                    f"(type={self.cdp_connection_type}, backend={backend})"
                 )
                 browser_obj = getattr(self._playwright, self.browser_type)
 
@@ -171,7 +278,8 @@ class CDPEngine:
                         )
             else:
                 logger.info(
-                    f"[cdp] Launching local browser (headless={self.headless}, type={self.browser_type})"
+                    f"[cdp] Launching local browser "
+                    f"(headless={self.headless}, type={self.browser_type}, backend={backend})"
                 )
                 base_args = []
                 if self.browser_type == "chromium":
@@ -191,26 +299,15 @@ class CDPEngine:
             await self._playwright.stop()
             self._playwright = None
             raise e
-            base_args = []
-            if self.browser_type == "chromium":
-                # --no-sandbox is required on Linux environments that don't have
-                # user namespace support (VMs, containers, CI). Without it,
-                # Chromium hangs silently at launch.
-                base_args = [
-                    "--disable-blink-features=AutomationControlled",
-                    "--no-sandbox",
-                    "--disable-setuid-sandbox",
-                ]
-            extra = [a for a in self.launch_args if a not in base_args]
-
-            browser_obj = getattr(self._playwright, self.browser_type)
-            self._browser = await browser_obj.launch(
-                headless=self.headless,
-                args=base_args + extra,
-            )
 
     async def disconnect(self) -> None:
         """Close browser and Playwright."""
+        if self._cloak_context:
+            try:
+                await self._cloak_context.close()
+            except Exception:
+                pass
+            self._cloak_context = None
         if self._browser:
             await self._browser.close()
             self._browser = None
@@ -384,7 +481,7 @@ class CDPEngine:
             # unless we specifically want to share state (TODO: session support)
             # Update: storage_state passed in allows checking/setting state
 
-            context_opts = {}
+            context_opts: dict[str, Any] = {}
             if self.user_agent:
                 context_opts["user_agent"] = self.user_agent
             if self.viewport:
@@ -397,7 +494,7 @@ class CDPEngine:
                     if parsed.port
                     else f"{parsed.scheme}://{parsed.hostname}"
                 )
-                proxy_dict = {"server": proxy_server}
+                proxy_dict: dict[str, Any] = {"server": proxy_server}
                 if parsed.username:
                     proxy_dict["username"] = parsed.username
                 if parsed.password:
@@ -408,59 +505,105 @@ class CDPEngine:
             # If we have basic cookies to set via context creation (simpler than add_cookies sometimes)
             # But better to use add_cookies for consistency with 'cookies' arg
 
-            browser_context = None
-            page = None
+            browser_context: Any = None
+            page: Any = None
             using_existing = False
+            using_persistent = False
 
             try:
-                # Use existing page/context if available (for recording compatibility)
                 if self._existing_page and self._existing_context:
                     browser_context = self._existing_context
                     page = self._existing_page
                     using_existing = True
                     logger.debug(f"[cdp] Reusing existing page for {url}")
-                # Create new context with BrowserForge fingerprint injection (if enabled)
+
+                # CloakBrowser — binary-level stealth, no BrowserForge injection.
+                # CloakBrowser handles canvas/WebGL/GPU/UA/automation signals natively.
+                # Uses cloakbrowser.launch_async() + browser.new_context() for non-persistent,
+                # or launch_persistent_context_async() for persistent.
+                elif self._cloak_browser_available:
+                    proxy_arg: dict[str, Any] | None = proxy_dict if proxy else None
+
+                    if self.persistent_context_dir:
+                        using_persistent = True
+                        if self._cloak_context is None:
+                            from cloakbrowser import launch_persistent_context_async
+
+                            launch_kwargs: dict[str, Any] = {
+                                "headless": self.headless,
+                                "user_agent": self.user_agent,
+                                "viewport": self.viewport,
+                                "stealth_args": False,
+                                "humanize": self.cloak_browser_humanize,
+                                "human_preset": self.cloak_browser_human_preset,
+                                "backend": self.backend,
+                                "proxy": proxy_arg,
+                                "geoip": self.cloak_browser_geoip,
+                            }
+                            self._cloak_context = await launch_persistent_context_async(
+                                self.persistent_context_dir,
+                                **launch_kwargs,
+                            )
+                        browser_context = self._cloak_context
+                        page = await browser_context.new_page()
+                    else:
+                        browser_context = await self._browser.new_context(
+                            user_agent=self.user_agent,
+                            viewport=self.viewport,
+                            proxy=proxy_arg,
+                        )
+                        page = await browser_context.new_page()
+
+                # BrowserForge fingerprint injection (rebrowser/stock playwright)
                 elif self._fp_gen is not None:
-                    # Generate a fingerprint with any per-instance constraints
                     fp = self._fp_gen.generate(**self.fingerprint_options)
 
-                    # Sync UA and viewport FROM the fingerprint for full consistency.
-                    # Explicit user_agent/viewport overrides take precedence.
-                    if not self.user_agent:
-                        context_opts["user_agent"] = fp.navigator.userAgent
                     if not self.viewport:
                         context_opts["viewport"] = {
                             "width": fp.screen.width,
                             "height": fp.screen.height,
                         }
 
-                    logger.debug(
-                        f"[cdp] BrowserForge fingerprint: UA={fp.navigator.userAgent[:60]}..."
-                    )
-
-                    # AsyncNewContext injects all fingerprint JS overrides
-                    # (Canvas, WebGL, navigator, AudioContext, fonts, etc.)
-                    browser_context = await AsyncNewContext(
-                        self._browser,
-                        fingerprint=fp,
-                        **context_opts,
+                    user_provided_ua = self.user_agent or (
+                        headers.get("user-agent") if headers else None
                     )
 
-                    # Apply matching headers so HTTP-layer headers are consistent
-                    # with the JS navigator (UA, sec-ch-ua*, Accept-Language, etc.)
-                    if fp.headers:
-                        # Merge: fingerprint headers are base; caller's explicit
-                        # headers=... arg will be applied later via set_extra_http_headers.
-                        # Here we only set the fingerprint-derived defaults.
-                        fp_headers = dict(fp.headers)
-                        # Remove headers that Playwright manages internally to avoid conflicts
-                        for managed in (
-                            "Host",
-                            "Content-Length",
-                            "Transfer-Encoding",
-                        ):
-                            fp_headers.pop(managed, None)
-                        await browser_context.set_extra_http_headers(fp_headers)
+                    if user_provided_ua:
+                        context_opts["user_agent"] = user_provided_ua
+                        logger.debug(
+                            f"[cdp] BrowserForge fingerprint (custom UA): "
+                            f"fp_UA={fp.navigator.userAgent[:40]}... "
+                            f"user_UA={user_provided_ua[:40]}..."
+                        )
+                        browser_context = await self._browser.new_context(
+                            **context_opts,
+                        )
+                        await browser_context.set_extra_http_headers(
+                            only_injectable_headers(
+                                fp.headers, self._browser.browser_type.name
+                            )
+                        )
+                        await browser_context.add_init_script(InjectFunction(fp))
+                    else:
+                        context_opts["user_agent"] = fp.navigator.userAgent
+                        logger.debug(
+                            f"[cdp] BrowserForge fingerprint: "
+                            f"UA={fp.navigator.userAgent[:60]}..."
+                        )
+                        browser_context = await AsyncNewContext(
+                            self._browser,
+                            fingerprint=fp,
+                            **context_opts,
+                        )
+                        if fp.headers:
+                            fp_headers = dict(fp.headers)
+                            for managed in (
+                                "Host",
+                                "Content-Length",
+                                "Transfer-Encoding",
+                            ):
+                                fp_headers.pop(managed, None)
+                            await browser_context.set_extra_http_headers(fp_headers)
                 else:
                     browser_context = await self._browser.new_context(**context_opts)
 
@@ -479,7 +622,8 @@ class CDPEngine:
             # Apply stealth (works for both new and existing contexts)
             # Note: For remote browsers, launch args like --disable-blink-features=AutomationControlled
             # must be set by the *server* at launch time. We cannot retroactively apply them here.
-            if stealth and browser_context:
+            # CloakBrowser: skip stealth_async — binary handles fingerprinting at C++ level.
+            if stealth and browser_context and not self._cloak_browser_available:
                 logger.debug("[cdp] Applying stealth_async")
                 await stealth_async(browser_context)
 
@@ -558,8 +702,8 @@ class CDPEngine:
                 if headers:
                     await browser_context.set_extra_http_headers(headers)
 
-                # Create page if not reusing existing
-                if not using_existing:
+                # Create page if not reusing existing or persistent
+                if not using_existing and not using_persistent:
                     # If storing state, we should have done it on context.
                     page = await browser_context.new_page()
 
@@ -857,7 +1001,7 @@ class CDPEngine:
 
             except asyncio.CancelledError:
                 logger.warning("Scrape cancelled by orchestrator. Shielding teardown.")
-                if not using_existing and browser_context:
+                if not using_existing and not using_persistent and browser_context:
                     try:
                         await asyncio.shield(browser_context.close())
                     except Exception:
@@ -879,7 +1023,7 @@ class CDPEngine:
                 )
 
             finally:
-                if not using_existing and browser_context:
+                if not using_existing and not using_persistent and browser_context:
                     try:
                         await browser_context.close()
                     except Exception:

{phantomfetch-0.4.7 → phantomfetch-0.4.9}/src/phantomfetch/fetch.py

@@ -1,11 +1,11 @@
 import asyncio
 import json
 import os
-from typing import Any, Literal, cast
+from typing import Any, Literal
 
 from loguru import logger
 
-from .cache import Cache, FileSystemCache
+from .cache import Cache
 from .engines import CDPEngine, CurlEngine
 from .pool import ProxyPool
 from .telemetry import get_tracer
@@ -46,10 +46,19 @@ class Fetcher:
         cache: Cache | bool | None = None,
         # Advanced CDP
         cdp_use_existing_page: bool = True,
+        cdp_connection_type: str = "cdp",
+        backend: Literal["rebrowser", "playwright", "patchright"] = "rebrowser",
         # BrowserForge fingerprinting
         fingerprint: bool = True,
         fingerprint_options: dict[str, Any] | None = None,
         browser_type: str = "chromium",
+        # CloakBrowser
+        cloak_browser: bool = False,
+        cloak_browser_humanize: bool = False,
+        cloak_browser_human_preset: str = "default",
+        cloak_browser_geoip: bool = False,
+        cloak_binary_path: str | None = None,
+        persistent_context_dir: str | None = None,
     ):
         """
         Initialize the Fetcher.
@@ -68,12 +77,24 @@ class Fetcher:
             max_concurrent_browser: Max concurrent browser requests
             cache: Cache implementation (e.g. FileSystemCache)
             cdp_use_existing_page: Reuse existing page in remote CDP (default: True)
+            backend: Which Playwright variant to use: "rebrowser", "playwright", or "patchright".
+                     CloakBrowser integration requires "playwright" or "patchright".
             fingerprint: Enable BrowserForge fingerprint injection in the browser engine
                          (default: True). Injects realistic Canvas, WebGL, navigator
                          and screen fingerprints into every new Playwright context.
             fingerprint_options: Constraints for BrowserForge FingerprintGenerator
                                  (e.g. {"browser": "chrome", "os": "windows"}).
             browser_type: Which Playwright browser engine to use: "chromium", "firefox", or "webkit"
+            cloak_browser: Use CloakBrowser's stealth Chromium binary instead of stock browser.
+                           When True, fingerprint is disabled (binary handles it).
+                           Requires: pip install phantomfetch[cloakbrowser]
+            cloak_browser_humanize: Enable human-like mouse, keyboard, and scroll behavior
+                                    when using CloakBrowser.
+            cloak_browser_human_preset: Humanize preset — "default" (normal) or "careful" (slower).
+            cloak_browser_geoip: Auto-detect timezone/locale from proxy IP using MaxMind GeoIP.
+            cloak_binary_path: Path to CloakBrowser binary. If None, downloads automatically.
+            persistent_context_dir: Directory for persistent browser profile (cookies/localStorage
+                                    persist across sessions).
         """
         # Cache
         self.cache: Cache | None = None
@@ -97,9 +118,11 @@ class Fetcher:
             timeout=timeout,
             max_retries=max_retries,
         )
-        
+
         if browser_engine == "baas":
-            raise ValueError("BaaSEngine has been removed. Please use 'cdp' engine or contact support.")
+            raise ValueError(
+                "BaaSEngine has been removed. Please use 'cdp' engine or contact support."
+            )
 
         # Browser engine
         # Always use CDPEngine now
@@ -109,9 +132,17 @@ class Fetcher:
             timeout=browser_timeout,
             cache=self.cache,
             use_existing_page=cdp_use_existing_page,
+            cdp_connection_type=cdp_connection_type,
+            backend=backend,
             fingerprint=fingerprint,
             fingerprint_options=fingerprint_options,
             browser_type=browser_type,
+            cloak_browser=cloak_browser,
+            cloak_browser_humanize=cloak_browser_humanize,
+            cloak_browser_human_preset=cloak_browser_human_preset,
+            cloak_browser_geoip=cloak_browser_geoip,
+            cloak_binary_path=cloak_binary_path,
+            persistent_context_dir=persistent_context_dir,
         )
         self._browser = self._cdp_engine
 
@@ -147,7 +178,7 @@ class Fetcher:
         Stop the browser engine.
         """
         if self._browser:
-            await self._browser.stop()
+            await self._browser.disconnect()
 
     def save_session(self, path: str) -> None:
         """
@@ -268,7 +299,7 @@ class Fetcher:
             proxy: Specific proxy to use (overrides pool)
             location: Geo location for proxy selection
             actions: List of `Action` objects or dicts (implies engine="browser")
-            
+
             ...
         """
         # Normalize actions - implies browser
@@ -319,21 +350,21 @@ class Fetcher:
                 cache_key_parts = [engine, url]
                 if location:
                     cache_key_parts.append(f"loc={location}")
-                
+
                 # Use proxy URL for cache key if explicit proxy is used
                 # Note: We rely on the proxy *argument* (manual override) for this separation.
-                # If using pool, we typically don't split cache by specific pool proxy, 
+                # If using pool, we typically don't split cache by specific pool proxy,
                 # UNLESS location was requested (handled above).
-                if proxy: 
+                if proxy:
                     # If manual proxy string/object provided, include it
                     p_url = proxy if isinstance(proxy, str) else proxy.url
-                    # Sanitize sensitive info? user:pass might be sensitive, 
-                    # but for cache key uniqueness it's needed. 
+                    # Sanitize sensitive info? user:pass might be sensitive,
+                    # but for cache key uniqueness it's needed.
                     # Since MD5 is used downstream, it's somewhat obscured.
                     cache_key_parts.append(f"proxy={p_url}")
 
                 cache_key = ":".join(cache_key_parts)
-                
+
                 cached_resp = await self.cache.get(cache_key)
                 if cached_resp:
                     cached_resp.from_cache = True
@@ -347,10 +378,12 @@ class Fetcher:
             selected_proxy: Proxy | None = None
             if proxy:
                 if isinstance(proxy, str):
-                    selected_proxy = Proxy(url=proxy, metadata={"source": "manual_override"})
+                    selected_proxy = Proxy(
+                        url=proxy, metadata={"source": "manual_override"}
+                    )
                 else:
                     selected_proxy = proxy
-            
+
             # 2. From Pool (if no override)
             if not selected_proxy:
                 selected_proxy = self.proxy_pool.get(url=url, location=location)
@@ -358,20 +391,27 @@ class Fetcher:
             if selected_proxy:
                 span.set_attribute("phantomfetch.proxy", selected_proxy.url)
                 if selected_proxy.vendor:
-                    span.set_attribute("phantomfetch.proxy.vendor", selected_proxy.vendor)
+                    span.set_attribute(
+                        "phantomfetch.proxy.vendor", selected_proxy.vendor
+                    )
                 if selected_proxy.proxy_type:
-                    span.set_attribute("phantomfetch.proxy.type", selected_proxy.proxy_type)
+                    span.set_attribute(
+                        "phantomfetch.proxy.type", selected_proxy.proxy_type
+                    )
                 if selected_proxy.location:
-                    span.set_attribute("phantomfetch.proxy.location", selected_proxy.location)
+                    span.set_attribute(
+                        "phantomfetch.proxy.location", selected_proxy.location
+                    )
                 if selected_proxy.provider:
-                    span.set_attribute("phantomfetch.proxy.provider", selected_proxy.provider)
+                    span.set_attribute(
+                        "phantomfetch.proxy.provider", selected_proxy.provider
+                    )
 
             # Route to engine
             if engine == "browser":
                 resp = await self._fetch_browser(
                     url=url,
                     proxy=selected_proxy,
-
                     headers=headers,
                     cookies=cookies,
                     actions=normalized_actions,
@@ -406,7 +446,7 @@ class Fetcher:
             # For simplicity, if we have a pool, and this proxy matches one in the pool, we could update it.
             # But the 'selected_proxy' might be a new instance specific to this request (manual override).
             # The pool.mark_* methods take a Proxy object.
-            
+
             # Logic: If 'proxy' argument was None, it came from pool -> Update stats.
             # If 'proxy' argument was set -> Do NOT update pool stats (it's a manual override).
             if not proxy and selected_proxy:
@@ -421,10 +461,10 @@ class Fetcher:
                 cache_key_parts = [engine, url]
                 if location:
                     cache_key_parts.append(f"loc={location}")
-                if proxy: 
+                if proxy:
                     p_url = proxy if isinstance(proxy, str) else proxy.url
                     cache_key_parts.append(f"proxy={p_url}")
-                
+
                 cache_key = ":".join(cache_key_parts)
                 await self.cache.set(cache_key, resp)
 
@@ -451,26 +491,26 @@ class Fetcher:
             async with self._browser_semaphore:
                 # Direct CDP usage (BaaSEngine removed)
                 if not self._cdp_engine:
-                     # Lazy init if not done (though currently init in __init__)
-                     # But wait, logic in __init__ was: 
-                     # self._cdp_engine = CDPEngine(...) if browser_engine == "cdp"
-                     # Since we removed engine selection, we should ensure it's initialized.
-                     # In __init__ I see: self._cdp_engine: CDPEngine | None = None
-                     # And the constructor logic for it was tied to the "if browser_engine == 'cdp'" block which I might have messed up or need to fix.
-                     # Let's check __init__ again.
-                     pass 
-
-                # Actually, looking at the previous file content, I removed the 'if browser_engine ==' logic in __init__? 
+                    # Lazy init if not done (though currently init in __init__)
+                    # But wait, logic in __init__ was:
+                    # self._cdp_engine = CDPEngine(...) if browser_engine == "cdp"
+                    # Since we removed engine selection, we should ensure it's initialized.
+                    # In __init__ I see: self._cdp_engine: CDPEngine | None = None
+                    # And the constructor logic for it was tied to the "if browser_engine == 'cdp'" block which I might have messed up or need to fix.
+                    # Let's check __init__ again.
+                    pass
+
+                # Actually, looking at the previous file content, I removed the 'if browser_engine ==' logic in __init__?
                 # No, I only updated the arguments. I need to make sure __init__ initializes _cdp_engine unconditionally.
                 # Let's assume I fix __init__ in a separate recursive step if needed, or I can fix it here if I see it.
-                # In the previous `view_file` output (Step 356), lines 87-101 show the old init logic. 
-                # I need to clean that up too! 
-                
+                # In the previous `view_file` output (Step 356), lines 87-101 show the old init logic.
+                # I need to clean that up too!
+
                 # Let's just assume _browser attribute is now _cdp_engine.
                 # Wait, the __init__ logic was:
                 # self._browser = CDPEngine(...)
                 # So here I should just use self._browser (which is typed as CDPEngine in the new world).
-                
+
                 # Correct implementation for _fetch_browser:
                 return await self._cdp_engine.fetch(
                     url=url,

{phantomfetch-0.4.7 → phantomfetch-0.4.9}/src/phantomfetch/types.py

@@ -63,9 +63,6 @@ class Proxy(msgspec.Struct):
     metadata: dict[str, Any] = {}
 
 
-
-
-
 class Action(msgspec.Struct):
     """
     Browser interaction definition.
@@ -99,8 +96,6 @@ class Action(msgspec.Struct):
     state: str | None = None
     x: int | None = None
     y: int | None = None
-    x: int | None = None
-    y: int | None = None
     schema: dict[str, Any] | None = None
     actions: list["Action"] | None = None
     then_actions: list["Action"] | None = None