seleniumbase 4.34.8__py3-none-any.whl → 4.36.2__py3-none-any.whl

seleniumbase/core/sb_cdp.py

@@ -1,4 +1,5 @@
 """Add CDP methods to extend the driver"""
+import asyncio
 import fasteners
 import os
 import re
@@ -11,6 +12,7 @@ from seleniumbase.fixtures import constants
 from seleniumbase.fixtures import js_utils
 from seleniumbase.fixtures import page_utils
 from seleniumbase.fixtures import shared_utils
+from seleniumbase.undetected.cdp_driver import cdp_util
 
 
 class CDPMethods():
@@ -56,12 +58,16 @@ class CDPMethods():
             element, *args, **kwargs
         )
         element.focus = lambda: self.__focus(element)
+        element.gui_click = (
+            lambda *args, **kwargs: self.__gui_click(element, *args, **kwargs)
+        )
         element.highlight_overlay = lambda: self.__highlight_overlay(element)
         element.mouse_click = lambda: self.__mouse_click(element)
         element.mouse_drag = (
             lambda destination: self.__mouse_drag(element, destination)
         )
         element.mouse_move = lambda: self.__mouse_move(element)
+        element.press_keys = lambda text: self.__press_keys(element, text)
         element.query_selector = (
             lambda selector: self.__query_selector(element, selector)
         )
@@ -91,6 +97,8 @@ class CDPMethods():
         element.get_attribute = (
             lambda attribute: self.__get_attribute(element, attribute)
         )
+        # element.get_parent() should come last
+        element.get_parent = lambda: self.__get_parent(element)
         return element
 
     def get(self, url):
@@ -98,7 +106,7 @@ class CDPMethods():
         driver = self.driver
         if hasattr(driver, "cdp_base"):
             driver = driver.cdp_base
-        self.page = self.loop.run_until_complete(driver.get(url))
+        self.loop.run_until_complete(self.page.get(url))
         url_protocol = url.split(":")[0]
         safe_url = True
         if url_protocol not in ["about", "data", "chrome"]:
@@ -202,14 +210,17 @@ class CDPMethods():
                 element = self.__add_sync_methods(element)
                 return self.__add_sync_methods(element)
             elif (
-                element.parent
+                element
+                and element.parent
                 and tag_name in element.parent.tag_name.lower()
                 and text.strip() in element.parent.text
             ):
                 element = self.__add_sync_methods(element.parent)
                 return self.__add_sync_methods(element)
             elif (
-                element.parent.parent
+                element
+                and element.parent
+                and element.parent.parent
                 and tag_name in element.parent.parent.tag_name.lower()
                 and text.strip() in element.parent.parent.text
             ):
@@ -262,7 +273,8 @@ class CDPMethods():
                 if element not in updated_elements:
                     updated_elements.append(element)
             elif (
-                element.parent
+                element
+                and element.parent
                 and tag_name in element.parent.tag_name.lower()
                 and text.strip() in element.parent.text
             ):
@@ -270,7 +282,9 @@ class CDPMethods():
                 if element not in updated_elements:
                     updated_elements.append(element)
             elif (
-                element.parent.parent
+                element
+                and element.parent
+                and element.parent.parent
                 and tag_name in element.parent.parent.tag_name.lower()
                 and text.strip() in element.parent.parent.text
             ):
@@ -280,7 +294,7 @@ class CDPMethods():
         return updated_elements
 
     def select(self, selector, timeout=None):
-        """Similar to find_element(), but without text-based search."""
+        """Similar to find_element()."""
         if not timeout:
             timeout = settings.SMALL_TIMEOUT
         self.__add_light_pause()
@@ -289,12 +303,25 @@ class CDPMethods():
             tag_name = selector.split(":contains(")[0].split(" ")[-1]
             text = selector.split(":contains(")[1].split(")")[0][1:-1]
             with suppress(Exception):
+                new_timeout = timeout
+                if new_timeout < 1:
+                    new_timeout = 1
+                self.loop.run_until_complete(
+                    self.page.select(tag_name, timeout=new_timeout)
+                )
                 self.loop.run_until_complete(
-                    self.page.select(tag_name, timeout=5)
+                    self.page.find(text, timeout=new_timeout)
                 )
