seleniumbase 4.32.9__py3-none-any.whl → 4.32.10a1__py3-none-any.whl

seleniumbase/__version__.py

@@ -1,2 +1,2 @@
 # seleniumbase package
-__version__ = "4.32.9"
+__version__ = "4.32.10a1"

seleniumbase/core/browser_launcher.py

@@ -603,6 +603,7 @@ def uc_open_with_cdp_mode(driver, url=None):
     cdp.click = CDPM.click
     cdp.click_active_element = CDPM.click_active_element
     cdp.click_if_visible = CDPM.click_if_visible
+    cdp.click_visible_elements = CDPM.click_visible_elements
     cdp.mouse_click = CDPM.mouse_click
     cdp.remove_element = CDPM.remove_element
     cdp.remove_from_dom = CDPM.remove_from_dom
@@ -611,6 +612,7 @@ def uc_open_with_cdp_mode(driver, url=None):
     cdp.send_keys = CDPM.send_keys
     cdp.press_keys = CDPM.press_keys
     cdp.type = CDPM.type
+    cdp.set_value = CDPM.set_value
     cdp.evaluate = CDPM.evaluate
     cdp.js_dumps = CDPM.js_dumps
     cdp.maximize = CDPM.maximize
@@ -625,6 +627,11 @@ def uc_open_with_cdp_mode(driver, url=None):
     cdp.gui_write = CDPM.gui_write
     cdp.gui_click_x_y = CDPM.gui_click_x_y
     cdp.gui_click_element = CDPM.gui_click_element
+    cdp.gui_drag_drop_points = CDPM.gui_drag_drop_points
+    cdp.gui_drag_and_drop = CDPM.gui_drag_and_drop
+    cdp.gui_hover_x_y = CDPM.gui_hover_x_y
+    cdp.gui_hover_element = CDPM.gui_hover_element
+    cdp.gui_hover_and_click = CDPM.gui_hover_and_click
     cdp.internalize_links = CDPM.internalize_links
     cdp.get_window = CDPM.get_window
     cdp.get_element_attributes = CDPM.get_element_attributes
@@ -651,7 +658,9 @@ def uc_open_with_cdp_mode(driver, url=None):
     cdp.get_window_rect = CDPM.get_window_rect
     cdp.get_window_size = CDPM.get_window_size
     cdp.nested_click = CDPM.nested_click
+    cdp.select_option_by_text = CDPM.select_option_by_text
     cdp.flash = CDPM.flash
+    cdp.highlight = CDPM.highlight
     cdp.focus = CDPM.focus
     cdp.highlight_overlay = CDPM.highlight_overlay
     cdp.get_window_position = CDPM.get_window_position
@@ -663,8 +672,11 @@ def uc_open_with_cdp_mode(driver, url=None):
     cdp.is_element_present = CDPM.is_element_present
     cdp.is_element_visible = CDPM.is_element_visible
     cdp.assert_element_present = CDPM.assert_element_present
+    cdp.assert_element_absent = CDPM.assert_element_absent
     cdp.assert_element = CDPM.assert_element
     cdp.assert_element_visible = CDPM.assert_element
+    cdp.assert_element_not_visible = CDPM.assert_element_not_visible
+    cdp.assert_title = CDPM.assert_title
     cdp.assert_text = CDPM.assert_text
     cdp.assert_exact_text = CDPM.assert_exact_text
     cdp.scroll_down = CDPM.scroll_down
@@ -680,6 +692,7 @@ def uc_open_with_cdp_mode(driver, url=None):
     core_items.tab = cdp.tab
     core_items.util = cdp.util
     cdp.core = core_items
+    cdp.loop = cdp.get_event_loop()
     driver.cdp = cdp
     driver._is_using_cdp = True
 
@@ -944,48 +957,46 @@ def uc_gui_click_x_y(driver, x, y, timeframe=0.25):
         connected = True
         width_ratio = 1.0
         if IS_WINDOWS:
-            try:
-                driver.window_handles
-            except Exception:
-                connected = False
+            connected = driver.is_connected()
             if (
                 not connected
                 and (
                     not hasattr(sb_config, "_saved_width_ratio")
                     or not sb_config._saved_width_ratio
                 )
+                and not __is_cdp_swap_needed(driver)
             ):
                 driver.reconnect(0.1)
-                connected = True
-        if IS_WINDOWS and connected:
+        if IS_WINDOWS and not __is_cdp_swap_needed(driver):
             window_rect = driver.get_window_rect()
             width = window_rect["width"]
             height = window_rect["height"]
             win_x = window_rect["x"]
             win_y = window_rect["y"]
-            if (
-                hasattr(sb_config, "_saved_width_ratio")
-                and sb_config._saved_width_ratio
-            ):
-                width_ratio = sb_config._saved_width_ratio
-            else:
-                scr_width = pyautogui.size().width
-                driver.maximize_window()
-                win_width = driver.get_window_size()["width"]
-                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
+            scr_width = pyautogui.size().width
+            driver.maximize_window()
+            win_width = driver.get_window_size()["width"]
+            width_ratio = round(float(scr_width) / float(win_width), 2) + 0.01
+            if width_ratio < 0.45 or width_ratio > 2.55:
+                width_ratio = 1.01
+            sb_config._saved_width_ratio = width_ratio
             driver.minimize_window()
             driver.set_window_rect(win_x, win_y, width, height)
