seleniumbase 4.34.7__py3-none-any.whl → 4.36.2__py3-none-any.whl

seleniumbase/undetected/__init__.py

@@ -452,14 +452,24 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
                 self.service.start()
         with suppress(Exception):
             self.start_session()
+            time.sleep(0.0075)
         with suppress(Exception):
-            if self.current_url.startswith("chrome-extension://"):
-                self.close()
-                if self.service.is_connectable():
-                    self.stop_client()
-                    self.service.stop()
-                self.service.start()
-                self.start_session()
+            for window_handle in self.window_handles:
+                self.switch_to.window(window_handle)
+                if self.current_url.startswith(
+                    "chrome-extension://"
+                ):
+                    # https://issues.chromium.org/issues/396611138
+                    # (Uncomment below when resolved)
+                    # self.close()
+                    if self.service.is_connectable():
+                        self.stop_client()
+                        self.service.stop()
+                    self.service.start()
+                    self.start_session()
+                    time.sleep(0.003)
+        with suppress(Exception):
+            self.switch_to.window(self.window_handles[-1])
         self._is_connected = True
 
     def disconnect(self):
@@ -469,6 +479,7 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
             with suppress(Exception):
                 if self.service.is_connectable():
                     self.stop_client()
+                    time.sleep(0.003)
                     self.service.stop()
         self._is_connected = False
 
@@ -480,14 +491,24 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
                 self.service.start()
         with suppress(Exception):
             self.start_session()
+            time.sleep(0.0075)
         with suppress(Exception):
-            if self.current_url.startswith("chrome-extension://"):
-                self.close()
-                if self.service.is_connectable():
-                    self.stop_client()
-                    self.service.stop()
-                self.service.start()
-                self.start_session()
+            for window_handle in self.window_handles:
+                self.switch_to.window(window_handle)
+                if self.current_url.startswith(
+                    "chrome-extension://"
+                ):
+                    # https://issues.chromium.org/issues/396611138
+                    # (Uncomment below when resolved)
+                    # self.close()
+                    if self.service.is_connectable():
+                        self.stop_client()
+                        self.service.stop()
+                    self.service.start()
+                    self.start_session()
+                    time.sleep(0.003)
+        with suppress(Exception):
+            self.switch_to.window(self.window_handles[-1])
         self._is_connected = True
 
     def start_session(self, capabilities=None):
@@ -576,14 +597,14 @@ def find_chrome_executable():
     if IS_POSIX:
         for item in os.environ.get("PATH").split(os.pathsep):
             for subitem in (
-                "chromium",
                 "google-chrome",
-                "chromium-browser",
-                "chrome",
                 "google-chrome-stable",
                 "google-chrome-beta",
                 "google-chrome-dev",
                 "google-chrome-unstable",
+                "chrome",
+                "chromium",
+                "chromium-browser",
             ):
                 candidates.add(os.sep.join((item, subitem)))
         if "darwin" in sys.platform:

seleniumbase/undetected/cdp_driver/__init__.py

@@ -1 +1,3 @@
 from seleniumbase.undetected.cdp_driver import cdp_util  # noqa
+from seleniumbase.undetected.cdp_driver.cdp_util import start_async  # noqa
+from seleniumbase.undetected.cdp_driver.cdp_util import start_sync  # noqa

seleniumbase/undetected/cdp_driver/browser.py

@@ -15,6 +15,7 @@ import urllib.parse
 import urllib.request
 import warnings
 from collections import defaultdict
+from seleniumbase import config as sb_config
 from typing import List, Set, Tuple, Union
 import mycdp as cdp
 from . import cdp_util as util
