seleniumbase 4.27.5__py3-none-any.whl → 4.28.0__py3-none-any.whl

seleniumbase/__init__.py

@@ -1,4 +1,5 @@
 import collections
+import os
 import pdb
 try:
     import pdbp  # (Pdb+) --- Python Debugger Plus
@@ -34,11 +35,13 @@ if sys.version_info[0] < 3 and "pdbp" in locals():
         pdb.DefaultConfig.truncate_long_lines = False
         pdb.DefaultConfig.sticky_by_default = True
 colored_traceback.add_hook()
+os.environ["SE_AVOID_STATS"] = "true"  # Disable Selenium Manager stats
 if sys.version_info >= (3, 7):
     webdriver.TouchActions = None  # Lifeline for past selenium-wire versions
 if sys.version_info >= (3, 10):
     collections.Callable = collections.abc.Callable  # Lifeline for nosetests
 del collections  # Undo "import collections" / Simplify "dir(seleniumbase)"
+del os  # Undo "import os" / Simplify "dir(seleniumbase)"
 del sys  # Undo "import sys" / Simplify "dir(seleniumbase)"
 del webdriver  # Undo "import webdriver" / Simplify "dir(seleniumbase)"
 

seleniumbase/__version__.py

@@ -1,2 +1,2 @@
 # seleniumbase package
-__version__ = "4.27.5"
+__version__ = "4.28.0"

seleniumbase/behave/behave_sb.py

@@ -862,14 +862,17 @@ def get_configured_sb(context):
         and not sb.headless2
         and not sb.xvfb
     ):
-        print(
-            '(Linux uses "-D headless" by default. '
-            'To override, use "-D headed" / "-D gui". '
-            'For Xvfb mode instead, use "-D xvfb". '
-            "Or you can hide this info by using"
-            '"-D headless" / "-D headless2".)'
-        )
-        sb.headless = True
+        if not sb.undetectable:
+            print(
+                '(Linux uses "-D headless" by default. '
+                'To override, use "-D headed" / "-D gui". '
+                'For Xvfb mode instead, use "-D xvfb". '
+                "Or you can hide this info by using"
+                '"-D headless" / "-D headless2" / "-D uc".)'
+            )
+            sb.headless = True
+        else:
+            sb.xvfb = True
     # Recorder Mode can still optimize scripts in --headless2 mode.
     if sb.recorder_mode and sb.headless:
         sb.headless = False

seleniumbase/core/browser_launcher.py

@@ -11,6 +11,7 @@ import urllib3
 import warnings
 from selenium import webdriver
 from selenium.common.exceptions import ElementClickInterceptedException
+from selenium.common.exceptions import InvalidSessionIdException
 from selenium.webdriver.chrome.service import Service as ChromeService
 from selenium.webdriver.common.options import ArgOptions
 from selenium.webdriver.common.service import utils as service_utils
@@ -28,6 +29,7 @@ from seleniumbase.core import proxy_helper
 from seleniumbase.core import sb_driver
 from seleniumbase.fixtures import constants
 from seleniumbase.fixtures import js_utils
+from seleniumbase.fixtures import page_actions
 from seleniumbase.fixtures import shared_utils
 
 urllib3.disable_warnings()
@@ -130,9 +132,13 @@ def extend_driver(driver):
     page.assert_element_not_visible = DM.assert_element_not_visible
     page.assert_text = DM.assert_text
     page.assert_exact_text = DM.assert_exact_text
+    page.assert_non_empty_text = DM.assert_non_empty_text
+    page.assert_text_not_visible = DM.assert_text_not_visible
     page.wait_for_element = DM.wait_for_element
     page.wait_for_text = DM.wait_for_text
     page.wait_for_exact_text = DM.wait_for_exact_text
+    page.wait_for_non_empty_text = DM.wait_for_non_empty_text
+    page.wait_for_text_not_visible = DM.wait_for_text_not_visible
     page.wait_for_and_accept_alert = DM.wait_for_and_accept_alert
     page.wait_for_and_dismiss_alert = DM.wait_for_and_dismiss_alert
     page.is_element_present = DM.is_element_present
