playwright-ruby-client 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e631604c0af31dc184fd1bfe6953be910d4f19be8613e8a2a11c83a3d5e9049
-  data.tar.gz: b320853082ae065cc09195f09e35f9a5bf18edc3105c729c9bd4a4daeb804948
+  metadata.gz: 5c0e5286a6e8faaa590ce17ed083f4e6f93c54fb6899571c5edc2a99c4148b15
+  data.tar.gz: bccd47264ec992c5c901c94faf28ec346a606d75e4636ae80828e5d64a685bf0
 SHA512:
-  metadata.gz: 1ea608b469db2082b899c3b4c10cbfea703f222a79fb255a0d07d03eb46eacbd0274cb98c1c32a9241f120f5059bdb20fbc82a65a072c05e616bdbd4b76586aa
-  data.tar.gz: 50ea41552e79e96add337084c9a38961bae124dfcaf04c9fe3ab61ceb2cd5e8738f0ae6fffdb6e04157416593f351bc7177e03e0da75cf51a80e929e1bce3f42
+  metadata.gz: c34792ec1bb838c99b5a540833c7e02c718147738d2b6129eb9ba63f53e6d6d1460e5abc62f9e94fecec2bc9dd07321c9badc1c4e4173ae0548151ebcbc38e12
+  data.tar.gz: 12b99906a534b8ec3a5eef041824ec4d0357fe70e3a1c696dc4f11a95c1b54edbe8c7a5d67694c7b9dc846bd34fa6e18fbb3d84f241aa345a1d89c8af4ac4a39

data/documentation/docs/api/download.md