-        elif (
-            IS_WINDOWS
-            and not connected
-            and hasattr(sb_config, "_saved_width_ratio")
-            and sb_config._saved_width_ratio
-        ):
-            width_ratio = sb_config._saved_width_ratio
+        elif IS_WINDOWS and __is_cdp_swap_needed(driver):
+            window_rect = driver.cdp.get_window_rect()
+            width = window_rect["width"]
+            height = window_rect["height"]
+            win_x = window_rect["x"]
+            win_y = window_rect["y"]
+            scr_width = pyautogui.size().width
+            driver.cdp.maximize()
+            win_width = driver.cdp.get_window_size()["width"]
+            width_ratio = round(float(scr_width) / float(win_width), 2) + 0.01
+            if width_ratio < 0.45 or width_ratio > 2.55:
+                width_ratio = 1.01
+            sb_config._saved_width_ratio = width_ratio
+            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
@@ -1090,6 +1101,21 @@ def _uc_gui_click_captcha(
             sb_config._saved_width_ratio = width_ratio
             driver.minimize_window()
             driver.set_window_rect(win_x, win_y, width, height)
+        elif IS_WINDOWS and __is_cdp_swap_needed(driver):
+            window_rect = driver.cdp.get_window_rect()
+            width = window_rect["width"]
+            height = window_rect["height"]
+            win_x = window_rect["x"]
+            win_y = window_rect["y"]
+            scr_width = pyautogui.size().width
+            driver.cdp.maximize()
+            win_width = driver.cdp.get_window_size()["width"]
+            width_ratio = round(float(scr_width) / float(win_width), 2) + 0.01
+            if width_ratio < 0.45 or width_ratio > 2.55:
+                width_ratio = 1.01
+            sb_config._saved_width_ratio = width_ratio
+            driver.cdp.minimize()
+            driver.cdp.set_window_rect(win_x, win_y, width, height)
         if ctype == "cf_t":
             if (
                 driver.is_element_present(".cf-turnstile-wrapper iframe")
@@ -1201,10 +1227,10 @@ def _uc_gui_click_captcha(
                 element = driver.wait_for_element_present(
                     selector, timeout=2.5
                 )
-                x = i_x + element.rect["x"] + int(element.rect["width"] / 2)
-                x += 1
-                y = i_y + element.rect["y"] + int(element.rect["height"] / 2)
-                y += 1
+                x = i_x + element.rect["x"] + (element.rect["width"] / 2.0)
+                x += 0.5
+                y = i_y + element.rect["y"] + (element.rect["height"] / 2.0)
+                y += 0.5
             else:
                 x = (i_x + 34) * width_ratio
                 y = (i_y + 34) * width_ratio

seleniumbase/core/sb_cdp.py

@@ -39,7 +39,9 @@ class CDPMethods():
             return element
         element.clear_input = lambda: self.__clear_input(element)
         element.click = lambda: self.__click(element)
-        element.flash = lambda: self.__flash(element)
+        element.flash = lambda *args, **kwargs: self.__flash(
+            element, *args, **kwargs
+        )
         element.focus = lambda: self.__focus(element)
         element.highlight_overlay = lambda: self.__highlight_overlay(element)
         element.mouse_click = lambda: self.__mouse_click(element)
@@ -258,9 +260,11 @@ class CDPMethods():
         self.loop.run_until_complete(self.page.wait())
         return result
 
-    def __flash(self, element):
+    def __flash(self, element, *args, **kwargs):
         return (
-            self.loop.run_until_complete(element.flash_async())
+            self.loop.run_until_complete(
+                element.flash_async(*args, **kwargs)
+            )
         )
 
     def __focus(self, element):
@@ -292,11 +296,11 @@ class CDPMethods():
 
     def __query_selector(self, element, selector):
         selector = self.__convert_to_css_if_xpath(selector)
-        element = self.loop.run_until_complete(
+        element2 = self.loop.run_until_complete(
             element.query_selector_async(selector)
         )
-        element = self.__add_sync_methods(element)
-        return element
+        element2 = self.__add_sync_methods(element2)
+        return element2
 
     def __query_selector_all(self, element, selector):
         selector = self.__convert_to_css_if_xpath(selector)
@@ -467,6 +471,19 @@ class CDPMethods():
             self.__slow_mode_pause_if_set()
             self.loop.run_until_complete(self.page.wait())
 
+    def click_visible_elements(self, selector):
+        elements = self.select_all(selector)
+        for element in elements:
+            try:
+                position = element.get_position()
+                if (position.width != 0 or position.height != 0):
+                    element.click()
+                    time.sleep(0.0375)
+                    self.__slow_mode_pause_if_set()
+                    self.loop.run_until_complete(self.page.wait())
+            except Exception:
+                pass
+
     def mouse_click(self, selector, timeout=settings.SMALL_TIMEOUT):
         """(Attempt simulating a mouse click)"""
         self.__slow_mode_pause_if_set()
@@ -491,9 +508,45 @@ class CDPMethods():
         element = self.find_element(parent_selector)
         return element.query_selector(selector)
 
-    def flash(self, selector):
+    def select_option_by_text(self, dropdown_selector, option):
+        element = self.find_element(dropdown_selector)
+        options = element.query_selector_all("option")
+        for found_option in options:
+            if found_option.text.strip() == option.strip():
+                found_option.select_option()
+                return
+        raise Exception(
+            "Unable to find text option {%s} in dropdown {%s}!"
+            % (dropdown_selector, option)
+        )
+
+    def flash(
+        self,
+        selector,  # The CSS Selector to flash
+        duration=1,  # (seconds) flash duration
+        color="44CC88",  # RGB hex flash color
+        pause=0,  # (seconds) If 0, the next action starts during flash
+    ):
         """Paint a quickly-vanishing dot over an element."""
-        self.find_element(selector).flash()
+        selector = self.__convert_to_css_if_xpath(selector)
+        element = self.find_element(selector)
+        element.flash(duration=duration, color=color)
+        if pause and isinstance(pause, (int, float)):
+            time.sleep(pause)
+
+    def highlight(self, selector):
+        """Highlight an element with multi-colors."""
+        selector = self.__convert_to_css_if_xpath(selector)
+        element = self.find_element(selector)
+        element = self.find_element(selector)
+        element.flash(0.46, "44CC88")
+        time.sleep(0.15)
+        element.flash(0.42, "8844CC")
+        time.sleep(0.15)
+        element.flash(0.38, "CC8844")
+        time.sleep(0.15)
+        element.flash(0.30, "44CC88")
+        time.sleep(0.30)
 
     def focus(self, selector):
         self.find_element(selector).focus()
@@ -526,8 +579,9 @@ class CDPMethods():
         self.find_element(selector).scroll_into_view()
 
     def send_keys(self, selector, text, timeout=settings.SMALL_TIMEOUT):
-        element = self.select(selector)
         self.__slow_mode_pause_if_set()
+        element = self.select(selector, timeout=timeout)
+        self.__add_light_pause()
         if text.endswith("\n") or text.endswith("\r"):
             text = text[:-1] + "\r\n"
         element.send_keys(text)
@@ -536,8 +590,9 @@ class CDPMethods():
 
     def press_keys(self, selector, text, timeout=settings.SMALL_TIMEOUT):
         """Similar to send_keys(), but presses keys at human speed."""
-        element = self.select(selector)
         self.__slow_mode_pause_if_set()
+        element = self.select(selector, timeout=timeout)
+        self.__add_light_pause()
         submit = False
         if text.endswith("\n") or text.endswith("\r"):
             submit = True
@@ -553,8 +608,9 @@ class CDPMethods():
 
     def type(self, selector, text, timeout=settings.SMALL_TIMEOUT):
         """Similar to send_keys(), but clears the text field first."""
-        element = self.select(selector)
         self.__slow_mode_pause_if_set()
+        element = self.select(selector, timeout=timeout)
+        self.__add_light_pause()
         with suppress(Exception):
             element.clear_input()
         if text.endswith("\n") or text.endswith("\r"):
@@ -563,6 +619,42 @@ class CDPMethods():
         self.__slow_mode_pause_if_set()
         self.loop.run_until_complete(self.page.wait())
 
+    def set_value(self, selector, text, timeout=settings.SMALL_TIMEOUT):
+        """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()
+        press_enter = False
+        if text.endswith("\n"):
+            text = text[:-1]
+            press_enter = True
+        value = js_utils.escape_quotes_if_needed(re.escape(text))
+        css_selector = re.escape(selector)
+        css_selector = js_utils.escape_quotes_if_needed(css_selector)
+        set_value_script = (
+            """m_elm = document.querySelector('%s');"""
+            """m_elm.value = '%s';""" % (css_selector, value)
+        )
+        self.loop.run_until_complete(self.page.evaluate(set_value_script))
+        the_type = self.get_element_attribute(selector, "type")
+        if the_type == "range":
+            # Some input sliders need a mouse event to trigger listeners.
+            with suppress(Exception):
+                mouse_move_script = (
+                    """m_elm = document.querySelector('%s');"""
+                    """m_evt = new Event('mousemove');"""
+                    """m_elm.dispatchEvent(m_evt);""" % css_selector
+                )
+                self.loop.run_until_complete(
+                    self.page.evaluate(mouse_move_script)
+                )
+        elif press_enter:
+            self.__add_light_pause()
+            self.send_keys(selector, "\n")
+        self.__slow_mode_pause_if_set()
+        self.loop.run_until_complete(self.page.wait())
+
     def evaluate(self, expression):
         """Run a JavaScript expression and return the result."""
         return self.loop.run_until_complete(
@@ -576,21 +668,30 @@ class CDPMethods():
         )
 
     def maximize(self):
-        return self.loop.run_until_complete(
-            self.page.maximize()
-        )
+        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.0375)
+        return self.loop.run_until_complete(self.page.maximize())
 
     def minimize(self):
-        return self.loop.run_until_complete(
-            self.page.minimize()
-        )
+        if self.get_window()[1].window_state.value != "minimized":
+            return self.loop.run_until_complete(self.page.minimize())
 
     def medimize(self):
-        return self.loop.run_until_complete(
-            self.page.medimize()
-        )
+        if self.get_window()[1].window_state.value == "minimized":
+            self.loop.run_until_complete(self.page.medimize())
+            time.sleep(0.0375)
+        return self.loop.run_until_complete(self.page.medimize())
 
     def set_window_rect(self, x, y, width, height):
+        if self.get_window()[1].window_state.value == "minimized":
+            self.loop.run_until_complete(
+                self.page.set_window_size(
+                    left=x, top=y, width=width, height=height)
+            )
+            time.sleep(0.0375)
         return self.loop.run_until_complete(
             self.page.set_window_size(
                 left=x, top=y, width=width, height=height)
@@ -602,6 +703,7 @@ class CDPMethods():
         width = settings.CHROME_START_WIDTH
         height = settings.CHROME_START_HEIGHT
         self.set_window_rect(x, y, width, height)
+        self.__add_light_pause()
 
     def get_window(self):
         return self.loop.run_until_complete(
@@ -785,7 +887,7 @@ class CDPMethods():
         e_height = element_rect["height"]
         e_x = element_rect["x"]
         e_y = element_rect["y"]
-        return ((e_x + e_width / 2), (e_y + e_height / 2))
+        return ((e_x + e_width / 2.0) + 0.5, (e_y + e_height / 2.0) + 0.5)
 
     def get_document(self):
         return self.loop.run_until_complete(
@@ -798,6 +900,7 @@ class CDPMethods():
         )
 
     def get_element_attributes(self, selector):
+        selector = self.__convert_to_css_if_xpath(selector)
         return self.loop.run_until_complete(
             self.page.js_dumps(
                 """document.querySelector('%s')"""
@@ -1013,6 +1116,156 @@ class CDPMethods():
             pyautogui.click(x=x, y=y)
 
     def gui_click_x_y(self, x, y, timeframe=0.25):
+        gui_lock = fasteners.InterProcessLock(
+            constants.MultiBrowser.PYAUTOGUILOCK
+        )
+        with gui_lock:  # Prevent issues with multiple processes
+            self.__install_pyautogui_if_missing()
+            import pyautogui
+            pyautogui = self.__get_configured_pyautogui(pyautogui)
+            width_ratio = 1.0
+            if shared_utils.is_windows():
+                window_rect = self.get_window_rect()
+                width = window_rect["width"]
+                height = window_rect["height"]
+                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"]
+                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
+            self.bring_active_window_to_front()
+            self.__gui_click_x_y(x, y, timeframe=timeframe, uc_lock=False)
+
+    def gui_click_element(self, selector, timeframe=0.25):
+        self.__slow_mode_pause_if_set()
+        x, y = self.get_gui_element_center(selector)
+        self.__add_light_pause()
+        self.gui_click_x_y(x, y, timeframe=timeframe)
+        self.__slow_mode_pause_if_set()
+        self.loop.run_until_complete(self.page.wait())
+
+    def __gui_drag_drop(self, x1, y1, x2, y2, timeframe=0.25, uc_lock=False):
+        self.__install_pyautogui_if_missing()
+        import pyautogui
+        pyautogui = self.__get_configured_pyautogui(pyautogui)
+        screen_width, screen_height = pyautogui.size()
+        if x1 < 0 or y1 < 0 or x1 > screen_width or y1 > screen_height:
+            raise Exception(
+                "PyAutoGUI cannot drag-drop from point (%s, %s)"
+                " outside screen. (Width: %s, Height: %s)"
+                % (x1, y1, screen_width, screen_height)
+            )
+        if x2 < 0 or y2 < 0 or x2 > screen_width or y2 > screen_height:
+            raise Exception(
+                "PyAutoGUI cannot drag-drop to point (%s, %s)"
+                " outside screen. (Width: %s, Height: %s)"
+                % (x2, y2, screen_width, screen_height)
+            )
+        if uc_lock:
+            gui_lock = fasteners.InterProcessLock(
+                constants.MultiBrowser.PYAUTOGUILOCK
+            )
+            with gui_lock:  # Prevent issues with multiple processes
+                pyautogui.moveTo(x1, y1, 0.25, pyautogui.easeOutQuad)
+                self.__add_light_pause()
+                if "--debug" in sys.argv:
+                    print(" <DEBUG> pyautogui.moveTo(%s, %s)" % (x1, y1))
+                pyautogui.dragTo(x2, y2, button="left", duration=timeframe)
+        else:
+            # Called from a method where the gui_lock is already active
+            pyautogui.moveTo(x1, y1, 0.25, pyautogui.easeOutQuad)
+            self.__add_light_pause()
+            if "--debug" in sys.argv:
+                print(" <DEBUG> pyautogui.dragTo(%s, %s)" % (x2, y2))
+            pyautogui.dragTo(x2, y2, button="left", duration=timeframe)
+
+    def gui_drag_drop_points(self, x1, y1, x2, y2, timeframe=0.35):
+        gui_lock = fasteners.InterProcessLock(
+            constants.MultiBrowser.PYAUTOGUILOCK
+        )
+        with gui_lock:  # Prevent issues with multiple processes
+            self.__install_pyautogui_if_missing()
+            import pyautogui
+            pyautogui = self.__get_configured_pyautogui(pyautogui)
+            width_ratio = 1.0
+            if shared_utils.is_windows():
+                window_rect = self.get_window_rect()
+                width = window_rect["width"]
+                height = window_rect["height"]
+                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"]
+                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()
+                x1 = x1 * width_ratio
+                y1 = y1 * width_ratio
+                x2 = x2 * width_ratio
+                y2 = y2 * width_ratio
+            self.bring_active_window_to_front()
+            self.__gui_drag_drop(
+                x1, y1, x2, y2, timeframe=timeframe, uc_lock=False
+            )
+        self.__slow_mode_pause_if_set()
+        self.loop.run_until_complete(self.page.wait())
+
+    def gui_drag_and_drop(self, drag_selector, drop_selector, timeframe=0.35):
+        self.__slow_mode_pause_if_set()
+        x1, y1 = self.get_gui_element_center(drag_selector)
+        self.__add_light_pause()
+        x2, y2 = self.get_gui_element_center(drop_selector)
+        self.__add_light_pause()
+        self.gui_drag_drop_points(x1, y1, x2, y2, timeframe=timeframe)
+
+    def __gui_hover_x_y(self, x, y, timeframe=0.25, uc_lock=False):
+        self.__install_pyautogui_if_missing()
+        import pyautogui
+        pyautogui = self.__get_configured_pyautogui(pyautogui)
+        screen_width, screen_height = pyautogui.size()
+        if x < 0 or y < 0 or x > screen_width or y > screen_height:
+            raise Exception(
+                "PyAutoGUI cannot hover on point (%s, %s)"
+                " outside screen. (Width: %s, Height: %s)"
+                % (x, y, screen_width, screen_height)
+            )
+        if uc_lock:
+            gui_lock = fasteners.InterProcessLock(
+                constants.MultiBrowser.PYAUTOGUILOCK
+            )
+            with gui_lock:  # Prevent issues with multiple processes
+                pyautogui.moveTo(x, y, timeframe, pyautogui.easeOutQuad)
+                time.sleep(0.056)
+                if "--debug" in sys.argv:
+                    print(" <DEBUG> pyautogui.moveTo(%s, %s)" % (x, y))
+        else:
+            # Called from a method where the gui_lock is already active
+            pyautogui.moveTo(x, y, timeframe, pyautogui.easeOutQuad)
+            time.sleep(0.056)
+            if "--debug" in sys.argv:
+                print(" <DEBUG> pyautogui.moveTo(%s, %s)" % (x, y))
+
+    def gui_hover_x_y(self, x, y, timeframe=0.25):
         gui_lock = fasteners.InterProcessLock(
             constants.MultiBrowser.PYAUTOGUILOCK
         )
@@ -1041,6 +1294,7 @@ class CDPMethods():
                 else:
                     scr_width = pyautogui.size().width
                     self.maximize()
+                    self.__add_light_pause()
                     win_width = self.get_window_size()["width"]
                     width_ratio = round(float(scr_width) / float(win_width), 2)
                     width_ratio += 0.01
@@ -1048,6 +1302,7 @@ class CDPMethods():
                         width_ratio = 1.01
                     sb_config._saved_width_ratio = width_ratio
                 self.set_window_rect(win_x, win_y, width, height)
+                self.__add_light_pause()
                 self.bring_active_window_to_front()
             elif (
                 shared_utils.is_windows()
@@ -1059,19 +1314,29 @@ class CDPMethods():
             if shared_utils.is_windows():
                 x = x * width_ratio
                 y = y * width_ratio
-                self.__gui_click_x_y(x, y, timeframe=timeframe, uc_lock=False)
+                self.__gui_hover_x_y(x, y, timeframe=timeframe, uc_lock=False)
                 return
             self.bring_active_window_to_front()
-            self.__gui_click_x_y(x, y, timeframe=timeframe, uc_lock=False)
+            self.__gui_hover_x_y(x, y, timeframe=timeframe, uc_lock=False)
 
-    def gui_click_element(self, selector, timeframe=0.25):
+    def gui_hover_element(self, selector, timeframe=0.25):
         self.__slow_mode_pause_if_set()
         x, y = self.get_gui_element_center(selector)
         self.__add_light_pause()
-        self.gui_click_x_y(x, y, timeframe=timeframe)
+        self.__gui_hover_x_y(x, y, timeframe=timeframe)
         self.__slow_mode_pause_if_set()
         self.loop.run_until_complete(self.page.wait())
 
+    def gui_hover_and_click(self, hover_selector, click_selector):
+        gui_lock = fasteners.InterProcessLock(
+            constants.MultiBrowser.PYAUTOGUILOCK
+        )
+        with gui_lock:
+            self.gui_hover_element(hover_selector)
+            time.sleep(0.15)
+            self.gui_hover_element(click_selector)
+            self.click(click_selector)
+
     def internalize_links(self):
         """All `target="_blank"` links become `target="_self"`.
         This prevents those links from opening in a new tab."""
@@ -1079,24 +1344,30 @@ class CDPMethods():
 
     def is_checked(self, selector):
         """Return True if checkbox (or radio button) is checked."""
+        selector = self.__convert_to_css_if_xpath(selector)
         self.find_element(selector, timeout=settings.SMALL_TIMEOUT)
         return self.get_element_attribute(selector, "checked")
 
     def is_selected(self, selector):
+        selector = self.__convert_to_css_if_xpath(selector)
         return self.is_checked(selector)
 
     def check_if_unchecked(self, selector):
+        selector = self.__convert_to_css_if_xpath(selector)
         if not self.is_checked(selector):
             self.click(selector)
 
     def select_if_unselected(self, selector):
+        selector = self.__convert_to_css_if_xpath(selector)
         self.check_if_unchecked(selector)
 
     def uncheck_if_checked(self, selector):
+        selector = self.__convert_to_css_if_xpath(selector)
         if self.is_checked(selector):
             self.click(selector)
 
     def unselect_if_selected(self, selector):
+        selector = self.__convert_to_css_if_xpath(selector)
         self.uncheck_if_checked(selector)
 
     def is_element_present(self, selector):
@@ -1105,32 +1376,22 @@ class CDPMethods():
             return True
         except Exception:
             return False
-        selector = self.__convert_to_css_if_xpath(selector)
-        element = self.loop.run_until_complete(
-            self.page.js_dumps(
-                """document.querySelector('%s')"""
-                % js_utils.escape_quotes_if_needed(re.escape(selector))
-            )
-        )
-        return element is not None
 
     def is_element_visible(self, selector):
         selector = self.__convert_to_css_if_xpath(selector)
         element = None
         if ":contains(" not in selector:
             try:
-                element = self.loop.run_until_complete(
-                    self.page.js_dumps(
-                        """window.getComputedStyle(document.querySelector"""
-                        """('%s'))"""
-                        % js_utils.escape_quotes_if_needed(re.escape(selector))
-                    )
-                )
+                element = self.select(selector, timeout=0.01)
             except Exception:
                 return False
             if not element:
                 return False
-            return element.get("display") != "none"
+            try:
+                position = element.get_position()
+                return (position.width != 0 or position.height != 0)
+            except Exception:
+                return False
         else:
             with suppress(Exception):
                 tag_name = selector.split(":contains(")[0].split(" ")[-1]
@@ -1160,9 +1421,66 @@ class CDPMethods():
             raise Exception("Element {%s} not found!" % selector)
         return True
 
+    def assert_element_absent(self, selector, timeout=settings.SMALL_TIMEOUT):
+        start_ms = time.time() * 1000.0
+        stop_ms = start_ms + (timeout * 1000.0)
+        for i in range(int(timeout * 10)):
+            if not self.is_element_present(selector):
+                return True
+            now_ms = time.time() * 1000.0
+            if now_ms >= stop_ms:
+                break
+            time.sleep(0.1)
+        plural = "s"
+        if timeout == 1:
+            plural = ""
+        raise Exception(
+            "Element {%s} was still present after %s second%s!"
+            % (selector, timeout, plural)
+        )
+
+    def assert_element_not_visible(
+        self, selector, timeout=settings.SMALL_TIMEOUT
+    ):
+        start_ms = time.time() * 1000.0
+        stop_ms = start_ms + (timeout * 1000.0)
+        for i in range(int(timeout * 10)):
+            if not self.is_element_present(selector):
+                return True
+            elif not self.is_element_visible(selector):
+                return True
+            now_ms = time.time() * 1000.0
+            if now_ms >= stop_ms:
+                break
+            time.sleep(0.1)
+        plural = "s"
+        if timeout == 1:
+            plural = ""
+        raise Exception(
+            "Element {%s} was still visible after %s second%s!"
+            % (selector, timeout, plural)
+        )
+
+    def assert_title(self, title):
+        expected = title.strip()
+        actual = self.get_title().strip()
+        error = (
+            "Expected page title [%s] does not match the actual title [%s]!"
+        )
+        try:
+            if expected != actual:
+                raise Exception(error % (expected, actual))
+        except Exception:
+            time.sleep(2)
+            expected = title.strip()
+            actual = self.get_title().strip()
+            if expected != actual:
+                raise Exception(error % (expected, actual))
+
     def assert_text(
         self, text, selector="html", timeout=settings.SMALL_TIMEOUT
     ):
+        text = text.strip()
         element = None
         try:
             element = self.select(selector, timeout=timeout)
@@ -1180,6 +1498,7 @@ class CDPMethods():
     def assert_exact_text(
         self, text, selector="html", timeout=settings.SMALL_TIMEOUT
     ):
+        text = text.strip()
         element = None
         try:
             element = self.select(selector, timeout=timeout)

seleniumbase/core/sb_driver.py

@@ -198,6 +198,11 @@ class DriverMethods():
         In CDP Mode, the CDP-Driver controls the web browser.
         The CDP-Driver can be connected while WebDriver isn't.
         """
+        if shared_utils.is_windows():
+            return (
+                not hasattr(self.driver, "_is_connected")
+                or self.driver._is_connected
+            )
         try:
             self.driver.window_handles
             return True
@@ -238,6 +243,14 @@ class DriverMethods():
         return js_utils.get_user_agent(self.driver, *args, **kwargs)
 
     def highlight(self, *args, **kwargs):
+        if self.__is_cdp_swap_needed():
+            selector = None
+            if "selector" in kwargs:
+                selector = kwargs["selector"]
+            else:
+                selector = args[0]
+            self.driver.cdp.highlight(selector)
+            return
         if "scroll" in kwargs:
             kwargs.pop("scroll")
         w_args = kwargs.copy()

seleniumbase/fixtures/base_case.py

@@ -1592,6 +1592,9 @@ class BaseCase(unittest.TestCase):
     def click_link_text(self, link_text, timeout=None):
         """This method clicks link text on a page."""
         self.__check_scope()
+        if self.__is_cdp_swap_needed():
+            self.cdp.find_element(link_text).click()
+            return
         self.__skip_if_esc()
         if not timeout:
             timeout = settings.SMALL_TIMEOUT
@@ -2197,6 +2200,9 @@ class BaseCase(unittest.TestCase):
         if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
             timeout = self.__get_new_timeout(timeout)
         selector, by = self.__recalculate_selector(selector, by)
+        if self.__is_cdp_swap_needed():
+            self.cdp.click_visible_elements(selector)
+            return
         self.wait_for_ready_state_complete()
         if self.__needs_minimum_wait():
             time.sleep(0.12)
@@ -2637,6 +2643,9 @@ class BaseCase(unittest.TestCase):
         original_selector = selector
         original_by = by
         selector, by = self.__recalculate_selector(selector, by)
+        if self.__is_cdp_swap_needed():
+            self.cdp.gui_hover_element(selector)
+            return
         self.wait_for_element_visible(
             original_selector, by=original_by, timeout=timeout
         )
@@ -2679,6 +2688,9 @@ class BaseCase(unittest.TestCase):
         click_selector, click_by = self.__recalculate_selector(
             click_selector, click_by
         )
+        if self.__is_cdp_swap_needed():
+            self.cdp.gui_hover_and_click(hover_selector, click_selector)
+            return
         dropdown_element = self.wait_for_element_visible(
             original_selector, by=original_by, timeout=timeout
         )
@@ -3105,6 +3117,9 @@ class BaseCase(unittest.TestCase):
             timeout = settings.SMALL_TIMEOUT
         if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
             timeout = self.__get_new_timeout(timeout)
+        if self.__is_cdp_swap_needed():
+            self.cdp.select_option_by_text(dropdown_selector, option)
+            return
         self.__select_option(
             dropdown_selector,
             option,
@@ -3419,8 +3434,8 @@ class BaseCase(unittest.TestCase):
         if self.__is_cdp_swap_needed():
             return self.cdp.get_gui_element_center(selector)
         element_rect = self.get_gui_element_rect(selector, by=by)
-        x = int(element_rect["x"]) + int(element_rect["width"] / 2) + 1
-        y = int(element_rect["y"]) + int(element_rect["height"] / 2) + 1
+        x = element_rect["x"] + (element_rect["width"] / 2.0) + 0.5
+        y = element_rect["y"] + (element_rect["height"] / 2.0) + 0.5
         return (x, y)
 
     def get_window_rect(self):
@@ -5959,6 +5974,9 @@ class BaseCase(unittest.TestCase):
         scroll - the option to scroll to the element first (Default: True)
         timeout - the time to wait for the element to appear """
         self.__check_scope()
+        if self.__is_cdp_swap_needed():
+            self.cdp.highlight(selector)
+            return
         self._check_browser()
         self.__skip_if_esc()
         if isinstance(selector, WebElement):
@@ -7676,6 +7694,9 @@ class BaseCase(unittest.TestCase):
             but then the title switches over to the actual page title.
         In Recorder Mode, this assertion is skipped because the Recorder
             changes the page title to the selector of the hovered element."""
+        if self.__is_cdp_swap_needed():
+            self.cdp.assert_title(title)
+            return
         self.wait_for_ready_state_complete()
         expected = title.strip()
         actual = self.get_page_title().strip()
@@ -8166,7 +8187,7 @@ class BaseCase(unittest.TestCase):
             timeout = self.__get_new_timeout(timeout)
         selector, by = self.__recalculate_selector(selector, by, xp_ok=False)
         if self.__is_cdp_swap_needed():
-            self.cdp.type(selector, text)
+            self.cdp.set_value(selector, text)
             return
         self.wait_for_ready_state_complete()
         self.wait_for_element_present(selector, by=by, timeout=timeout)
@@ -8932,6 +8953,9 @@ class BaseCase(unittest.TestCase):
             timeout = self.__get_new_timeout(timeout)
         original_selector = selector
         selector, by = self.__recalculate_selector(selector, by)
+        if self.__is_cdp_swap_needed():
+            self.cdp.assert_element_absent(selector)
+            return True
         return page_actions.wait_for_element_absent(
             self.driver,
             selector,
@@ -9966,6 +9990,9 @@ class BaseCase(unittest.TestCase):
             timeout = settings.SMALL_TIMEOUT
         if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
             timeout = self.__get_new_timeout(timeout)
+        if self.__is_cdp_swap_needed():
+            self.cdp.find_element(link_text)
+            return
         self.wait_for_link_text_visible(link_text, timeout=timeout)
         if self.demo_mode:
             a_t = "ASSERT LINK TEXT"
@@ -10065,6 +10092,9 @@ class BaseCase(unittest.TestCase):
             timeout = settings.SMALL_TIMEOUT
         if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
             timeout = self.__get_new_timeout(timeout)
+        if self.__is_cdp_swap_needed():
+            self.cdp.assert_element_absent(selector)
+            return True
         self.wait_for_element_absent(selector, by=by, timeout=timeout)
         return True
 
@@ -10083,6 +10113,9 @@ class BaseCase(unittest.TestCase):
             timeout = self.__get_new_timeout(timeout)
         original_selector = selector
         selector, by = self.__recalculate_selector(selector, by)
+        if self.__is_cdp_swap_needed():
+            self.cdp.assert_element_not_visible(selector)
+            return True
         return page_actions.wait_for_element_not_visible(
             self.driver,
             selector,

seleniumbase/fixtures/shared_utils.py

@@ -93,9 +93,9 @@ def is_cdp_swap_needed(driver):
     For other webdriver methods, SeleniumBase will reconnect first.
     """
     return (
-        driver.is_cdp_mode_active()
-        # and hasattr(driver, "_is_connected")
-        # and not driver._is_connected
+        hasattr(driver, "is_cdp_mode_active")
+        and driver.is_cdp_mode_active()
+        and hasattr(driver, "is_connected")
         and not driver.is_connected()
     )
 

seleniumbase/undetected/cdp_driver/element.py

@@ -5,6 +5,7 @@ import logging
 import pathlib
 import secrets
 import typing
+from contextlib import suppress
 from . import cdp_util as util
 from ._contradict import ContraDict
 from .config import PathLike
@@ -768,6 +769,11 @@ class Element:
         Gets the text contents of this element and child nodes, concatenated.
         Note: This includes text in the form of script content, (text nodes).
         """
+        with suppress(Exception):
+            if self.node.node_name.lower() in ["input", "textarea"]:
+                input_node = self.node.shadow_roots[0].children[0].children[0]
+                if input_node:
+                    return input_node.node_value
         text_nodes = util.filter_recurse_all(
             self.node, lambda n: n.node_type == 3
         )
@@ -776,6 +782,11 @@ class Element:
     @property
     def text_all(self):
         """Same as text(). Kept for backwards compatibility."""
+        with suppress(Exception):
+            if self.node.node_name.lower() in ["input", "textarea"]:
+                input_node = self.node.shadow_roots[0].children[0].children[0]
+                if input_node:
+                    return input_node.node_value
         text_nodes = util.filter_recurse_all(
             self.node, lambda n: n.node_type == 3
         )
@@ -868,7 +879,11 @@ class Element:
         path.write_bytes(data_bytes)
         return str(path)
 
-    async def flash_async(self, duration: typing.Union[float, int] = 0.5):
+    async def flash_async(
+        self,
+        duration: typing.Union[float, int] = 0.5,
+        color: typing.Optional[str] = "EE4488",
+    ):
         """
         Displays for a short time a red dot on the element.
         (Only if the element itself is visible)
@@ -892,11 +907,12 @@ class Element:
         style = (
             "position:absolute;z-index:99999999;padding:0;margin:0;"
             "left:{:.1f}px; top: {:.1f}px; opacity:0.7;"
-            "width:8px;height:8px;border-radius:50%;background:#EE4488;"
+            "width:8px;height:8px;border-radius:50%;background:#{};"
             "animation:show-pointer-ani {:.2f}s ease 1;"
         ).format(
             pos.center[0] - 4,  # -4 to account for drawn circle itself (w,h)
             pos.center[1] - 4,
+            color,
             duration,
         )
         script = (

{seleniumbase-4.32.9.dist-info → seleniumbase-4.32.10a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: seleniumbase
-Version: 4.32.9
+Version: 4.32.10a1
 Summary: A complete web automation framework for end-to-end testing.
 Home-page: https://github.com/seleniumbase/SeleniumBase
 Author: Michael Mintz
@@ -67,7 +67,7 @@ Requires-Dist: certifi>=2024.8.30
 Requires-Dist: exceptiongroup>=1.2.2
 Requires-Dist: filelock>=3.16.1
 Requires-Dist: fasteners>=0.19
-Requires-Dist: mycdp>=1.0.1
+Requires-Dist: mycdp>=1.1.0
 Requires-Dist: pynose>=1.5.3
 Requires-Dist: platformdirs>=4.3.6
 Requires-Dist: typing-extensions>=4.12.2
@@ -117,9 +117,9 @@ Requires-Dist: pyreadline3>=3.5.3; platform_system == "Windows"
 Requires-Dist: setuptools~=70.2; python_version < "3.10"
 Requires-Dist: urllib3<2,>=1.26.20; python_version < "3.10"
 Requires-Dist: websockets~=13.1; python_version < "3.9"
-Requires-Dist: setuptools>=73.0.1; python_version >= "3.10"
+Requires-Dist: setuptools>=75.5.0; python_version >= "3.10"
 Requires-Dist: urllib3<2.3.0,>=1.26.20; python_version >= "3.10"
-Requires-Dist: websockets>=14.0; python_version >= "3.9"
+Requires-Dist: websockets>=14.1; python_version >= "3.9"
 Provides-Extra: allure
 Requires-Dist: allure-pytest>=2.13.5; extra == "allure"
 Requires-Dist: allure-python-commons>=2.13.5; extra == "allure"

{seleniumbase-4.32.9.dist-info → seleniumbase-4.32.10a1.dist-info}/RECORD

@@ -3,7 +3,7 @@ sbase/__main__.py,sha256=G0bVB1-DM4PGwQ1KyOupaWCs4ePbChZNNWuX2htim5U,647
 sbase/steps.py,sha256=bKT_u5bJkKzYWEuAXi9NVVRYYxQRCM1_YJUrNFFRVPY,42865
 seleniumbase/__init__.py,sha256=OtJh8nGKL4xtZpw8KPqmn7Q6R-86t4cWUDyVF5MbMTo,2398
 seleniumbase/__main__.py,sha256=dn1p6dgCchmcH1zzTzzQvFwwdQQqnTGH6ULV9m4hv24,654
-seleniumbase/__version__.py,sha256=am_TdSeFJWZgGKFn3vmM8ge4vQM8qlkXsvTrl75KN2M,46
+seleniumbase/__version__.py,sha256=mB07opo9QE8Mwmi2PHdixrHjmflPaAc2Gc-yYAxT6ps,49
 seleniumbase/behave/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 seleniumbase/behave/behave_helper.py,sha256=elkl8P9eLulRAioLstE9baYNM9N_PHBmAOcajX-pH_Y,24198
 seleniumbase/behave/behave_sb.py,sha256=-hza7Nx2U41mSObYiPMi48v3JlPh3sJO3yzP0kqZ1Gk,59174
@@ -36,7 +36,7 @@ seleniumbase/console_scripts/sb_print.py,sha256=tNy-bMDgwHJO3bZxMpmo9weSE8uhbH0C
 seleniumbase/console_scripts/sb_recorder.py,sha256=1oAA4wFzVboNhIFDwJLD3jgy9RuoavywKQG7R67bNZE,10908
 seleniumbase/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 seleniumbase/core/application_manager.py,sha256=e_0sjtI8cjY5BNyZj1QBR0j6_oCScxGmSXYEpcYwuZE,576
-seleniumbase/core/browser_launcher.py,sha256=HG8_3PsRDx1acbA0ZW9DO_cYjkPy3OfDOvHaZnFUwJM,217440
+seleniumbase/core/browser_launcher.py,sha256=WjW--f7w0hUc8Y86tsUen4s2-bh8aXlhd3ad2G2Ws1Q,219040
 seleniumbase/core/capabilities_parser.py,sha256=meIS2uHapTCq2ldfNAToC7r0cKmZDRXuYNKExM1GHDY,6038
 seleniumbase/core/colored_traceback.py,sha256=DrRWfg7XEnKcgY59Xj7Jdk09H-XqHYBSUpB-DiZt6iY,2020
 seleniumbase/core/create_db_tables.sql,sha256=VWPtrdiW_HQ6yETHjqTu-VIrTwvd8I8o1NfBeaVSHpU,972
@@ -50,8 +50,8 @@ seleniumbase/core/proxy_helper.py,sha256=cXhu8ErK9Vjdm82RMaQj7hEq_yUWizSp6LyiD50
 seleniumbase/core/recorder_helper.py,sha256=fNGjbapXmEsht54x1o6Igk198QdnPxDDnjUOzQxNhNQ,25055
 seleniumbase/core/report_helper.py,sha256=AIl6Qava2yW1uSzbLpJBlPlYDz0KE-rVhogh8hsGWBo,12201
 seleniumbase/core/s3_manager.py,sha256=bkeI8I4y19ebWuQG1oEZV5qJbotC6eN8vin31OCNWJk,3521
-seleniumbase/core/sb_cdp.py,sha256=4dp20r_KSK8n8nhqzqPMTk48nXt16wzGKSW2v63j_p0,45560
-seleniumbase/core/sb_driver.py,sha256=-k4vHwMnuiBIkdVInTtJA-IDLrgQfyMhNxSHMIsjepw,11623
+seleniumbase/core/sb_cdp.py,sha256=IwK8KeDdO1vCwzqocbok7hWDFY6qOf-aB_tL_WMVMSE,59423
+seleniumbase/core/sb_driver.py,sha256=Yd9BpjnOUuZqYRGmsERVKc1W-e8qwTt7SAytLatkXPA,12070
 seleniumbase/core/session_helper.py,sha256=s9zD3PVZEWVzG2h81cCUskbNWLfdjC_LwwQjKptHCak,558
 seleniumbase/core/settings_parser.py,sha256=KokVXpCiGZhJ-D4Bo-hizPz5r-iefzWoiTANu9zNaq4,7504
 seleniumbase/core/style_sheet.py,sha256=tPpJ1xl6Kuw425Z-3Y0OgVRLGXk_ciBDREZjXk_NuPE,11395
@@ -65,14 +65,14 @@ seleniumbase/extensions/disable_csp.zip,sha256=YMifIIgEBiLrEFrS1sfW4Exh4br1V4oK1
 seleniumbase/extensions/recorder.zip,sha256=OOyzF-Ize2cSRu1CqhzSAq5vusI9hqLLd2OIApUHesI,11918
 seleniumbase/extensions/sbase_ext.zip,sha256=3s1N8zrVaMz8RQEOIoBzC3KDjtmHwVZRvVsX25Odr_s,8175
 seleniumbase/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-seleniumbase/fixtures/base_case.py,sha256=DfOl1L5VCOaKduVqvnkBeUc4qHs3n6SEdl65CLXaEFs,711565
+seleniumbase/fixtures/base_case.py,sha256=vzgC_qp8nT1-6i7UMLB8KMiqrAyJuvw61oQJDLk0EdU,712816
 seleniumbase/fixtures/constants.py,sha256=XYYMpB-ZDI756LvfhSK9RxdqQ_qO9fJVXgBqBYlQNkk,13609
 seleniumbase/fixtures/css_to_xpath.py,sha256=9ouDB1xl4MJ2os6JOgTIAyHKOQfuxtxvXC3O5hSnEKA,1954
 seleniumbase/fixtures/errors.py,sha256=KyxuEVx_e3MPhVrJfNIa_3ltMpbCFxfy_jxK8RFNTns,555
 seleniumbase/fixtures/js_utils.py,sha256=5o4CTLcCyd717lJ_atOYcC6kPRiZFx-LJIlixRrP_cE,51061
 seleniumbase/fixtures/page_actions.py,sha256=fOCb2NB2PpEaE8gpAVu-73VjwLzfwP1R9HsRkix_z6s,66634
 seleniumbase/fixtures/page_utils.py,sha256=5m7iXpikLs80TJoRO6_gEfXE1AKeQgcH1aFbR8o1C9A,12034
-seleniumbase/fixtures/shared_utils.py,sha256=QdoepYzSpt0J_iKQhhJCENY9ry0hB2juXKkEVI3TSTg,7263
+seleniumbase/fixtures/shared_utils.py,sha256=MwCrt58YAv_XrfNfYjo_quUTWfYArlnf-aexSZGIyRs,7271
 seleniumbase/fixtures/unittest_helper.py,sha256=sfZ92rZeBAn_sF_yQ3I6_I7h3lyU5-cV_UMegBNoEm8,1294
 seleniumbase/fixtures/words.py,sha256=FOA4mAYvl3EPVpBTvgvK6YwCL8BdlRCmed685kEe7Vg,7827
 seleniumbase/fixtures/xpath_to_css.py,sha256=lML56k656fElXJ4NJF07r35FjctrbgQkXUotNk7A-as,8876
@@ -119,7 +119,7 @@ seleniumbase/undetected/cdp_driver/browser.py,sha256=mGmpWuR206yYJoBPTNslru8CbEp
 seleniumbase/undetected/cdp_driver/cdp_util.py,sha256=Erfb62fzpvGr0QIIJOiqvGkyoyBakHOIwgbrQ7dqUgM,16625
 seleniumbase/undetected/cdp_driver/config.py,sha256=Rjvde7V-XJ0ihZdTmOmHEVWSuDWm3SprQ3njg8SN3Go,12087
 seleniumbase/undetected/cdp_driver/connection.py,sha256=sOTUGjbUqKA2hPvDcRCdqw1VQjVGJs7mbgVvzS7ldtE,23360
-seleniumbase/undetected/cdp_driver/element.py,sha256=9oD9GxguctunrlHV3lWXlZgb9cNEjD5x03Oy84OqyVA,39631
+seleniumbase/undetected/cdp_driver/element.py,sha256=wEHtuF9oiny7cb4QMMjdtD5Yf1z3WOs2_NHEWcscusM,40289
 seleniumbase/undetected/cdp_driver/tab.py,sha256=wUNF8GHrbhaUqg57A9ZTYHKhNPjZIcOHwrz3pj1SAg0,50526
 seleniumbase/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 seleniumbase/utilities/selenium_grid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -135,9 +135,9 @@ seleniumbase/utilities/selenium_grid/start-grid-hub.bat,sha256=Ftq-GrAKRYH2ssDPr
 seleniumbase/utilities/selenium_grid/start-grid-hub.sh,sha256=KADv0RUHONLL2_I443QFK8PryBpDmKn5Gy0s4o0vDSM,106
 seleniumbase/utilities/selenium_ide/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 seleniumbase/utilities/selenium_ide/convert_ide.py,sha256=pZFnqEJQEKZPyNFjkLD29s2HPQgCrWW9XJWpCPhWOoM,31691
-seleniumbase-4.32.9.dist-info/LICENSE,sha256=odSYtWibXBnQ1gBg6CnDZ82n8kLF_if5-2nbqnEyD8k,1085
-seleniumbase-4.32.9.dist-info/METADATA,sha256=nd96od-BctakXK-zGmDPiKl4Ymfsz91frtzdx2s_rtg,86461
-seleniumbase-4.32.9.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-seleniumbase-4.32.9.dist-info/entry_points.txt,sha256=CNrh2EKNaHYEhO6pP1RJyVLB99LkDDYX7TnUK8xfjqk,623
-seleniumbase-4.32.9.dist-info/top_level.txt,sha256=4N97aBOQ8ETCnDnokBsWb07lJfTaq3C1ZzYRxvLMxqU,19
-seleniumbase-4.32.9.dist-info/RECORD,,
+seleniumbase-4.32.10a1.dist-info/LICENSE,sha256=odSYtWibXBnQ1gBg6CnDZ82n8kLF_if5-2nbqnEyD8k,1085
+seleniumbase-4.32.10a1.dist-info/METADATA,sha256=rXnleRderXsIB3mEybQOL3r-Kes-dpZtM9rCeJ_v_A8,86464
+seleniumbase-4.32.10a1.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+seleniumbase-4.32.10a1.dist-info/entry_points.txt,sha256=CNrh2EKNaHYEhO6pP1RJyVLB99LkDDYX7TnUK8xfjqk,623
+seleniumbase-4.32.10a1.dist-info/top_level.txt,sha256=4N97aBOQ8ETCnDnokBsWb07lJfTaq3C1ZzYRxvLMxqU,19
+seleniumbase-4.32.10a1.dist-info/RECORD,,

{seleniumbase-4.32.9.dist-info → seleniumbase-4.32.10a1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: true
 Tag: py3-none-any