playwright-ruby-client 0.0.5 → 0.0.6

data/lib/playwright_api/file_chooser.rb

@@ -7,6 +7,14 @@ module Playwright
   #   await fileChooser.setFiles('/tmp/myfile.pdf');
   # });
   # ```
+  # 
+  # ```python async
+  # page.on("filechooser", lambda file_chooser: file_chooser.set_files("/tmp/myfile.pdf"))
+  # ```
+  # 
+  # ```python sync
+  # page.on("filechooser", lambda file_chooser: file_chooser.set_files("/tmp/myfile.pdf"))
+  # ```
   class FileChooser < PlaywrightApi
 
     # Returns input element associated with this file chooser.

data/lib/playwright_api/frame.rb

@@ -31,13 +31,47 @@ module Playwright
   # })();
   # ```
   # 
-  # An example of getting text from an iframe element:
+  # ```python async
+  # import asyncio
+  # from playwright.async_api import async_playwright
   # 
-  #
-  # ```js
-  # const frame = page.frames().find(frame => frame.name() === 'myframe');
-  # const text = await frame.$eval('.selector', element => element.textContent);
-  # console.log(text);
+  # async def run(playwright):
+  #     firefox = playwright.firefox
+  #     browser = await firefox.launch()
+  #     page = await browser.new_page()
+  #     await page.goto("https://www.theverge.com")
+  #     dump_frame_tree(page.main_frame, "")
+  #     await browser.close()
+  # 
+  # def dump_frame_tree(frame, indent):
+  #     print(indent + frame.name + '@' + frame.url)
+  #     for child in frame.child_frames:
+  #         dump_frame_tree(child, indent + "    ")
+  # 
+  # async def main():
+  #     async with async_playwright() as playwright:
+  #         await run(playwright)
+  # asyncio.run(main())
+  # ```
+  # 
+  # ```python sync
+  # from playwright.sync_api import sync_playwright
+  # 
+  # def run(playwright):
+  #     firefox = playwright.firefox
+  #     browser = firefox.launch()
+  #     page = browser.new_page()
+  #     page.goto("https://www.theverge.com")
+  #     dump_frame_tree(page.main_frame, "")
+  #     browser.close()
+  # 
+  # def dump_frame_tree(frame, indent):
+  #     print(indent + frame.name + '@' + frame.url)
+  #     for child in frame.child_frames:
+  #         dump_frame_tree(child, indent + "    ")
+  # 
+  # with sync_playwright() as playwright:
+  #     run(playwright)
   # ```
   class Frame < PlaywrightApi
 
@@ -47,7 +81,7 @@ module Playwright
     # [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector,
     # returns `null`.
     def query_selector(selector)
-      raise NotImplementedError.new('query_selector is not implemented yet.')
+      wrap_impl(@impl.query_selector(selector))
     end
 
     # Returns the ElementHandles pointing to the frame elements.
@@ -56,7 +90,7 @@ module Playwright
     # [Working with selectors](./selectors.md#working-with-selectors) for more details. If no elements match the selector,
     # returns empty array.
     def query_selector_all(selector)
-      raise NotImplementedError.new('query_selector_all is not implemented yet.')
+      wrap_impl(@impl.query_selector_all(selector))
     end
 
     # Returns the return value of `pageFunction`
@@ -75,8 +109,20 @@ module Playwright
     # const preloadHref = await frame.$eval('link[rel=preload]', el => el.href);
     # const html = await frame.$eval('.main-container', (e, suffix) => e.outerHTML + suffix, 'hello');
     # ```
+    # 
+    # ```python async
+    # search_value = await frame.eval_on_selector("#search", "el => el.value")
+    # preload_href = await frame.eval_on_selector("link[rel=preload]", "el => el.href")
+    # html = await frame.eval_on_selector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello")
+    # ```
+    # 
+    # ```python sync
+    # search_value = frame.eval_on_selector("#search", "el => el.value")
+    # preload_href = frame.eval_on_selector("link[rel=preload]", "el => el.href")
+    # html = frame.eval_on_selector(".main-container", "(e, suffix) => e.outerHTML + suffix", "hello")
+    # ```
     def eval_on_selector(selector, pageFunction, arg: nil)
