seleniumbase 4.43.3__tar.gz → 4.44.0__tar.gz

{seleniumbase-4.43.3/seleniumbase.egg-info → seleniumbase-4.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seleniumbase
-Version: 4.43.3
+Version: 4.44.0
 Summary: A complete web automation framework for end-to-end testing.
 Home-page: https://github.com/seleniumbase/SeleniumBase
 Author: Michael Mintz
@@ -60,7 +60,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pip>=25.0.1; python_version < "3.9"
-Requires-Dist: pip>=25.2; python_version >= "3.9"
+Requires-Dist: pip>=25.3; python_version >= "3.9"
 Requires-Dist: packaging>=25.0
 Requires-Dist: setuptools~=70.2; python_version < "3.10"
 Requires-Dist: setuptools>=80.9.0; python_version >= "3.10"
@@ -113,7 +113,7 @@ Requires-Dist: websocket-client~=1.8.0; python_version < "3.9"
 Requires-Dist: websocket-client~=1.9.0; python_version >= "3.9"
 Requires-Dist: selenium==4.27.1; python_version < "3.9"
 Requires-Dist: selenium==4.32.0; python_version >= "3.9" and python_version < "3.10"
-Requires-Dist: selenium==4.37.0; python_version >= "3.10"
+Requires-Dist: selenium==4.38.0; python_version >= "3.10"
 Requires-Dist: cssselect==1.2.0; python_version < "3.9"
 Requires-Dist: cssselect==1.3.0; python_version >= "3.9"
 Requires-Dist: sortedcontainers==2.4.0

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/requirements.txt

@@ -1,5 +1,5 @@
 pip>=25.0.1;python_version<"3.9"
-pip>=25.2;python_version>="3.9"
+pip>=25.3;python_version>="3.9"
 packaging>=25.0
 setuptools~=70.2;python_version<"3.10"
 setuptools>=80.9.0;python_version>="3.10"
@@ -52,7 +52,7 @@ websocket-client~=1.8.0;python_version<"3.9"
 websocket-client~=1.9.0;python_version>="3.9"
 selenium==4.27.1;python_version<"3.9"
 selenium==4.32.0;python_version>="3.9" and python_version<"3.10"
-selenium==4.37.0;python_version>="3.10"
+selenium==4.38.0;python_version>="3.10"
 cssselect==1.2.0;python_version<"3.9"
 cssselect==1.3.0;python_version>="3.9"
 sortedcontainers==2.4.0

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/seleniumbase/__version__.py

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

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/seleniumbase/core/browser_launcher.py

@@ -551,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)
@@ -885,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
@@ -2979,12 +2993,16 @@ def get_driver(
         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")
@@ -2997,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

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/seleniumbase/core/detect_b_ver.py

@@ -278,6 +278,7 @@ def opera_on_windows_path(browser_type=None):
         ),
     ):
         for subitem in (
+            "Programs/Opera",
             "Opera",
             "Opera/Application",
         ):
@@ -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-4.43.3 → seleniumbase-4.44.0}/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":
@@ -1725,18 +1732,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()
                 x = x * (width_ratio + 0.03)
                 y = y * (width_ratio - 0.03)
             self.bring_active_window_to_front()
@@ -2021,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
@@ -2114,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 (
@@ -2694,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):
@@ -2707,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-4.43.3 → seleniumbase-4.44.0}/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-4.43.3 → seleniumbase-4.44.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:

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/seleniumbase/fixtures/page_actions.py

@@ -1530,7 +1530,7 @@ def save_page_source(driver, name, folder=None):
     rendered_source = log_helper.get_html_source_with_base_href(
         driver, page_source
     )
-    html_file = open(html_file_path, "w+", "utf-8")
+    html_file = open(html_file_path, mode="w+", encoding="utf-8")
     html_file.write(rendered_source)
     html_file.close()
 

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/seleniumbase/plugins/driver_manager.py

@@ -455,8 +455,6 @@ def Driver(
         )
     if sb_config._browser_shortcut:
         browser = sb_config._browser_shortcut
-    if browser in constants.ChromiumSubs.chromium_subs:
-        browser = "chrome"  # Still uses chromedriver
     if headless is None:
         if "--headless" in sys_argv:
             headless = True
