seleniumbase 4.44.2__py3-none-any.whl → 4.45.10__py3-none-any.whl

seleniumbase/undetected/cdp_driver/cdp_util.py

@@ -51,12 +51,27 @@ def __activate_virtual_display_as_needed(
     headless, headed, xvfb, xvfb_metrics
 ):
     """This is only needed on Linux."""
+    reset_virtual_display = False
+    if IS_LINUX and (not headed or xvfb):
+        if (
+            not hasattr(sb_config, "_closed_connection_ids")
+            or not isinstance(sb_config._closed_connection_ids, list)
+        ):
+            sb_config._closed_connection_ids = []
+        if (
+            not hasattr(sb_config, "_xvfb_users")
+            or not isinstance(sb_config._xvfb_users, int)
+        ):
+            reset_virtual_display = True
+            sb_config._xvfb_users = 0
+        sb_config._xvfb_users += 1
     if (
         IS_LINUX
         and (not headed or xvfb)
         and (
             not hasattr(sb_config, "_virtual_display")
             or not sb_config._virtual_display
+            or reset_virtual_display
         )
     ):
         from sbvirtualdisplay import Display
@@ -102,7 +117,8 @@ def __activate_virtual_display_as_needed(
                     _xvfb_display.start()
                     if "DISPLAY" not in os.environ.keys():
                         print(
-                            "\nX11 display failed! Will use regular xvfb!"
+                            "\n  X11 display failed! Is Xvfb installed? "
+                            "\n  Try this: `sudo apt install -y xvfb`"
                         )
                         __activate_standard_virtual_display()
                     else:
@@ -280,7 +296,10 @@ async def start(
     proxy: Optional[str] = None,  # "host:port" or "user:pass@host:port"
     tzone: Optional[str] = None,  # Eg "America/New_York", "Asia/Kolkata"
     geoloc: Optional[list | tuple] = None,  # Eg (48.87645, 2.26340)
+    mobile: Optional[bool] = None,  # Use Mobile Mode with default args
+    disable_csp: Optional[str] = None,  # Disable content security policy
     extension_dir: Optional[str] = None,  # Chrome extension directory
+    use_chromium: Optional[str] = None,  # Use the base Chromium browser
     **kwargs: Optional[dict],
 ) -> Browser:
     """
@@ -351,11 +370,25 @@ async def start(
             guest = True
         else:
             guest = False
+    if mobile is None:
+        if "--mobile" in sys_argv:
+            mobile = True
+        else:
+            mobile = False
+    if mobile:
+        sb_config._cdp_mobile_mode = True
+    else:
+        sb_config._cdp_mobile_mode = False
     if ad_block is None:
         if "--ad-block" in sys_argv or "--ad_block" in sys_argv:
             ad_block = True
         else:
             ad_block = False
+    if disable_csp is None:
+        if "--disable-csp" in sys_argv or "--disable_csp" in sys_argv:
+            disable_csp = True
+        else:
+            disable_csp = False
     if xvfb_metrics is None and "--xvfb-metrics" in arg_join:
         x_m = xvfb_metrics
         count = 0
@@ -482,6 +515,8 @@ async def start(
                 print("  Using default Chrome browser instead!")
                 bin_loc = None
             browser_executable_path = bin_loc
+        elif use_chromium or "--use-chromium" in arg_join:
+            browser_executable_path = "_chromium_"
     if proxy is None and "--proxy" in arg_join:
         proxy_string = None
         if "--proxy=" in arg_join:
@@ -530,7 +565,11 @@ async def start(
                 platform_var = platform_var[1:-1]
     if IS_LINUX and not headless and not headed and not xvfb:
         xvfb = True  # The default setting on Linux
-    __activate_virtual_display_as_needed(headless, headed, xvfb, xvfb_metrics)
+    if not host or not port:
+        # The browser hasn't been launched yet. (May need a virtual display)
+        __activate_virtual_display_as_needed(
+            headless, headed, xvfb, xvfb_metrics
+        )
     if proxy and "@" in str(proxy):
         user_with_pass = proxy.split("@")[0]
         if ":" in user_with_pass:
@@ -548,12 +587,15 @@ async def start(
                 proxy_scheme,
             )
     if ad_block:
+        sb_config.ad_block_on = True
         incognito = False
         guest = False
         ad_block_zip = AD_BLOCK_ZIP_PATH
         ad_block_dir = os.path.join(DOWNLOADS_FOLDER, "ad_block")
         __unzip_to_new_folder(ad_block_zip, ad_block_dir)
         extension_dir = __add_chrome_ext_dir(extension_dir, ad_block_dir)
+    if disable_csp:
+        sb_config.disable_csp = True
     if "binary_location" in kwargs and not browser_executable_path:
         browser_executable_path = kwargs["binary_location"]
     if not browser_executable_path:
@@ -607,6 +649,8 @@ async def start(
             sb_config._cdp_browser = "atlas"
         else:
             sb_config._cdp_browser = "chrome"
+    sb_config.incognito = incognito
+    sb_config.guest_mode = guest
     if not config:
         config = Config(
             user_data_dir,
@@ -666,6 +710,8 @@ async def start(
         sb_config._cdp_platform = platform_var
     else:
         sb_config._cdp_platform = None
+    driver.page = driver.main_tab
+    driver.solve_captcha = driver.page.solve_captcha
     return driver
 
 
@@ -695,18 +741,6 @@ def start_sync(*args, **kwargs) -> Browser:
         loop = kwargs["loop"]
     else:
         loop = asyncio.new_event_loop()
-    if "user_data_dir" in kwargs and kwargs["user_data_dir"]:
-        headless = False
-        if "headless" in kwargs:
-            headless = kwargs["headless"]
-        decoy_args = kwargs
-        decoy_args["headless"] = True
-        driver = loop.run_until_complete(start(**decoy_args))
-        kwargs["headless"] = headless
-        kwargs["user_data_dir"] = driver.config.user_data_dir
-        time.sleep(0.2)
-        driver.stop()  # Due to Chrome-130, must stop & start
-        time.sleep(0.1)
     return loop.run_until_complete(start(*args, **kwargs))
 
 

seleniumbase/undetected/cdp_driver/config.py

@@ -7,6 +7,9 @@ import tempfile
 import zipfile
 from contextlib import suppress
 from seleniumbase.config import settings
+from seleniumbase.drivers import chromium_drivers
+from seleniumbase.fixtures import constants
+from seleniumbase.fixtures import shared_utils
 from typing import Union, List, Optional
 
 __all__ = [
@@ -23,6 +26,12 @@ is_posix = sys.platform.startswith(("darwin", "cygwin", "linux", "linux2"))
 
 PathLike = Union[str, pathlib.Path]
 AUTO = None
+IS_MAC = shared_utils.is_mac()
+IS_LINUX = shared_utils.is_linux()
+IS_WINDOWS = shared_utils.is_windows()
+CHROMIUM_DIR = os.path.dirname(
+    os.path.realpath(chromium_drivers.__file__)
+)
 
 
 class Config:
@@ -79,7 +88,8 @@ class Config:
         if not browser_args:
             browser_args = []
         if not user_data_dir:
-            self._user_data_dir = temp_profile_dir()
+            self.user_data_dir = temp_profile_dir()
+            self._user_data_dir = self.user_data_dir
             self._custom_data_dir = False
         else:
             self.user_data_dir = user_data_dir
@@ -91,8 +101,51 @@ class Config:
                     os.makedirs(profile)
             with open(preferences_file, "w") as f:
                 f.write(preferences)
+        mock_keychain = False
         if not browser_executable_path:
             browser_executable_path = find_chrome_executable()
+        elif browser_executable_path == "_chromium_":
+            from filelock import FileLock
+            binary_folder = None
+            if IS_MAC:
+                binary_folder = "chrome-mac"
+            elif IS_LINUX:
+                binary_folder = "chrome-linux"
+            elif IS_WINDOWS:
+                binary_folder = "chrome-win"
+            binary_location = os.path.join(CHROMIUM_DIR, binary_folder)
+            gui_lock = FileLock(constants.MultiBrowser.DRIVER_FIXING_LOCK)
+            with gui_lock:
+                with suppress(Exception):
+                    shared_utils.make_writable(
+                        constants.MultiBrowser.DRIVER_FIXING_LOCK
+                    )
+                if not os.path.exists(binary_location):
+                    from seleniumbase.console_scripts import sb_install
+                    sys_args = sys.argv  # Save a copy of sys args
+                    sb_install.log_d("\nWarning: Chromium binary not found...")
+                    sb_install.main(override="chromium")
+                    sys.argv = sys_args  # Put back original args
+            binary_name = binary_location.split("/")[-1].split("\\")[-1]
+            if binary_name in ["chrome-mac"]:
+                binary_name = "Chromium"
+                binary_location += "/Chromium.app"
+                binary_location += "/Contents/MacOS/Chromium"
+            elif binary_name == "chrome-linux":
+                binary_name = "chrome"
+                binary_location += "/chrome"
+            elif binary_name in ["chrome-win"]:
+                binary_name = "chrome.exe"
+                binary_location += "\\chrome.exe"
+            if os.path.exists(binary_location):
+                mock_keychain = True
+                browser_executable_path = binary_location
+            else:
+                print(
+                    f"{binary_location} not found. "
+                    f"Defaulting to regular Chrome!"
+                )
+                browser_executable_path = find_chrome_executable()
         self._browser_args = browser_args
         self.browser_executable_path = browser_executable_path
         self.headless = headless
@@ -122,35 +175,43 @@ class Config:
         self._default_browser_args = [
             "--window-size=%s,%s" % (start_width, start_height),
             "--window-position=%s,%s" % (start_x, start_y),
-            "--remote-allow-origins=*",
             "--no-first-run",
             "--no-service-autorun",
             "--disable-auto-reload",
             "--no-default-browser-check",
             "--homepage=about:blank",
             "--no-pings",
+            "--enable-unsafe-extension-debugging",
             "--wm-window-animations-disabled",
             "--animation-duration-scale=0",
             "--enable-privacy-sandbox-ads-apis",
             "--safebrowsing-disable-download-protection",
             '--simulate-outdated-no-au="Tue, 31 Dec 2099 23:59:59 GMT"',
+            "--test-type",
+            "--ash-no-nudges",
             "--password-store=basic",
             "--deny-permission-prompts",
-            "--disable-infobars",
             "--disable-breakpad",
+            "--disable-setuid-sandbox",
             "--disable-prompt-on-repost",
+            "--disable-application-cache",
             "--disable-password-generation",
+            "--disable-save-password-bubble",
+            "--disable-single-click-autofill",
             "--disable-ipc-flooding-protection",
             "--disable-background-timer-throttling",
             "--disable-search-engine-choice-screen",
             "--disable-backgrounding-occluded-windows",
             "--disable-client-side-phishing-detection",
+            "--disable-device-discovery-notifications",
             "--disable-top-sites",
             "--disable-translate",
+            "--dns-prefetch-disable",
             "--disable-renderer-backgrounding",
-            "--disable-background-networking",
             "--disable-dev-shm-usage",
         ]
+        if mock_keychain:
+            self._default_browser_args.append("--use-mock-keychain")
 
     @property
     def browser_args(self):
@@ -203,11 +264,10 @@ class Config:
             "OptimizationTargetPrediction,OptimizationGuideModelDownloading,"
             "SidePanelPinning,UserAgentClientHint,PrivacySandboxSettings4,"
             "OptimizationHintsFetching,InterestFeedContentSuggestions,"
-            "DisableLoadExtensionCommandLineSwitch"
+            "Bluetooth,WebBluetooth,UnifiedWebBluetooth,ComponentUpdater,"
+            "DisableLoadExtensionCommandLineSwitch,"
+            "WebAuthentication,PasskeyAuth"
         ]
-        if self.proxy:
-            args += ["--test-type"]
-        args += ["--disable-session-crashed-bubble"]
         if self.expert:
             args += [
                 "--disable-web-security",
@@ -315,10 +375,13 @@ def find_chrome_executable(return_all=False):
         for item in os.environ.get("PATH").split(os.pathsep):
             for subitem in (
                 "google-chrome",
+                "google-chrome-stable",
+                "google-chrome-beta",
+                "google-chrome-dev",
+                "google-chrome-unstable",
+                "chrome",
                 "chromium",
                 "chromium-browser",
-                "chrome",
-                "google-chrome-stable",
             ):
                 candidates.append(os.sep.join((item, subitem)))
         if "darwin" in sys.platform:
@@ -347,7 +410,11 @@ def find_chrome_executable(return_all=False):
                     )
     rv = []
     for candidate in candidates:
-        if os.path.exists(candidate) and os.access(candidate, os.X_OK):
+        if (
+            os.path.exists(candidate)
+            and os.access(candidate, os.R_OK)
+            and os.access(candidate, os.X_OK)
+        ):
             logger.debug("%s is a valid candidate... " % candidate)
             rv.append(candidate)
         else:

seleniumbase/undetected/cdp_driver/connection.py

@@ -184,13 +184,13 @@ class Connection(metaclass=CantTouchThis):
         self,
         websocket_url=None,
         target=None,
-        _owner=None,
+        browser=None,
         **kwargs,
     ):
         super().__init__()
         self._target = target
         self.__count__ = itertools.count(0)
-        self._owner = _owner
+        self.browser = browser
         self.websocket_url: str = websocket_url
         self.websocket = None
         self.mapper = {}
@@ -370,8 +370,8 @@ class Connection(metaclass=CantTouchThis):
 
     async def set_geolocation(self, geolocation: Optional[tuple] = None):
         """Sets the User Agent via set_geolocation_override."""
-        await self.send(cdp.browser.grant_permissions(
-            permissions=["geolocation"],
+        await self.send(cdp.browser.set_permission(
+            permission={"name": "geolocation"}, setting="granted"
         ))
         await self.send(cdp.emulation.set_geolocation_override(
             latitude=geolocation[0],
@@ -379,36 +379,6 @@ class Connection(metaclass=CantTouchThis):
             accuracy=100,
         ))
 
-    async def set_auth(self, username, password, tab):
-        async def auth_challenge_handler(event: cdp.fetch.AuthRequired):
-            await tab.send(
-                cdp.fetch.continue_with_auth(
-                    request_id=event.request_id,
-                    auth_challenge_response=cdp.fetch.AuthChallengeResponse(
-                        response="ProvideCredentials",
-                        username=username,
-                        password=password,
-                    ),
-                )
-            )
-
-        async def req_paused(event: cdp.fetch.RequestPaused):
-            await tab.send(
-                cdp.fetch.continue_request(request_id=event.request_id)
-            )
-
-        tab.add_handler(
-            cdp.fetch.RequestPaused,
-            lambda event: asyncio.create_task(req_paused(event)),
-        )
-
-        tab.add_handler(
-            cdp.fetch.AuthRequired,
-            lambda event: asyncio.create_task(auth_challenge_handler(event)),
-        )
-
-        await tab.send(cdp.fetch.enable(handle_auth_requests=True))
-
     def __getattr__(self, item):
         """:meta private:"""
         try:
@@ -456,8 +426,8 @@ class Connection(metaclass=CantTouchThis):
         await self.aopen()
         if not self.websocket or self.websocket.state is State.CLOSED:
             return
-        if self._owner:
-            browser = self._owner
+        if self.browser:
+            browser = self.browser
             if browser.config:
                 if browser.config.expert:
                     await self._prepare_expert()
@@ -640,11 +610,11 @@ class Listener:
                 # Probably an event
                 try:
                     event = cdp.util.parse_json_event(message)
-                    event_tx = EventTransaction(event)
-                    if not self.connection.mapper:
-                        self.connection.__count__ = itertools.count(0)
-                    event_tx.id = next(self.connection.__count__)
-                    self.connection.mapper[event_tx.id] = event_tx
+                    # event_tx = EventTransaction(event)
+                    # if not self.connection.mapper:
+                    #     self.connection.__count__ = itertools.count(0)
+                    # event_tx.id = next(self.connection.__count__)
+                    # self.connection.mapper[event_tx.id] = event_tx
                 except Exception as e:
                     logger.info(
                         "%s: %s during parsing of json from event : %s"
@@ -669,9 +639,11 @@ class Listener:
                                 or inspect.iscoroutine(callback)
                             ):
                                 try:
-                                    await callback(event, self.connection)
+                                    asyncio.create_task(
+                                        callback(event, self.connection)
+                                    )
                                 except TypeError:
-                                    await callback(event)
+                                    asyncio.create_task(callback(event))
                             else:
                                 try:
                                     callback(event, self.connection)

seleniumbase/undetected/cdp_driver/element.py

@@ -372,7 +372,10 @@ class Element:
         arguments = [cdp.runtime.CallArgument(
             object_id=self._remote_object.object_id
         )]
-        await self.flash_async(0.25)
+        script = 'sessionStorage.getItem("pxsid") !== null;'
+        using_px = await self.tab.evaluate(script)
+        if not using_px:
+            await self.flash_async(0.25)
         await self._tab.send(
             cdp.runtime.call_function_on(
                 "(el) => el.click()",
@@ -501,8 +504,11 @@ class Element:
             logger.warning("Could not calculate box model for %s", self)
             return
         logger.debug("Clicking on location: %.2f, %.2f" % center)
-        await asyncio.gather(
-            self.flash_async(0.25),
+        script = 'sessionStorage.getItem("pxsid") !== null;'
+        using_px = await self.tab.evaluate(script)
+        if not using_px:
+            asyncio.create_task(self.flash_async(0.25))
+        asyncio.create_task(
             self._tab.send(
                 cdp.input_.dispatch_mouse_event(
                     "mousePressed",
@@ -514,6 +520,8 @@ class Element:
                     click_count=1,
                 )
             ),
+        )
+        asyncio.create_task(
             self._tab.send(
                 cdp.input_.dispatch_mouse_event(
                     "mouseReleased",
@@ -558,11 +566,16 @@ class Element:
             logger.debug("Clicking on location: %.2f, %.2f" % center_pos)
         else:
             logger.debug("Clicking on location: %.2f, %.2f" % (x_pos, y_pos))
-        await asyncio.gather(
-            self.flash_async(
-                x_offset=x_offset - int(width / 2),
-                y_offset=y_offset - int(height / 2),
-            ),
+        script = 'sessionStorage.getItem("pxsid") !== null;'
+        using_px = await self.tab.evaluate(script)
+        if not using_px:
+            asyncio.create_task(
+                self.flash_async(
+                    x_offset=x_offset - (width / 2),
+                    y_offset=y_offset - (height / 2),
+                ),
+            )
+        asyncio.create_task(
             self._tab.send(
                 cdp.input_.dispatch_mouse_event(
                     "mousePressed",
@@ -573,7 +586,9 @@ class Element:
                     buttons=buttons,
                     click_count=1,
                 )
-            ),
+            )
+        )
+        asyncio.create_task(
             self._tab.send(
                 cdp.input_.dispatch_mouse_event(
                     "mouseReleased",
@@ -602,16 +617,13 @@ class Element:
             *center,
             self,
         )
-        await self._tab.send(
-            cdp.input_.dispatch_mouse_event(
-                "mouseMoved", x=center[0], y=center[1]
-            )
-        )
-        await self._tab.sleep(0.05)
-        await self._tab.send(
-            cdp.input_.dispatch_mouse_event(
-                "mouseReleased", x=center[0], y=center[1]
-            )
+        await asyncio.gather(
+            self._tab.send(
+                cdp.input_.dispatch_mouse_event(
+                    "mouseMoved", x=center[0], y=center[1]
+                )
+            ),
+            self._tab.sleep(0.05),
         )
 
     async def mouse_drag_async(
@@ -806,7 +818,10 @@ class Element:
 
     async def get_html_async(self):
         return await self._tab.send(
-            cdp.dom.get_outer_html(backend_node_id=self.backend_node_id)
+            cdp.dom.get_outer_html(
+                backend_node_id=self.backend_node_id,
+                include_shadow_dom=True,
+            )
         )
 
     @property
@@ -825,7 +840,7 @@ class Element:
         """
         with suppress(Exception):
             if self.node.node_name.lower() in ["input", "textarea"]:
-                input_node = self.node.shadow_roots[0].children[0].children[0]
+                input_node = self.node.shadow_roots[0].children[-1].children[0]
                 if input_node:
                     return input_node.node_value
         text_nodes = util.filter_recurse_all(
@@ -838,7 +853,7 @@ class Element:
         """Same as text(). Kept for backwards compatibility."""
         with suppress(Exception):
             if self.node.node_name.lower() in ["input", "textarea"]:
-                input_node = self.node.shadow_roots[0].children[0].children[0]
+                input_node = self.node.shadow_roots[0].children[-1].children[0]
                 if input_node:
                     return input_node.node_value
         text_nodes = util.filter_recurse_all(