-                self.loop.run_until_complete(self.page.find(text, timeout=5))
-            element = self.find_elements_by_text(text, tag_name=tag_name)[0]
-            return self.__add_sync_methods(element)
+            elements = self.find_elements_by_text(text, tag_name=tag_name)
+            if not elements:
+                plural = "s"
+                if timeout == 1:
+                    plural = ""
+                msg = "\n Element {%s} was not found after %s second%s!"
+                message = msg % (selector, timeout, plural)
+                raise Exception(message)
+            element = self.__add_sync_methods(elements[0])
+            return element
         failure = False
         try:
             element = self.loop.run_until_complete(
@@ -305,11 +332,8 @@ class CDPMethods():
             plural = "s"
             if timeout == 1:
                 plural = ""
-            message = "\n Element {%s} was not found after %s second%s!" % (
-                selector,
-                timeout,
-                plural,
-            )
+            msg = "\n Element {%s} was not found after %s second%s!"
+            message = msg % (selector, timeout, plural)
         if failure:
             raise Exception(message)
         element = self.__add_sync_methods(element)
@@ -421,6 +445,39 @@ class CDPMethods():
             self.loop.run_until_complete(element.focus_async())
         )
 
+    def __gui_click(self, element, timeframe=None):
+        element.scroll_into_view()
+        self.__add_light_pause()
+        position = element.get_position()
+        x = position.x
+        y = position.y
+        e_width = position.width
+        e_height = position.height
+        # Relative to window
+        element_rect = {"height": e_height, "width": e_width, "x": x, "y": y}
+        window_rect = self.get_window_rect()
+        w_bottom_y = window_rect["y"] + window_rect["height"]
+        viewport_height = window_rect["innerHeight"]
+        x = window_rect["x"] + element_rect["x"]
+        y = w_bottom_y - viewport_height + element_rect["y"]
+        y_scroll_offset = window_rect["pageYOffset"]
+        y = y - y_scroll_offset
+        x = x + window_rect["scrollX"]
+        y = y + window_rect["scrollY"]
+        # Relative to screen
+        element_rect = {"height": e_height, "width": e_width, "x": x, "y": y}
+        e_width = element_rect["width"]
+        e_height = element_rect["height"]
+        e_x = element_rect["x"]
+        e_y = element_rect["y"]
+        x, y = ((e_x + e_width / 2.0) + 0.5), ((e_y + e_height / 2.0) + 0.5)
+        if not timeframe or not isinstance(timeframe, (int, float)):
+            timeframe = 0.25
+        if timeframe > 3:
+            timeframe = 3
+        self.gui_click_x_y(x, y, timeframe=timeframe)
+        return self.loop.run_until_complete(self.page.wait())
+
     def __highlight_overlay(self, element):
         return (
             self.loop.run_until_complete(element.highlight_overlay_async())
@@ -443,6 +500,21 @@ class CDPMethods():
             self.loop.run_until_complete(element.mouse_move_async())
         )
 
