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

seleniumbase/undetected/cdp_driver/config.py

@@ -5,7 +5,11 @@ import secrets
 import sys
 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__ = [
@@ -22,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:
@@ -78,12 +88,64 @@ 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
+            profile = os.path.join(self.user_data_dir, "Default")
+            preferences_file = os.path.join(profile, "Preferences")
+            preferences = get_default_preferences()
+            if not os.path.exists(profile):
+                with suppress(Exception):
+                    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
@@ -113,40 +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",
-            "--disable-features=IsolateOrigins,site-per-process,Translate,"
-            "InsecureDownloadWarnings,DownloadBubble,DownloadBubbleV2,"
-            "OptimizationTargetPrediction,OptimizationGuideModelDownloading,"
-            "SidePanelPinning,UserAgentClientHint,PrivacySandboxSettings4,"
-            "DisableLoadExtensionCommandLineSwitch",
         ]
+        if mock_keychain:
+            self._default_browser_args.append("--use-mock-keychain")
 
     @property
     def browser_args(self):
@@ -193,8 +258,16 @@ class Config:
         # By the time it starts, the port is probably already taken.
         args = self._default_browser_args.copy()
         args += ["--user-data-dir=%s" % self.user_data_dir]
-        args += ["--disable-features=IsolateOrigins,site-per-process"]
-        args += ["--disable-session-crashed-bubble"]
+        args += [
+            "--disable-features=IsolateOrigins,site-per-process,Translate,"
+            "InsecureDownloadWarnings,DownloadBubble,DownloadBubbleV2,"
+            "OptimizationTargetPrediction,OptimizationGuideModelDownloading,"
+            "SidePanelPinning,UserAgentClientHint,PrivacySandboxSettings4,"
+            "OptimizationHintsFetching,InterestFeedContentSuggestions,"
+            "Bluetooth,WebBluetooth,UnifiedWebBluetooth,ComponentUpdater,"
+            "DisableLoadExtensionCommandLineSwitch,"
+            "WebAuthentication,PasskeyAuth"
+        ]
         if self.expert:
             args += [
                 "--disable-web-security",
@@ -270,9 +343,25 @@ def is_root():
         return ctypes.windll.shell32.IsUserAnAdmin() != 0
 
 
+def get_default_preferences():
+    return (
+        """{"credentials_enable_service": false,
+        "password_manager_enabled": false,
+        "password_manager_leak_detection": false}"""
+    )
+
+
 def temp_profile_dir():
     """Generate a temp dir (path)"""
     path = os.path.normpath(tempfile.mkdtemp(prefix="uc_"))
+    profile = os.path.join(path, "Default")
+    preferences_file = os.path.join(profile, "Preferences")
+    preferences = get_default_preferences()
+    if not os.path.exists(profile):
+        with suppress(Exception):
+            os.makedirs(profile)
+    with open(preferences_file, "w") as f:
+        f.write(preferences)
     return path
 
 
@@ -286,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:
@@ -318,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

@@ -7,7 +7,6 @@ import json
 import logging
 import sys
 import types
-from asyncio import iscoroutine, iscoroutinefunction
 from typing import (
     Optional,
     Generator,
@@ -33,6 +32,7 @@ GLOBAL_DELAY = 0.005
 MAX_SIZE: int = 2**28
 PING_TIMEOUT: int = 1800  # 30 minutes
 TargetType = Union[cdp.target.TargetInfo, cdp.target.TargetID]
+logging.getLogger("asyncio").setLevel(logging.CRITICAL)
 logger = logging.getLogger("uc.connection")
 
 
@@ -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()
@@ -520,8 +490,6 @@ class Connection(metaclass=CantTouchThis):
                     except BaseException:
                         logger.debug("NOT GOOD", exc_info=True)
                         continue
-                finally:
-                    continue
         for ed in enabled_domains:
             # Items still present at this point are unused and need removal.
             self.enabled_domains.remove(ed)
@@ -642,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"
@@ -667,13 +635,15 @@ class Listener:
                     for callback in callbacks:
                         try:
                             if (
-                                iscoroutinefunction(callback)
-                                or iscoroutine(callback)
+                                inspect.iscoroutinefunction(callback)
+                                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()",
@@ -484,17 +487,14 @@ class Element:
         buttons: typing.Optional[int] = 1,
         modifiers: typing.Optional[int] = 0,
         hold: bool = False,
-        _until_event: typing.Optional[type] = None,
     ):
         """
         Native click (on element).
-        Note: This likely does not work at the moment. Use click() instead.
         :param button: str (default = "left")
         :param buttons: which button (default 1 = left)
         :param modifiers: *(Optional)*
                 Bit field representing pressed modifier keys.
                 Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
-        :param _until_event: Internal. Event to wait for before returning.
         """
         try:
             center = (await self.get_position_async()).center
@@ -504,7 +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(
+        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",
@@ -516,6 +520,8 @@ class Element:
                     click_count=1,
                 )
             ),
+        )
+        asyncio.create_task(
             self._tab.send(
                 cdp.input_.dispatch_mouse_event(
                     "mouseReleased",
@@ -528,10 +534,73 @@ class Element:
                 )
             ),
         )
+
+    async def mouse_click_with_offset_async(
+        self,
+        x: typing.Union[float, int],
+        y: typing.Union[float, int],
+        center: bool = False,
+        button: str = "left",
+        buttons: typing.Optional[int] = 1,
+        modifiers: typing.Optional[int] = 0,
+    ):
+        x_offset = int(x)
+        y_offset = int(y)
         try:
-            await self.flash_async()
-        except BaseException:
-            pass
+            position = (await self.get_position_async())
+            width = position.width
+            height = position.height
+            x_pos = position.left
+            y_pos = position.top
+            center_pos = (await self.get_position_async()).center
+        except AttributeError:
+            return
+        if not center_pos:
+            logger.warning("Could not calculate box model for %s", self)
+            return
+        if center:
+            x_pos = center_pos[0]
+            y_pos = center_pos[1]
+            width = 0
+            height = 0
+            logger.debug("Clicking on location: %.2f, %.2f" % center_pos)
+        else:
+            logger.debug("Clicking on location: %.2f, %.2f" % (x_pos, y_pos))
+        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",
+                    x=x_pos + x_offset,
+                    y=y_pos + y_offset,
+                    modifiers=modifiers,
+                    button=cdp.input_.MouseButton(button),
+                    buttons=buttons,
+                    click_count=1,
+                )
+            )
+        )
+        asyncio.create_task(
+            self._tab.send(
+                cdp.input_.dispatch_mouse_event(
+                    "mouseReleased",
+                    x=x_pos + x_offset,
+                    y=y_pos + y_offset,
+                    modifiers=modifiers,
+                    button=cdp.input_.MouseButton(button),
+                    buttons=buttons,
+                    click_count=1,
+                )
+            ),
+        )
 
     async def mouse_move_async(self):
         """
@@ -548,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(
@@ -664,7 +730,7 @@ class Element:
             return
         # await self.apply("""(el) => el.scrollIntoView(false)""")
 
-    async def clear_input_async(self, _until_event: type = None):
+    async def clear_input_async(self):
         """Clears an input field."""
         try:
             await self.apply('function (element) { element.value = "" } ')
@@ -752,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
@@ -771,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(
@@ -784,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(
@@ -952,18 +1021,21 @@ class Element:
             .replace("  ", "")
             .replace("\n", "")
         )
-        arguments = [cdp.runtime.CallArgument(
-            object_id=self._remote_object.object_id
-        )]
-        await self._tab.send(
-            cdp.runtime.call_function_on(
-                script,
-                object_id=self._remote_object.object_id,
-                arguments=arguments,
-                await_promise=True,
-                user_gesture=True,
+        try:
+            arguments = [cdp.runtime.CallArgument(
+                object_id=self._remote_object.object_id
+            )]
+            await self._tab.send(
+                cdp.runtime.call_function_on(
+                    script,
+                    object_id=self._remote_object.object_id,
+                    arguments=arguments,
+                    await_promise=True,
+                    user_gesture=True,
+                )
             )
-        )
+        except Exception:
+            pass
 
     async def highlight_overlay_async(self):
         """