-      raise NotImplementedError.new('eval_on_selector is not implemented yet.')
+      wrap_impl(@impl.eval_on_selector(selector, pageFunction, arg: arg))
     end
 
     # Returns the return value of `pageFunction`
@@ -93,8 +139,16 @@ module Playwright
     # ```js
     # const divsCounts = await frame.$$eval('div', (divs, min) => divs.length >= min, 10);
     # ```
+    # 
+    # ```python async
+    # divs_counts = await frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
+    # ```
+    # 
+    # ```python sync
+    # divs_counts = frame.eval_on_selector_all("div", "(divs, min) => divs.length >= min", 10)
+    # ```
     def eval_on_selector_all(selector, pageFunction, arg: nil)
-      raise NotImplementedError.new('eval_on_selector_all is not implemented yet.')
+      wrap_impl(@impl.eval_on_selector_all(selector, pageFunction, arg: arg))
     end
 
     # Returns the added tag when the script's onload fires or when the script content was injected into frame.
@@ -130,7 +184,7 @@ module Playwright
     end
 
     def child_frames
-      wrap_channel_owner(@channel_owner.child_frames)
+      wrap_impl(@impl.child_frames)
     end
 
     # This method clicks an element matching `selector` by performing the following steps:
@@ -153,12 +207,12 @@ module Playwright
           noWaitAfter: nil,
           position: nil,
           timeout: nil)
-      raise NotImplementedError.new('click is not implemented yet.')
+      wrap_impl(@impl.click(selector, button: button, clickCount: clickCount, delay: delay, force: force, modifiers: modifiers, noWaitAfter: noWaitAfter, position: position, timeout: timeout))
     end
 
     # Gets the full HTML contents of the frame, including the doctype.
     def content
-      wrap_channel_owner(@channel_owner.content)
+      wrap_impl(@impl.content)
     end
 
     # This method double clicks an element matching `selector` by performing the following steps:
@@ -173,7 +227,7 @@ module Playwright
     # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
     # Passing zero timeout disables this.
     # 
