seleniumbase 4.33.6__tar.gz → 4.33.8__tar.gz

{seleniumbase-4.33.6/seleniumbase.egg-info → seleniumbase-4.33.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: seleniumbase
-Version: 4.33.6
+Version: 4.33.8
 Summary: A complete web automation framework for end-to-end testing.
 Home-page: https://github.com/seleniumbase/SeleniumBase
 Author: Michael Mintz

{seleniumbase-4.33.6 → seleniumbase-4.33.8}/examples/raw_pixelscan.py

@@ -1,7 +1,7 @@
 from seleniumbase import SB
 
 with SB(uc=True, incognito=True, test=True) as sb:
-    sb.driver.uc_open_with_reconnect("https://pixelscan.net/", 10)
+    sb.driver.uc_open_with_reconnect("https://pixelscan.net/", 7)
     sb.remove_elements("div.banner")  # Remove the banner
     sb.remove_elements("jdiv")  # Remove chat widgets
     no_automation_detected = "No automation framework detected"

{seleniumbase-4.33.6 → seleniumbase-4.33.8}/examples/raw_recaptcha.py

@@ -1,16 +1,18 @@
 from seleniumbase import SB
 
-with SB(uc=True, test=True) as sb:
+with SB(uc=True, test=True, incognito=True) as sb:
     url = "https://seleniumbase.io/apps/recaptcha"
     sb.activate_cdp_mode(url)
+    sb.sleep(1)
     sb.uc_gui_handle_captcha()  # Try with TAB + SPACEBAR
     sb.assert_element("img#captcha-success", timeout=3)
     sb.set_messenger_theme(location="top_left")
     sb.post_message("SeleniumBase wasn't detected", duration=3)
 
-with SB(uc=True, test=True) as sb:
+with SB(uc=True, test=True, incognito=True) as sb:
     url = "https://seleniumbase.io/apps/recaptcha"
     sb.activate_cdp_mode(url)
+    sb.sleep(1)
     sb.uc_gui_click_captcha('iframe[src*="/recaptcha/"]')
     sb.assert_element("img#captcha-success", timeout=3)
     sb.set_messenger_theme(location="top_left")

{seleniumbase-4.33.6 → seleniumbase-4.33.8}/seleniumbase/__version__.py

@@ -1,2 +1,2 @@
 # seleniumbase package
-__version__ = "4.33.6"
+__version__ = "4.33.8"

{seleniumbase-4.33.6 → seleniumbase-4.33.8}/seleniumbase/core/browser_launcher.py

@@ -658,6 +658,7 @@ def uc_open_with_cdp_mode(driver, url=None):
     cdp.get_window = CDPM.get_window
     cdp.get_element_attributes = CDPM.get_element_attributes
     cdp.get_element_attribute = CDPM.get_element_attribute
+    cdp.get_attribute = CDPM.get_attribute
     cdp.get_element_html = CDPM.get_element_html
     cdp.get_element_rect = CDPM.get_element_rect
     cdp.get_element_size = CDPM.get_element_size
@@ -1413,7 +1414,7 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
             ctype = "cf_t"
         else:
             return
-    if not driver.is_connected():
+    if not driver.is_connected() and not __is_cdp_swap_needed(driver):
         driver.connect()
         time.sleep(2)
     install_pyautogui_if_missing(driver)
@@ -1425,7 +1426,10 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
     )
     with gui_lock:  # Prevent issues with multiple processes
         needs_switch = False
-        is_in_frame = js_utils.is_in_frame(driver)
+        if not __is_cdp_swap_needed(driver):
+            is_in_frame = js_utils.is_in_frame(driver)
+        else:
+            is_in_frame = False
         selector = "#challenge-stage"
         if ctype == "g_rc":
             selector = "#recaptcha-token"
@@ -1433,7 +1437,7 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
             driver.switch_to.parent_frame()
             needs_switch = True
             is_in_frame = js_utils.is_in_frame(driver)