@@ -265,6 +266,8 @@ class Browser:
         :param new_window: Open new window
         :return: Page
         """
+        if url and ":" not in url:
+            url = "https://" + url
         if new_tab or new_window:
             # Create new target using the browser session.
             target_id = await self.connection.send(
@@ -285,6 +288,9 @@ class Browser:
                 filter(lambda item: item.type_ == "page", self.targets)
             )
             # Use the tab to navigate to new url
+            if hasattr(sb_config, "_cdp_locale") and sb_config._cdp_locale:
+                await connection.send(cdp.page.navigate("about:blank"))
+                await connection.set_locale(sb_config._cdp_locale)
             frame_id, loader_id, *_ = await connection.send(
                 cdp.page.navigate(url)
             )
@@ -565,10 +571,11 @@ class Browser:
             # asyncio.get_running_loop().create_task(
             #     self.connection.send(cdp.browser.close())
             # )
-            asyncio.get_event_loop().create_task(self.connection.aclose())
-            logger.debug(
-                "Closed the connection using get_event_loop().create_task()"
-            )
+            if self.connection:
+                asyncio.get_event_loop().create_task(self.connection.aclose())
+                logger.debug(
+                    "Closed connection using get_event_loop().create_task()"
+                )
         except RuntimeError:
             if self.connection:
                 try:
@@ -653,7 +660,7 @@ class CookieJar:
             break
         else:
             connection = self._browser.connection
-        cookies = await connection.send(cdp.storage.get_cookies())
+        cookies = await connection.send(cdp.network.get_cookies())
         if requests_cookie_format:
             import requests.cookies
 
@@ -683,8 +690,7 @@ class CookieJar:
             break
         else:
             connection = self._browser.connection
-        cookies = await connection.send(cdp.storage.get_cookies())
-        await connection.send(cdp.storage.set_cookies(cookies))
+        await connection.send(cdp.network.set_cookies(cookies))
 
     async def save(self, file: PathLike = ".session.dat", pattern: str = ".*"):
         """
@@ -711,7 +717,7 @@ class CookieJar:
             break
         else:
             connection = self._browser.connection
-        cookies = await connection.send(cdp.storage.get_cookies())
+        cookies = await connection.send(cdp.network.get_cookies())
         # if not connection:
         #     return
         # if not connection.websocket:
@@ -769,7 +775,7 @@ class CookieJar:
                     cookie.value,
                 )
                 break