-    # > **NOTE** `frame.dblclick()` dispatches two `click` events and a single `dblclick` event.
+    # > NOTE: `frame.dblclick()` dispatches two `click` events and a single `dblclick` event.
     def dblclick(
           selector,
           button: nil,
@@ -195,6 +249,14 @@ module Playwright
     # await frame.dispatchEvent('button#submit', 'click');
     # ```
     # 
+    # ```python async
+    # await frame.dispatch_event("button#submit", "click")
+    # ```
+    # 
+    # ```python sync
+    # frame.dispatch_event("button#submit", "click")
+    # ```
+    # 
     # Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
     # and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
     # 
@@ -215,18 +277,30 @@ module Playwright
     # const dataTransfer = await frame.evaluateHandle(() => new DataTransfer());
     # await frame.dispatchEvent('#source', 'dragstart', { dataTransfer });
     # ```
+    # 
+    # ```python async
+    # # note you can only create data_transfer in chromium and firefox
+    # data_transfer = await frame.evaluate_handle("new DataTransfer()")
+    # await frame.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
+    # ```
+    # 
+    # ```python sync
+    # # note you can only create data_transfer in chromium and firefox
+    # data_transfer = frame.evaluate_handle("new DataTransfer()")
+    # frame.dispatch_event("#source", "dragstart", { "dataTransfer": data_transfer })
+    # ```
     def dispatch_event(selector, type, eventInit: nil, timeout: nil)
       raise NotImplementedError.new('dispatch_event is not implemented yet.')
     end
 
     # Returns the return value of `pageFunction`
     # 
-    # If the function passed to the `frame.evaluate` returns a [Promise], then `frame.evaluate` would wait for the promise to
-    # resolve and return its value.
+    # If the function passed to the [`method: Frame.evaluate`] returns a [Promise], then [`method: Frame.evaluate`] would wait
+    # for the promise to resolve and return its value.
     # 
-    # If the function passed to the `frame.evaluate` returns a non-[Serializable] value, then `frame.evaluate` returns
-    # `undefined`. DevTools Protocol also supports transferring some additional values that are not serializable by `JSON`:
-    # `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
+    # If the function passed to the [`method: Frame.evaluate`] returns a non-[Serializable] value,
+    # then[ method: `Frame.evaluate`] returns `undefined`. DevTools Protocol also supports transferring some additional values
+    # that are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
     # 
     #
     # ```js
@@ -236,6 +310,16 @@ module Playwright
     # console.log(result); // prints "56"
     # ```
     # 
+    # ```python async
+    # result = await frame.evaluate("([x, y]) => Promise.resolve(x * y)", [7, 8])
+    # print(result) # prints "56"
+    # ```
+    # 
+    # ```python sync
+    # result = frame.evaluate("([x, y]) => Promise.resolve(x * y)", [7, 8])
+    # print(result) # prints "56"
+    # ```
+    # 
     # A string can also be passed in instead of a function.
     # 
     #
@@ -243,7 +327,19 @@ module Playwright
     # console.log(await frame.evaluate('1 + 2')); // prints "3"
     # ```
     # 
-    # `ElementHandle` instances can be passed as an argument to the `frame.evaluate`:
+    # ```python async
+    # print(await frame.evaluate("1 + 2")) # prints "3"
+    # x = 10
+    # print(await frame.evaluate(f"1 + {x}")) # prints "11"
+    # ```
+    # 
+    # ```python sync
+    # print(frame.evaluate("1 + 2")) # prints "3"
+    # x = 10
+    # print(frame.evaluate(f"1 + {x}")) # prints "11"
+    # ```
+    # 
+    # `ElementHandle` instances can be passed as an argument to the [`method: Frame.evaluate`]:
     # 
     #
     # ```js
@@ -251,17 +347,29 @@ module Playwright
     # const html = await frame.evaluate(([body, suffix]) => body.innerHTML + suffix, [bodyHandle, 'hello']);
     # await bodyHandle.dispose();
     # ```
+    # 
+    # ```python async
+    # body_handle = await frame.query_selector("body")
+    # html = await frame.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
+    # await body_handle.dispose()
+    # ```
+    # 
+    # ```python sync
+    # body_handle = frame.query_selector("body")
+    # html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
+    # body_handle.dispose()
+    # ```
     def evaluate(pageFunction, arg: nil)
-      wrap_channel_owner(@channel_owner.evaluate(pageFunction, arg: arg))
+      wrap_impl(@impl.evaluate(pageFunction, arg: arg))
     end
 
     # Returns the return value of `pageFunction` as in-page object (JSHandle).
     # 
-    # The only difference between `frame.evaluate` and `frame.evaluateHandle` is that `frame.evaluateHandle` returns in-page
-    # object (JSHandle).
+    # The only difference between [`method: Frame.evaluate`] and [`method: Frame.evaluateHandle`] is
+    # that[ method: Fframe.evaluateHandle`] returns in-page object (JSHandle).
     # 
-    # If the function, passed to the `frame.evaluateHandle`, returns a [Promise], then `frame.evaluateHandle` would wait for
-    # the promise to resolve and return its value.
+    # If the function, passed to the [`method: Frame.evaluateHandle`], returns a [Promise],
+    # then[ method: Fframe.evaluateHandle`] would wait for the promise to resolve and return its value.
     # 
     #
     # ```js
@@ -269,6 +377,17 @@ module Playwright
     # aWindowHandle; // Handle for the window object.
     # ```
     # 
+    # ```python async
+    # # FIXME
+    # a_window_handle = await frame.evaluate_handle("Promise.resolve(window)")
+    # a_window_handle # handle for the window object.
+    # ```
+    # 
+    # ```python sync
+    # a_window_handle = frame.evaluate_handle("Promise.resolve(window)")
+    # a_window_handle # handle for the window object.
+    # ```
+    # 
     # A string can also be passed in instead of a function.
     # 
     #
@@ -276,7 +395,15 @@ module Playwright
     # const aHandle = await frame.evaluateHandle('document'); // Handle for the 'document'.
     # ```
     # 
-    # `JSHandle` instances can be passed as an argument to the `frame.evaluateHandle`:
+    # ```python async
+    # a_handle = await page.evaluate_handle("document") # handle for the "document"
+    # ```
+    # 
+    # ```python sync
+    # a_handle = page.evaluate_handle("document") # handle for the "document"
+    # ```
+    # 
+    # `JSHandle` instances can be passed as an argument to the [`method: Frame.evaluateHandle`]:
     # 
     #
     # ```js
@@ -285,8 +412,22 @@ module Playwright
     # console.log(await resultHandle.jsonValue());
     # await resultHandle.dispose();
     # ```
+    # 
+    # ```python async
+    # a_handle = await page.evaluate_handle("document.body")
+    # result_handle = await page.evaluate_handle("body => body.innerHTML", a_handle)
+    # print(await result_handle.json_value())
+    # await result_handle.dispose()
+    # ```
+    # 
+    # ```python sync
+    # a_handle = page.evaluate_handle("document.body")
+    # result_handle = page.evaluate_handle("body => body.innerHTML", a_handle)
+    # print(result_handle.json_value())
+    # result_handle.dispose()
+    # ```
     def evaluate_handle(pageFunction, arg: nil)
-      wrap_channel_owner(@channel_owner.evaluate_handle(pageFunction, arg: arg))
+      wrap_impl(@impl.evaluate_handle(pageFunction, arg: arg))
     end
 
     # This method waits for an element matching `selector`, waits for [actionability](./actionability.md) checks, focuses the
@@ -302,7 +443,7 @@ module Playwright
     # This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
     # waits until a matching element appears in the DOM.
     def focus(selector, timeout: nil)
-      wrap_channel_owner(@channel_owner.focus(selector, timeout: timeout))
+      wrap_impl(@impl.focus(selector, timeout: timeout))
     end
 
     # Returns the `frame` or `iframe` element handle which corresponds to this frame.
@@ -318,6 +459,18 @@ module Playwright
     # const contentFrame = await frameElement.contentFrame();
     # console.log(frame === contentFrame);  // -> true
     # ```
+    # 
+    # ```python async
+    # frame_element = await frame.frame_element()
+    # content_frame = await frame_element.content_frame()
+    # assert frame == content_frame
+    # ```
+    # 
+    # ```python sync
+    # frame_element = frame.frame_element()
+    # content_frame = frame_element.content_frame()
+    # assert frame == content_frame
+    # ```
     def frame_element
       raise NotImplementedError.new('frame_element is not implemented yet.')
     end
@@ -341,12 +494,12 @@ module Playwright
     # "Not Found" and 500 "Internal Server Error".  The status code for such responses can be retrieved by calling
     # [`method: Response.status`].
     # 
-    # > **NOTE** `frame.goto` either throws an error or returns a main resource response. The only exceptions are navigation
-    # to `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.
-    # > **NOTE** Headless mode doesn't support navigation to a PDF document. See the
+    # > NOTE: `frame.goto` either throws an error or returns a main resource response. The only exceptions are navigation to
+    # `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.
+    # > NOTE: Headless mode doesn't support navigation to a PDF document. See the
     # [upstream issue](https://bugs.chromium.org/p/chromium/issues/detail?id=761295).
     def goto(url, referer: nil, timeout: nil, waitUntil: nil)
-      wrap_channel_owner(@channel_owner.goto(url, referer: referer, timeout: timeout, waitUntil: waitUntil))
+      wrap_impl(@impl.goto(url, referer: referer, timeout: timeout, waitUntil: waitUntil))
     end
 
     # This method hovers over an element matching `selector` by performing the following steps:
@@ -417,20 +570,19 @@ module Playwright
     # 
     # If the name is empty, returns the id attribute instead.
     # 
-    # > **NOTE** This value is calculated once when the frame is created, and will not update if the attribute is changed
-    # later.
+    # > NOTE: This value is calculated once when the frame is created, and will not update if the attribute is changed later.
     def name
-      wrap_channel_owner(@channel_owner.name)
+      wrap_impl(@impl.name)
     end
 
     # Returns the page containing this frame.
     def page
-      wrap_channel_owner(@channel_owner.page)
+      wrap_impl(@impl.page)
     end
 
     # Parent frame, if any. Detached frames and main frames return `null`.
     def parent_frame
-      wrap_channel_owner(@channel_owner.parent_frame)
+      wrap_impl(@impl.parent_frame)
     end
 
     # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
@@ -455,7 +607,7 @@ module Playwright
           delay: nil,
           noWaitAfter: nil,
           timeout: nil)