+    def __press_keys(self, element, text):
+        element.scroll_into_view()
+        submit = False
+        if text.endswith("\n") or text.endswith("\r"):
+            submit = True
+            text = text[:-1]
+        for key in text:
+            element.send_keys(key)
+            time.sleep(0.044)
+        if submit:
+            element.send_keys("\r\n")
+            time.sleep(0.044)
+        self.__slow_mode_pause_if_set()
+        return self.loop.run_until_complete(self.page.sleep(0.025))
+
     def __query_selector(self, element, selector):
         selector = self.__convert_to_css_if_xpath(selector)
         element2 = self.loop.run_until_complete(
@@ -549,6 +621,9 @@ class CDPMethods():
                 pass
         return None
 
+    def __get_parent(self, element):
+        return self.__add_sync_methods(element.parent)
+
     def __get_x_scroll_offset(self):
         x_scroll_offset = self.loop.run_until_complete(
             self.page.evaluate("window.pageXOffset")
@@ -769,6 +844,11 @@ class CDPMethods():
     def highlight_overlay(self, selector):
         self.find_element(selector).highlight_overlay()
 
+    def get_parent(self, element):
+        if isinstance(element, str):
+            element = self.select(element)
+        return self.__add_sync_methods(element.parent)
+
     def remove_element(self, selector):
         self.select(selector).remove_from_dom()
 
@@ -800,7 +880,7 @@ class CDPMethods():
             text = text[:-1] + "\r\n"
         element.send_keys(text)
         self.__slow_mode_pause_if_set()
-        self.loop.run_until_complete(self.page.wait())
+        self.loop.run_until_complete(self.page.sleep(0.025))
 
     def press_keys(self, selector, text, timeout=None):
         """Similar to send_keys(), but presses keys at human speed."""
@@ -820,7 +900,7 @@ class CDPMethods():
             element.send_keys("\r\n")
             time.sleep(0.044)
         self.__slow_mode_pause_if_set()
-        self.loop.run_until_complete(self.page.wait())
+        self.loop.run_until_complete(self.page.sleep(0.025))
 
     def type(self, selector, text, timeout=None):
         """Similar to send_keys(), but clears the text field first."""
@@ -835,7 +915,7 @@ class CDPMethods():
             text = text[:-1] + "\r\n"
         element.send_keys(text)
         self.__slow_mode_pause_if_set()
-        self.loop.run_until_complete(self.page.wait())
+        self.loop.run_until_complete(self.page.sleep(0.025))
 
     def set_value(self, selector, text, timeout=None):
         """Similar to send_keys(), but clears the text field first."""
@@ -873,7 +953,21 @@ class CDPMethods():
             self.__add_light_pause()
             self.send_keys(selector, "\n")
         self.__slow_mode_pause_if_set()
-        self.loop.run_until_complete(self.page.wait())
+        self.loop.run_until_complete(self.page.sleep(0.025))
+
+    def submit(self, selector):
+        submit_script = (
+            """elm = document.querySelector('%s');
+            const event = new KeyboardEvent("keydown", {
+                key: "Enter",
+                keyCode: 13,
+                code: "Enter",
+                which: 13,
+                bubbles: true
+            });
+            elm.dispatchEvent(event);""" % selector
+        )
+        self.loop.run_until_complete(self.page.evaluate(submit_script))
 
     def evaluate(self, expression):
         """Run a JavaScript expression and return the result."""
@@ -934,10 +1028,61 @@ class CDPMethods():
         self.set_window_rect(x, y, width, height)
         self.__add_light_pause()
 
+    def open_new_window(self, url=None, switch_to=True):
+        return self.open_new_tab(url=url, switch_to=switch_to)
+
+    def switch_to_window(self, window):
+        self.switch_to_tab(window)
+
+    def switch_to_newest_window(self):
+        self.switch_to_tab(-1)
+
+    def open_new_tab(self, url=None, switch_to=True):
+        if not isinstance(url, str):
+            url = "about:blank"
+        self.loop.run_until_complete(self.page.get(url, new_tab=True))
+        if switch_to:
+            self.switch_to_newest_tab()
+
+    def switch_to_tab(self, tab):
+        driver = self.driver
+        if hasattr(driver, "cdp_base"):
+            driver = driver.cdp_base
+        if isinstance(tab, int):
+            self.page = driver.tabs[tab]
+        elif isinstance(tab, cdp_util.Tab):
+            self.page = tab
+        else:
+            raise Exception("`tab` must be an int or a Tab type!")
+        self.bring_active_window_to_front()
+
+    def switch_to_newest_tab(self):
+        self.switch_to_tab(-1)
+
+    def close_active_tab(self):
+        """Close the active tab.
+        The active tab is the one currenly controlled by CDP.
+        The active tab MIGHT NOT be the currently visible tab!
+        (If a page opens a new tab, the new tab WON'T be active)
+        To switch the active tab, call: sb.switch_to_tab(tab)"""
+        return self.loop.run_until_complete(self.page.close())
+
+    def get_active_tab(self):
+        """Return the active tab.
+        The active tab is the one currenly controlled by CDP.
+        The active tab MIGHT NOT be the currently visible tab!
+        (If a page opens a new tab, the new tab WON'T be active)
+        To switch the active tab, call: sb.switch_to_tab(tab)"""
+        return self.page
+
+    def get_tabs(self):
+        driver = self.driver
+        if hasattr(driver, "cdp_base"):
+            driver = driver.cdp_base
+        return driver.tabs
+
     def get_window(self):
-        return self.loop.run_until_complete(
-            self.page.get_window()
-        )
+        return self.loop.run_until_complete(self.page.get_window())
 
     def get_text(self, selector):
         return self.find_element(selector).text_all
@@ -984,6 +1129,16 @@ class CDPMethods():
             self.page.evaluate("navigator.language || navigator.languages[0]")
         )
 
+    def get_local_storage_item(self, key):
+        js_code = """localStorage.getItem('%s');""" % key
+        with suppress(Exception):
+            return self.loop.run_until_complete(self.page.evaluate(js_code))
+
+    def get_session_storage_item(self, key):
+        js_code = """sessionStorage.getItem('%s');""" % key
+        with suppress(Exception):
+            return self.loop.run_until_complete(self.page.evaluate(js_code))
+
     def get_screen_rect(self):
         coordinates = self.loop.run_until_complete(
             self.page.js_dumps("window.screen")
@@ -1131,14 +1286,10 @@ class CDPMethods():
         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(
-            self.page.get_document()
-        )
+        return self.loop.run_until_complete(self.page.get_document())
 
     def get_flattened_document(self):
-        return self.loop.run_until_complete(
-            self.page.get_flattened_document()
-        )
+        return self.loop.run_until_complete(self.page.get_flattened_document())
 
     def get_element_attributes(self, selector):
         selector = self.__convert_to_css_if_xpath(selector)
@@ -1175,6 +1326,16 @@ class CDPMethods():
         """(Settings will take effect on the next page load)"""
         self.loop.run_until_complete(self.page.set_locale(locale))
 
+    def set_local_storage_item(self, key, value):
+        js_code = """localStorage.setItem('%s','%s');""" % (key, value)
+        with suppress(Exception):
+            self.loop.run_until_complete(self.page.evaluate(js_code))
+
+    def set_session_storage_item(self, key, value):
+        js_code = """sessionStorage.setItem('%s','%s');""" % (key, value)
+        with suppress(Exception):
+            self.loop.run_until_complete(self.page.evaluate(js_code))
+
     def set_attributes(self, selector, attribute, value):
         """This method uses JavaScript to set/update a common attribute.
         All matching selectors from querySelectorAll() are used.
@@ -1313,7 +1474,7 @@ class CDPMethods():
             pyautogui.press(key)
             time.sleep(0.044)
         self.__slow_mode_pause_if_set()
-        self.loop.run_until_complete(self.page.wait())
+        self.loop.run_until_complete(self.page.sleep(0.025))
 
     def gui_press_keys(self, keys):
         self.__install_pyautogui_if_missing()
@@ -1328,7 +1489,7 @@ class CDPMethods():
                 pyautogui.press(key)
                 time.sleep(0.044)
         self.__slow_mode_pause_if_set()
-        self.loop.run_until_complete(self.page.wait())
+        self.loop.run_until_complete(self.page.sleep(0.025))
 
     def gui_write(self, text):
         self.__install_pyautogui_if_missing()
@@ -1341,7 +1502,7 @@ class CDPMethods():
             self.__make_sure_pyautogui_lock_is_writable()
             pyautogui.write(text)
         self.__slow_mode_pause_if_set()
-        self.loop.run_until_complete(self.page.wait())
+        self.loop.run_until_complete(self.page.sleep(0.025))
 
     def __gui_click_x_y(self, x, y, timeframe=0.25, uc_lock=False):
         self.__install_pyautogui_if_missing()
@@ -1671,59 +1832,93 @@ class CDPMethods():
                 return True
             return False
 
-    def wait_for_element_visible(self, selector, timeout=None):
-        if not timeout:
-            timeout = settings.SMALL_TIMEOUT
+    def is_text_visible(self, text, selector="body"):
+        selector = self.__convert_to_css_if_xpath(selector)
+        text = text.strip()
+        element = None
         try:
-            self.select(selector, timeout=timeout)
+            element = self.find_element(selector, timeout=0.1)
         except Exception:
-            raise Exception("Element {%s} was not found!" % selector)
-        for i in range(30):
-            if self.is_element_visible(selector):
-                return self.select(selector)
-            time.sleep(0.1)
-        raise Exception("Element {%s} was not visible!" % selector)
+            return False
+        with suppress(Exception):
+            if text in element.text_all:
+                return True
+        return False
 
-    def assert_element(self, selector, timeout=None):
-        """Same as assert_element_visible()"""
+    def is_exact_text_visible(self, text, selector="body"):
+        selector = self.__convert_to_css_if_xpath(selector)
+        text = text.strip()
+        element = None
+        try:
+            element = self.find_element(selector, timeout=0.1)
+        except Exception:
+            return False
+        with suppress(Exception):
+            if text == element.text_all.strip():
+                return True
+        return False
+
+    def wait_for_text(self, text, selector="body", timeout=None):
         if not timeout:
             timeout = settings.SMALL_TIMEOUT
+        start_ms = time.time() * 1000.0
+        stop_ms = start_ms + (timeout * 1000.0)
+        text = text.strip()
+        element = None
         try:
-            self.select(selector, timeout=timeout)
+            element = self.find_element(selector, timeout=timeout)
         except Exception:
-            raise Exception("Element {%s} was not found!" % selector)
-        for i in range(30):
-            if self.is_element_visible(selector):
+            raise Exception("Element {%s} not found!" % selector)
+        for i in range(int(timeout * 10)):
+            with suppress(Exception):
+                element = self.find_element(selector, timeout=0.1)
+            if text in element.text_all:
                 return True
+            now_ms = time.time() * 1000.0
+            if now_ms >= stop_ms:
+                break
             time.sleep(0.1)
-        raise Exception("Element {%s} was not visible!" % selector)
+        raise Exception(
+            "Text {%s} not found in {%s}! Actual text: {%s}"
+            % (text, selector, element.text_all)
+        )
 
-    def assert_element_visible(self, selector, timeout=None):
-        """Same as assert_element()"""
+    def wait_for_text_not_visible(self, text, selector="body", timeout=None):
         if not timeout:
             timeout = settings.SMALL_TIMEOUT
-        try:
-            self.select(selector, timeout=timeout)
-        except Exception:
-            raise Exception("Element {%s} was not found!" % selector)
-        for i in range(30):
-            if self.is_element_visible(selector):
+        text = text.strip()
+        start_ms = time.time() * 1000.0
+        stop_ms = start_ms + (timeout * 1000.0)
+        for i in range(int(timeout * 10)):
+            if not self.is_text_visible(text, selector):
                 return True
+            now_ms = time.time() * 1000.0
+            if now_ms >= stop_ms:
+                break
             time.sleep(0.1)
-        raise Exception("Element {%s} was not visible!" % selector)
+        plural = "s"
+        if timeout == 1:
+            plural = ""
+        raise Exception(
+            "Text {%s} in {%s} was still visible after %s second%s!"
+            % (text, selector, timeout, plural)
+        )
 
-    def assert_element_present(self, selector, timeout=None):
-        """Assert element is present in the DOM. (Visibility NOT required)"""
+    def wait_for_element_visible(self, selector, timeout=None):
         if not timeout:
             timeout = settings.SMALL_TIMEOUT
         try:
             self.select(selector, timeout=timeout)
         except Exception:
             raise Exception("Element {%s} was not found!" % selector)
-        return True
+        for i in range(30):
+            if self.is_element_visible(selector):
+                return self.select(selector)
+            time.sleep(0.1)
+        raise Exception("Element {%s} was not visible!" % selector)
 
-    def assert_element_absent(self, selector, timeout=None):
-        """Assert element is not present in the DOM."""
+    def wait_for_element_not_visible(self, selector, timeout=None):
+        """Wait for element to not be visible on page. (May still be in DOM)"""
         if not timeout:
             timeout = settings.SMALL_TIMEOUT
         start_ms = time.time() * 1000.0
@@ -1731,6 +1926,8 @@ class CDPMethods():
         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
@@ -1739,12 +1936,12 @@ class CDPMethods():
         if timeout == 1:
             plural = ""
         raise Exception(
-            "Element {%s} was still present after %s second%s!"
+            "Element {%s} was still visible after %s second%s!"
             % (selector, timeout, plural)
         )
 
-    def assert_element_not_visible(self, selector, timeout=None):
-        """Assert element is not visible on page. (May still be in DOM)"""
+    def wait_for_element_absent(self, selector, timeout=None):
+        """Wait for element to not be present in the DOM."""
         if not timeout:
             timeout = settings.SMALL_TIMEOUT
         start_ms = time.time() * 1000.0
@@ -1752,8 +1949,6 @@ class CDPMethods():
         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
@@ -1762,10 +1957,49 @@ class CDPMethods():
         if timeout == 1:
             plural = ""
         raise Exception(
-            "Element {%s} was still visible after %s second%s!"
+            "Element {%s} was still present after %s second%s!"
             % (selector, timeout, plural)
         )
 
+    def assert_element(self, selector, timeout=None):
+        """Same as assert_element_visible()"""
+        self.assert_element_visible(selector, timeout=timeout)
+        return True
+
+    def assert_element_visible(self, selector, timeout=None):
+        """Same as assert_element()"""
+        if not timeout:
+            timeout = settings.SMALL_TIMEOUT
+        try:
+            self.select(selector, timeout=timeout)
+        except Exception:
+            raise Exception("Element {%s} was not found!" % selector)
+        for i in range(30):
+            if self.is_element_visible(selector):
+                return True
+            time.sleep(0.1)
+        raise Exception("Element {%s} was not visible!" % selector)
+
+    def assert_element_present(self, selector, timeout=None):
+        """Assert element is present in the DOM. (Visibility NOT required)"""
+        if not timeout:
+            timeout = settings.SMALL_TIMEOUT
+        try:
+            self.select(selector, timeout=timeout)
+        except Exception:
+            raise Exception("Element {%s} was not found!" % selector)
+        return True
+
+    def assert_element_absent(self, selector, timeout=None):
+        """Assert element is not present in the DOM."""
+        self.wait_for_element_absent(selector, timeout=timeout)
+        return True
+
+    def assert_element_not_visible(self, selector, timeout=None):
+        """Assert element is not visible on page. (May still be in DOM)"""
+        self.wait_for_element_not_visible(selector, timeout=timeout)
+        return True
+
     def assert_element_attribute(self, selector, attribute, value=None):
         attributes = self.get_element_attributes(selector)
         if attribute not in attributes:
@@ -1842,29 +2076,9 @@ class CDPMethods():
                 raise Exception(error % (expected, actual))
 
     def assert_text(self, text, selector="body", timeout=None):
-        if not timeout:
-            timeout = settings.SMALL_TIMEOUT
-        start_ms = time.time() * 1000.0
-        stop_ms = start_ms + (timeout * 1000.0)
-        text = text.strip()
-        element = None
-        try:
-            element = self.find_element(selector, timeout=timeout)
-        except Exception:
-            raise Exception("Element {%s} not found!" % selector)
-        for i in range(int(timeout * 10)):
-            with suppress(Exception):
-                element = self.find_element(selector, timeout=0.1)
-            if text in element.text_all:
-                return True
-            now_ms = time.time() * 1000.0
-            if now_ms >= stop_ms:
-                break
-            time.sleep(0.1)
-        raise Exception(
-            "Text {%s} not found in {%s}! Actual text: {%s}"
-            % (text, selector, element.text_all)
-        )
+        """Same as wait_for_text()"""
+        self.wait_for_text(text, selector=selector, timeout=timeout)
+        return True
 
     def assert_exact_text(self, text, selector="body", timeout=None):
         if not timeout:
@@ -1894,6 +2108,13 @@ class CDPMethods():
             % (text, element.text_all, selector)
         )
 
+    def assert_text_not_visible(self, text, selector="body", timeout=None):
+        """Raises an exception if the text is still visible after timeout."""
+        self.wait_for_text_not_visible(
+            text, selector=selector, timeout=timeout
+        )
+        return True
+
     def assert_true(self, expression):
         if not expression:
             raise AssertionError("%s is not true" % expression)
@@ -1959,3 +2180,19 @@ class CDPMethods():
             )
         else:
             self.select(selector).save_screenshot(filename)
+
+    def print_to_pdf(self, name, folder=None):
+        filename = name
+        if folder:
+            filename = os.path.join(folder, name)
+        self.loop.run_until_complete(self.page.print_to_pdf(filename))
+
+
+class Chrome(CDPMethods):
+    def __init__(self, url=None, **kwargs):
+        if not url:
+            url = "about:blank"
+        loop = asyncio.new_event_loop()
+        driver = cdp_util.start_sync(**kwargs)
+        page = loop.run_until_complete(driver.get(url))
+        super().__init__(loop, page, driver)