ft: User-Agent and Sec-CH-UA spoofing

CHANGELOG.md

@@ -1,10 +1,12 @@
 2.0.0
- - __breaking change__: more consistent parameter names for the Stealth object
+ - __breaking change__: more consistent naming all around
+ - __breaking change__: Stealth object only takes kwargs now
  - new methods to hook context: Stealth.use_async and Stealth.use_sync
     - this allows us to patch CLI options as well, which are often better at faking than JS
  - chore: name options consistently
  - fix: scripts will not crash if in headful mode f9f84861
  - ft: use replaceProperty util which copies existing property descriptors 2b9b4b39
  - fix: remove deprecated pkg_resources usage (to support Python 3.12) (#2)
  - fix: navigator_platform typo (#1)
- - ft: better type hinted functions
+ - ft: better type hinted functions
+ - ft: User-Agent and Sec-CH-UA spoofing

README.md

@@ -2,7 +2,7 @@
 
 Transplanted from [puppeteer-extra-plugin-stealth](https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra-plugin-stealth), with some improvements. Don't expect this to bypass anything but the simplest of bot detection methods. Consider this a proof-of-concept starting point.
 
-This is a WIP fork, with the goal of replacing the out-of-date upstream.
+This is a WIP fork, with the goal of replacing the out-of-date upstream. See the [changelog](./README.md).
 
 ## Install
 

playwright_stealth/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