@@ -0,0 +1,97 @@
+---
+sidebar_position: 10
+---
+
+# Download
+
+[Download](./download) objects are dispatched by page via the [`event: Page.download`] event.
+
+All the downloaded files belonging to the browser context are deleted when the browser context is closed.
+
+Download event is emitted once the download starts. Download path becomes available once download completes:
+
+```ruby
+download = page.expect_download do
+  page.click('a')
+end
+
+# wait for download to complete
+path = download.path
+```
+
+> NOTE: Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the
+downloaded content. If `acceptDownloads` is not set, download events are emitted, but the actual download is not
+performed and user has no access to the downloaded files.
+
+## cancel
+
+```
+def cancel
+```
+
+Cancels a download. Will not fail if the download is already finished or canceled. Upon successful cancellations,
+`download.failure()` would resolve to `'canceled'`.
+
+## delete
+
+```
+def delete
+```
+
+Deletes the downloaded file. Will wait for the download to finish if necessary.
+
+## failure
+
+```
+def failure
+```
+
+Returns download error if any. Will wait for the download to finish if necessary.
+
+## page
+
+```
+def page
+```
+
+Get the page that the download belongs to.
+
+## path
+
+```
+def path
+```
+
+Returns path to the downloaded file in case of successful download. The method will wait for the download to finish if
+necessary. The method throws when connected remotely.
+
+Note that the download's file name is a random GUID, use [Download#suggested_filename](./download#suggested_filename) to get suggested file
+name.
+
+## save_as
+
+```
+def save_as(path)
+```
+
+Copy the download to a user-specified path. It is safe to call this method while the download is still in progress. Will
+wait for the download to finish if necessary.
+
+## suggested_filename
+
+```
+def suggested_filename
+```
+
+Returns suggested filename for this download. It is typically computed by the browser from the
+[`Content-Disposition`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) response header
+or the `download` attribute. See the spec on [whatwg](https://html.spec.whatwg.org/#downloading-resources). Different
+browsers can use different logic for computing it.
+
+## url
+
+```
+def url
+```
+
+Returns downloaded url.

data/documentation/docs/api/element_handle.md

@@ -10,10 +10,8 @@ ElementHandle represents an in-page DOM element. ElementHandles can be created w
 method.
 
 ```ruby
-page.goto("https://example.com")
 href_element = page.query_selector("a")
 href_element.click
-# ...
 ```
 
 ElementHandle prevents DOM element from garbage collection unless the handle is disposed with
@@ -22,6 +20,33 @@ ElementHandle prevents DOM element from garbage collection unless the handle is
 ElementHandle instances can be used as an argument in [Page#eval_on_selector](./page#eval_on_selector) and [Page#evaluate](./page#evaluate)
 methods.
 
+> NOTE: In most cases, you would want to use the [Locator](./locator) object instead. You should only use [ElementHandle](./element_handle) if you
+want to retain a handle to a particular DOM Node that you intend to pass into [Page#evaluate](./page#evaluate) as an argument.
+
+The difference between the [Locator](./locator) and ElementHandle is that the ElementHandle points to a particular element, while
+[Locator](./locator) captures the logic of how to retrieve an element.
+
+In the example below, handle points to a particular DOM element on page. If that element changes text or is used by
+React to render an entirely different component, handle is still pointing to that very DOM element. This can lead to
+unexpected behaviors.
+
+```ruby
+handle = page.query_selector("text=Submit")
+handle.hover
+handle.click
+```
+
+With the locator, every time the `element` is used, up-to-date DOM element is located in the page using the selector. So
+in the snippet below, underlying DOM element is going to be located twice.
+
+```ruby
+locator = page.locator("text=Submit")
+locator.hover
+locator.click
+```
+
+
+
 ## bounding_box
 
 ```

data/documentation/docs/api/frame.md

@@ -68,6 +68,7 @@ def check(
       force: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -106,6 +107,7 @@ def click(
       modifiers: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -140,6 +142,7 @@ def dblclick(
       modifiers: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -161,7 +164,12 @@ zero timeout disables this.
 ## dispatch_event
 
 ```
-def dispatch_event(selector, type, eventInit: nil, timeout: nil)
+def dispatch_event(
+      selector,
+      type,
+      eventInit: nil,
+      strict: nil,
+      timeout: nil)
 ```
 
 The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the element,
@@ -204,6 +212,7 @@ def drag_and_drop(
       target,
       force: nil,
       noWaitAfter: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -213,7 +222,7 @@ def drag_and_drop(
 ## eval_on_selector
 
 ```
-def eval_on_selector(selector, expression, arg: nil)
+def eval_on_selector(selector, expression, arg: nil, strict: nil)
 ```
 
 Returns the return value of `expression`.
@@ -345,6 +354,7 @@ def fill(
       value,
       force: nil,
       noWaitAfter: nil,
+      strict: nil,
       timeout: nil)
 ```
 
@@ -362,7 +372,7 @@ To send fine-grained keyboard events, use [Frame#type](./frame#type).
 ## focus
 
 ```
-def focus(selector, timeout: nil)
+def focus(selector, strict: nil, timeout: nil)
 ```
 
 This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
@@ -393,7 +403,7 @@ assert frame == content_frame
 ## get_attribute
 
 ```
-def get_attribute(selector, name, timeout: nil)
+def get_attribute(selector, name, strict: nil, timeout: nil)
 ```
 
 Returns element attribute value.
@@ -431,6 +441,7 @@ def hover(
       force: nil,
       modifiers: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -449,7 +460,7 @@ zero timeout disables this.
 ## inner_html
 
 ```
-def inner_html(selector, timeout: nil)
+def inner_html(selector, strict: nil, timeout: nil)
 ```
 
 Returns `element.innerHTML`.
@@ -457,7 +468,7 @@ Returns `element.innerHTML`.
 ## inner_text
 
 ```
-def inner_text(selector, timeout: nil)
+def inner_text(selector, strict: nil, timeout: nil)
 ```
 
 Returns `element.innerText`.
@@ -465,7 +476,7 @@ Returns `element.innerText`.
 ## input_value
 
 ```
-def input_value(selector, timeout: nil)
+def input_value(selector, strict: nil, timeout: nil)
 ```
 
 Returns `input.value` for the selected `<input>` or `<textarea>` element. Throws for non-input elements.
@@ -473,7 +484,7 @@ Returns `input.value` for the selected `<input>` or `<textarea>` element. Throws
 ## checked?
 
 ```
-def checked?(selector, timeout: nil)
+def checked?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
@@ -489,7 +500,7 @@ Returns `true` if the frame has been detached, or `false` otherwise.
 ## disabled?
 
 ```
-def disabled?(selector, timeout: nil)
+def disabled?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability).
@@ -497,7 +508,7 @@ Returns whether the element is disabled, the opposite of [enabled](https://playw
 ## editable?
 
 ```
-def editable?(selector, timeout: nil)
+def editable?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is [editable](https://playwright.dev/python/docs/actionability).
@@ -505,7 +516,7 @@ Returns whether the element is [editable](https://playwright.dev/python/docs/act
 ## enabled?
 
 ```
-def enabled?(selector, timeout: nil)
+def enabled?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability).
@@ -513,7 +524,7 @@ Returns whether the element is [enabled](https://playwright.dev/python/docs/acti
 ## hidden?
 
 ```
-def hidden?(selector, timeout: nil)
+def hidden?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability).  `selector` that does not
@@ -522,12 +533,24 @@ match any elements is considered hidden.
 ## visible?
 
 ```
-def visible?(selector, timeout: nil)
+def visible?(selector, strict: nil, timeout: nil)
 ```
 
 Returns whether the element is [visible](https://playwright.dev/python/docs/actionability). `selector` that does not match any elements is
 considered not visible.
 
+## locator
+
+```
+def locator(selector)
+```
+
+The method returns an element locator that can be used to perform actions in the frame. Locator is resolved to the
+element immediately before performing an action, so a series of actions on the same locator can in fact be performed on
+different DOM elements. That would happen if the DOM structure between those actions has changed.
+
+Note that locator always implies visibility, so it will always be locating visible elements.
+
 ## name
 
 ```
@@ -564,6 +587,7 @@ def press(
       key,
       delay: nil,
       noWaitAfter: nil,
+      strict: nil,
       timeout: nil)
 ```
 
@@ -587,7 +611,7 @@ modifier, modifier is pressed and being held while the subsequent key is being p
 ## query_selector
 
 ```
-def query_selector(selector)
+def query_selector(selector, strict: nil)
 ```
 
 Returns the ElementHandle pointing to the frame element.
@@ -617,6 +641,7 @@ def select_option(
       label: nil,
       force: nil,
       noWaitAfter: nil,
+      strict: nil,
       timeout: nil)
 ```
 
@@ -655,7 +680,12 @@ alias: `content=`
 ## set_input_files
 
 ```
-def set_input_files(selector, files, noWaitAfter: nil, timeout: nil)
+def set_input_files(
+      selector,
+      files,
+      noWaitAfter: nil,
+      strict: nil,
+      timeout: nil)
 ```
 
 This method expects `selector` to point to an
@@ -673,6 +703,7 @@ def tap_point(
       modifiers: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -693,7 +724,7 @@ zero timeout disables this.
 ## text_content
 
 ```
-def text_content(selector, timeout: nil)
+def text_content(selector, strict: nil, timeout: nil)
 ```
 
 Returns `element.textContent`.
@@ -714,6 +745,7 @@ def type(
       text,
       delay: nil,
       noWaitAfter: nil,
+      strict: nil,
       timeout: nil)
 ```
 
@@ -738,6 +770,7 @@ def uncheck(
       force: nil,
       noWaitAfter: nil,
       position: nil,
+      strict: nil,
       timeout: nil,
       trial: nil)
 ```
@@ -845,7 +878,7 @@ considered a navigation.
 ## wait_for_selector
 
 ```
-def wait_for_selector(selector, state: nil, timeout: nil)
+def wait_for_selector(selector, state: nil, strict: nil, timeout: nil)
 ```
 
 Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or

data/documentation/docs/api/locator.md

@@ -0,0 +1,650 @@
+---
+sidebar_position: 10
+---
+
+# Locator
+
+Locator represents a view to the element(s) on the page. It captures the logic sufficient to retrieve the element at any
+given moment. Locator can be created with the [Page#locator](./page#locator) method.
+
+```python sync title=example_9f72eed0cd4b2405e6a115b812b36ff2624e889f9086925c47665333a7edabbc.py
+locator = page.locator("text=Submit")
+locator.click()
+
+```
+
+The difference between the Locator and [ElementHandle](./element_handle) is that the latter points to a particular element, while Locator
+captures the logic of how to retrieve that element.
+
+In the example below, handle points to a particular DOM element on page. If that element changes text or is used by
+React to render an entirely different component, handle is still pointing to that very DOM element. This can lead to
+unexpected behaviors.
+
+```ruby
+handle = page.query_selector("text=Submit")
+handle.hover
+handle.click
+```
+
+With the locator, every time the `element` is used, up-to-date DOM element is located in the page using the selector. So
+in the snippet below, underlying DOM element is going to be located twice.
+
+```ruby
+locator = page.locator("text=Submit")
+locator.hover
+locator.click
+```
+
+
+
+## all_inner_texts
+
+```
+def all_inner_texts
+```
+
+Returns an array of `node.innerText` values for all matching nodes.
+
+## all_text_contents
+
+```
+def all_text_contents
+```
+
+Returns an array of `node.textContent` values for all matching nodes.
+
+## bounding_box
+
+```
+def bounding_box(timeout: nil)
+```
+
+This method returns the bounding box of the element, or `null` if the element is not visible. The bounding box is
+calculated relative to the main frame viewport - which is usually the same as the browser window.
+
+Scrolling affects the returned bonding box, similarly to
+[Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect). That
+means `x` and/or `y` may be negative.
+
+Elements from child frames return the bounding box relative to the main frame, unlike the
+[Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
+
+Assuming the page is static, it is safe to use bounding box coordinates to perform input. For example, the following
+snippet should click the center of the element.
+
+```python sync title=example_4d635e937854fa2ee56b7c43151ded535940f0bbafc00cf48e8214bed86715eb.py
+box = element.bounding_box()
+page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
+
+```
+
+
+
+## check
+
+```
+def check(
+      force: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil,
+      trial: nil)
+```
+
+This method checks the element by performing the following steps:
+1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already checked,
+   this method returns immediately.
+1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+1. Scroll the element into view if needed.
+1. Use [Page#mouse](./page#mouse) to click in the center of the element.
+1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+1. Ensure that the element is now checked. If not, this method throws.
+
+If the element is detached from the DOM at any moment during the action, this method throws.
+
+When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+zero timeout disables this.
+
+## click
+
+```
+def click(
+      button: nil,
+      clickCount: nil,
+      delay: nil,
+      force: nil,
+      modifiers: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil,
+      trial: nil)
+```
+
+This method clicks the element by performing the following steps:
+1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+1. Scroll the element into view if needed.
+1. Use [Page#mouse](./page#mouse) to click in the center of the element, or the specified `position`.
+1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+
+If the element is detached from the DOM at any moment during the action, this method throws.
+
+When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+zero timeout disables this.
+
+## count
+
+```
+def count
+```
+
+Returns the number of elements matching given selector.
+
+## dblclick
+
+```
+def dblclick(
+      button: nil,
+      delay: nil,
+      force: nil,
+      modifiers: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil,
+      trial: nil)
+```
+
+This method double clicks the element by performing the following steps:
+1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+1. Scroll the element into view if needed.
+1. Use [Page#mouse](./page#mouse) to double click in the center of the element, or the specified `position`.
+1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the
+   first click of the `dblclick()` triggers a navigation event, this method will throw.
+
+If the element is detached from the DOM at any moment during the action, this method throws.
+
+When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+zero timeout disables this.
+
+> NOTE: `element.dblclick()` dispatches two `click` events and a single `dblclick` event.
+
+## dispatch_event
+
+```
+def dispatch_event(type, eventInit: nil, timeout: nil)
+```
+
+The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the element,
+`click` is dispatched. This is equivalent to calling
+[element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).
+
+```python sync title=example_8d92b900a98c237ffdcb102ddc35660e37101bde7d107dc64d97a7edeed62a43.py
+element.dispatch_event("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.
+
+Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
+- [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)
+- [FocusEvent](https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent)
+- [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/KeyboardEvent)
+- [MouseEvent](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent)
+- [PointerEvent](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/PointerEvent)
+- [TouchEvent](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/TouchEvent)
+- [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)
+
+You can also specify [JSHandle](./js_handle) as the property value if you want live objects to be passed into the event:
+
+```python sync title=example_e369442a3ff291ab476da408ef63a63dacf47984dc766ff7189d82008ae2848b.py
+# note you can only create data_transfer in chromium and firefox
+data_transfer = page.evaluate_handle("new DataTransfer()")
+element.dispatch_event("#source", "dragstart", {"dataTransfer": data_transfer})
+
+```
+
+
+
+## element_handle
+
+```
+def element_handle(timeout: nil)
+```
+
+Resolves given locator to the first matching DOM element. If no elements matching the query are visible, waits for them
+up to a given timeout. If multiple elements match the selector, throws.
+
+## element_handles
+
+```
+def element_handles
+```
+
+Resolves given locator to all matching DOM elements.
+
+## evaluate
+
+```
+def evaluate(expression, arg: nil, timeout: nil)
+```
+
+Returns the return value of `expression`.
+
+This method passes this handle as the first argument to `expression`.
+
+If `expression` returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then `handle.evaluate` would wait for the promise to resolve and return its value.
+
+Examples:
+
+```python sync title=example_df39b3df921f81e7cfb71cd873b76a5e91e46b4aa41e1f164128cb322aa38305.py
+tweets = page.locator(".tweet .retweets")
+assert tweets.evaluate("node => node.innerText") == "10 retweets"
+
+```
+
+
+
+## evaluate_all
+
+```
+def evaluate_all(expression, arg: nil)
+```
+
+The method finds all elements matching the specified locator and passes an array of matched elements as a first argument
+to `expression`. Returns the result of `expression` invocation.
+
+If `expression` returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then [`Locator.evaluateAll`] would wait for the promise to resolve and return its
+value.
+
+Examples:
+
+```python sync title=example_32478e941514ed28b6ac221e6d54b55cf117038ecac6f4191db676480ab68d44.py
+elements = page.locator("div")
+div_counts = elements("(divs, min) => divs.length >= min", 10)
+
+```
+
+
+
+## evaluate_handle
+
+```
+def evaluate_handle(expression, arg: nil, timeout: nil)
+```
+
+Returns the return value of `expression` as a [JSHandle](./js_handle).
+
+This method passes this handle as the first argument to `expression`.
+
+The only difference between [Locator#evaluate](./locator#evaluate) and [Locator#evaluate_handle](./locator#evaluate_handle) is that
+[Locator#evaluate_handle](./locator#evaluate_handle) returns [JSHandle](./js_handle).
+
+If the function passed to the [Locator#evaluate_handle](./locator#evaluate_handle) returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then
+[Locator#evaluate_handle](./locator#evaluate_handle) would wait for the promise to resolve and return its value.
+
+See [Page#evaluate_handle](./page#evaluate_handle) for more details.
+
+## fill
+
+```
+def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
+```
+
+This method waits for [actionability](https://playwright.dev/python/docs/actionability) checks, focuses the element, fills it and triggers an `input`
+event after filling. Note that you can pass an empty string to clear the input field.
+
+If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error.
+However, if the element is inside the `<label>` element that has an associated
+[control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled
+instead.
+
+To send fine-grained keyboard events, use [Locator#type](./locator#type).
+
+## first
+
+```
+def first
+```
+
+Returns locator to the first matching element.
+
+## focus
+
+```
+def focus(timeout: nil)
+```
+
+Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the element.
+
+## get_attribute
+
+```
+def get_attribute(name, timeout: nil)
+```
+
+Returns element attribute value.
+
+## hover
+
+```
+def hover(
+      force: nil,
+      modifiers: nil,
+      position: nil,
+      timeout: nil,
+      trial: nil)
+```
+
+This method hovers over the element by performing the following steps:
+1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+1. Scroll the element into view if needed.
+1. Use [Page#mouse](./page#mouse) to hover over the center of the element, or the specified `position`.
+1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+
+If the element is detached from the DOM at any moment during the action, this method throws.
+
+When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+zero timeout disables this.
+
+## inner_html
+
+```
+def inner_html(timeout: nil)
+```
+
+Returns the `element.innerHTML`.
+
+## inner_text
+
+```
+def inner_text(timeout: nil)
+```
+
+Returns the `element.innerText`.
+
+## input_value
+
+```
+def input_value(timeout: nil)
+```
+
+Returns `input.value` for `<input>` or `<textarea>` element. Throws for non-input elements.
+
+## checked?
+
+```
+def checked?(timeout: nil)
+```
+
+Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
+
+## disabled?
+
+```
+def disabled?(timeout: nil)
+```
+
+Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability).
+
+## editable?
+
+```
+def editable?(timeout: nil)
+```
+
+Returns whether the element is [editable](https://playwright.dev/python/docs/actionability).
+
+## enabled?
+
+```
+def enabled?(timeout: nil)
+```
+
+Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability).
+
+## hidden?
+
+```
+def hidden?(timeout: nil)
+```
+
+Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability).
+
+## visible?
+
+```
+def visible?(timeout: nil)
+```
+
+Returns whether the element is [visible](https://playwright.dev/python/docs/actionability).
+
+## last
+
+```
+def last
+```
+
+Returns locator to the last matching element.
+
+## locator
+
+```
+def locator(selector)
+```
+
+The method finds an element matching the specified selector in the [Locator](./locator)'s subtree. See
+[Working with selectors](https://playwright.dev/python/docs/selectors) for more details.
+
+## nth
+
+```
+def nth(index)
+```
+
+Returns locator to the n-th matching element.
+
+## press
+
+```
+def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
+```
+
+Focuses the element, and then uses [Keyboard#down](./keyboard#down) and [Keyboard#up](./keyboard#up).
+
+`key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
+value or a single character to generate the text for. A superset of the `key` values can be found
+[here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:
+
+`F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,
+`Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`, etc.
+
+Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+
+Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
+
+If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
+texts.
+
+Shortcuts such as `key: "Control+o"` or `key: "Control+Shift+T"` are supported as well. When specified with the
+modifier, modifier is pressed and being held while the subsequent key is being pressed.
+
+## screenshot
+
+```
+def screenshot(
+      omitBackground: nil,
+      path: nil,
+      quality: nil,
+      timeout: nil,
+      type: nil)
+```
+
+Returns the buffer with the captured screenshot.
+
+This method waits for the [actionability](https://playwright.dev/python/docs/actionability) checks, then scrolls element into view before taking a
+screenshot. If the element is detached from DOM, the method throws an error.
+
+## scroll_into_view_if_needed
+
+```
+def scroll_into_view_if_needed(timeout: nil)
+```
+
+This method waits for [actionability](https://playwright.dev/python/docs/actionability) checks, then tries to scroll element into view, unless it is
+completely visible as defined by
+[IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s `ratio`.
+
+## select_option
+
+```
+def select_option(
+      element: nil,
+      index: nil,
+      value: nil,
+      label: nil,
+      force: nil,
+      noWaitAfter: nil,
+      timeout: nil)
+```
+
+This method waits for [actionability](https://playwright.dev/python/docs/actionability) checks, waits until all specified options are present in the
+`<select>` element and selects these options.
+
+If the target element is not a `<select>` element, this method throws an error. However, if the element is inside the
+`<label>` element that has an associated
+[control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be used instead.
+
+Returns the array of option values that have been successfully selected.
+
+Triggers a `change` and `input` event once all the provided options have been selected.
+
+```python sync title=example_2825b0a50091868d1ce3ea0752d94ba32d826d504c1ac6842522796ca405913e.py
+# single selection matching the value
+element.select_option("blue")
+# single selection matching both the label
+element.select_option(label="blue")
+# multiple selection
+element.select_option(value=["red", "green", "blue"])
+
+```
+
+```python sync title=example_3aaff4985dc38e64fad34696c88a6a68a633e26aabee6fc749125f3ee1784e34.py
+# single selection matching the value
+element.select_option("blue")
+# single selection matching both the value and the label
+element.select_option(label="blue")
+# multiple selection
+element.select_option("red", "green", "blue")
+# multiple selection for blue, red and second option
+element.select_option(value="blue", { index: 2 }, "red")
+
+```
+
+
+
+## select_text
+
+```
+def select_text(force: nil, timeout: nil)
+```
+
+This method waits for [actionability](https://playwright.dev/python/docs/actionability) checks, then focuses the element and selects all its text
+content.
+
+## set_input_files
+
+```
+def set_input_files(files, noWaitAfter: nil, timeout: nil)
+```
+alias: `input_files=`
+
+This method expects `element` to point to an
+[input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input).
+
+Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then they
+are resolved relative to the the current working directory. For empty array, clears the selected files.
+
+## tap_point
+
+```
+def tap_point(
+      force: nil,
+      modifiers: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil,
+      trial: nil)
+```
+
+This method taps the element by performing the following steps:
+1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+1. Scroll the element into view if needed.
+1. Use [Page#touchscreen](./page#touchscreen) to tap the center of the element, or the specified `position`.
+1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+
+If the element is detached from the DOM at any moment during the action, this method throws.
+
+When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+zero timeout disables this.
+
+> NOTE: `element.tap()` requires that the `hasTouch` option of the browser context be set to true.
+
+## text_content
+
+```
+def text_content(timeout: nil)
+```
+
+Returns the `node.textContent`.
+
+## type
+
+```
+def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
+```
+
+Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
+
+To press a special key, like `Control` or `ArrowDown`, use [Locator#press](./locator#press).
+
+```python sync title=example_fa1712c0b6ceb96fcaa74790d33f2c2eefe2bd1f06e61b78e0bb84a6f22c7961.py
+element.type("hello") # types instantly
+element.type("world", delay=100) # types slower, like a user
+
+```
+
+An example of typing into a text field and then submitting the form:
+
+```python sync title=example_adefe90dee78708d4375c20f081f12f2b71f2becb472a2e0d4fdc8cc49c37809.py
+element = page.locator("input")
+element.type("some text")
+element.press("Enter")
+
+```
+
+
+
+## uncheck
+
+```
+def uncheck(
+      force: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil,
+      trial: nil)
+```
+
+This method checks the element by performing the following steps:
+1. Ensure that element is a checkbox or a radio input. If not, this method throws. If the element is already
+   unchecked, this method returns immediately.
+1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+1. Scroll the element into view if needed.
+1. Use [Page#mouse](./page#mouse) to click in the center of the element.
+1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+1. Ensure that the element is now unchecked. If not, this method throws.
+
+If the element is detached from the DOM at any moment during the action, this method throws.
+
+When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
+zero timeout disables this.