phantomwright 0.0.4__tar.gz → 0.0.7__tar.gz

{phantomwright-0.0.4 → phantomwright-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phantomwright
-Version: 0.0.4
+Version: 0.0.7
 Summary: Bridging playwright-core patch + extending playwright API for stealth injection & user simulation
 Project-URL: homepage, https://github.com/ai-microsoft/phantom-wright
 Project-URL: changelog, https://github.com/ai-microsoft/phantom-wright/blob/main/CHANGELOG.md
@@ -10,7 +10,7 @@ License-File: LICENSE
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
-Requires-Dist: patchright==1.56.0
+Requires-Dist: patchright-fork==1.56.2
 Provides-Extra: black
 Requires-Dist: black>=25.9.0; extra == 'black'
 Provides-Extra: dev
@@ -34,8 +34,8 @@ Phantomwright is a library that bridging playwright-core patch + extending playw
     uv venv
     .venv\Scripts\activate
     uv sync --extra dev
-    uv run patchright install-deps
-    uv run patchright install
+    uv run patchright_fork install-deps
+    uv run patchright_fork install
     uv run pytest
 ```
 
@@ -45,6 +45,20 @@ Phantomwright is a library that bridging playwright-core patch + extending playw
     uv venv --clear
 ```
 
+### Debug Playwright Core
+
+Phantomwright provide the ability to not only debug playwright-python, but also attach to node process that run playwright-core.
+
+You need to first open `Chrome` and goto `chrome://inspect`, then `Open dedicated DevTools for Node`
+
+In `Connection` tab, add connection to `localhost:9229`  
+
+Then you just need to choose debug session `Core Repro: Select Case`, then pick (or write your own) one minimal repro case.
+
+Node process will stopped at the first place and you can debug playwright-core.
+
+This is to provide the ability to debug and send PR to patchright to fix critical issue.
+
 ### Thanks
 
 + [patchright](https://pypi.org/project/patchright/) 

{phantomwright-0.0.4 → phantomwright-0.0.7}/README.md

@@ -14,8 +14,8 @@ Phantomwright is a library that bridging playwright-core patch + extending playw
     uv venv
     .venv\Scripts\activate
     uv sync --extra dev
-    uv run patchright install-deps
-    uv run patchright install
+    uv run patchright_fork install-deps
+    uv run patchright_fork install
     uv run pytest
 ```
 
@@ -25,6 +25,20 @@ Phantomwright is a library that bridging playwright-core patch + extending playw
     uv venv --clear
 ```
 
+### Debug Playwright Core
+
+Phantomwright provide the ability to not only debug playwright-python, but also attach to node process that run playwright-core.
+
+You need to first open `Chrome` and goto `chrome://inspect`, then `Open dedicated DevTools for Node`
+
+In `Connection` tab, add connection to `localhost:9229`  
+
+Then you just need to choose debug session `Core Repro: Select Case`, then pick (or write your own) one minimal repro case.
+
+Node process will stopped at the first place and you can debug playwright-core.
+
+This is to provide the ability to debug and send PR to patchright to fix critical issue.
+
 ### Thanks
 
 + [patchright](https://pypi.org/project/patchright/) 

phantomwright-0.0.7/phantomwright/__init__.py

@@ -0,0 +1,8 @@
+"""
+Patchright + Stealth Plugin + User Behavior Simulation = PhantomWright
+"""
+
+from ._impl import _core_debug_patch, _evaluate_patch
+
+_evaluate_patch.do_patch()
+_core_debug_patch.do_patch()

phantomwright-0.0.7/phantomwright/_impl/_core_debug_patch.py

@@ -0,0 +1,38 @@
+import os
+
+import patchright_fork._impl._transport as t
+
+_patched = False
+
+
+def do_patch() -> None:
+    """
+    Automatically enable Node.js debug mode if PHANTOMWRIGHT_DEBUG environment variable is set.
+
+    Environment variables:
+        PHANTOMWRIGHT_DEBUG: Set to "1" or "true" to enable debug mode
+        PHANTOMWRIGHT_DEBUG_PORT: Debug port (default: 9229)
+        PHANTOMWRIGHT_DEBUG_BREAK: Set to "0" or "false" to disable break on start
+    """
+    global _patched
+    if _patched:
+        return
+
+    debug_env = os.environ.get("PHANTOMWRIGHT_DEBUG", "").lower()
+    if debug_env not in ("1", "true"):
+        return
+
+    port = int(os.environ.get("PHANTOMWRIGHT_DEBUG_PORT", "9229"))
+    break_on_start = os.environ.get("PHANTOMWRIGHT_DEBUG_BREAK", "1").lower() not in ("0", "false")
+    inspect_flag = f"--inspect-brk={port}" if break_on_start else f"--inspect={port}"
+
+    orig_create = t.asyncio.create_subprocess_exec
+
+    async def patched_create(*args, **kwargs):
+        args = list(args)
+        args.insert(1, inspect_flag)
+        print(f"[PhantomWright Debug] Launching Node with: {args}")
+        return await orig_create(*args, **kwargs)
+
+    t.asyncio.create_subprocess_exec = patched_create
+    _patched = True

phantomwright-0.0.7/phantomwright/_impl/_evaluate_patch.py

@@ -0,0 +1,54 @@
+from functools import wraps
+
+from patchright_fork.async_api import Page as AsyncPage
+from patchright_fork.sync_api import Page as SyncPage
+
+def do_patch() -> None:
+    """ Aysnc / Sync version of evaluate override"""
+    _original_sync_evaluate = SyncPage.evaluate
+
+
+    @wraps(_original_sync_evaluate)
+    def _hooked_sync_evaluate(self, *args, **kwargs):
+        # Ensure isolated_context defaults to False if not provided
+        kwargs.setdefault("isolated_context", False)
+        return _original_sync_evaluate(self, *args, **kwargs)
+
+
+    SyncPage.evaluate = _hooked_sync_evaluate
+
+    _original_sync_evaluate_handle = SyncPage.evaluate_handle
+
+
+    @wraps(_original_sync_evaluate_handle)
+    def _hooked_sync_evaluate_handle(self, *args, **kwargs):
+        # Ensure isolated_context defaults to False if not provided
+        kwargs.setdefault("isolated_context", False)
+        return _original_sync_evaluate_handle(self, *args, **kwargs)
+
+
+    SyncPage.evaluate_handle = _hooked_sync_evaluate_handle
+
+    _original_async_evaluate = AsyncPage.evaluate
+
+
+    @wraps(_original_async_evaluate)
+    async def _hooked_async_evaluate(self, *args, **kwargs):
+        # Ensure isolated_context defaults to False if not provided
+        kwargs.setdefault("isolated_context", False)
+        return await _original_async_evaluate(self, *args, **kwargs)
+
+
+    AsyncPage.evaluate = _hooked_async_evaluate
+
+    _original_async_evaluate_handle = AsyncPage.evaluate_handle
+
+
+    @wraps(_original_async_evaluate_handle)
+    async def _hooked_async_evaluate_handle(self, *args, **kwargs):
+        # Ensure isolated_context defaults to False if not provided
+        kwargs.setdefault("isolated_context", False)
+        return await _original_async_evaluate_handle(self, *args, **kwargs)
+
+
+    AsyncPage.evaluate_handle = _hooked_async_evaluate_handle

phantomwright-0.0.7/phantomwright/_repo_version.py

@@ -0,0 +1 @@
+version = 'v0.0.7'

{phantomwright-0.0.4 → phantomwright-0.0.7}/phantomwright/async_api/__init__.py

@@ -1,6 +1,4 @@
-from patchright.async_api import expect, async_playwright, Accessibility, APIRequest, APIRequestContext, APIResponse, Browser, BrowserContext, BrowserType, CDPSession, ChromiumBrowserContext, ConsoleMessage, Cookie, Dialog, Download, ElementHandle, Error, FileChooser, FilePayload, FloatRect, Frame, FrameLocator, Geolocation, HttpCredentials, JSHandle, Keyboard, Locator, Mouse, Page, PdfMargins, Position, Playwright, ProxySettings, Request, ResourceTiming, Response, Route, Selectors, SourceLocation, StorageState, StorageStateCookie, TimeoutError, Touchscreen, Video, ViewportSize, WebError, WebSocket, WebSocketRoute, Worker
-from ._patch_goto import *
-from ._patch_evaluate import *
+from patchright_fork.async_api import expect, async_playwright, Accessibility, APIRequest, APIRequestContext, APIResponse, Browser, BrowserContext, BrowserType, CDPSession, ChromiumBrowserContext, ConsoleMessage, Cookie, Dialog, Download, ElementHandle, Error, FileChooser, FilePayload, FloatRect, Frame, FrameLocator, Geolocation, HttpCredentials, JSHandle, Keyboard, Locator, Mouse, Page, PdfMargins, Position, Playwright, ProxySettings, Request, ResourceTiming, Response, Route, Selectors, SourceLocation, StorageState, StorageStateCookie, TimeoutError, Touchscreen, Video, ViewportSize, WebError, WebSocket, WebSocketRoute, Worker
 
 __all__ = [
     "expect",

phantomwright-0.0.7/phantomwright/stealth/stealth.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+import json
+from pathlib import Path
+from typing import Any, Dict, Union, Tuple, Optional
+import warnings
+
+from patchright_fork import async_api, sync_api
+
+
+def from_file(name) -> str:
+    return (Path(__file__).parent / "js" / name).read_text()
+
+
+SCRIPTS: Dict[str, str] = {
+    "generate_magic_arrays": from_file("generate.magic.arrays.js"),
+    "utils": from_file("utils.js"),
+    "chrome_app": from_file("evasions/chrome.app.js"),
+    "chrome_csi": from_file("evasions/chrome.csi.js"),
+    "chrome_hairline": from_file("evasions/chrome.hairline.js"),
+    "chrome_load_times": from_file("evasions/chrome.load.times.js"),
+    "chrome_runtime": from_file("evasions/chrome.runtime.js"),
+    "iframe_content_window": from_file("evasions/iframe.contentWindow.js"),
+    "media_codecs": from_file("evasions/media.codecs.js"),
+    "navigator_hardware_concurrency": from_file("evasions/navigator.hardwareConcurrency.js"),
+    "navigator_languages": from_file("evasions/navigator.languages.js"),
+    "navigator_permissions": from_file("evasions/navigator.permissions.js"),
+    "navigator_platform": from_file("evasions/navigator.platform.js"),
+    "navigator_plugins": from_file("evasions/navigator.plugins.js"),
+    "navigator_user_agent": from_file("evasions/navigator.userAgent.js"),
+    "navigator_vendor": from_file("evasions/navigator.vendor.js"),
+    "error_prototype": from_file("evasions/error.prototype.js"),
+    "webgl_vendor": from_file("evasions/webgl.vendor.js"),
+}
+
+
+class Stealth:
+    """
+    Playwright stealth configuration that applies stealth strategies to Playwright.
+    The stealth strategies are contained in ./js package and are basic javascript scripts that are executed
+    on every page.goto() called.
+    Note:
+        All init scripts are combined by playwright into one script and then executed this means
+        the scripts should not have conflicting constants/variables etc. !
+        This also means scripts can be extended by overriding enabled_scripts generator:
+        ```
+        @property
+        def enabled_scripts():
+            yield 'console.log("first script")'
+            yield from super().enabled_scripts()
+            yield 'console.log("last script")'
+        ```
+    """
+
+    _USER_AGENT_OVERRIDE_PIGGYBACK_KEY = "_stealth_user_agent"
+    _SEC_CH_UA_OVERRIDE_PIGGYBACK_KEY = "_stealth_sec_ch_ua"
+
+    def __init__(
+        self,
+        *,
+        chrome_app: bool = True,
+        chrome_csi: bool = True,
+        chrome_load_times: bool = True,
+        chrome_runtime: bool = False,
+        hairline: bool = True,
+        iframe_content_window: bool = True,
+        media_codecs: bool = True,
+        navigator_hardware_concurrency: bool = True,
+        navigator_languages: bool = True,
+        navigator_permissions: bool = True,
+        navigator_platform: bool = True,
+        navigator_plugins: bool = True,
+        navigator_user_agent: bool = True,
+        navigator_vendor: bool = True,
+        error_prototype: bool = True,
+        sec_ch_ua: bool = True,
+        webgl_vendor: bool = True,
+        navigator_languages_override: Tuple[str, str] = ("en-US", "en"),
+        navigator_platform_override: str = "Win32",
+        navigator_user_agent_override: Optional[str] = None,
+        navigator_vendor_override: str = None,
+        sec_ch_ua_override: Optional[str] = None,
+        webgl_renderer_override: str = None,
+        webgl_vendor_override: str = None,
+        init_scripts_only: bool = False,
+        script_logging: bool = False,
+    ):
+        # scripts to load
+        self.chrome_app: bool = chrome_app
+        self.chrome_csi: bool = chrome_csi
+        self.chrome_load_times: bool = chrome_load_times
+        self.chrome_runtime: bool = chrome_runtime
+        self.hairline: bool = hairline
+        self.iframe_content_window: bool = iframe_content_window
+        self.media_codecs: bool = media_codecs
+        self.navigator_hardware_concurrency: int = navigator_hardware_concurrency
+        self.navigator_languages: bool = navigator_languages
+        self.navigator_permissions: bool = navigator_permissions
+        self.navigator_platform: bool = navigator_platform
+        self.navigator_plugins: bool = navigator_plugins
+        self.navigator_user_agent: bool = navigator_user_agent
+        self.navigator_vendor: bool = navigator_vendor
+        self.error_prototype: bool = error_prototype
+        self.sec_ch_ua: bool = sec_ch_ua
+        self.webgl_vendor: bool = webgl_vendor
+
+        # warn if an override was provided for a disabled option
+        self._check_for_disabled_options_overridden(locals())
+        # evasion options
+        self.navigator_languages_override: Tuple[str, str] = navigator_languages_override or ("en-US", "en")
+        self.navigator_platform_override: Optional[str] = navigator_platform_override
+        self.navigator_user_agent_override: Optional[str] = navigator_user_agent_override
+        self.navigator_vendor_override: str = navigator_vendor_override or None
+        if sec_ch_ua_override is None and self.navigator_user_agent_override is not None:
+            # we can get sec_ch_ua override for "free" here if we can parse the Chrome version string
+            self.sec_ch_ua_override = self._get_greased_chrome_sec_ua_ch(self.navigator_user_agent_override)
+        else:
+            self.sec_ch_ua_override: Optional[str] = sec_ch_ua_override
+        self.webgl_renderer_override: str = webgl_renderer_override or "Intel Iris OpenGL Engine"
+        self.webgl_vendor_override: str = webgl_vendor_override or "Intel Inc."
+        # other options
+        self.init_scripts_only: bool = init_scripts_only
+        self.script_logging = script_logging
+
+    @property
+    def script_payload(self) -> str:
+        """
+        Generates an immediately invoked function expression for all enabled scripts
+        Returns: string of enabled scripts in IIFE
+        """
+        scripts_block = "\n".join(self.enabled_scripts)
+        if len(scripts_block) == 0:
+            return ""
+        return "(() => {\n" + scripts_block + "\n})();"
+
+    @property
+    def options_payload(self) -> str:
+        opts = {
+            "navigator_hardware_concurrency": self.navigator_hardware_concurrency,
+            "navigator_languages_override": self.navigator_languages_override,
+            "navigator_platform": self.navigator_platform_override,
+            "navigator_user_agent": self.navigator_user_agent_override,
+            "navigator_vendor": self.navigator_vendor_override,
+            "webgl_renderer": self.webgl_renderer_override,
+            "webgl_vendor": self.webgl_vendor_override,
+            "script_logging": self.script_logging,
+        }
+        return f"const opts = {json.dumps(opts)};"
+
+    @property
+    def enabled_scripts(self):
+        evasion_script_block = "\n".join(self._evasion_scripts)
+        if len(evasion_script_block) == 0:
+            return ""
+
+        yield self.options_payload
+        yield SCRIPTS["utils"]
+        yield SCRIPTS["generate_magic_arrays"]
+        yield evasion_script_block
+
+    @property
+    def _evasion_scripts(self) -> str:
+        if self.chrome_app:
+            yield SCRIPTS["chrome_app"]
+        if self.chrome_csi:
+            yield SCRIPTS["chrome_csi"]
+        if self.hairline:
+            yield SCRIPTS["chrome_hairline"]
+        if self.chrome_load_times:
+            yield SCRIPTS["chrome_load_times"]
+        if self.chrome_runtime:
+            yield SCRIPTS["chrome_runtime"]
+        if self.iframe_content_window:
+            yield SCRIPTS["iframe_content_window"]
+        if self.media_codecs:
+            yield SCRIPTS["media_codecs"]
+        if self.navigator_languages:
+            yield SCRIPTS["navigator_languages"]
+        if self.navigator_permissions:
+            yield SCRIPTS["navigator_permissions"]
+        if self.navigator_platform:
+            yield SCRIPTS["navigator_platform"]
+        if self.navigator_plugins:
+            yield SCRIPTS["navigator_plugins"]
+        if self.navigator_user_agent:
+            yield SCRIPTS["navigator_user_agent"]
+        if self.navigator_vendor:
+            yield SCRIPTS["navigator_vendor"]
+        if self.error_prototype:
+            yield SCRIPTS["error_prototype"]
+        if self.webgl_vendor:
+            yield SCRIPTS["webgl_vendor"]
+
+    async def apply_stealth_async(self, page_or_context: Union[async_api.Page, async_api.BrowserContext]) -> None:
+        if len(self.script_payload) > 0:
+            await page_or_context.add_init_script(self.script_payload)
+
+    def apply_stealth_sync(self, page_or_context: Union[sync_api.Page, sync_api.BrowserContext]) -> None:
+        if len(self.script_payload) > 0:
+            page_or_context.add_init_script(self.script_payload)
+
+    @staticmethod
+    def _check_for_disabled_options_overridden(packed_kwargs: Dict[str, Any]) -> None:
+        for key in ALL_EVASIONS_DISABLED_KWARGS.keys():
+            if not packed_kwargs.get(key) and packed_kwargs.get(f"{key}_override") is not None:
+                warnings.warn(
+                    f"{key} is False, but an override ({key}_override) was provided, "
+                    f"which is probably not what you intended to do",
+                    stacklevel=3,
+                )
+
+ALL_EVASIONS_DISABLED_KWARGS = {
+    "chrome_app": False,
+    "chrome_csi": False,
+    "chrome_load_times": False,
+    "chrome_runtime": False,
+    "hairline": False,
+    "iframe_content_window": False,
+    "media_codecs": False,
+    "navigator_hardware_concurrency": False,
+    "navigator_languages": False,
+    "navigator_permissions": False,
+    "navigator_platform": False,
+    "navigator_plugins": False,
+    "navigator_user_agent": False,
+    "navigator_vendor": False,
+    "error_prototype": False,
+    "sec_ch_ua": False,
+    "webgl_vendor": False,
+}

{phantomwright-0.0.4 → phantomwright-0.0.7}/phantomwright/sync_api/__init__.py

@@ -1,6 +1,4 @@
-from patchright.sync_api import expect, Accessibility, APIRequest, APIRequestContext, APIResponse, Browser, BrowserContext, BrowserType, CDPSession, ChromiumBrowserContext, ConsoleMessage, Cookie, Dialog, Download, ElementHandle, Error, FileChooser, FilePayload, FloatRect, Frame, FrameLocator, Geolocation, HttpCredentials, JSHandle, Keyboard, Locator, Mouse, Page, PdfMargins, Position, Playwright, ProxySettings, Request, ResourceTiming, Response, Route, Selectors, SourceLocation, StorageState, StorageStateCookie, sync_playwright, TimeoutError, Touchscreen, Video, ViewportSize, WebError, WebSocket, WebSocketRoute, Worker
-from ._patch_goto import *
-from ._patch_evaluate import *
+from patchright_fork.sync_api import expect, Accessibility, APIRequest, APIRequestContext, APIResponse, Browser, BrowserContext, BrowserType, CDPSession, ChromiumBrowserContext, ConsoleMessage, Cookie, Dialog, Download, ElementHandle, Error, FileChooser, FilePayload, FloatRect, Frame, FrameLocator, Geolocation, HttpCredentials, JSHandle, Keyboard, Locator, Mouse, Page, PdfMargins, Position, Playwright, ProxySettings, Request, ResourceTiming, Response, Route, Selectors, SourceLocation, StorageState, StorageStateCookie, sync_playwright, TimeoutError, Touchscreen, Video, ViewportSize, WebError, WebSocket, WebSocketRoute, Worker
 
 __all__ = [
     "expect",

{phantomwright-0.0.4 → phantomwright-0.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "phantomwright"
-version = "0.0.4"
+version = "0.0.7"
 description = "Bridging playwright-core patch + extending playwright API for stealth injection & user simulation"
 authors = [
     {name="Hang Yin", email="hangyin@microsoft.com"},
@@ -11,7 +11,7 @@ readme = "README.md"
 requires-python = ">=3.9"
 
 dependencies = [
-    "patchright==1.56.0",
+    "patchright-fork==1.56.2",
 ]
 
 classifiers = [

phantomwright-0.0.4/phantomwright/__init__.py

@@ -1,5 +0,0 @@
-"""
-Patchright + Stealth Plugin + User Behavior Simulation = PhantomWright
-"""
-
-__version__ = "0.0.4"

phantomwright-0.0.4/phantomwright/_impl/_user_sim/_mouse_move_sim.py

@@ -1,36 +0,0 @@
-import random
-import logging
-import asyncio
-
-logger = logging.getLogger(__name__)
-
-async def async_mouse_move(page):
-    try:
-        await asyncio.sleep(random.uniform(0.5, 1.5))
-        viewport = page.viewport_size
-        if not viewport:
-            return
-        width, height = viewport['width'], viewport['height']
-        for _ in range(random.randint(3, 7)):
-            x = random.randint(100, width - 100)
-            y = random.randint(100, height - 100)
-            await page.mouse.move(x, y)
-            await asyncio.sleep(random.uniform(0.1, 0.3))
-    except Exception as e:
-        logger.error(f"Error simulating user activity: {e}")
-
-def sync_mouse_move(page):
-    try:
-        import time
-        time.sleep(random.uniform(0.5, 1.5))
-        viewport = page.viewport_size
-        if not viewport:
-            return
-        width, height = viewport['width'], viewport['height']
-        for _ in range(random.randint(3, 7)):
-            x = random.randint(100, width - 100)
-            y = random.randint(100, height - 100)
-            page.mouse.move(x, y)
-            time.sleep(random.uniform(0.1, 0.3))
-    except Exception as e:
-        logger.error(f"Error simulating user activity: {e}")

phantomwright-0.0.4/phantomwright/_impl/_user_sim/_mouse_wheel_sim.py

@@ -1,18 +0,0 @@
-import random
-import logging
-
-logger = logging.getLogger(__name__)
-
-async def async_mouse_wheel(page):
-    try:
-        scroll_amount = random.randint(100, 300)
-        await page.mouse.wheel(0, scroll_amount)
-    except Exception as e:
-        logger.error(f"Error simulating mouse wheel activity: {e}")
-
-def sync_mouse_wheel(page):
-    try:
-        scroll_amount = random.randint(100, 300)
-        page.mouse.wheel(0, scroll_amount)
-    except Exception as e:
-        logger.error(f"Error simulating mouse wheel activity: {e}")

phantomwright-0.0.4/phantomwright/async_api/_patch_evaluate.py

@@ -1,26 +0,0 @@
-from functools import wraps
-from patchright.async_api import Page
-
-_original_evaluate = Page.evaluate
-
-
-@wraps(_original_evaluate)
-async def _hooked_evaluate(self, *args, **kwargs):
-    # Ensure isolated_context defaults to False if not provided
-    kwargs.setdefault("isolated_context", False)
-    return await _original_evaluate(self, *args, **kwargs)
-
-
-Page.evaluate = _hooked_evaluate
-
-_original_evaluate_handle = Page.evaluate_handle
-
-
-@wraps(_original_evaluate_handle)
-async def _hooked_evaluate_handle(self, *args, **kwargs):
-    # Ensure isolated_context defaults to False if not provided
-    kwargs.setdefault("isolated_context", False)
-    return await _original_evaluate_handle(self, *args, **kwargs)
-
-
-Page.evaluate_handle = _hooked_evaluate_handle

phantomwright-0.0.4/phantomwright/async_api/_patch_goto.py

@@ -1,35 +0,0 @@
-import asyncio
-from functools import wraps
-import logging
-import random
-from patchright.async_api import Page
-from phantomwright._impl._user_sim._mouse_move_sim import async_mouse_move
-from phantomwright._impl._user_sim._mouse_wheel_sim import async_mouse_wheel
-
-logger = logging.getLogger(__name__)
-
-
-async def _user_sim_hook(self, *args, **kwargs):
-    url = kwargs.get("url")
-    if url is None and args:
-        url = args[0]
-    logger.info(f"Navigating to {url} (async)")
-    await async_mouse_move(self)
-    await asyncio.sleep(random.uniform(0.1, 0.3))
-    await async_mouse_wheel(self)
-
-
-if not hasattr(Page.goto, "_pre_hooks"):
-    _original_goto = Page.goto
-
-    @wraps(_original_goto)
-    async def _hooked_goto(self, *args, **kwargs):
-        for hook in _hooked_goto._pre_hooks:
-            await hook(self, *args, **kwargs)
-        return await _original_goto(self, *args, **kwargs)
-
-    _hooked_goto._pre_hooks = []
-    Page.goto = _hooked_goto
-
-if _user_sim_hook not in Page.goto._pre_hooks:
-    Page.goto._pre_hooks.append(_user_sim_hook)

phantomwright-0.0.4/phantomwright/stealth/case_insensitive_dict.py

@@ -1,77 +0,0 @@
-from collections.abc import MutableMapping
-
-
-# straight from: https://github.com/kennethreitz/requests/blob/master/src/requests/structures.py
-class CaseInsensitiveDict(MutableMapping):
-    """A case-insensitive ``dict``-like object.
-
-    Implements all methods and operations of
-    ``MutableMapping`` as well as dict's ``copy``. Also
-    provides ``lower_items``.
-
-    All keys are expected to be strings. The structure remembers the
-    case of the last key to be set, and ``iter(instance)``,
-    ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
-    will contain case-sensitive keys. However, querying and contains
-    testing is case insensitive::
-
-        cid = CaseInsensitiveDict()
-        cid['Accept'] = 'application/json'
-        cid['aCCEPT'] == 'application/json'  # True
-        list(cid) == ['Accept']  # True
-
-    For example, ``headers['content-encoding']`` will return the
-    value of a ``'Content-Encoding'`` response header, regardless
-    of how the header name was originally stored.
-
-    If the constructor, ``.update``, or equality comparison
-    operations are given keys that have equal ``.lower()``s, the
-    behavior is undefined.
-    """
-
-    def __init__(self, data=None, **kwargs):
-        self._store = {}
-        if data is None:
-            data = {}
-        self.update(data, **kwargs)
-
-    def __setitem__(self, key, value):
-        # Use the lowercased key for lookups, but store the actual
-        # key alongside the value.
-        self._store[key.lower()] = (key, value)
-
-    def __getitem__(self, key):
-        return self._store[key.lower()][1]
-
-    def __delitem__(self, key):
-        del self._store[key.lower()]
-
-    def __iter__(self):
-        return (casedkey for casedkey, mappedvalue in self._store.values())
-
-    def __len__(self):
-        return len(self._store)
-
-    def lower_items(self):
-        """Like iteritems(), but with all lowercase keys."""
-        return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items())
-
-    def __eq__(self, other):
-        from collections.abc import Mapping
-
-        if isinstance(other, Mapping):
-            other = CaseInsensitiveDict(other)
-        else:
-            return NotImplemented
-        # Compare insensitively
-        return dict(self.lower_items()) == dict(other.lower_items())
-
-    # Copy is required
-    def copy(self):
-        return CaseInsensitiveDict(self._store.values())
-
-    def __repr__(self):
-        return str(dict(self.items()))
-
-    def items(self):
-        pass