@@ -140,12 +146,20 @@ def extend_driver(driver):
     page.is_text_visible = DM.is_text_visible
     page.is_exact_text_visible = DM.is_exact_text_visible
     page.is_attribute_present = DM.is_attribute_present
+    page.is_non_empty_text_visible = DM.is_non_empty_text_visible
     page.get_text = DM.get_text
     page.find_element = DM.find_element
     page.find_elements = DM.find_elements
     page.locator = DM.locator
     page.get_page_source = DM.get_page_source
     page.get_title = DM.get_title
+    page.switch_to_default_window = DM.switch_to_default_window
+    page.switch_to_newest_window = DM.switch_to_newest_window
+    page.open_new_window = DM.open_new_window
+    page.open_new_tab = DM.open_new_tab
+    page.switch_to_window = DM.switch_to_window
+    page.switch_to_tab = DM.switch_to_tab
+    page.switch_to_frame = DM.switch_to_frame
     driver.page = page
     js = types.SimpleNamespace()
     js.js_click = DM.js_click
@@ -169,12 +183,16 @@ def extend_driver(driver):
     driver.assert_element_not_visible = DM.assert_element_not_visible
     driver.assert_text = DM.assert_text
     driver.assert_exact_text = DM.assert_exact_text
+    driver.assert_non_empty_text = DM.assert_non_empty_text
+    driver.assert_text_not_visible = DM.assert_text_not_visible
     driver.wait_for_element = DM.wait_for_element
     driver.wait_for_element_visible = DM.wait_for_element_visible
     driver.wait_for_element_present = DM.wait_for_element_present
     driver.wait_for_selector = DM.wait_for_selector
     driver.wait_for_text = DM.wait_for_text
     driver.wait_for_exact_text = DM.wait_for_exact_text
+    driver.wait_for_non_empty_text = DM.wait_for_non_empty_text
+    driver.wait_for_text_not_visible = DM.wait_for_text_not_visible
     driver.wait_for_and_accept_alert = DM.wait_for_and_accept_alert
     driver.wait_for_and_dismiss_alert = DM.wait_for_and_dismiss_alert
     driver.is_element_present = DM.is_element_present
@@ -182,8 +200,10 @@ def extend_driver(driver):
     driver.is_text_visible = DM.is_text_visible
     driver.is_exact_text_visible = DM.is_exact_text_visible
     driver.is_attribute_present = DM.is_attribute_present
-    driver.get_text = DM.get_text
+    driver.is_non_empty_text_visible = DM.is_non_empty_text_visible
+    driver.is_online = DM.is_online
     driver.js_click = DM.js_click
+    driver.get_text = DM.get_text
     driver.get_active_element_css = DM.get_active_element_css
     driver.get_locale_code = DM.get_locale_code
     driver.get_origin = DM.get_origin
@@ -195,6 +215,12 @@ def extend_driver(driver):
     driver.get_attribute = DM.get_attribute
     driver.get_page_source = DM.get_page_source
     driver.get_title = DM.get_title
+    driver.switch_to_default_window = DM.switch_to_default_window
+    driver.switch_to_newest_window = DM.switch_to_newest_window
+    driver.open_new_window = DM.open_new_window
+    driver.open_new_tab = DM.open_new_tab
+    driver.switch_to_window = DM.switch_to_window
+    driver.switch_to_tab = DM.switch_to_tab
     driver.switch_to_frame = DM.switch_to_frame
     if hasattr(driver, "proxy"):
         driver.set_wire_proxy = DM.set_wire_proxy
@@ -409,7 +435,7 @@ def uc_open(driver, url):
     if (url.startswith("http:") or url.startswith("https:")):
         with driver:
             script = 'window.location.href = "%s";' % url
-            js_utils.call_me_later(driver, script, 33)
+            js_utils.call_me_later(driver, script, 5)
     else:
         driver.default_get(url)  # The original one
     return None
@@ -440,22 +466,28 @@ def uc_open_with_reconnect(driver, url, reconnect_time=None):
         url = "https://" + url
     if (url.startswith("http:") or url.startswith("https:")):
         script = 'window.open("%s","_blank");' % url
-        js_utils.call_me_later(driver, script, 3)
-        time.sleep(0.007)
+        driver.execute_script(script)
+        time.sleep(0.05)
         driver.close()
         if reconnect_time == "disconnect":
             driver.disconnect()
-            time.sleep(0.007)
+            time.sleep(0.008)
         else:
             driver.reconnect(reconnect_time)
-            driver.switch_to.window(driver.window_handles[-1])
+            time.sleep(0.004)
+            try:
+                driver.switch_to.window(driver.window_handles[-1])
+            except InvalidSessionIdException:
+                time.sleep(0.05)
+                driver.switch_to.window(driver.window_handles[-1])
     else:
         driver.default_get(url)  # The original one
     return None
 
 
-def uc_open_with_disconnect(driver, url):
+def uc_open_with_disconnect(driver, url, timeout=None):
     """Open a url and disconnect chromedriver.
+    Then waits for the duration of the timeout.
     Note: You can't perform Selenium actions again
     until after you've called driver.connect()."""
     if url.startswith("//"):
@@ -464,11 +496,16 @@ def uc_open_with_disconnect(driver, url):
         url = "https://" + url
     if (url.startswith("http:") or url.startswith("https:")):
         script = 'window.open("%s","_blank");' % url
-        js_utils.call_me_later(driver, script, 3)
-        time.sleep(0.007)
+        driver.execute_script(script)
+        time.sleep(0.05)
         driver.close()
         driver.disconnect()
-        time.sleep(0.007)
+        min_timeout = 0.008
+        if timeout and not str(timeout).replace(".", "", 1).isdigit():
+            timeout = min_timeout
+        if not timeout or timeout < min_timeout:
+            timeout = min_timeout
+        time.sleep(timeout)
     else:
         driver.default_get(url)  # The original one
     return None