@@ -953,6 +951,10 @@ def Driver(
                     driver_version = None
                 break
             count += 1
+    if browser in constants.ChromiumSubs.chromium_subs:
+        if not binary_location:
+            browser = "chrome"  # Still uses chromedriver
+            sb_config._browser_shortcut = browser
     browser_name = browser
 
     # Launch a web browser

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/seleniumbase/plugins/pytest_plugin.py

@@ -1676,8 +1676,23 @@ def pytest_configure(config):
     sb_config.browser = config.getoption("browser")
     if sb_config._browser_shortcut:
         sb_config.browser = sb_config._browser_shortcut
-    if sb_config.browser in constants.ChromiumSubs.chromium_subs:
-        sb_config.browser = "chrome"  # Still uses chromedriver
+    elif sys_argv == ["-c"]:  # Multithreading messes with args
+        if config.getoption("use_opera"):
+            bin_loc = detect_b_ver.get_binary_location("opera")
+            if bin_loc and os.path.exists(bin_loc):
+                sb_config.browser = "opera"
+        elif config.getoption("use_brave"):
+            bin_loc = detect_b_ver.get_binary_location("brave")
+            if bin_loc and os.path.exists(bin_loc):
+                sb_config.browser = "brave"
+        elif config.getoption("use_comet"):
+            bin_loc = detect_b_ver.get_binary_location("comet")
+            if bin_loc and os.path.exists(bin_loc):
+                sb_config.browser = "comet"
+        elif config.getoption("use_atlas"):
+            bin_loc = detect_b_ver.get_binary_location("atlas")
+            if bin_loc and os.path.exists(bin_loc):
+                sb_config.browser = "atlas"
     sb_config.account = config.getoption("account")
     sb_config.data = config.getoption("data")
     sb_config.var1 = config.getoption("var1")
@@ -1714,6 +1729,35 @@ def pytest_configure(config):
     sb_config.binary_location = config.getoption("binary_location")
     if hasattr(sb_config, "_cdp_bin_loc") and sb_config._cdp_bin_loc:
         sb_config.binary_location = sb_config._cdp_bin_loc
+    elif not sb_config.binary_location:
+        if (
+            config.getoption("use_opera")
+            or sb_config._browser_shortcut == "opera"
+        ):
+            bin_loc = detect_b_ver.get_binary_location("opera")
+            if bin_loc and os.path.exists(bin_loc):
+                sb_config.binary_location = bin_loc
+        elif (
+            config.getoption("use_brave")
+            or sb_config._browser_shortcut == "brave"
+        ):
+            bin_loc = detect_b_ver.get_binary_location("brave")
+            if bin_loc and os.path.exists(bin_loc):
+                sb_config.binary_location = bin_loc
+        elif (
+            config.getoption("use_comet")
+            or sb_config._browser_shortcut == "comet"
+        ):
+            bin_loc = detect_b_ver.get_binary_location("comet")
+            if bin_loc and os.path.exists(bin_loc):
+                sb_config.binary_location = bin_loc
+        elif (
+            config.getoption("use_atlas")
+            or sb_config._browser_shortcut == "atlas"
+        ):
+            bin_loc = detect_b_ver.get_binary_location("atlas")
+            if bin_loc and os.path.exists(bin_loc):
+                sb_config.binary_location = bin_loc
     if config.getoption("use_cft") and not sb_config.binary_location:
         sb_config.binary_location = "cft"
     elif config.getoption("use_chs") and not sb_config.binary_location:
@@ -1726,6 +1770,10 @@ def pytest_configure(config):
         sb_config.headless = True
         sb_config.headless1 = False
         sb_config.headless2 = False
+    if sb_config.browser in constants.ChromiumSubs.chromium_subs:
+        if not sb_config.binary_location:
+            sb_config.browser = "chrome"  # Still uses chromedriver
+            sb_config._browser_shortcut = sb_config.browser
     sb_config.driver_version = config.getoption("driver_version")
     sb_config.page_load_strategy = config.getoption("page_load_strategy")
     sb_config.with_testing_base = config.getoption("with_testing_base")

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/seleniumbase/plugins/sb_manager.py

@@ -1132,8 +1132,6 @@ def SB(
     sb_config.browser = browser
     if sb_config._browser_shortcut:
         sb_config.browser = sb_config._browser_shortcut
-    if sb_config.browser in constants.ChromiumSubs.chromium_subs:
-        sb_config.browser = "chrome"  # Still uses chromedriver
     if not hasattr(sb_config, "is_behave"):
         sb_config.is_behave = False
     if not hasattr(sb_config, "is_pytest"):
@@ -1242,6 +1240,10 @@ def SB(
     sb_config.interval = interval
     sb_config.cap_file = cap_file
     sb_config.cap_string = cap_string
+    if sb_config.browser in constants.ChromiumSubs.chromium_subs:
+        if not sb_config.binary_location:
+            sb_config.browser = "chrome"  # Still uses chromedriver
+            sb_config._browser_shortcut = sb_config.browser
 
     sb = BaseCase()
     sb.with_testing_base = sb_config.with_testing_base

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/seleniumbase/plugins/selenium_plugin.py

@@ -1302,8 +1302,6 @@ class SeleniumBrowser(Plugin):
         if sb_config._browser_shortcut:
             self.options.browser = sb_config._browser_shortcut
             test.test.browser = sb_config._browser_shortcut
-        if test.test.browser in constants.ChromiumSubs.chromium_subs:
-            test.test.browser = "chrome"  # Still uses chromedriver
         test.test.cap_file = self.options.cap_file
         test.test.cap_string = self.options.cap_string
         test.test.headless = self.options.headless
@@ -1355,6 +1353,10 @@ class SeleniumBrowser(Plugin):
             test.test.headless = True
             test.test.headless1 = False
             test.test.headless2 = False
+        if test.test.browser in constants.ChromiumSubs.chromium_subs:
+            if not sb_config.binary_location:
+                test.test.browser = "chrome"  # Still uses chromedriver
+                sb_config._browser_shortcut = test.test.browser
         test.test.driver_version = self.options.driver_version
         test.test.page_load_strategy = self.options.page_load_strategy
         test.test.chromium_arg = self.options.chromium_arg

{seleniumbase-4.43.3 → seleniumbase-4.44.0/seleniumbase.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seleniumbase
-Version: 4.43.3
+Version: 4.44.0
 Summary: A complete web automation framework for end-to-end testing.
 Home-page: https://github.com/seleniumbase/SeleniumBase
 Author: Michael Mintz
@@ -60,7 +60,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pip>=25.0.1; python_version < "3.9"
-Requires-Dist: pip>=25.2; python_version >= "3.9"
+Requires-Dist: pip>=25.3; python_version >= "3.9"
 Requires-Dist: packaging>=25.0
 Requires-Dist: setuptools~=70.2; python_version < "3.10"
 Requires-Dist: setuptools>=80.9.0; python_version >= "3.10"
@@ -113,7 +113,7 @@ Requires-Dist: websocket-client~=1.8.0; python_version < "3.9"
 Requires-Dist: websocket-client~=1.9.0; python_version >= "3.9"
 Requires-Dist: selenium==4.27.1; python_version < "3.9"
 Requires-Dist: selenium==4.32.0; python_version >= "3.9" and python_version < "3.10"
-Requires-Dist: selenium==4.37.0; python_version >= "3.10"
+Requires-Dist: selenium==4.38.0; python_version >= "3.10"
 Requires-Dist: cssselect==1.2.0; python_version < "3.9"
 Requires-Dist: cssselect==1.3.0; python_version >= "3.9"
 Requires-Dist: sortedcontainers==2.4.0

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/seleniumbase.egg-info/requires.txt

@@ -72,13 +72,13 @@ setuptools>=80.9.0
 filelock>=3.20.0
 platformdirs>=4.5.0
 urllib3<2.6.0,>=1.26.20
-selenium==4.37.0
+selenium==4.38.0
 iniconfig==2.3.0
 pytest-rerunfailures==16.1
 markdown-it-py==4.0.0
 
 [:python_version >= "3.9"]
-pip>=25.2
+pip>=25.3
 attrs>=25.4.0
 websockets>=15.0.1
 typing-extensions>=4.15.0

{seleniumbase-4.43.3 → seleniumbase-4.44.0}/setup.py

@@ -148,7 +148,7 @@ setup(
     python_requires=">=3.8",
     install_requires=[
         'pip>=25.0.1;python_version<"3.9"',
-        'pip>=25.2;python_version>="3.9"',
+        'pip>=25.3;python_version>="3.9"',
         'packaging>=25.0',
         'setuptools~=70.2;python_version<"3.10"',  # Newer ones had issues
         'setuptools>=80.9.0;python_version>="3.10"',
@@ -201,7 +201,7 @@ setup(
         'websocket-client~=1.9.0;python_version>="3.9"',
         'selenium==4.27.1;python_version<"3.9"',
         'selenium==4.32.0;python_version>="3.9" and python_version<"3.10"',
-        'selenium==4.37.0;python_version>="3.10"',
+        'selenium==4.38.0;python_version>="3.10"',
         'cssselect==1.2.0;python_version<"3.9"',
         'cssselect==1.3.0;python_version>="3.9"',
         "sortedcontainers==2.4.0",