-        if not is_in_frame:
+        if not is_in_frame and not __is_cdp_swap_needed(driver):
             # Make sure the window is on top
             page_actions.switch_to_window(
                 driver, driver.current_window_handle, 2, uc_lock=False
@@ -1500,17 +1504,18 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
                 and frame == "iframe"
             ):
                 frame = 'iframe[title="reCAPTCHA"]'
-        if not is_in_frame or needs_switch:
-            # Currently not in frame (or nested frame outside CF one)
-            try:
-                if visible_iframe or ctype == "g_rc":
-                    driver.switch_to_frame(frame)
-            except Exception:
-                if visible_iframe or ctype == "g_rc":
-                    if driver.is_element_present("iframe"):
-                        driver.switch_to_frame("iframe")
-                    else:
-                        return
+        if not __is_cdp_swap_needed(driver):
+            if not is_in_frame or needs_switch:
+                # Currently not in frame (or nested frame outside CF one)
+                try:
+                    if visible_iframe or ctype == "g_rc":
+                        driver.switch_to_frame(frame)
+                except Exception:
+                    if visible_iframe or ctype == "g_rc":
+                        if driver.is_element_present("iframe"):
+                            driver.switch_to_frame("iframe")
+                        else:
+                            return
         try:
             selector = "div.cf-turnstile"
             if ctype == "g_rc":
@@ -1526,11 +1531,11 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
                 tab_count += 1
                 time.sleep(0.027)
                 active_element_css = js_utils.get_active_element_css(driver)
-                print(active_element_css)
                 if (
                     active_element_css.startswith(selector)
                     or active_element_css.endswith(" > div" * 2)
                     or (special_form and active_element_css.endswith(" div"))
+                    or (ctype == "g_rc" and "frame[name" in active_element_css)
                 ):
                     found_checkbox = True
                     sb_config._saved_cf_tab_count = tab_count
@@ -1550,6 +1555,7 @@ def _uc_gui_handle_captcha_(driver, frame="iframe", ctype=None):
             )
             and hasattr(sb_config, "_saved_cf_tab_count")
             and sb_config._saved_cf_tab_count
+            and not __is_cdp_swap_needed(driver)
         ):
             driver.uc_open_with_disconnect(driver.current_url, 3.8)
             with suppress(Exception):
@@ -1764,17 +1770,27 @@ def _add_chrome_proxy_extension(
     ):
         # Single-threaded
         if zip_it:
-            proxy_helper.create_proxy_ext(
-                proxy_string, proxy_user, proxy_pass, bypass_list
-            )
-            proxy_zip = proxy_helper.PROXY_ZIP_PATH
-            chrome_options.add_extension(proxy_zip)
+            proxy_zip_lock = fasteners.InterProcessLock(PROXY_ZIP_LOCK)
+            with proxy_zip_lock:
+                proxy_helper.create_proxy_ext(
+                    proxy_string, proxy_user, proxy_pass, bypass_list
+                )
+                proxy_zip = proxy_helper.PROXY_ZIP_PATH
+                chrome_options.add_extension(proxy_zip)
         else:
-            proxy_helper.create_proxy_ext(
-                proxy_string, proxy_user, proxy_pass, bypass_list, zip_it=False
-            )
-            proxy_dir_path = proxy_helper.PROXY_DIR_PATH
-            chrome_options = add_chrome_ext_dir(chrome_options, proxy_dir_path)
+            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
+                chrome_options = add_chrome_ext_dir(
+                    chrome_options, proxy_dir_path
+                )
     else:
         # Multi-threaded
         if zip_it:
@@ -1803,7 +1819,7 @@ def _add_chrome_proxy_extension(
                         proxy_user,
                         proxy_pass,
                         bypass_list,
-                        False,
+                        zip_it=False,
                     )
                 chrome_options = add_chrome_ext_dir(
                     chrome_options, proxy_helper.PROXY_DIR_PATH
@@ -2306,7 +2322,6 @@ def _set_chrome_options(
     chrome_options.add_argument("--disable-ipc-flooding-protection")
     chrome_options.add_argument("--disable-password-generation")
     chrome_options.add_argument("--disable-domain-reliability")
-    chrome_options.add_argument("--disable-component-update")
     chrome_options.add_argument("--disable-breakpad")
     included_disabled_features = []
     included_disabled_features.append("OptimizationHints")
@@ -4056,7 +4071,6 @@ def get_local_driver(
         edge_options.add_argument("--disable-ipc-flooding-protection")
         edge_options.add_argument("--disable-password-generation")
         edge_options.add_argument("--disable-domain-reliability")
-        edge_options.add_argument("--disable-component-update")
         edge_options.add_argument("--disable-breakpad")
         included_disabled_features = []
         included_disabled_features.append("OptimizationHints")
@@ -4845,7 +4859,12 @@ def get_local_driver(
                                 )
                                 uc_activated = True
                             except URLError as e:
-                                if cert in e.args[0] and IS_MAC:
+                                if (
+                                    IS_MAC
+                                    and hasattr(e, "args")
+                                    and isinstance(e.args, (list, tuple))
+                                    and cert in e.args[0]
+                                ):
                                     mac_certificate_error = True
                                 else:
                                     raise

{seleniumbase-4.33.6 → seleniumbase-4.33.8}/seleniumbase/core/log_helper.py

@@ -7,6 +7,7 @@ from contextlib import suppress
 from seleniumbase import config as sb_config
 from seleniumbase.config import settings
 from seleniumbase.fixtures import constants
+from seleniumbase.fixtures import shared_utils
 
 python3_11_or_newer = False
 if sys.version_info >= (3, 11):
@@ -33,6 +34,8 @@ def log_screenshot(test_logpath, driver, screenshot=None, get=False):
         if screenshot != screenshot_warning:
             with open(screenshot_path, "wb") as file:
                 file.write(screenshot)
+            with suppress(Exception):
+                shared_utils.make_writable(screenshot_path)
         else:
             print("WARNING: %s" % screenshot_warning)
         if get:
@@ -282,13 +285,14 @@ def log_test_failure_data(test, test_logpath, driver, browser, url=None):
         sb_config._report_time = the_time
         sb_config._report_traceback = traceback_message
         sb_config._report_exception = exc_message
-    with suppress(Exception):
-        if not os.path.exists(test_logpath):
+    if not os.path.exists(test_logpath):
+        with suppress(Exception):
             os.makedirs(test_logpath)
     with suppress(Exception):
         log_file = codecs.open(basic_file_path, "w+", encoding="utf-8")
         log_file.writelines("\r\n".join(data_to_save))
         log_file.close()
+        shared_utils.make_writable(basic_file_path)
 
 
 def log_skipped_test_data(test, test_logpath, driver, browser, reason):
@@ -343,6 +347,7 @@ def log_skipped_test_data(test, test_logpath, driver, browser, reason):
         log_file = codecs.open(file_path, "w+", encoding="utf-8")
         log_file.writelines("\r\n".join(data_to_save))
         log_file.close()
+        shared_utils.make_writable(file_path)
 
 
 def log_page_source(test_logpath, driver, source=None):
@@ -365,14 +370,15 @@ def log_page_source(test_logpath, driver, source=None):
                 "unresponsive, or closed prematurely!</h4>"
             )
         )
-    with suppress(Exception):
-        if not os.path.exists(test_logpath):
+    if not os.path.exists(test_logpath):
+        with suppress(Exception):
             os.makedirs(test_logpath)
     html_file_path = os.path.join(test_logpath, html_file_name)
     with suppress(Exception):
         html_file = codecs.open(html_file_path, "w+", encoding="utf-8")
         html_file.write(page_source)
         html_file.close()
+        shared_utils.make_writable(html_file_path)
 
 
 def get_test_id(test):

{seleniumbase-4.33.6 → seleniumbase-4.33.8}/seleniumbase/core/proxy_helper.py

@@ -2,10 +2,12 @@ import os
 import re
 import warnings
 import zipfile
+from contextlib import suppress
 from seleniumbase.config import proxy_list
 from seleniumbase.config import settings
 from seleniumbase.fixtures import constants
 from seleniumbase.fixtures import page_utils
+from seleniumbase.fixtures import shared_utils
 
 DOWNLOADS_DIR = constants.Files.DOWNLOADS_FOLDER
 PROXY_ZIP_PATH = os.path.join(DOWNLOADS_DIR, "proxy.zip")
@@ -109,31 +111,35 @@ def create_proxy_ext(
         """"minimum_chrome_version":"22.0.0"\n"""
         """}"""
     )
-    import threading
-
-    lock = threading.RLock()  # Support multi-threaded tests. Eg. "pytest -n=4"
-    with lock:
-        abs_path = os.path.abspath(".")
-        downloads_path = os.path.join(abs_path, DOWNLOADS_DIR)
-        if not os.path.exists(downloads_path):
-            os.mkdir(downloads_path)
-        if zip_it:
-            zf = zipfile.ZipFile(PROXY_ZIP_PATH, mode="w")
-            zf.writestr("background.js", background_js)
-            zf.writestr("manifest.json", manifest_json)
-            zf.close()
-        else:
-            proxy_ext_dir = PROXY_DIR_PATH
-            if not os.path.exists(proxy_ext_dir):
-                os.mkdir(proxy_ext_dir)
-            manifest_file = os.path.join(proxy_ext_dir, "manifest.json")
-            with open(manifest_file, mode="w") as f:
-                f.write(manifest_json)
-            proxy_host = proxy_string.split(":")[0]
-            proxy_port = proxy_string.split(":")[1]
-            background_file = os.path.join(proxy_ext_dir, "background.js")
-            with open(background_file, mode="w") as f:
-                f.write(background_js)
+    abs_path = os.path.abspath(".")
+    downloads_path = os.path.join(abs_path, DOWNLOADS_DIR)
+    if not os.path.exists(downloads_path):
+        os.mkdir(downloads_path)
+    if zip_it:
+        zf = zipfile.ZipFile(PROXY_ZIP_PATH, mode="w")
+        zf.writestr("background.js", background_js)
+        zf.writestr("manifest.json", manifest_json)
+        zf.close()
+        with suppress(Exception):
+            shared_utils.make_writable(PROXY_ZIP_PATH)
+    else:
+        proxy_ext_dir = PROXY_DIR_PATH
+        if not os.path.exists(proxy_ext_dir):
+            os.mkdir(proxy_ext_dir)
+        with suppress(Exception):
+            shared_utils.make_writable(proxy_ext_dir)
+        manifest_file = os.path.join(proxy_ext_dir, "manifest.json")
+        with open(manifest_file, mode="w") as f:
+            f.write(manifest_json)
+        with suppress(Exception):
+            shared_utils.make_writable(manifest_json)
+        proxy_host = proxy_string.split(":")[0]
+        proxy_port = proxy_string.split(":")[1]
+        background_file = os.path.join(proxy_ext_dir, "background.js")
+        with open(background_file, mode="w") as f:
+            f.write(background_js)
+        with suppress(Exception):
+            shared_utils.make_writable(background_js)
 
 
 def remove_proxy_zip_if_present():
@@ -141,13 +147,12 @@ def remove_proxy_zip_if_present():
     Used in the implementation of https://stackoverflow.com/a/35293284
     for https://stackoverflow.com/questions/12848327/
     """
-    try:
-        if os.path.exists(PROXY_ZIP_PATH):
+    if os.path.exists(PROXY_ZIP_PATH):
+        with suppress(Exception):
             os.remove(PROXY_ZIP_PATH)
-        if os.path.exists(PROXY_ZIP_LOCK):
+    if os.path.exists(PROXY_ZIP_LOCK):
+        with suppress(Exception):
             os.remove(PROXY_ZIP_LOCK)
-    except Exception:
-        pass
 
 
 def validate_proxy_string(proxy_string):

{seleniumbase-4.33.6 → seleniumbase-4.33.8}/seleniumbase/core/sb_cdp.py

@@ -83,6 +83,9 @@ class CDPMethods():
         element.get_position = lambda: self.__get_position(element)
         element.get_html = lambda: self.__get_html(element)
         element.get_js_attributes = lambda: self.__get_js_attributes(element)
+        element.get_attribute = (
+            lambda attribute: self.__get_attribute(element, attribute)
+        )
         return element
 
     def get(self, url):
@@ -268,6 +271,7 @@ class CDPMethods():
         if number < 0:
             number = 0
         element = elements[number]
+        element.scroll_into_view()
         element.click()
 
     def click_nth_visible_element(self, selector, number):
@@ -284,6 +288,7 @@ class CDPMethods():
         if number < 0:
             number = 0
         element = elements[number]
+        element.scroll_into_view()
         element.click()
 
     def click_link(self, link_text):
@@ -311,6 +316,13 @@ class CDPMethods():
         return result
 
     def __flash(self, element, *args, **kwargs):
+        element.scroll_into_view()
+        if len(args) < 3 and "x_offset" not in kwargs:
+            x_offset = self.__get_x_scroll_offset()
+            kwargs["x_offset"] = x_offset
+        if len(args) < 3 and "y_offset" not in kwargs:
+            y_offset = self.__get_y_scroll_offset()
+            kwargs["y_offset"] = y_offset
         return (
             self.loop.run_until_complete(
                 element.flash_async(*args, **kwargs)
@@ -382,9 +394,9 @@ class CDPMethods():
         )
 
     def __scroll_into_view(self, element):
-        return (
-            self.loop.run_until_complete(element.scroll_into_view_async())
-        )
+        self.loop.run_until_complete(element.scroll_into_view_async())
+        self.__add_light_pause()
+        return None
 
     def __select_option(self, element):
         return (
@@ -431,6 +443,24 @@ class CDPMethods():
             self.loop.run_until_complete(element.get_js_attributes_async())
         )
 
+    def __get_attribute(self, element, attribute):
+        try:
+            return element.get_js_attributes()[attribute]
+        except Exception:
+            return None
+
+    def __get_x_scroll_offset(self):
+        x_scroll_offset = self.loop.run_until_complete(
+            self.page.evaluate("window.pageXOffset")
+        )
+        return x_scroll_offset or 0
+
+    def __get_y_scroll_offset(self):
+        y_scroll_offset = self.loop.run_until_complete(
+            self.page.evaluate("window.pageYOffset")
+        )
+        return y_scroll_offset or 0
+
     def tile_windows(self, windows=None, max_columns=0):
         """Tile windows and return the grid of tiled windows."""
         driver = self.driver
@@ -504,7 +534,7 @@ class CDPMethods():
     def click(self, selector, timeout=settings.SMALL_TIMEOUT):
         self.__slow_mode_pause_if_set()
         element = self.find_element(selector, timeout=timeout)
-        self.__add_light_pause()
+        element.scroll_into_view()
         element.click()
         self.__slow_mode_pause_if_set()
         self.loop.run_until_complete(self.page.wait())
@@ -518,7 +548,9 @@ class CDPMethods():
 
     def click_if_visible(self, selector):
         if self.is_element_visible(selector):
-            self.find_element(selector).click()
+            element = self.find_element(selector)
+            element.scroll_into_view()
+            element.click()
             self.__slow_mode_pause_if_set()
             self.loop.run_until_complete(self.page.wait())
 
@@ -545,9 +577,10 @@ class CDPMethods():
                 except Exception:
                     continue
                 if (width != 0 or height != 0):
+                    element.scroll_into_view()
                     element.click()
                     click_count += 1
-                    time.sleep(0.044)
+                    time.sleep(0.042)
                     self.__slow_mode_pause_if_set()
                     self.loop.run_until_complete(self.page.wait())
             except Exception:
@@ -557,7 +590,7 @@ class CDPMethods():
         """(Attempt simulating a mouse click)"""
         self.__slow_mode_pause_if_set()
         element = self.find_element(selector, timeout=timeout)
-        self.__add_light_pause()
+        element.scroll_into_view()
         element.mouse_click()
         self.__slow_mode_pause_if_set()
         self.loop.run_until_complete(self.page.wait())
@@ -579,6 +612,7 @@ class CDPMethods():
 
     def select_option_by_text(self, dropdown_selector, option):
         element = self.find_element(dropdown_selector)
+        element.scroll_into_view()
         options = element.query_selector_all("option")
         for found_option in options:
             if found_option.text.strip() == option.strip():
@@ -599,7 +633,10 @@ class CDPMethods():
         """Paint a quickly-vanishing dot over an element."""
         selector = self.__convert_to_css_if_xpath(selector)
         element = self.find_element(selector)
-        element.flash(duration=duration, color=color)
+        element.scroll_into_view()
+        x_offset = self.__get_x_scroll_offset()
+        y_offset = self.__get_y_scroll_offset()
+        element.flash(duration, color, x_offset, y_offset)
         if pause and isinstance(pause, (int, float)):
             time.sleep(pause)
 
@@ -607,17 +644,22 @@ class CDPMethods():
         """Highlight an element with multi-colors."""
         selector = self.__convert_to_css_if_xpath(selector)
         element = self.find_element(selector)
-        element.flash(0.46, "44CC88")
+        element.scroll_into_view()
+        x_offset = self.__get_x_scroll_offset()
+        y_offset = self.__get_y_scroll_offset()
+        element.flash(0.46, "44CC88", x_offset, y_offset)
         time.sleep(0.15)
-        element.flash(0.42, "8844CC")
+        element.flash(0.42, "8844CC", x_offset, y_offset)
         time.sleep(0.15)
-        element.flash(0.38, "CC8844")
+        element.flash(0.38, "CC8844", x_offset, y_offset)
         time.sleep(0.15)
-        element.flash(0.30, "44CC88")
+        element.flash(0.30, "44CC88", x_offset, y_offset)
         time.sleep(0.30)
 
     def focus(self, selector):
-        self.find_element(selector).focus()
+        element = self.find_element(selector)
+        element.scroll_into_view()
+        element.focus()
 
     def highlight_overlay(self, selector):
         self.find_element(selector).highlight_overlay()
@@ -646,7 +688,7 @@ class CDPMethods():
     def send_keys(self, selector, text, timeout=settings.SMALL_TIMEOUT):
         self.__slow_mode_pause_if_set()
         element = self.select(selector, timeout=timeout)
-        self.__add_light_pause()
+        element.scroll_into_view()
         if text.endswith("\n") or text.endswith("\r"):
             text = text[:-1] + "\r\n"
         element.send_keys(text)
@@ -657,7 +699,7 @@ class CDPMethods():
         """Similar to send_keys(), but presses keys at human speed."""
         self.__slow_mode_pause_if_set()
         element = self.select(selector, timeout=timeout)
-        self.__add_light_pause()
+        element.scroll_into_view()
         submit = False
         if text.endswith("\n") or text.endswith("\r"):
             submit = True
@@ -675,7 +717,7 @@ class CDPMethods():
         """Similar to send_keys(), but clears the text field first."""
         self.__slow_mode_pause_if_set()
         element = self.select(selector, timeout=timeout)
-        self.__add_light_pause()
+        element.scroll_into_view()
         with suppress(Exception):
             element.clear_input()
         if text.endswith("\n") or text.endswith("\r"):
@@ -688,8 +730,8 @@ class CDPMethods():
         """Similar to send_keys(), but clears the text field first."""
         self.__slow_mode_pause_if_set()
         selector = self.__convert_to_css_if_xpath(selector)
-        self.select(selector, timeout=timeout)
-        self.__add_light_pause()
+        element = self.select(selector, timeout=timeout)
+        element.scroll_into_view()
         press_enter = False
         if text.endswith("\n"):
             text = text[:-1]
@@ -980,8 +1022,10 @@ class CDPMethods():
         )
 
     def get_element_attribute(self, selector, attribute):
-        attributes = self.get_element_attributes(selector)
-        return attributes[attribute]
+        return self.get_element_attributes(selector)[attribute]
+
+    def get_attribute(self, selector, attribute):
+        return self.find_element(selector).get_attribute(attribute)
 
     def get_element_html(self, selector):
         selector = self.__convert_to_css_if_xpath(selector)
@@ -1655,17 +1699,24 @@ class CDPMethods():
                 raise Exception(error % (expected, actual))
 
     def assert_text(
-        self, text, selector="html", timeout=settings.SMALL_TIMEOUT
+        self, text, selector="body", timeout=settings.SMALL_TIMEOUT
     ):
+        start_ms = time.time() * 1000.0
+        stop_ms = start_ms + (timeout * 1000.0)
         text = text.strip()
         element = None
         try:
             element = self.find_element(selector, timeout=timeout)
         except Exception:
             raise Exception("Element {%s} not found!" % selector)
-        for i in range(30):
+        for i in range(int(timeout * 10)):
+            with suppress(Exception):
+                element = self.find_element(selector, timeout=0.1)
             if text in element.text_all:
                 return True
+            now_ms = time.time() * 1000.0
+            if now_ms >= stop_ms:
+                break
             time.sleep(0.1)
         raise Exception(
             "Text {%s} not found in {%s}! Actual text: {%s}"
@@ -1673,20 +1724,27 @@ class CDPMethods():
         )
 
     def assert_exact_text(
-        self, text, selector="html", timeout=settings.SMALL_TIMEOUT
+        self, text, selector="body", timeout=settings.SMALL_TIMEOUT
     ):
+        start_ms = time.time() * 1000.0
+        stop_ms = start_ms + (timeout * 1000.0)
         text = text.strip()
         element = None
         try:
             element = self.select(selector, timeout=timeout)
         except Exception:
             raise Exception("Element {%s} not found!" % selector)
-        for i in range(30):
+        for i in range(int(timeout * 10)):
+            with suppress(Exception):
+                element = self.select(selector, timeout=0.1)
             if (
                 self.is_element_visible(selector)
                 and text.strip() == element.text_all.strip()
             ):
                 return True
+            now_ms = time.time() * 1000.0
+            if now_ms >= stop_ms:
+                break
             time.sleep(0.1)
         raise Exception(
             "Expected Text {%s}, is not equal to {%s} in {%s}!"

{seleniumbase-4.33.6 → seleniumbase-4.33.8}/seleniumbase/core/settings_parser.py

@@ -71,6 +71,8 @@ def set_settings(settings_file):
             settings.LARGE_TIMEOUT = override_settings[key]
         elif key == "EXTREME_TIMEOUT":
             settings.EXTREME_TIMEOUT = override_settings[key]
+        elif key == "PAGE_LOAD_TIMEOUT":
+            settings.PAGE_LOAD_TIMEOUT = override_settings[key]
         elif key == "ARCHIVE_EXISTING_LOGS":
             settings.ARCHIVE_EXISTING_LOGS = override_settings[key]
         elif key == "ARCHIVE_EXISTING_DOWNLOADS":