@@ -490,7 +527,7 @@ def uc_click(
         pass
     element = driver.wait_for_selector(selector, by=by, timeout=timeout)
     tag_name = element.tag_name
-    if not tag_name == "span":  # Element must be "visible"
+    if not tag_name == "span" and not tag_name == "input":  # Must be "visible"
         element = driver.wait_for_element(selector, by=by, timeout=timeout)
     try:
         element.uc_click(
@@ -509,7 +546,154 @@ def uc_click(
             driver.reconnect(reconnect_time)
 
 
-def uc_switch_to_frame(driver, frame, reconnect_time=None):
+def verify_pyautogui_has_a_headed_browser():
+    """PyAutoGUI requires a headed browser so that it can
+    focus on the correct element when performing actions."""
+    if sb_config.headless or sb_config.headless2:
+        raise Exception(
+            "PyAutoGUI can't be used in headless mode!"
+        )
+
+
+def install_pyautogui_if_missing():
+    verify_pyautogui_has_a_headed_browser()
+    pip_find_lock = fasteners.InterProcessLock(
+        constants.PipInstall.FINDLOCK
+    )
+    with pip_find_lock:  # Prevent issues with multiple processes
+        try:
+            import pyautogui
+            try:
+                use_pyautogui_ver = constants.PyAutoGUI.VER
+                if pyautogui.__version__ != use_pyautogui_ver:
+                    del pyautogui
+                    shared_utils.pip_install(
+                        "pyautogui", version=use_pyautogui_ver
+                    )
+                    import pyautogui
+            except Exception:
+                pass
+        except Exception:
+            print("\nPyAutoGUI required! Installing now...")
+            shared_utils.pip_install(
+                "pyautogui", version=constants.PyAutoGUI.VER
+            )
+
+
+def get_configured_pyautogui(pyautogui_copy):
+    if (
+        IS_LINUX
+        and hasattr(pyautogui_copy, "_pyautogui_x11")
+        and "DISPLAY" in os.environ.keys()
+    ):
+        if (
+            hasattr(sb_config, "_pyautogui_x11_display")
+            and sb_config._pyautogui_x11_display
+            and hasattr(pyautogui_copy._pyautogui_x11, "_display")
+            and (
+                sb_config._pyautogui_x11_display
+                == pyautogui_copy._pyautogui_x11._display
+            )
+        ):
+            pass
+        else:
+            import Xlib.display
+            pyautogui_copy._pyautogui_x11._display = (
+                Xlib.display.Display(os.environ['DISPLAY'])
+            )
+            sb_config._pyautogui_x11_display = (
+                pyautogui_copy._pyautogui_x11._display
+            )
+    return pyautogui_copy
+
+
+def uc_gui_press_key(driver, key):
+    install_pyautogui_if_missing()
+    import pyautogui
+    pyautogui = get_configured_pyautogui(pyautogui)
+    gui_lock = fasteners.InterProcessLock(
+        constants.MultiBrowser.PYAUTOGUILOCK
+    )
+    with gui_lock:
+        pyautogui.press(key)
+
+
+def uc_gui_press_keys(driver, keys):
+    install_pyautogui_if_missing()
+    import pyautogui
+    pyautogui = get_configured_pyautogui(pyautogui)
+    gui_lock = fasteners.InterProcessLock(
+        constants.MultiBrowser.PYAUTOGUILOCK
+    )
+    with gui_lock:
+        for key in keys:
+            pyautogui.press(key)
+
+
+def uc_gui_write(driver, text):
+    install_pyautogui_if_missing()
+    import pyautogui
+    pyautogui = get_configured_pyautogui(pyautogui)
+    gui_lock = fasteners.InterProcessLock(
+        constants.MultiBrowser.PYAUTOGUILOCK
+    )
+    with gui_lock:
+        pyautogui.write(text)
+
+
+def uc_gui_handle_cf(driver, frame="iframe"):
+    source = driver.get_page_source()
+    if (
+        "//challenges.cloudflare.com" not in source
+        and 'aria-label="Cloudflare"' not in source
+    ):
+        return
+    install_pyautogui_if_missing()
+    import pyautogui
+    pyautogui = get_configured_pyautogui(pyautogui)
+    gui_lock = fasteners.InterProcessLock(
+        constants.MultiBrowser.PYAUTOGUILOCK
+    )
+    with gui_lock:  # Prevent issues with multiple processes
+        needs_switch = False
+        is_in_frame = js_utils.is_in_frame(driver)
+        if is_in_frame and driver.is_element_present("#challenge-stage"):
+            driver.switch_to.parent_frame()
+            needs_switch = True
+            is_in_frame = js_utils.is_in_frame(driver)
+        if not is_in_frame:
+            # Make sure the window is on top
+            page_actions.switch_to_window(
+                driver,
+                driver.current_window_handle,
+                timeout=settings.SMALL_TIMEOUT,
+            )
+        if not is_in_frame or needs_switch:
+            # Currently not in frame (or nested frame outside CF one)
+            try:
+                driver.switch_to_frame(frame)
+            except Exception:
+                if driver.is_element_present("iframe"):
+                    driver.switch_to_frame("iframe")
+                else:
+                    return
+        try:
+            driver.execute_script('document.querySelector("input").focus()')
+        except Exception:
+            try:
+                driver.switch_to.default_content()
+            except Exception:
+                return
+        driver.disconnect()
+        try:
+            pyautogui.press(" ")
+        except Exception:
+            pass
+    reconnect_time = (float(constants.UC.RECONNECT_TIME) / 2.0) + 0.5
+    driver.reconnect(reconnect_time)
+
+
+def uc_switch_to_frame(driver, frame="iframe", reconnect_time=None):
     from selenium.webdriver.remote.webelement import WebElement
     if isinstance(frame, WebElement):
         if not reconnect_time:
@@ -847,7 +1031,7 @@ def _set_chrome_options(
     prefs["download.prompt_for_download"] = False
     prefs["credentials_enable_service"] = False
     prefs["local_discovery.notifications_enabled"] = False
-    prefs["safebrowsing.enabled"] = False
+    prefs["safebrowsing.enabled"] = False  # Prevent PW "data breach" pop-ups
     prefs["safebrowsing.disable_download_protection"] = True
     prefs["omnibox-max-zero-suggest-matches"] = 0
     prefs["omnibox-use-existing-autocomplete-client"] = 0
@@ -1145,6 +1329,7 @@ def _set_chrome_options(
         chrome_options.add_argument("--auto-open-devtools-for-tabs")
     if user_agent:
         chrome_options.add_argument("--user-agent=%s" % user_agent)
+    chrome_options.add_argument("--safebrowsing-disable-download-protection")
     chrome_options.add_argument("--disable-browser-side-navigation")
     chrome_options.add_argument("--disable-save-password-bubble")
     chrome_options.add_argument("--disable-single-click-autofill")
@@ -1183,10 +1368,9 @@ def _set_chrome_options(
     included_disabled_features.append("DownloadBubbleV2")
     included_disabled_features.append("InsecureDownloadWarnings")
     included_disabled_features.append("InterestFeedContentSuggestions")
-    if user_data_dir:
-        included_disabled_features.append("PrivacySandboxSettings4")
-    if not is_using_uc(undetectable, browser_name) or user_data_dir:
-        included_disabled_features.append("SidePanelPinning")
+    included_disabled_features.append("PrivacySandboxSettings4")
+    included_disabled_features.append("SidePanelPinning")
+    included_disabled_features.append("UserAgentClientHint")
     for item in extra_disabled_features:
         if item not in included_disabled_features:
             included_disabled_features.append(item)
@@ -1374,7 +1558,7 @@ def _set_firefox_options(
                     f_pref_value = False
                 elif f_pref_value.isdigit():
                     f_pref_value = int(f_pref_value)
-                elif f_pref_value.isdecimal():
+                elif f_pref_value.replace(".", "", 1).isdigit():
                     f_pref_value = float(f_pref_value)
                 else:
                     pass  # keep as string
@@ -2438,7 +2622,7 @@ def get_local_driver(
             "credentials_enable_service": False,
             "local_discovery.notifications_enabled": False,
             "safebrowsing.disable_download_protection": True,
-            "safebrowsing.enabled": False,
+            "safebrowsing.enabled": False,  # Prevent PW "data breach" pop-ups
             "omnibox-max-zero-suggest-matches": 0,
             "omnibox-use-existing-autocomplete-client": 0,
             "omnibox-trending-zero-prefix-suggestions-on-ntp": 0,
@@ -2707,6 +2891,7 @@ def get_local_driver(
         edge_options.add_argument(
             "--disable-autofill-keyboard-accessory-view[8]"
         )
+        edge_options.add_argument("--safebrowsing-disable-download-protection")
         edge_options.add_argument("--disable-browser-side-navigation")
         edge_options.add_argument("--disable-translate")
         if not enable_ws:
@@ -2848,10 +3033,9 @@ def get_local_driver(
         included_disabled_features.append("OptimizationGuideModelDownloading")
         included_disabled_features.append("InsecureDownloadWarnings")
         included_disabled_features.append("InterestFeedContentSuggestions")
-        if user_data_dir:
-            included_disabled_features.append("PrivacySandboxSettings4")
-        if not is_using_uc(undetectable, browser_name) or user_data_dir:
-            included_disabled_features.append("SidePanelPinning")
+        included_disabled_features.append("PrivacySandboxSettings4")
+        included_disabled_features.append("SidePanelPinning")
+        included_disabled_features.append("UserAgentClientHint")
         for item in extra_disabled_features:
             if item not in included_disabled_features:
                 included_disabled_features.append(item)
@@ -3822,6 +4006,26 @@ def get_local_driver(
                     driver.uc_click = lambda *args, **kwargs: uc_click(
                         driver, *args, **kwargs
                     )
+                    driver.uc_gui_press_key = (
+                        lambda *args, **kwargs: uc_gui_press_key(
+                            driver, *args, **kwargs
+                        )
+                    )
+                    driver.uc_gui_press_keys = (
+                        lambda *args, **kwargs: uc_gui_press_keys(
+                            driver, *args, **kwargs
+                        )
+                    )
+                    driver.uc_gui_write = (
+                        lambda *args, **kwargs: uc_gui_write(
+                            driver, *args, **kwargs
+                        )
+                    )
+                    driver.uc_gui_handle_cf = (
+                        lambda *args, **kwargs: uc_gui_handle_cf(
+                            driver, *args, **kwargs
+                        )
+                    )
                     driver.uc_switch_to_frame = (
                         lambda *args, **kwargs: uc_switch_to_frame(
                             driver, *args, **kwargs

seleniumbase/core/sb_driver.py

@@ -94,6 +94,16 @@ class DriverMethods():
     def assert_exact_text(self, *args, **kwargs):
         page_actions.assert_exact_text(self.driver, *args, **kwargs)
 
+    def assert_non_empty_text(self, *args, **kwargs):
+        return page_actions.assert_non_empty_text(
+            self.driver, *args, **kwargs
+        )
+
+    def assert_text_not_visible(self, *args, **kwargs):
+        return page_actions.assert_text_not_visible(
+            self.driver, *args, **kwargs
+        )
+
     def wait_for_element(self, *args, **kwargs):
         return page_actions.wait_for_element(self.driver, *args, **kwargs)
 
@@ -112,6 +122,16 @@ class DriverMethods():
     def wait_for_exact_text(self, *args, **kwargs):
         return page_actions.wait_for_exact_text(self.driver, *args, **kwargs)
 
+    def wait_for_non_empty_text(self, *args, **kwargs):
+        return page_actions.wait_for_non_empty_text(
+            self.driver, *args, **kwargs
+        )
+
+    def wait_for_text_not_visible(self, *args, **kwargs):
+        return page_actions.wait_for_text_not_visible(
+            self.driver, *args, **kwargs
+        )
+
     def wait_for_and_accept_alert(self, *args, **kwargs):
         return page_actions.wait_for_and_accept_alert(
             self.driver, *args, **kwargs
@@ -134,14 +154,22 @@ class DriverMethods():
     def is_exact_text_visible(self, *args, **kwargs):
         return page_actions.is_exact_text_visible(self.driver, *args, **kwargs)
 
-    def get_text(self, *args, **kwargs):
-        return page_actions.get_text(self.driver, *args, **kwargs)
+    def is_attribute_present(self, *args, **kwargs):
+        return page_actions.has_attribute(self.driver, *args, **kwargs)
+
+    def is_non_empty_text_visible(self, *args, **kwargs):
+        return page_actions.is_non_empty_text_visible(
+            self.driver, *args, **kwargs
+        )
+
+    def is_online(self):
+        return self.driver.execute_script("return navigator.onLine;")
 
     def js_click(self, *args, **kwargs):
         return page_actions.js_click(self.driver, *args, **kwargs)
 
-    def is_attribute_present(self, *args, **kwargs):
-        return page_actions.has_attribute(self.driver, *args, **kwargs)
+    def get_text(self, *args, **kwargs):
+        return page_actions.get_text(self.driver, *args, **kwargs)
 
     def get_active_element_css(self, *args, **kwargs):
         return js_utils.get_active_element_css(self.driver, *args, **kwargs)
@@ -182,7 +210,32 @@ class DriverMethods():
         if self.is_element_visible(selector, by=by):
             self.highlight(selector, by=by, loops=loops, scroll=scroll)
 
-    def switch_to_frame(self, frame):
+    def switch_to_default_window(self):
+        self.driver.switch_to.window(self.driver.window_handles[0])
+
+    def switch_to_newest_window(self):
+        self.driver.switch_to.window(self.driver.window_handles[-1])
+
+    def open_new_window(self, switch_to=True):
+        if switch_to:
+            try:
+                self.driver.switch_to.new_window("tab")
+            except Exception:
+                self.driver.execute_script("window.open('');")
+                self.switch_to_newest_window()
+        else:
+            self.driver.execute_script("window.open('');")
+
+    def open_new_tab(self, switch_to=True):
+        self.open_new_window(switch_to=switch_to)
+
+    def switch_to_window(self, *args, **kwargs):
+        page_actions.switch_to_window(self.driver, *args, **kwargs)
+
+    def switch_to_tab(self, *args, **kwargs):
+        self.switch_to_window(*args, **kwargs)
+
+    def switch_to_frame(self, frame="iframe"):
         if isinstance(frame, WebElement):
             self.driver.switch_to.frame(frame)
         else: