init 1.54.1

Author: nek0us

playwright_firefox/_impl/_browser.py

@@ -65,19 +65,19 @@ def __init__(
         self, parent: "BrowserType", type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
-        self._browser_type: parent # Optional["BrowserType"] = None
+        self._browser_type: Optional["BrowserType"] = None
         self._is_connected = True
         self._should_close_connection_on_close = False
         self._cr_tracing_path: Optional[str] = None
 
-        self._contexts: List[BrowserContext] = [] # Set[BrowserContext] = set()
+        self._contexts: Set[BrowserContext] = set()
         self._traces_dir: Optional[str] = None
-        # self._channel.on(
-        #     "context",
-        #     lambda params: self._did_create_context(
-        #         cast(BrowserContext, from_channel(params["context"]))
-        #     ),
-        # )
+        self._channel.on(
+            "context",
+            lambda params: self._did_create_context(
+                cast(BrowserContext, from_channel(params["context"]))
+            ),
+        )
         self._channel.on("close", lambda _: self._on_close())
         self._close_reason: Optional[str] = None
 
@@ -115,11 +115,11 @@ def _on_close(self) -> None:
 
     @property
     def contexts(self) -> List[BrowserContext]:
-        return self._contexts.copy() # list(self._contexts)
+        return list(self._contexts)
 
     @property
     def browser_type(self) -> "BrowserType":
-        # assert self._browser_type is not None
+        assert self._browser_type is not None
         return self._browser_type
 
     def is_connected(self) -> bool:

playwright_firefox/_impl/_browser_context.py

@@ -110,14 +110,13 @@ def __init__(
         self._browser: Optional["Browser"] = None
         if parent.__class__.__name__ == "Browser":
             self._browser = cast("Browser", parent)
-            self._browser._contexts.append(self)
         self._pages: List[Page] = []
         self._routes: List[RouteHandler] = []
         self._web_socket_routes: List[WebSocketRouteHandler] = []
         self._bindings: Dict[str, Any] = {}
         self._timeout_settings = TimeoutSettings(None)
         self._owner_page: Optional[Page] = None
-        self._options: Dict[str, Any] = {'viewport': {'width': 1280, 'height': 720}, 'acceptDownloads': 'accept', 'serviceWorkers': 'block', 'selectorEngines': []}  # initializer["options"]
+        self._options: Dict[str, Any] = initializer["options"]
         self._background_pages: Set[Page] = set()
         self._service_workers: Set[Worker] = set()
         self._base_url: Optional[str] = self._options.get("baseURL")
@@ -455,20 +454,16 @@ async def _unroute_internal(
         behavior: Literal["default", "ignoreErrors", "wait"] = None,
     ) -> None:
         self._routes = remaining
-        # if behavior is not None and behavior != "default":
-        #     await asyncio.gather(*map(lambda router: router.stop(behavior), removed))  # type: ignore
+        if behavior is not None and behavior != "default":
+            await asyncio.gather(*map(lambda router: router.stop(behavior), removed))  # type: ignore
         await self._update_interception_patterns()
-        if behavior is None or behavior == "default":
-            return
-        await asyncio.gather(*map(lambda router: router.stop(behavior), removed))  # type: ignore
 
     async def route_web_socket(
         self, url: URLMatch, handler: WebSocketRouteHandlerCallback
     ) -> None:
         self._web_socket_routes.insert(
             0,
-            # WebSocketRouteHandler(self._base_url, url, handler),
-            WebSocketRouteHandler(self._options.get("baseURL"), url, handler),
+            WebSocketRouteHandler(self._base_url, url, handler),
         )
         await self._update_web_socket_interception_patterns()
 

playwright_firefox/_impl/_driver.py

@@ -19,7 +19,7 @@
 from typing import Tuple
 
 import playwright_firefox
-from playwright_firefox._repo_version import version
+# from playwright_firefox._repo_version import version
 
 
 def compute_driver_executable() -> Tuple[str, str]:
@@ -37,5 +37,5 @@ def get_driver_env() -> dict:
     env = os.environ.copy()
     env["PW_LANG_NAME"] = "python"
     env["PW_LANG_NAME_VERSION"] = f"{sys.version_info.major}.{sys.version_info.minor}"
-    env["PW_CLI_DISPLAY_VERSION"] = version
+    # env["PW_CLI_DISPLAY_VERSION"] = version
     return env

playwright_firefox/_impl/_network.py

@@ -501,8 +501,8 @@ async def continue_(
 
         async def _inner() -> None:
             self.request._apply_fallback_overrides(overrides)
-            # await self._inner_continue(False)
-            await self._internal_continue()
+            await self._inner_continue(False)
+            # await self._internal_continue()
 
         return await self._handle_route(_inner)
 

playwright_firefox/case_insensitive_dict.py

@@ -0,0 +1,77 @@
+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

playwright_firefox/context_managers.py

@@ -0,0 +1,40 @@
+# from . import async_api, sync_api
+
+from .async_api import PlaywrightContextManager,Playwright
+from .sync_api import PlaywrightContextManager,Playwright
+
+
+class AsyncWrappingContextManager:
+    def __init__(self, stealth: "Stealth", manager: PlaywrightContextManager):
+        if isinstance(manager, PlaywrightContextManager):
+            raise TypeError("You need to call 'use_sync' instead of 'use_async' for a sync Playwright context")
+        self.stealth = stealth
+        self.manager = manager
+
+    async def __aenter__(
+        self,
+    ) -> Playwright:
+        context = await self.manager.__aenter__()
+        self.stealth.hook_playwright_context(context)
+        return context
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        await self.manager.__aexit__(exc_type, exc_val, exc_tb)
+
+
+class SyncWrappingContextManager:
+    def __init__(self, stealth: "Stealth", manager: PlaywrightContextManager):
+        if isinstance(manager, PlaywrightContextManager):
+            raise TypeError("You need to call 'use_async' instead of 'use_sync' for an async Playwright context")
+        self.stealth = stealth
+        self.manager = manager
+
+    def __enter__(
+        self,
+    ) -> Playwright:
+        context = self.manager.__enter__()
+        self.stealth.hook_playwright_context(context)
+        return context
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.manager.__exit__(exc_type, exc_val, exc_tb)

playwright_firefox/js/evasions/chrome.app.js

@@ -0,0 +1,68 @@
+log("loading chrome.app.js");
+
+if (!window.chrome) {
+  // Use the exact property descriptor found in headful Chrome
+  // fetch it via `Object.getOwnPropertyDescriptor(window, 'chrome')`
+  Object.defineProperty(window, "chrome", {
+    writable: true,
+    enumerable: true,
+    configurable: false, // note!
+    value: {}, // We'll extend that later
+  });
+}
+
+// app in window.chrome means we're running headful and don't need to mock anything
+if (!("app" in window.chrome)) {
+  const makeError = {
+    ErrorInInvocation: (fn) => {
+      const err = new TypeError(`Error in invocation of app.${fn}()`);
+      return utils.stripErrorWithAnchor(err, `at ${fn} (eval at <anonymous>`);
+    },
+  };
+
+  const APP_STATIC_DATA = JSON.parse(
+    `
+{
+  "isInstalled": false,
+  "InstallState": {
+    "DISABLED": "disabled",
+    "INSTALLED": "installed",
+    "NOT_INSTALLED": "not_installed"
+  },
+  "RunningState": {
+    "CANNOT_RUN": "cannot_run",
+    "READY_TO_RUN": "ready_to_run",
+    "RUNNING": "running"
+  }
+}
+        `.trim()
+  );
+
+  window.chrome.app = {
+    ...APP_STATIC_DATA,
+
+    get isInstalled() {
+      return false;
+    },
+
+    getDetails: function getDetails() {
+      if (arguments.length) {
+        throw makeError.ErrorInInvocation(`getDetails`);
+      }
+      return null;
+    },
+    getIsInstalled: function getDetails() {
+      if (arguments.length) {
+        throw makeError.ErrorInInvocation(`getIsInstalled`);
+      }
+      return false;
+    },
+    runningState: function getDetails() {
+      if (arguments.length) {
+        throw makeError.ErrorInInvocation(`runningState`);
+      }
+      return "cannot_run";
+    },
+  };
+  utils.patchToStringNested(window.chrome.app);
+}

playwright_firefox/js/evasions/chrome.csi.js

@@ -0,0 +1,29 @@
+log("loading chrome.csi.js");
+
+if (!window.chrome) {
+  // Use the exact property descriptor found in headful Chrome
+  // fetch it via `Object.getOwnPropertyDescriptor(window, 'chrome')`
+  Object.defineProperty(window, "chrome", {
+    writable: true,
+    enumerable: true,
+    configurable: false, // note!
+    value: {}, // We'll extend that later
+  });
+}
+
+// Check if we're running headful and don't need to mock anything
+// Check that the Navigation Timing API v1 is available, we need that
+if (!("csi" in window.chrome) && window.performance?.timing) {
+  const { csi_timing } = window.performance;
+
+  log("loading chrome.csi.js");
+  window.chrome.csi = function () {
+    return {
+      onloadT: csi_timing?.domContentLoadedEventEnd,
+      startE: csi_timing?.navigationStart,
+      pageT: Date.now() - csi_timing?.navigationStart,
+      tran: 15, // transition? seems constant
+    };
+  };
+  utils.patchToString(window.chrome.csi);
+}

playwright_firefox/js/evasions/chrome.hairline.js

@@ -0,0 +1,13 @@
+log("loading chrome.hairline.js");
+// inspired by: https://intoli.com/blog/making-chrome-headless-undetectable/
+const elementDescriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "offsetHeight");
+
+utils.replaceProperty(HTMLDivElement.prototype, "offsetHeight", {
+  get: function () {
+    // hmmm not sure about this
+    if (this.id === "modernizr") {
+      return 1;
+    }
+    return elementDescriptor.get.apply(this);
+  },
+});