seleniumbase 4.43.2__py3-none-any.whl → 4.44.0__py3-none-any.whl

seleniumbase/__version__.py

@@ -1,2 +1,2 @@
 # seleniumbase package
-__version__ = "4.43.2"
+__version__ = "4.44.0"

seleniumbase/core/browser_launcher.py

@@ -28,6 +28,10 @@ from seleniumbase import decorators
 from seleniumbase import drivers  # webdriver storage folder for SeleniumBase
 from seleniumbase.drivers import cft_drivers  # chrome-for-testing
 from seleniumbase.drivers import chs_drivers  # chrome-headless-shell
+from seleniumbase.drivers import opera_drivers  # still uses chromedriver
+from seleniumbase.drivers import brave_drivers  # still uses chromedriver
+from seleniumbase.drivers import comet_drivers  # still uses chromedriver
+from seleniumbase.drivers import atlas_drivers  # still uses chromedriver
 from seleniumbase import extensions  # browser extensions storage folder
 from seleniumbase.config import settings
 from seleniumbase.core import detect_b_ver
@@ -44,6 +48,10 @@ urllib3.disable_warnings()
 DRIVER_DIR = os.path.dirname(os.path.realpath(drivers.__file__))
 DRIVER_DIR_CFT = os.path.dirname(os.path.realpath(cft_drivers.__file__))
 DRIVER_DIR_CHS = os.path.dirname(os.path.realpath(chs_drivers.__file__))
+DRIVER_DIR_OPERA = os.path.dirname(os.path.realpath(opera_drivers.__file__))
+DRIVER_DIR_BRAVE = os.path.dirname(os.path.realpath(brave_drivers.__file__))
+DRIVER_DIR_COMET = os.path.dirname(os.path.realpath(comet_drivers.__file__))
+DRIVER_DIR_ATLAS = os.path.dirname(os.path.realpath(atlas_drivers.__file__))
 # Make sure that the SeleniumBase DRIVER_DIR is at the top of the System PATH
 # (Changes to the System PATH with os.environ only last during the test run)
 if not os.environ["PATH"].startswith(DRIVER_DIR):
@@ -543,6 +551,19 @@ def uc_open_with_tab(driver, url):
 
 def uc_open_with_reconnect(driver, url, reconnect_time=None):
     """Open a url, disconnect chromedriver, wait, and reconnect."""
+    if (
+        hasattr(sb_config, "_cdp_browser")
+        and sb_config._cdp_browser in ["comet", "opera", "atlas"]
+    ):
+        if not __is_cdp_swap_needed(driver):
+            if not driver.current_url.startswith(
+                ("about", "data", "chrome")
+            ):
+                driver.get("about:blank")
+            uc_activate_cdp_mode(driver, url)
+        else:
+            driver.cdp.open(url)
+        return
     url = shared_utils.fix_url_as_needed(url)
     if __is_cdp_swap_needed(driver):
         driver.cdp.get(url)
@@ -877,6 +898,7 @@ def uc_open_with_cdp_mode(driver, url=None, **kwargs):
     cdp.assert_not_in = CDPM.assert_not_in
     cdp.scroll_into_view = CDPM.scroll_into_view
     cdp.scroll_to_y = CDPM.scroll_to_y
+    cdp.scroll_by_y = CDPM.scroll_by_y
     cdp.scroll_to_top = CDPM.scroll_to_top
     cdp.scroll_to_bottom = CDPM.scroll_to_bottom
     cdp.scroll_up = CDPM.scroll_up
@@ -1218,8 +1240,8 @@ def uc_gui_click_x_y(driver, x, y, timeframe=0.25):
             driver.cdp.minimize()
             driver.cdp.set_window_rect(win_x, win_y, width, height)
         if IS_WINDOWS:
-            x = x * width_ratio
-            y = y * width_ratio
+            x = x * (width_ratio + 0.03)
+            y = y * (width_ratio - 0.03)
             _uc_gui_click_x_y(driver, x, y, timeframe=timeframe, uc_lock=False)
             return
         with suppress(Exception):
@@ -1260,7 +1282,7 @@ def _uc_gui_click_captcha(
     ctype=None,
 ):
     cdp_mode_on_at_start = __is_cdp_swap_needed(driver)
-    if cdp_mode_on_at_start and (not ctype or ctype == "cf_t"):
+    if cdp_mode_on_at_start:
         return driver.cdp.gui_click_captcha()
     _on_a_captcha_page = None
     if ctype == "cf_t":
@@ -1952,6 +1974,15 @@ def get_valid_binary_names_for_browser(browser):
         raise Exception("Invalid combination for OS browser binaries!")
 
 
+def _special_binary_exists(location, name):
+    filename = str(location).split("/")[-1].split("\\")[-1]
+    return (
+        location
+        and str(name).lower() in filename.lower()
+        and os.path.exists(location)
+    )
+
+
 def _repair_chromedriver(chrome_options, headless_options, mcv=None):
     if mcv:
         subprocess.check_call(
@@ -2960,6 +2991,18 @@ def get_driver(
         and sb_config.binary_location == "chs"
     ):
         driver_dir = DRIVER_DIR_CHS
+    if _special_binary_exists(binary_location, "opera"):
+        driver_dir = DRIVER_DIR_OPERA
+        sb_config._cdp_browser = "opera"
+    if _special_binary_exists(binary_location, "brave"):
+        driver_dir = DRIVER_DIR_BRAVE
+        sb_config._cdp_browser = "brave"
+    if _special_binary_exists(binary_location, "comet"):
+        driver_dir = DRIVER_DIR_COMET
+        sb_config._cdp_browser = "comet"
+    if _special_binary_exists(binary_location, "atlas"):
+        driver_dir = DRIVER_DIR_ATLAS
+        sb_config._cdp_browser = "atlas"
     if (
         hasattr(sb_config, "settings")
         and hasattr(sb_config.settings, "NEW_DRIVER_DIR")
@@ -2972,6 +3015,8 @@ def get_driver(
             browser_name = browser
         else:
             browser_name = "chrome"  # The default if not specified
+    if browser_name in constants.ChromiumSubs.chromium_subs:
+        browser_name = "chrome"
     browser_name = browser_name.lower()
     if headless2 and browser_name == constants.Browser.FIREFOX:
         headless2 = False  # Only for Chromium
@@ -3919,6 +3964,18 @@ def get_local_driver(
     ):
         special_chrome = True
         driver_dir = DRIVER_DIR_CHS
+    if _special_binary_exists(binary_location, "opera"):
+        special_chrome = True
+        driver_dir = DRIVER_DIR_OPERA
+    if _special_binary_exists(binary_location, "brave"):
+        special_chrome = True
+        driver_dir = DRIVER_DIR_BRAVE
+    if _special_binary_exists(binary_location, "comet"):
+        special_chrome = True
+        driver_dir = DRIVER_DIR_COMET
+    if _special_binary_exists(binary_location, "atlas"):
+        special_chrome = True
+        driver_dir = DRIVER_DIR_ATLAS
     if (
         hasattr(sb_config, "settings")
         and hasattr(sb_config.settings, "NEW_DRIVER_DIR")
@@ -4756,6 +4813,27 @@ def get_local_driver(
         )
         return extend_driver(driver)
     elif browser_name == constants.Browser.GOOGLE_CHROME:
+        set_chromium = None
+        if _special_binary_exists(binary_location, "opera"):
+            set_chromium = "opera"
+            local_chromedriver = DRIVER_DIR_OPERA + "/chromedriver"
+            if IS_WINDOWS:
+                local_chromedriver = DRIVER_DIR_OPERA + "/chromedriver.exe"
+        if _special_binary_exists(binary_location, "brave"):
+            set_chromium = "brave"
+            local_chromedriver = DRIVER_DIR_BRAVE + "/chromedriver"
+            if IS_WINDOWS:
+                local_chromedriver = DRIVER_DIR_BRAVE + "/chromedriver.exe"
+        if _special_binary_exists(binary_location, "comet"):
+            set_chromium = "comet"
+            local_chromedriver = DRIVER_DIR_COMET + "/chromedriver"
+            if IS_WINDOWS:
+                local_chromedriver = DRIVER_DIR_COMET + "/chromedriver.exe"
+        if _special_binary_exists(binary_location, "atlas"):
+            set_chromium = "atlas"
+            local_chromedriver = DRIVER_DIR_ATLAS + "/chromedriver"
+            if IS_WINDOWS:
+                local_chromedriver = DRIVER_DIR_ATLAS + "/chromedriver.exe"
         try:
             chrome_options = _set_chrome_options(
                 browser_name,
@@ -4877,6 +4955,12 @@ def get_local_driver(
                 major_chrome_version = None
             if major_chrome_version:
                 use_version = major_chrome_version
+            if (
+                set_chromium == "opera"
+                and use_version.isnumeric()
+                and int(use_version) < 130
+            ):
+                use_version = "130"  # Special case
             ch_driver_version = None
             path_chromedriver = chromedriver_on_path()
             if os.path.exists(local_chromedriver):
@@ -4894,7 +4978,7 @@ def get_local_driver(
                         ch_driver_version = output
                         if driver_version == "keep":
                             driver_version = ch_driver_version
-            elif path_chromedriver:
+            elif path_chromedriver and not set_chromium:
                 try:
                     make_driver_executable_if_not(path_chromedriver)
                 except Exception as e:

seleniumbase/core/detect_b_ver.py

@@ -278,11 +278,12 @@ def opera_on_windows_path(browser_type=None):
         ),
     ):
         for subitem in (
+            "Programs/Opera",
             "Opera",
             "Opera/Application",
         ):
             try:
-                candidates.append(os.sep.join((item, subitem, "launcher.exe")))
+                candidates.append(os.sep.join((item, subitem, "opera.exe")))
             except TypeError:
                 pass
     for candidate in candidates:
@@ -336,6 +337,7 @@ def comet_on_windows_path(browser_type=None):
     ):
         for subitem in (
             "Comet/Application",
+            "Programs/Comet",
         ):
             try:
                 candidates.append(os.sep.join((item, subitem, "Comet.exe")))
@@ -364,6 +366,7 @@ def atlas_on_windows_path(browser_type=None):
     ):
         for subitem in (
             "Atlas/Application",
+            "Programs/Atlas",
         ):
             try:
                 candidates.append(os.sep.join((item, subitem, "Atlas.exe")))

seleniumbase/core/sb_cdp.py

@@ -1029,12 +1029,19 @@ class CDPMethods():
         return self.loop.run_until_complete(self.page.js_dumps(obj_name))
 
     def maximize(self):
-        if self.get_window()[1].window_state.value == "maximized":
-            return
-        elif self.get_window()[1].window_state.value == "minimized":
-            self.loop.run_until_complete(self.page.maximize())
-            time.sleep(0.044)
-        return self.loop.run_until_complete(self.page.maximize())
+        try:
+            if self.get_window()[1].window_state.value == "maximized":
+                return
+            elif self.get_window()[1].window_state.value == "minimized":
+                self.loop.run_until_complete(self.page.maximize())
+                time.sleep(0.044)
+            return self.loop.run_until_complete(self.page.maximize())
+        except Exception:
+            with suppress(Exception):
+                width = self.evaluate("screen.availWidth;")
+                height = self.evaluate("screen.availHeight;")
+                self.__set_window_rect(0, 0, width, height)
+                return
 
     def minimize(self):
         if self.get_window()[1].window_state.value != "minimized":
@@ -1333,6 +1340,17 @@ class CDPMethods():
         x = window_rect["x"] + element_rect["x"]
         y = w_bottom_y - viewport_height + element_rect["y"]
         y_scroll_offset = window_rect["pageYOffset"]
+        if (
+            hasattr(sb_config, "_cdp_browser")
+            and sb_config._cdp_browser == "opera"
+        ):
+            # Handle special case where Opera side panel shifts coordinates
+            x_offset = window_rect["outerWidth"] - window_rect["innerWidth"]
+            if x_offset > 56:
+                x_offset = 56
+            elif x_offset < 22:
+                x_offset = 0
+            x = x + x_offset
         y = y - y_scroll_offset
         x = x + window_rect["scrollX"]
         y = y + window_rect["scrollY"]
@@ -1674,11 +1692,6 @@ class CDPMethods():
         import pyautogui
         pyautogui = self.__get_configured_pyautogui(pyautogui)
         screen_width, screen_height = pyautogui.size()
-        if (
-            hasattr(sb_config, "_cdp_browser")
-            and sb_config._cdp_browser == "opera"
-        ):
-            x = x + 55
         if x < 0 or y < 0 or x > screen_width or y > screen_height:
             raise Exception(
                 "PyAutoGUI cannot click on point (%s, %s)"
@@ -1719,20 +1732,20 @@ class CDPMethods():
                 win_x = window_rect["x"]
                 win_y = window_rect["y"]
                 scr_width = pyautogui.size().width
-                self.maximize()
-                self.__add_light_pause()
-                win_width = self.get_window_size()["width"]
+                win_width = self.evaluate("screen.availWidth;")
                 width_ratio = round(float(scr_width) / float(win_width), 2)
                 width_ratio += 0.01
                 if width_ratio < 0.45 or width_ratio > 2.55:
                     width_ratio = 1.01
                 sb_config._saved_width_ratio = width_ratio
-                self.minimize()
-                self.__add_light_pause()
-                self.__set_window_rect(win_x, win_y, width, height)
-                self.__add_light_pause()
-                x = x * width_ratio
-                y = y * width_ratio
+                with suppress(Exception):
+                    self.get_window()  # If this fails, skip the rest
+                    self.minimize()
+                    self.__add_light_pause()
+                    self.__set_window_rect(win_x, win_y, width, height)
+                    self.__add_light_pause()
+                x = x * (width_ratio + 0.03)
+                y = y * (width_ratio - 0.03)
             self.bring_active_window_to_front()
             self.__gui_click_x_y(x, y, timeframe=timeframe, uc_lock=False)
 
@@ -1760,8 +1773,43 @@ class CDPMethods():
             return True
         return False
 
+    def _on_a_g_recaptcha_page(self):
+        time.sleep(0.042)
+        source = self.get_page_source()
+        if not source or len(source) < 400:
+            time.sleep(0.22)
+            source = self.get_page_source()
+        if (
+            'id="recaptcha-token"' in source
+            or 'title="reCAPTCHA"' in source
+        ):
+            return True
+        return False
+
+    def __gui_click_recaptcha(self):
+        selector = None
+        if self.is_element_visible('iframe[title="reCAPTCHA"]'):
+            selector = 'iframe[title="reCAPTCHA"]'
+        else:
+            return
+        with suppress(Exception):
+            time.sleep(0.08)
+            element_rect = self.get_gui_element_rect(selector, timeout=1)
+            e_x = element_rect["x"]
+            e_y = element_rect["y"]
+            x = e_x + 29
+            y = e_y + 35
+            sb_config._saved_cf_x_y = (x, y)
+            time.sleep(0.08)
+            self.gui_click_x_y(x, y)
+
     def gui_click_captcha(self):
-        if not self._on_a_cf_turnstile_page():
+        if self._on_a_cf_turnstile_page():
+            pass
+        elif self._on_a_g_recaptcha_page():
+            self.__gui_click_recaptcha()
+            return
+        else:
             return
         selector = None
         if (
@@ -1926,7 +1974,7 @@ class CDPMethods():
             if not shared_utils.is_windows():
                 y = e_y + 32
             else:
-                y = e_y + 22
+                y = e_y + 28
             sb_config._saved_cf_x_y = (x, y)
             time.sleep(0.08)
             self.gui_click_x_y(x, y)
@@ -1936,12 +1984,6 @@ class CDPMethods():
         import pyautogui
         pyautogui = self.__get_configured_pyautogui(pyautogui)
         screen_width, screen_height = pyautogui.size()
-        if (
-            hasattr(sb_config, "_cdp_browser")
-            and sb_config._cdp_browser == "opera"
-        ):
-            x1 = x1 + 55
-            x2 = x2 + 55
         if x1 < 0 or y1 < 0 or x1 > screen_width or y1 > screen_height:
             raise Exception(
                 "PyAutoGUI cannot drag-drop from point (%s, %s)"
@@ -1986,18 +2028,18 @@ class CDPMethods():
                 win_x = window_rect["x"]
                 win_y = window_rect["y"]
                 scr_width = pyautogui.size().width
-                self.maximize()
-                self.__add_light_pause()
-                win_width = self.get_window_size()["width"]
+                win_width = self.evaluate("screen.availWidth;")
                 width_ratio = round(float(scr_width) / float(win_width), 2)
                 width_ratio += 0.01
                 if width_ratio < 0.45 or width_ratio > 2.55:
                     width_ratio = 1.01
                 sb_config._saved_width_ratio = width_ratio
-                self.minimize()
-                self.__add_light_pause()
-                self.__set_window_rect(win_x, win_y, width, height)
-                self.__add_light_pause()
+                with suppress(Exception):
+                    self.get_window()  # If this fails, skip the rest
+                    self.minimize()
+                    self.__add_light_pause()
+                    self.__set_window_rect(win_x, win_y, width, height)
+                    self.__add_light_pause()
                 x1 = x1 * width_ratio
                 y1 = y1 * (width_ratio - 0.02)
                 x2 = x2 * width_ratio
@@ -2033,11 +2075,6 @@ class CDPMethods():
         import pyautogui
         pyautogui = self.__get_configured_pyautogui(pyautogui)
         screen_width, screen_height = pyautogui.size()
-        if (
-            hasattr(sb_config, "_cdp_browser")
-            and sb_config._cdp_browser == "opera"
-        ):
-            x = x + 55
         if x < 0 or y < 0 or x > screen_width or y > screen_height:
             raise Exception(
                 "PyAutoGUI cannot hover on point (%s, %s)"
@@ -2084,15 +2121,14 @@ class CDPMethods():
                     width_ratio = sb_config._saved_width_ratio
                 else:
                     scr_width = pyautogui.size().width
-                    self.maximize()
-                    self.__add_light_pause()
-                    win_width = self.get_window_size()["width"]
+                    win_width = self.evaluate("screen.availWidth;")
                     width_ratio = round(float(scr_width) / float(win_width), 2)
                     width_ratio += 0.01
                     if width_ratio < 0.45 or width_ratio > 2.55:
                         width_ratio = 1.01
                     sb_config._saved_width_ratio = width_ratio
-                self.__set_window_rect(win_x, win_y, width, height)
+                with suppress(Exception):
+                    self.__set_window_rect(win_x, win_y, width, height)
                 self.__add_light_pause()
                 self.bring_active_window_to_front()
             elif (
@@ -2118,7 +2154,7 @@ class CDPMethods():
         if width > 0 and height > 0:
             x, y = self.get_gui_element_center(selector)
             self.bring_active_window_to_front()
-            self.__gui_hover_x_y(x, y, timeframe=timeframe)
+            self.__gui_hover_x_y(x, y, timeframe=timeframe, uc_lock=False)
             self.__slow_mode_pause_if_set()
         self.loop.run_until_complete(self.page.wait())
 
@@ -2664,6 +2700,13 @@ class CDPMethods():
             self.loop.run_until_complete(self.page.evaluate(js_code))
             self.loop.run_until_complete(self.page.wait())
 
+    def scroll_by_y(self, y):
+        y = int(y)
+        js_code = "window.scrollBy(0, %s);" % y
+        with suppress(Exception):
+            self.loop.run_until_complete(self.page.evaluate(js_code))
+            self.loop.run_until_complete(self.page.wait())
+
     def scroll_to_top(self):
         js_code = "window.scrollTo(0, 0);"
         with suppress(Exception):
@@ -2677,11 +2720,21 @@ class CDPMethods():
             self.loop.run_until_complete(self.page.wait())
 
     def scroll_up(self, amount=25):
-        self.loop.run_until_complete(self.page.scroll_up(amount))
+        """Scrolls up as a percentage of the page."""
+        try:
+            self.loop.run_until_complete(self.page.scroll_up(amount))
+        except Exception:
+            amount = self.get_window_size()["height"] * amount / 100
+            self.execute_script("window.scrollBy(0, -%s);" % amount)
         self.loop.run_until_complete(self.page.wait())
 
     def scroll_down(self, amount=25):
-        self.loop.run_until_complete(self.page.scroll_down(amount))
+        """Scrolls down as a percentage of the page."""
+        try:
+            self.loop.run_until_complete(self.page.scroll_down(amount))
+        except Exception:
+            amount = self.get_window_size()["height"] * amount / 100
+            self.execute_script("window.scrollBy(0, %s);" % amount)
         self.loop.run_until_complete(self.page.wait())
 
     def save_page_source(self, name, folder=None):

seleniumbase/fixtures/base_case.py

@@ -3577,9 +3577,18 @@ class BaseCase(unittest.TestCase):
             self.cdp.maximize()
             return
         self._check_browser()
-        self.driver.maximize_window()
+        try:
+            self.driver.maximize_window()
+        except Exception:
+            with suppress(Exception):
+                width = self.execute_script("return screen.availWidth;")
+                height = self.execute_script("return screen.availHeight;")
+                self.set_window_rect(0, 0, width, height)
         self.__demo_mode_pause_if_active(tiny=True)
 
+    def maximize(self):
+        self.maximize_window()
+
     def minimize_window(self):
         self.__check_scope()
         if self.__is_cdp_swap_needed():
@@ -3589,6 +3598,9 @@ class BaseCase(unittest.TestCase):
         self.driver.minimize_window()
         self.__demo_mode_pause_if_active(tiny=True)
 
+    def minimize(self):
+        self.minimize_window()
+
     def reset_window_size(self):
         self.__check_scope()
         if self.__is_cdp_swap_needed():
@@ -4344,7 +4356,7 @@ class BaseCase(unittest.TestCase):
                 if self.is_chromium():
                     try:
                         if self.maximize_option:
-                            self.driver.maximize_window()
+                            self.maximize_window()
                             self.wait_for_ready_state_complete()
                         else:
                             pass  # Now handled in browser_launcher.py
@@ -4354,7 +4366,7 @@ class BaseCase(unittest.TestCase):
                 elif self.browser == "firefox":
                     try:
                         if self.maximize_option:
-                            self.driver.maximize_window()
+                            self.maximize_window()
                             self.wait_for_ready_state_complete()
                         else:
                             with suppress(Exception):
@@ -4364,7 +4376,7 @@ class BaseCase(unittest.TestCase):
                 elif self.browser == "safari":
                     if self.maximize_option:
                         try:
-                            self.driver.maximize_window()
+                            self.maximize_window()
                             self.wait_for_ready_state_complete()
                         except Exception:
                             pass  # Keep existing browser resolution
@@ -6511,6 +6523,34 @@ class BaseCase(unittest.TestCase):
             self.execute_script(scroll_script)
             time.sleep(0.012)
 
+    def scroll_by_y(self, y):
+        """Scrolls page by y pixels."""
+        self.__check_scope()
+        y = int(y)
+        if self.__is_cdp_swap_needed():
+            self.cdp.scroll_by_y(y)
+            return
+        scroll_script = "window.scrollBy(0, %s);" % y
+        with suppress(Exception):
+            self.execute_script(scroll_script)
+            time.sleep(0.012)
+
+    def scroll_up(self, amount=25):
+        """Scrolls up as a percentage of the page."""
+        if self.__is_cdp_swap_needed():
+            self.cdp.scroll_up(amount)
+            return
+        amount = self.get_window_size()["height"] * amount / 100
+        self.execute_script("window.scrollBy(0, -%s);" % amount)
+
+    def scroll_down(self, amount=25):
+        """Scrolls down as a percentage of the page."""
+        if self.__is_cdp_swap_needed():
+            self.cdp.scroll_down(amount)
+            return
+        amount = self.get_window_size()["height"] * amount / 100
+        self.execute_script("window.scrollBy(0, %s);" % amount)
+
     def click_xpath(self, xpath):
         """Technically, self.click() automatically detects xpath selectors,
         so self.click_xpath() is just a longer name for the same action."""
@@ -11408,7 +11448,13 @@ class BaseCase(unittest.TestCase):
 
     def __is_cdp_swap_needed(self):
         """If the driver is disconnected, use a CDP method when available."""
-        return shared_utils.is_cdp_swap_needed(self.driver)
+        cdp_swap_needed = shared_utils.is_cdp_swap_needed(self.driver)
+        if cdp_swap_needed:
+            if not self.cdp:
+                self.cdp = self.driver.cdp
+            return True
+        else:
+            return False
 
     ############
 
@@ -14001,7 +14047,7 @@ class BaseCase(unittest.TestCase):
             )
             raise Exception(message)
         except InvalidArgumentException:
-            if not self.browser == "chrome":
+            if not self.is_chromium():
                 raise
             chrome_version = self.driver.capabilities["browserVersion"]
             major_chrome_version = chrome_version.split(".")[0]
@@ -14616,7 +14662,7 @@ class BaseCase(unittest.TestCase):
                 try:
                     shadow_root = element.shadow_root
                 except Exception:
-                    if self.browser == "chrome":
+                    if self.is_chromium():
                         chrome_dict = self.driver.capabilities["chrome"]
                         chrome_dr_version = chrome_dict["chromedriverVersion"]
                         chromedriver_version = chrome_dr_version.split(" ")[0]

seleniumbase/fixtures/constants.py

@@ -264,16 +264,13 @@ class Reveal:
 
 
 class HighCharts:
+    LIB = "https://cdn.jsdelivr.net/npm/highcharts"
     VER = "10.3.3"
-    HC_CSS = "https://code.highcharts.com/%s/css/highcharts.css" % VER
-    HC_JS = "https://code.highcharts.com/%s/highcharts.js" % VER
-    EXPORTING_JS = "https://code.highcharts.com/%s/modules/exporting.js" % VER
-    EXPORT_DATA_JS = (
-        "https://code.highcharts.com/%s/modules/export-data.js" % VER
-    )
-    ACCESSIBILITY_JS = (
-        "https://code.highcharts.com/%s/modules/accessibility.js" % VER
-    )
+    HC_CSS = "%s@%s/css/highcharts.css" % (LIB, VER)
+    HC_JS = "%s@%s/highcharts.js" % (LIB, VER)
+    EXPORTING_JS = "%s@%s/modules/exporting.js" % (LIB, VER)
+    EXPORT_DATA_JS = "%s@%s/modules/export-data.js" % (LIB, VER)
+    ACCESSIBILITY_JS = "%s@%s/modules/accessibility.js" % (LIB, VER)
 
 
 class BootstrapTour:
@@ -387,6 +384,20 @@ class ValidBrowsers:
         "ie",
         "safari",
         "remote",
+        "opera",
+        "brave",
+        "comet",
+        "atlas",
+    ]
+
+
+class ChromiumSubs:
+    # Chromium browsers that still use chromedriver
+    chromium_subs = [
+        "opera",
+        "brave",
+        "comet",
+        "atlas",
     ]
 
 
@@ -430,8 +441,12 @@ class ValidBinaries:
         "Google Chrome Beta",
         "Google Chrome Dev",
         "Brave Browser",
+        "Brave",
+        "Opera Browser",
         "Opera",
+        "Comet Browser",
         "Comet",
+        "Atlas Browser",
         "Atlas",
     ]
     valid_edge_binaries_on_macos = [

seleniumbase/fixtures/js_utils.py

@@ -1278,7 +1278,7 @@ def scroll_to_element(driver, element):
     try:
         screen_width = driver.get_window_size()["width"]
     except Exception:
-        screen_width = execute_script("return window.innerWidth;")
+        screen_width = execute_script(driver, "return window.innerWidth;")
     element_location_y = element_location_y - constants.Scroll.Y_OFFSET
     if element_location_y < 0:
         element_location_y = 0
@@ -1327,7 +1327,7 @@ def slow_scroll_to_element(driver, element, *args, **kwargs):
     try:
         screen_width = driver.get_window_size()["width"]
     except Exception:
-        screen_width = execute_script("return window.innerWidth;")
+        screen_width = execute_script(driver, "return window.innerWidth;")
     element_location_y = element_location_y - constants.Scroll.Y_OFFSET
     if element_location_y < 0:
         element_location_y = 0