-      wrap_channel_owner(@channel_owner.press(selector, key, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
+      wrap_impl(@impl.press(selector, key, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
     end
 
     # Returns the array of option values that have been successfully selected.
@@ -463,6 +615,8 @@ module Playwright
     # Triggers a `change` and `input` event once all the provided options have been selected. If there's no `<select>` element
     # matching `selector`, the method throws an error.
     # 
+    # Will wait until all specified options are present in the `<select>` element.
+    # 
     #
     # ```js
     # // single selection matching the value
@@ -474,12 +628,30 @@ module Playwright
     # // multiple selection
     # frame.selectOption('select#colors', 'red', 'green', 'blue');
     # ```
+    # 
+    # ```python async
+    # # single selection matching the value
+    # await frame.select_option("select#colors", "blue")
+    # # single selection matching the label
+    # await frame.select_option("select#colors", label="blue")
+    # # multiple selection
+    # await frame.select_option("select#colors", value=["red", "green", "blue"])
+    # ```
+    # 
+    # ```python sync
+    # # single selection matching the value
+    # frame.select_option("select#colors", "blue")
+    # # single selection matching both the label
+    # frame.select_option("select#colors", label="blue")
+    # # multiple selection
+    # frame.select_option("select#colors", value=["red", "green", "blue"])
+    # ```
     def select_option(selector, values, noWaitAfter: nil, timeout: nil)
       raise NotImplementedError.new('select_option is not implemented yet.')
     end
 
     def set_content(html, timeout: nil, waitUntil: nil)
-      wrap_channel_owner(@channel_owner.set_content(html, timeout: timeout, waitUntil: waitUntil))
+      wrap_impl(@impl.set_content(html, timeout: timeout, waitUntil: waitUntil))
     end
     alias_method :content=, :set_content
 
@@ -503,7 +675,7 @@ module Playwright
     # When all steps combined have not finished during the specified `timeout`, this method rejects with a `TimeoutError`.
     # Passing zero timeout disables this.
     # 
-    # > **NOTE** `frame.tap()` requires that the `hasTouch` option of the browser context be set to true.
+    # > NOTE: `frame.tap()` requires that the `hasTouch` option of the browser context be set to true.
     def tap_point(
           selector,
           force: nil,
@@ -521,7 +693,7 @@ module Playwright
 
     # Returns the page title.
     def title
-      wrap_channel_owner(@channel_owner.title)
+      wrap_impl(@impl.title)
     end
 
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text. `frame.type` can be used to
@@ -534,13 +706,23 @@ module Playwright
     # await frame.type('#mytextarea', 'Hello'); // Types instantly
     # await frame.type('#mytextarea', 'World', {delay: 100}); // Types slower, like a user
     # ```
+    # 
+    # ```python async
+    # await frame.type("#mytextarea", "hello") # types instantly
+    # await frame.type("#mytextarea", "world", delay=100) # types slower, like a user
+    # ```
+    # 
+    # ```python sync
+    # frame.type("#mytextarea", "hello") # types instantly
+    # frame.type("#mytextarea", "world", delay=100) # types slower, like a user
+    # ```
     def type_text(
           selector,
           text,
           delay: nil,
           noWaitAfter: nil,
           timeout: nil)
-      wrap_channel_owner(@channel_owner.type_text(selector, text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
+      wrap_impl(@impl.type_text(selector, text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout))
     end
 
     # This method checks an element matching `selector` by performing the following steps:
@@ -562,7 +744,7 @@ module Playwright
 
     # Returns frame's url.
     def url
-      wrap_channel_owner(@channel_owner.url)
+      wrap_impl(@impl.url)
     end
 
     # Returns when the `pageFunction` returns a truthy value, returns that value.
@@ -583,6 +765,39 @@ module Playwright
     # })();
     # ```
     # 
+    # ```python async
+    # import asyncio
+    # from playwright.async_api import async_playwright
+    # 
+    # async def run(playwright):
+    #     webkit = playwright.webkit
+    #     browser = await webkit.launch()
+    #     page = await browser.new_page()
+    #     await page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);", force_expr=True)
+    #     await page.main_frame.wait_for_function("() => window.x > 0")
+    #     await browser.close()
+    # 
+    # async def main():
+    #     async with async_playwright() as playwright:
+    #         await run(playwright)
+    # asyncio.run(main())
+    # ```
+    # 
+    # ```python sync
+    # from playwright.sync_api import sync_playwright
+    # 
+    # def run(playwright):
+    #     webkit = playwright.webkit
+    #     browser = webkit.launch()
+    #     page = browser.new_page()
+    #     page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);", force_expr=True)
+    #     page.main_frame.wait_for_function("() => window.x > 0")
+    #     browser.close()
+    # 
+    # with sync_playwright() as playwright:
+    #     run(playwright)
+    # ```
+    # 
     # To pass an argument to the predicate of `frame.waitForFunction` function:
     # 
     #
@@ -590,6 +805,16 @@ module Playwright
     # const selector = '.foo';
     # await frame.waitForFunction(selector => !!document.querySelector(selector), selector);
     # ```
+    # 
+    # ```python async
+    # selector = ".foo"
+    # await frame.wait_for_function("selector => !!document.querySelector(selector)", selector)
+    # ```
+    # 
+    # ```python sync
+    # selector = ".foo"
+    # frame.wait_for_function("selector => !!document.querySelector(selector)", selector)
+    # ```
     def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)
       raise NotImplementedError.new('wait_for_function is not implemented yet.')
     end
@@ -604,13 +829,23 @@ module Playwright
     # await frame.click('button'); // Click triggers navigation.
     # await frame.waitForLoadState(); // Waits for 'load' state by default.
     # ```
+    # 
+    # ```python async
+    # await frame.click("button") # click triggers navigation.
+    # await frame.wait_for_load_state() # the promise resolves after "load" event.
+    # ```
+    # 
+    # ```python sync
+    # frame.click("button") # click triggers navigation.
+    # frame.wait_for_load_state() # the promise resolves after "load" event.
+    # ```
     def wait_for_load_state(state: nil, timeout: nil)
-      raise NotImplementedError.new('wait_for_load_state is not implemented yet.')
+      wrap_impl(@impl.wait_for_load_state(state: state, timeout: timeout))
     end
 
-    # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-    # last redirect. In case of navigation to a different anchor or navigation due to History API usage, the navigation will
-    # resolve with `null`.
+    # Waits for the frame navigation and returns the main resource response. In case of multiple redirects, the navigation
+    # will resolve with the response of the last redirect. In case of navigation to a different anchor or navigation due to
+    # History API usage, the navigation will resolve with `null`.
     # 
     # This method waits for the frame to navigate to a new URL. It is useful for when you run code which will indirectly cause
     # the frame to navigate. Consider this example:
@@ -618,15 +853,27 @@ module Playwright
     #
     # ```js
     # const [response] = await Promise.all([
-    #   frame.waitForNavigation(), // Wait for the navigation to finish
-    #   frame.click('a.my-link'), // Clicking the link will indirectly cause a navigation
+    #   frame.waitForNavigation(), // The promise resolves after navigation has finished
+    #   frame.click('a.delayed-navigation'), // Clicking the link will indirectly cause a navigation
     # ]);
     # ```
     # 
-    # **NOTE** Usage of the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) to change the URL is
+    # ```python async
+    # async with frame.expect_navigation():
+    #     await frame.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
+    # # Resolves after navigation has finished
+    # ```
+    # 
+    # ```python sync
+    # with frame.expect_navigation():
+    #     frame.click("a.delayed-navigation") # clicking the link will indirectly cause a navigation
+    # # Resolves after navigation has finished
+    # ```
+    # 
+    # > NOTE: Usage of the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) to change the URL is
     # considered a navigation.
-    def wait_for_navigation(timeout: nil, url: nil, waitUntil: nil)
-      raise NotImplementedError.new('wait_for_navigation is not implemented yet.')
+    def expect_navigation(timeout: nil, url: nil, waitUntil: nil)
+      raise NotImplementedError.new('expect_navigation is not implemented yet.')
     end
 
     # Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
@@ -640,21 +887,56 @@ module Playwright
     # 
     #
     # ```js
-    # const { webkit } = require('playwright');  // Or 'chromium' or 'firefox'.
+    # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
     # 
     # (async () => {
-    #   const browser = await webkit.launch();
+    #   const browser = await chromium.launch();
     #   const page = await browser.newPage();
-    #   let currentURL;
-    #   page.mainFrame()
-    #     .waitForSelector('img')
-    #     .then(() => console.log('First URL with image: ' + currentURL));
-    #   for (currentURL of ['https://example.com', 'https://google.com', 'https://bbc.com']) {
+    #   for (let currentURL of ['https://google.com', 'https://bbc.com']) {
     #     await page.goto(currentURL);
+    #     const element = await page.mainFrame().waitForSelector('img');
+    #     console.log('Loaded image: ' + await element.getAttribute('src'));
     #   }
     #   await browser.close();
     # })();
     # ```
+    # 
+    # ```python async
+    # import asyncio
+    # from playwright.async_api import async_playwright
+    # 
+    # async def run(playwright):
+    #     chromium = playwright.chromium
+    #     browser = await chromium.launch()
+    #     page = await browser.new_page()
+    #     for current_url in ["https://google.com", "https://bbc.com"]:
+    #         await page.goto(current_url, wait_until="domcontentloaded")
+    #         element = await page.main_frame.wait_for_selector("img")
+    #         print("Loaded image: " + str(await element.get_attribute("src")))
+    #     await browser.close()
+    # 
+    # async def main():
+    #     async with async_playwright() as playwright:
+    #         await run(playwright)
+    # asyncio.run(main())
+    # ```
+    # 
+    # ```python sync
+    # from playwright.sync_api import sync_playwright
+    # 
+    # def run(playwright):
+    #     chromium = playwright.chromium
+    #     browser = chromium.launch()
+    #     page = browser.new_page()
+    #     for current_url in ["https://google.com", "https://bbc.com"]:
+    #         page.goto(current_url, wait_until="domcontentloaded")
+    #         element = page.main_frame.wait_for_selector("img")
+    #         print("Loaded image: " + str(element.get_attribute("src")))
+    #     browser.close()
+    # 
+    # with sync_playwright() as playwright:
+    #     run(playwright)
+    # ```
     def wait_for_selector(selector, state: nil, timeout: nil)
       raise NotImplementedError.new('wait_for_selector is not implemented yet.')
     end
@@ -668,31 +950,36 @@ module Playwright
     end
 
     # @nodoc
-    def detached=(req)
-      wrap_channel_owner(@channel_owner.detached=(req))
+    def wait_for_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
+      wrap_impl(@impl.wait_for_navigation(timeout: timeout, url: url, waitUntil: waitUntil, &wrap_block_call(block)))
     end
 
     # @nodoc
     def after_initialize
-      wrap_channel_owner(@channel_owner.after_initialize)
+      wrap_impl(@impl.after_initialize)
+    end
+
+    # @nodoc
+    def detached=(req)
+      wrap_impl(@impl.detached=(req))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_channel_owner(@channel_owner.off(event, callback))
+    def on(event, callback)
+      wrap_impl(@impl.on(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_channel_owner(@channel_owner.once(event, callback))
+    def off(event, callback)
+      wrap_impl(@impl.off(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_channel_owner(@channel_owner.on(event, callback))
+    def once(event, callback)
+      wrap_impl(@impl.once(event, callback))
     end
   end
 end