seleniumbase 4.32.0__py3-none-any.whl → 4.32.2__py3-none-any.whl

seleniumbase/__version__.py

@@ -1,2 +1,2 @@
 # seleniumbase package
-__version__ = "4.32.0"
+__version__ = "4.32.2"

seleniumbase/core/browser_launcher.py

@@ -525,9 +525,6 @@ def uc_open_with_cdp_mode(driver, url=None):
         js_utils.call_me_later(driver, script, 3)
         time.sleep(0.012)
         driver.close()
-    driver.clear_cdp_listeners()
-    driver.delete_all_cookies()
-    driver.delete_network_conditions()
     driver.disconnect()
 
     cdp_details = driver._get_cdp_details()
@@ -546,6 +543,7 @@ def uc_open_with_cdp_mode(driver, url=None):
         cdp_util.start(host=cdp_host, port=cdp_port)
     )
     page = loop.run_until_complete(driver.cdp_base.get(url))
+    loop.run_until_complete(page.activate())
     if not safe_url:
         time.sleep(constants.UC.CDP_MODE_OPEN_WAIT)
     cdp = types.SimpleNamespace()

seleniumbase/fixtures/base_case.py

@@ -4090,6 +4090,88 @@ class BaseCase(unittest.TestCase):
                 "Browser: {%s} is not a valid browser option. "
                 "Valid options = {%s}" % (browser, valid_browsers)
             )