-        await connection.send(cdp.storage.set_cookies(included_cookies))
+        await connection.send(cdp.network.set_cookies(included_cookies))
 
     async def clear(self):
         """
@@ -784,7 +790,7 @@ class CookieJar:
             break
         else:
             connection = self._browser.connection
-        cookies = await connection.send(cdp.storage.get_cookies())
+        cookies = await connection.send(cdp.network.get_cookies())
         if cookies:
             await connection.send(cdp.storage.clear_cookies())
 

seleniumbase/undetected/cdp_driver/cdp_util.py

@@ -4,12 +4,15 @@ import asyncio
 import fasteners
 import logging
 import os
+import sys
 import time
 import types
 import typing
 from contextlib import suppress
 from seleniumbase import config as sb_config
 from seleniumbase.config import settings
+from seleniumbase.core import detect_b_ver
+from seleniumbase.core import proxy_helper
 from seleniumbase.fixtures import constants
 from seleniumbase.fixtures import shared_utils
 from typing import Optional, List, Union, Callable
@@ -22,6 +25,7 @@ import mycdp as cdp
 
 logger = logging.getLogger(__name__)
 IS_LINUX = shared_utils.is_linux()
+PROXY_DIR_LOCK = proxy_helper.PROXY_DIR_LOCK
 T = typing.TypeVar("T")
 
 
@@ -138,6 +142,85 @@ def __activate_virtual_display_as_needed(
                 __activate_standard_virtual_display()
 
 
+def __set_proxy_filenames():
+    DOWNLOADS_DIR = constants.Files.DOWNLOADS_FOLDER
+    for num in range(1000):
+        PROXY_DIR_PATH = os.path.join(DOWNLOADS_DIR, "proxy_ext_dir_%s" % num)
+        if os.path.exists(PROXY_DIR_PATH):
+            continue
+        proxy_helper.PROXY_DIR_PATH = PROXY_DIR_PATH
+        return
+    # Exceeded upper bound. Use Defaults:
+    PROXY_DIR_PATH = os.path.join(DOWNLOADS_DIR, "proxy_ext_dir")
+    proxy_helper.PROXY_DIR_PATH = PROXY_DIR_PATH
+
+
+def __add_chrome_ext_dir(extension_dir, dir_path):
+    # Add dir_path to the existing extension_dir
+    option_exists = False
+    if extension_dir:
+        option_exists = True
+        extension_dir = "%s,%s" % (
+            extension_dir, os.path.realpath(dir_path)
+        )
+    if not option_exists:
+        extension_dir = os.path.realpath(dir_path)
+    return extension_dir
+
+
+def __add_chrome_proxy_extension(
+    extension_dir,
+    proxy_string,
+    proxy_user,
+    proxy_pass,
+    proxy_bypass_list=None,
+    multi_proxy=False,
+):
+    """Implementation of https://stackoverflow.com/a/35293284/7058266
+    for https://stackoverflow.com/q/12848327/7058266
+    (Run Selenium on a proxy server that requires authentication.)"""
+    args = " ".join(sys.argv)
+    bypass_list = proxy_bypass_list
+    if (
+        not ("-n" in sys.argv or " -n=" in args or args == "-c")
+        and not multi_proxy
+    ):
+        # Single-threaded
+        proxy_dir_lock = fasteners.InterProcessLock(PROXY_DIR_LOCK)
+        with proxy_dir_lock:
+            proxy_helper.create_proxy_ext(
+                proxy_string,
+                proxy_user,
+                proxy_pass,
+                bypass_list,
+                zip_it=False,
+            )
+            proxy_dir_path = proxy_helper.PROXY_DIR_PATH
+            extension_dir = __add_chrome_ext_dir(
+                extension_dir, proxy_dir_path
+            )
+    else:
+        # Multi-threaded
+        proxy_dir_lock = fasteners.InterProcessLock(PROXY_DIR_LOCK)
+        with proxy_dir_lock:
+            with suppress(Exception):
+                shared_utils.make_writable(PROXY_DIR_LOCK)
+            if multi_proxy:
+                __set_proxy_filenames()
+            if not os.path.exists(proxy_helper.PROXY_DIR_PATH):
+                proxy_helper.create_proxy_ext(
+                    proxy_string,
+                    proxy_user,
+                    proxy_pass,
+                    bypass_list,
+                    zip_it=False,
+                )
+            extension_dir = __add_chrome_ext_dir(
+                extension_dir, proxy_helper.PROXY_DIR_PATH
+            )
+    return extension_dir
+
+
 async def start(
     config: Optional[Config] = None,
     *,
@@ -149,12 +232,14 @@ async def start(
     browser_args: Optional[List[str]] = None,
     xvfb_metrics: Optional[List[str]] = None,  # "Width,Height" for Linux
     sandbox: Optional[bool] = True,
-    lang: Optional[str] = None,
-    host: Optional[str] = None,
-    port: Optional[int] = None,
+    lang: Optional[str] = None,  # Set the Language Locale Code
+    host: Optional[str] = None,  # Chrome remote-debugging-host
+    port: Optional[int] = None,  # Chrome remote-debugging-port
     xvfb: Optional[int] = None,  # Use a special virtual display on Linux
     headed: Optional[bool] = None,  # Override default Xvfb mode on Linux
     expert: Optional[bool] = None,  # Open up closed Shadow-root elements
+    proxy: Optional[str] = None,  # "host:port" or "user:pass@host:port"
+    extension_dir: Optional[str] = None,  # Chrome extension directory
     **kwargs: Optional[dict],
 ) -> Browser:
     """