+        # Fix Chrome-130 issues by creating a user-data-dir in advance
+        if (
+            undetectable
+            and (
+                not user_data_dir
+                or not os.path.exists(user_data_dir)
+                or not any(os.scandir(user_data_dir))
+            )
+            and self.browser == "chrome"
+        ):
+            import tempfile
+            if not user_data_dir:
+                user_data_dir = os.path.normpath(tempfile.mkdtemp())
+            self.user_data_dir = user_data_dir
+            sb_config.user_data_dir = user_data_dir
+            try:
+                decoy_driver = browser_launcher.get_driver(
+                    browser_name=browser_name,
+                    headless=headless,
+                    locale_code=locale_code,
+                    use_grid=use_grid,
+                    protocol=protocol,
+                    servername=servername,
+                    port=port,
+                    proxy_string=proxy_string,
+                    proxy_bypass_list=proxy_bypass_list,
+                    proxy_pac_url=proxy_pac_url,
+                    multi_proxy=multi_proxy,
+                    user_agent=user_agent,
+                    cap_file=cap_file,
+                    cap_string=cap_string,
+                    recorder_ext=recorder_ext,
+                    disable_cookies=disable_cookies,
+                    disable_js=disable_js,
+                    disable_csp=disable_csp,
+                    enable_ws=enable_ws,
+                    enable_sync=enable_sync,
+                    use_auto_ext=use_auto_ext,
+                    undetectable=undetectable,
+                    uc_cdp_events=uc_cdp_events,
+                    uc_subprocess=uc_subprocess,
+                    log_cdp_events=log_cdp_events,
+                    no_sandbox=no_sandbox,
+                    disable_gpu=disable_gpu,
+                    headless1=headless1,
+                    headless2=True,
+                    incognito=incognito,
+                    guest_mode=guest_mode,
+                    dark_mode=dark_mode,
+                    devtools=devtools,
+                    remote_debug=remote_debug,
+                    enable_3d_apis=enable_3d_apis,
+                    swiftshader=swiftshader,
+                    ad_block_on=ad_block_on,
+                    host_resolver_rules=host_resolver_rules,
+                    block_images=block_images,
+                    do_not_track=do_not_track,
+                    chromium_arg=chromium_arg,
+                    firefox_arg=firefox_arg,
+                    firefox_pref=firefox_pref,
+                    user_data_dir=user_data_dir,
+                    extension_zip=extension_zip,
+                    extension_dir=extension_dir,
+                    disable_features=disable_features,
+                    binary_location=binary_location,
+                    driver_version=driver_version,
+                    page_load_strategy=page_load_strategy,
+                    use_wire=use_wire,
+                    external_pdf=external_pdf,
+                    test_id=test_id,
+                    mobile_emulator=is_mobile,
+                    device_width=d_width,
+                    device_height=d_height,
+                    device_pixel_ratio=d_p_r,
+                    browser=browser_name,
+                )
+                time.sleep(0.555)
+            except Exception:
+                pass
+            finally:
+                with suppress(Exception):
+                    decoy_driver.quit()
         # Launch a web browser
         new_driver = browser_launcher.get_driver(
             browser_name=browser_name,
@@ -4435,7 +4517,12 @@ class BaseCase(unittest.TestCase):
         """Loads the page cookies from the "saved_cookies" folder."""
         cookies = self.get_saved_cookies(name)
         self.wait_for_ready_state_complete()
+        origin = self.get_origin()
+        trim_origin = origin.split("://")[-1]
         for cookie in cookies:
+            if "domain" in cookie:
+                if cookie["domain"] not in origin:
+                    cookie["domain"] = trim_origin
             if "expiry" in cookie:
                 del cookie["expiry"]
             self.driver.add_cookie(cookie)
@@ -4656,30 +4743,6 @@ class BaseCase(unittest.TestCase):
         if hasattr(self.driver, "_is_using_uc") and self.driver._is_using_uc:
             self.driver.uc_open_with_cdp_mode(url)
         else:
-            # Fix Chrome-130 issues by creating a user-data-dir in advance
-            if (
-                (
-                    not self.user_data_dir
-                    or not os.path.exists(self.user_data_dir)
-                )
-                and self.browser == "chrome"
-            ):
-                import tempfile
-                user_data_dir = os.path.normpath(tempfile.mkdtemp())
-                self.user_data_dir = user_data_dir
-                sb_config.user_data_dir = user_data_dir
-                try:
-                    driver = self.get_new_driver(
-                        user_data_dir=user_data_dir,
-                        undetectable=True,
-                        headless2=True,
-                    )
-                    time.sleep(0.555)
-                except Exception:
-                    pass
-                finally:
-                    with suppress(Exception):
-                        driver.quit()
             self.get_new_driver(undetectable=True)
             self.driver.uc_open_with_cdp_mode(url)
         self.cdp = self.driver.cdp
@@ -14941,31 +15004,6 @@ class BaseCase(unittest.TestCase):
                         self.__js_start_time = int(time.time() * 1000.0)
         else:
             # Launch WebDriver for both pytest and pynose
-
-            # Fix Chrome-130 issues by creating a user-data-dir in advance
-            if (
-                self.undetectable
-                and (
-                    not self.user_data_dir
-                    or not os.path.exists(self.user_data_dir)
-                )
-                and self.browser == "chrome"
-            ):
-                import tempfile
-                user_data_dir = os.path.normpath(tempfile.mkdtemp())
-                self.user_data_dir = user_data_dir
-                sb_config.user_data_dir = user_data_dir
-                try:
-                    driver = self.get_new_driver(
-                        user_data_dir=user_data_dir,
-                        headless2=True,
-                    )
-                    time.sleep(0.555)
-                except Exception:
-                    pass
-                finally:
-                    with suppress(Exception):
-                        driver.quit()
             self.driver = self.get_new_driver(
                 browser=self.browser,
                 headless=self.headless,

seleniumbase/plugins/driver_manager.py

@@ -792,12 +792,21 @@ def Driver(
     from seleniumbase.core import browser_launcher
 
     # Fix Chrome-130 issues by creating a user-data-dir in advance
-    if undetectable and not user_data_dir and browser == "chrome":
+    if (
+        undetectable
+        and (
+            not user_data_dir
+            or not os.path.exists(user_data_dir)
+            or not any(os.scandir(user_data_dir))
+        )
+        and browser == "chrome"
+    ):
         import tempfile
         import time
-        user_data_dir = (
-            os.path.normpath(tempfile.mkdtemp())
-        )
+        if not user_data_dir:
+            user_data_dir = (
+                os.path.normpath(tempfile.mkdtemp())
+            )
         try:
             decoy_driver = browser_launcher.get_driver(
                 browser_name=browser_name,

seleniumbase/plugins/sb_manager.py

@@ -1212,30 +1212,6 @@ def SB(
         if not sb_config.multi_proxy:
             proxy_helper.remove_proxy_zip_if_present()
     start_time = time.time()
-    saved_headless2 = headless2
-
-    # Fix Chrome-130 issues by creating a user-data-dir in advance
-    if undetectable and not user_data_dir and browser == "chrome":
-        import tempfile
-        user_data_dir = (
-            os.path.normpath(tempfile.mkdtemp())
-        )
-        sb.user_data_dir = user_data_dir
-        sb_config.user_data_dir = user_data_dir
-        try:
-            decoy = sb
-            decoy.headless2 = True
-            decoy.setUp()
-            decoy.sleep(0.555)
-        except Exception:
-            pass
-        finally:
-            try:
-                decoy.tearDown()
-            except Exception:
-                pass
-            sb.headless2 = saved_headless2
-
     sb.setUp()
     test_passed = True  # This can change later
     teardown_exception = None

seleniumbase/undetected/__init__.py

@@ -133,8 +133,11 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
             options = ChromeOptions()
         try:
             if hasattr(options, "_session") and options._session is not None:
-                # Prevent reuse of options
-                raise RuntimeError("You cannot reuse the ChromeOptions object")
+                # Prevent reuse of options.
+                # (Probably a port overlap. Quit existing driver and continue.)
+                logger.debug("You cannot reuse the ChromeOptions object")
+                with suppress(Exception):
+                    options._session.quit()
         except AttributeError:
             pass
         options._session = self

seleniumbase/undetected/cdp_driver/__init__.py

@@ -0,0 +1 @@
+from seleniumbase.undetected.cdp_driver import cdp_util  # noqa

seleniumbase/undetected/cdp_driver/_contradict.py

@@ -0,0 +1,110 @@
+import warnings as _warnings
+from collections.abc import Mapping as _Mapping, Sequence as _Sequence
+import logging
+
+__logger__ = logging.getLogger(__name__)
+__all__ = ["cdict", "ContraDict"]
+
+
+def cdict(*args, **kwargs):
+    """Factory function"""
+    return ContraDict(*args, **kwargs)
+
+
+class ContraDict(dict):
+    """
+    Directly inherited from dict.
+    Accessible by attribute. o.x == o['x']
+    This works also for all corner cases.
+    Native json.dumps and json.loads work with it.
+
+    Names like "keys", "update", "values" etc won't overwrite the methods,
+    but will just be available using dict lookup notation obj['items']
+    instead of obj.items.
+
+    All key names are converted to snake_case.
+    Hyphen's (-), dot's (.) or whitespaces are replaced by underscore (_).
+    Autocomplete works even if the objects comes from a list.
+    Recursive action. Dict assignments will be converted too.
+    """
+    __module__ = None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        silent = kwargs.pop("silent", False)
+        _ = dict(*args, **kwargs)
+
+        super().__setattr__("__dict__", self)
+        for k, v in _.items():
+            _check_key(k, self, False, silent)
+            super().__setitem__(k, _wrap(self.__class__, v))
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key, _wrap(self.__class__, value))
+
+    def __setattr__(self, key, value):
+        super().__setitem__(key, _wrap(self.__class__, value))
+
+    def __getattribute__(self, attribute):
+        if attribute in self:
+            return self[attribute]
+        if not _check_key(attribute, self, True, silent=True):
+            return getattr(super(), attribute)
+        return object.__getattribute__(self, attribute)
+
+
+def _wrap(cls, v):
+    if isinstance(v, _Mapping):
+        v = cls(v)
+    elif isinstance(v, _Sequence) and not isinstance(
+        v, (str, bytes, bytearray, set, tuple)
+    ):
+        v = list([_wrap(cls, x) for x in v])
+    return v
+
+
+_warning_names = (
+    "items",
+    "keys",
+    "values",
+    "update",
+    "clear",
+    "copy",
+    "fromkeys",
+    "get",
+    "items",
+    "keys",
+    "pop",
+    "popitem",
+    "setdefault",
+    "update",
+    "values",
+    "class",
+)
+
+_warning_names_message = """\n\
+    While creating a ContraDict object, a key offending key name '{0}'
+    has been found, which might behave unexpected.
+    You will only be able to look it up using key,
+    eg. myobject['{0}']. myobject.{0} will not work with that name."""
+
+
+def _check_key(
+    key: str, mapping: _Mapping, boolean: bool = False, silent=False
+):
+    """Checks `key` and warns if needed.
+    :param key:
+    :param boolean: return True or False instead of passthrough
+    """
+    e = None
+    if not isinstance(key, (str,)):
+        if boolean:
+            return True
+        return key
+    if key.lower() in _warning_names or any(_ in key for _ in ("-", ".")):
+        if not silent:
+            _warnings.warn(_warning_names_message.format(key))
+        e = True
+    if not boolean:
+        return key
+    return not e