@@ -199,6 +284,18 @@ async def start(
     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 proxy and "@" in str(proxy):
+        user_with_pass = proxy.split("@")[0]
+        if ":" in user_with_pass:
+            proxy_user = user_with_pass.split(":")[0]
+            proxy_pass = user_with_pass.split(":")[1]
+            proxy_string = proxy.split("@")[1]
+            extension_dir = __add_chrome_proxy_extension(
+                extension_dir,
+                proxy_string,
+                proxy_user,
+                proxy_pass,
+            )
     if not config:
         config = Config(
             user_data_dir,
@@ -212,13 +309,27 @@ async def start(
             host=host,
             port=port,
             expert=expert,
+            proxy=proxy,
+            extension_dir=extension_dir,
             **kwargs,
         )
+    driver = None
     try:
-        return await Browser.create(config)
+        driver = await Browser.create(config)
     except Exception:
         time.sleep(0.15)
-        return await Browser.create(config)
+        driver = await Browser.create(config)
+    if proxy and "@" in str(proxy):
+        time.sleep(0.15)
+    if lang:
+        sb_config._cdp_locale = lang
+    elif "locale" in kwargs:
+        sb_config._cdp_locale = kwargs["locale"]
+    elif "locale_code" in kwargs:
+        sb_config._cdp_locale = kwargs["locale_code"]
+    else:
+        sb_config._cdp_locale = None
+    return driver
 
 
 async def start_async(*args, **kwargs) -> Browser:
@@ -226,7 +337,15 @@ async def start_async(*args, **kwargs) -> Browser:
     binary_location = None
     if "browser_executable_path" in kwargs:
         binary_location = kwargs["browser_executable_path"]
-    if shared_utils.is_chrome_130_or_newer(binary_location):
+    else:
+        binary_location = detect_b_ver.get_binary_location("google-chrome")
+        if binary_location and not os.path.exists(binary_location):
+            binary_location = None
+    if (
+        shared_utils.is_chrome_130_or_newer(binary_location)
+        and "user_data_dir" in kwargs
+        and kwargs["user_data_dir"]
+    ):
         if "headless" in kwargs:
             headless = kwargs["headless"]
         decoy_args = kwargs
@@ -241,12 +360,28 @@ async def start_async(*args, **kwargs) -> Browser:
 
 
 def start_sync(*args, **kwargs) -> Browser:
-    loop = asyncio.get_event_loop()
+    loop = None
+    if (
+        "loop" in kwargs
+        and kwargs["loop"]
+        and hasattr(kwargs["loop"], "create_task")
+    ):
+        loop = kwargs["loop"]
+    else:
+        loop = asyncio.new_event_loop()
     headless = False
     binary_location = None
     if "browser_executable_path" in kwargs:
         binary_location = kwargs["browser_executable_path"]
-    if shared_utils.is_chrome_130_or_newer(binary_location):
+    else:
+        binary_location = detect_b_ver.get_binary_location("google-chrome")
+        if binary_location and not os.path.exists(binary_location):
+            binary_location = None
+    if (
+        shared_utils.is_chrome_130_or_newer(binary_location)
+        and "user_data_dir" in kwargs
+        and kwargs["user_data_dir"]
+    ):
         if "headless" in kwargs:
             headless = kwargs["headless"]
         decoy_args = kwargs

seleniumbase/undetected/cdp_driver/config.py

@@ -40,6 +40,8 @@ class Config:
         host: str = AUTO,
         port: int = AUTO,
         expert: bool = AUTO,
+        proxy: Optional[str] = None,
+        extension_dir: Optional[str] = None,
         **kwargs: dict,
     ):
         """
@@ -91,6 +93,8 @@ class Config:
         self.host = host
         self.port = port
         self.expert = expert
+        self.proxy = proxy
+        self.extension_dir = extension_dir
         self._extensions = []
         # When using posix-ish operating system and running as root,
         # you must use no_sandbox=True
@@ -195,6 +199,12 @@ class Config:
                 "--disable-web-security",
                 "--disable-site-isolation-trials",
             ]
+        if self.proxy:
+            args.append("--proxy-server=%s" % self.proxy.split("@")[-1])
+            args.append("--ignore-certificate-errors")
+            args.append("--ignore-ssl-errors=yes")
+        if self.extension_dir:
+            args.append("--load-extension=%s" % self.extension_dir)
         if self._browser_args:
             args.extend([arg for arg in self._browser_args if arg not in args])
         if self.headless:

seleniumbase/undetected/cdp_driver/connection.py

@@ -382,7 +382,7 @@ class Connection(metaclass=CantTouchThis):
     async def send(
         self,
         cdp_obj: Generator[dict[str, Any], dict[str, Any], Any],
-        _is_update=False,
+        _is_update=True,
     ) -> Any:
         """
         Send a protocol command.

seleniumbase/undetected/cdp_driver/tab.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 import asyncio
+import base64
+import datetime
 import logging
 import pathlib
+import urllib.parse
 import warnings
 from typing import Dict, List, Union, Optional, Tuple
 from . import browser as cdp_browser
@@ -852,6 +855,7 @@ class Tab(Connection):
             await self.send(
                 cdp.target.close_target(target_id=self.target.target_id)
             )
+            await asyncio.sleep(0.1)
 
     async def get_window(self) -> Tuple[
         cdp.browser.WindowID, cdp.browser.Bounds
@@ -896,6 +900,10 @@ class Tab(Connection):
         """
         return await self.set_window_state(left, top, width, height)
 
+    async def set_window_rect(self, left=0, top=0, width=1280, height=1024):
+        """Same as set_window_size(). Uses a different naming convention."""
+        return await self.set_window_state(left, top, width, height)
+
     async def activate(self):
         """Active this target (Eg: tab, window, page)"""
         await self.send(cdp.target.activate_target(self.target.target_id))
@@ -1128,9 +1136,6 @@ class Tab(Connection):
         :return: The path/filename of the saved screenshot.
         :rtype: str
         """
-        import urllib.parse
-        import datetime
-
         await self.sleep()  # Update the target's URL
         path = None
         if format.lower() in ["jpg", "jpeg"]:
@@ -1161,8 +1166,40 @@ class Tab(Connection):
                 "Most possible cause is the page "
                 "has not finished loading yet."
             )
-        import base64
+        data_bytes = base64.b64decode(data)
+        if not path:
+            raise RuntimeError("Invalid filename or path: '%s'" % filename)
+        path.write_bytes(data_bytes)
+        return str(path)
 
+    async def print_to_pdf(
+        self,
+        filename: Optional[PathLike] = "auto",
+    ) -> str:
+        """
+        Saves a webpage as a PDF.
+        :param filename: uses this as the save path
+        :type filename: PathLike
+        :return: The path/filename of the saved screenshot.
+        :rtype: str
+        """
+        await self.sleep()  # Update the target's URL
+        path = None
+        ext = ".pdf"
+        if not filename or filename == "auto":
+            parsed = urllib.parse.urlparse(self.target.url)
+            parts = parsed.path.split("/")
+            last_part = parts[-1]
+            last_part = last_part.rsplit("?", 1)[0]
+            dt_str = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+            candidate = f"{parsed.hostname}__{last_part}_{dt_str}"
+            path = pathlib.Path(candidate + ext)  # noqa
+        else:
+            path = pathlib.Path(filename)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        data, _ = await self.send(cdp.page.print_to_pdf())
+        if not data:
+            raise ProtocolException("Could not save PDF.")
         data_bytes = base64.b64decode(data)
         if not path:
             raise RuntimeError("Invalid filename or path: '%s'" % filename)

seleniumbase/undetected/webelement.py

@@ -26,10 +26,11 @@ class WebElement(selenium.webdriver.remote.webelement.WebElement):
                 driver.js_click(selector, by=by, timeout=1)
         else:
             super().click()
+        driver = self._parent
         if not reconnect_time:
-            self._parent.reconnect(0.5)
+            driver.reconnect(0.5)
         else:
-            self._parent.reconnect(reconnect_time)
+            driver.reconnect(reconnect_time)
 
     def uc_reconnect(self, reconnect_time=None):
         if not reconnect_time: