playwright.async_api._generated.ElementHandle Class Reference

Inheritance diagram for playwright.async_api._generated.ElementHandle:

Collaboration diagram for playwright.async_api._generated.ElementHandle:

Public Member Functions
typing.Optional["ElementHandle"]	as_element (self)
typing.Optional["Frame"]	owner_frame (self)
typing.Optional["Frame"]	content_frame (self)
typing.Optional[str]	get_attribute (self, str name)
typing.Optional[str]	text_content (self)
str	inner_text (self)
str	inner_html (self)
bool	is_checked (self)
bool	is_disabled (self)
bool	is_editable (self)
bool	is_enabled (self)
bool	is_hidden (self)
bool	is_visible (self)
None	dispatch_event (self, str type, typing.Optional[typing.Dict] event_init=None)
None	scroll_into_view_if_needed (self, *typing.Optional[float] timeout=None)
None	hover (self, *typing.Optional[typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]] modifiers=None, typing.Optional[Position] position=None, typing.Optional[float] timeout=None, typing.Optional[bool] no_wait_after=None, typing.Optional[bool] force=None, typing.Optional[bool] trial=None)
None	click (self, *typing.Optional[typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]] modifiers=None, typing.Optional[Position] position=None, typing.Optional[float] delay=None, typing.Optional[Literal["left", "middle", "right"]] button=None, typing.Optional[int] click_count=None, typing.Optional[float] timeout=None, typing.Optional[bool] force=None, typing.Optional[bool] no_wait_after=None, typing.Optional[bool] trial=None, typing.Optional[int] steps=None)
None	dblclick (self, *typing.Optional[typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]] modifiers=None, typing.Optional[Position] position=None, typing.Optional[float] delay=None, typing.Optional[Literal["left", "middle", "right"]] button=None, typing.Optional[float] timeout=None, typing.Optional[bool] force=None, typing.Optional[bool] no_wait_after=None, typing.Optional[bool] trial=None, typing.Optional[int] steps=None)
typing.List[str]	select_option (self, typing.Optional[typing.Union[str, typing.Sequence[str]]] value=None, *typing.Optional[typing.Union[int, typing.Sequence[int]]] index=None, typing.Optional[typing.Union[str, typing.Sequence[str]]] label=None, typing.Optional[typing.Union["ElementHandle", typing.Sequence["ElementHandle"]]] element=None, typing.Optional[float] timeout=None, typing.Optional[bool] force=None, typing.Optional[bool] no_wait_after=None)
None	tap (self, *typing.Optional[typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]] modifiers=None, typing.Optional[Position] position=None, typing.Optional[float] timeout=None, typing.Optional[bool] force=None, typing.Optional[bool] no_wait_after=None, typing.Optional[bool] trial=None)
None	fill (self, str value, *typing.Optional[float] timeout=None, typing.Optional[bool] no_wait_after=None, typing.Optional[bool] force=None)
None	select_text (self, *typing.Optional[bool] force=None, typing.Optional[float] timeout=None)
str	input_value (self, *typing.Optional[float] timeout=None)
None	set_input_files (self, typing.Union[str, pathlib.Path, FilePayload, typing.Sequence[typing.Union[str, pathlib.Path]], typing.Sequence[FilePayload],] files, *typing.Optional[float] timeout=None, typing.Optional[bool] no_wait_after=None)
None	focus (self)
None	type (self, str text, *typing.Optional[float] delay=None, typing.Optional[float] timeout=None, typing.Optional[bool] no_wait_after=None)
None	press (self, str key, *typing.Optional[float] delay=None, typing.Optional[float] timeout=None, typing.Optional[bool] no_wait_after=None)
None	set_checked (self, bool checked, *typing.Optional[Position] position=None, typing.Optional[float] timeout=None, typing.Optional[bool] force=None, typing.Optional[bool] no_wait_after=None, typing.Optional[bool] trial=None)
None	check (self, *typing.Optional[Position] position=None, typing.Optional[float] timeout=None, typing.Optional[bool] force=None, typing.Optional[bool] no_wait_after=None, typing.Optional[bool] trial=None)
None	uncheck (self, *typing.Optional[Position] position=None, typing.Optional[float] timeout=None, typing.Optional[bool] force=None, typing.Optional[bool] no_wait_after=None, typing.Optional[bool] trial=None)
typing.Optional[FloatRect]	bounding_box (self)
bytes	screenshot (self, *typing.Optional[float] timeout=None, typing.Optional[Literal["jpeg", "png"]] type=None, typing.Optional[typing.Union[pathlib.Path, str]] path=None, typing.Optional[int] quality=None, typing.Optional[bool] omit_background=None, typing.Optional[Literal["allow", "disabled"]] animations=None, typing.Optional[Literal["hide", "initial"]] caret=None, typing.Optional[Literal["css", "device"]] scale=None, typing.Optional[typing.Sequence["Locator"]] mask=None, typing.Optional[str] mask_color=None, typing.Optional[str] style=None)
typing.Optional["ElementHandle"]	query_selector (self, str selector)
typing.List["ElementHandle"]	query_selector_all (self, str selector)
typing.Any	eval_on_selector (self, str selector, str expression, typing.Optional[typing.Any] arg=None)
typing.Any	eval_on_selector_all (self, str selector, str expression, typing.Optional[typing.Any] arg=None)
None	wait_for_element_state (self, Literal["disabled", "editable", "enabled", "hidden", "stable", "visible"] state, *typing.Optional[float] timeout=None)
typing.Optional["ElementHandle"]	wait_for_selector (self, str selector, *typing.Optional[Literal["attached", "detached", "hidden", "visible"]] state=None, typing.Optional[float] timeout=None, typing.Optional[bool] strict=None)
Public Member Functions inherited from playwright._impl._js_handle.JSHandle
None	__init__ (self, ChannelOwner parent, str type, str guid, Dict initializer)
str	__repr__ (self)
str	__str__ (self)
Any	evaluate (self, str expression, Serializable arg=None)
"JSHandle"	evaluate_handle (self, str expression, Serializable arg=None)
"JSHandle"	get_property (self, str propertyName)
Dict[str, "JSHandle"]	get_properties (self)
None	dispose (self)
Any	json_value (self)
Public Member Functions inherited from playwright._impl._connection.ChannelOwner
None	remove_listener (self, str event, Any f)
Public Member Functions inherited from pyee.asyncio.AsyncIOEventEmitter
bool	emit (Self self, str event, *Any args, **Any kwargs)
None	wait_for_complete (Self self)
None	cancel (Self self)
bool	complete (Self self)
Public Member Functions inherited from pyee.base.EventEmitter
Mapping[str, Any]	__getstate__ (Self self)
None	__setstate__ (Self self, Mapping[str, Any] state)
Callable[[Handler], Handler]	on (Self self, str event)
Handler	on (Self self, str event, Handler f)
Union[Handler, Callable[[Handler], Handler]]	on (Self self, str event, Optional[Handler] f=None)
Callable[[Handler], Handler]	listens_to (Self self, str event)
Handler	add_listener (Self self, str event, Handler f)
Set[str]	event_names (Self self)
Callable	once (Self self, str event, Optional[Callable] f=None)
None	remove_all_listeners (Self self, Optional[str] event=None)
List[Callable]	listeners (Self self, str event)

Additional Inherited Members
Protected Member Functions inherited from playwright._impl._js_handle.JSHandle
None	_on_preview_updated (self, str preview)
Protected Member Functions inherited from playwright._impl._connection.ChannelOwner
None	_dispose (self, Optional[str] reason)
None	_adopt (self, "ChannelOwner" child)
None	_set_event_to_subscription_mapping (self, Dict[str, str] mapping)
None	_update_subscription (self, str event, bool enabled)
None	_add_event_handler (self, str event, Any k, Any v)
Protected Member Functions inherited from pyee.asyncio.AsyncIOEventEmitter
None	_emit_run (Self self, Callable f, Tuple[Any,...] args, Dict[str, Any] kwargs)
Protected Member Functions inherited from pyee.base.EventEmitter
None	_emit_handle_potential_error (Self self, str event, Any error)
bool	_call_handlers (Self self, str event, Tuple[Any,...] args, Dict[str, Any] kwargs)
None	_remove_listener (Self self, str event, Callable f)
Protected Attributes inherited from playwright._impl._js_handle.JSHandle
	_preview
Protected Attributes inherited from playwright._impl._connection.ChannelOwner
	_type
	_initializer
	_was_collected
	_event_to_subscription_mapping
Protected Attributes inherited from pyee.asyncio.AsyncIOEventEmitter
	_waiting
Protected Attributes inherited from pyee.base.EventEmitter
	_lock
	_events

Member Function Documentation

as_element()

typing.Optional["ElementHandle"] playwright.async_api._generated.ElementHandle.as_element

(

self

)

ElementHandle.as_element

Returns either `null` or the object handle itself, if the object handle is an instance of `ElementHandle`.

Returns
-------
Union[ElementHandle, None]

Reimplemented from playwright._impl._js_handle.JSHandle.

bounding_box()

typing.Optional[FloatRect] playwright.async_api._generated.ElementHandle.bounding_box

(

self

)

ElementHandle.bounding_box

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 bounding 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.

**Usage**

```py
box = await element_handle.bounding_box()
await page.mouse.click(box[\"x\"] + box[\"width\"] / 2, box[\"y\"] + box[\"height\"] / 2)
```

Returns
-------
Union[{x: float, y: float, width: float, height: float}, None]

check()

None playwright.async_api._generated.ElementHandle.check	(		self,
		*typing.Optional[Position]	position = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	force = None,
		typing.Optional[bool]	no_wait_after = None,
		typing.Optional[bool]	trial = None
	)

ElementHandle.check

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` to click in the center of the element.
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.

Parameters
----------
position : Union[{x: float, y: float}, None]
    A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
    the element.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.
trial : Union[bool, None]
    When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
    to `false`. Useful to wait until the element is ready for the action without performing it.

click()

None playwright.async_api._generated.ElementHandle.click	(		self,
		*typing.Optional[ typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]] ]	modifiers = None,
		typing.Optional[Position]	position = None,
		typing.Optional[float]	delay = None,
		typing.Optional[Literal["left", "middle", "right"]]	button = None,
		typing.Optional[int]	click_count = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	force = None,
		typing.Optional[bool]	no_wait_after = None,
		typing.Optional[bool]	trial = None,
		typing.Optional[int]	steps = None
	)

ElementHandle.click

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` 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.

Parameters
----------
modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
    Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
    current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
    "Control" on Windows and Linux and to "Meta" on macOS.
position : Union[{x: float, y: float}, None]
    A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
    the element.
delay : Union[float, None]
    Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
button : Union["left", "middle", "right", None]
    Defaults to `left`.
click_count : Union[int, None]
    defaults to 1. See [UIEvent.detail].
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
no_wait_after : Union[bool, None]
    Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
    can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
    navigating to inaccessible pages. Defaults to `false`.
    Deprecated: This option will default to `true` in the future.
trial : Union[bool, None]
    When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
    to `false`. Useful to wait until the element is ready for the action without performing it.
steps : Union[int, None]
    Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
    position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.

content_frame()

typing.Optional["Frame"] playwright.async_api._generated.ElementHandle.content_frame

(

self

)

ElementHandle.content_frame

Returns the content frame for element handles referencing iframe nodes, or `null` otherwise

Returns
-------
Union[Frame, None]

dblclick()

None playwright.async_api._generated.ElementHandle.dblclick	(		self,
		*typing.Optional[ typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]] ]	modifiers = None,
		typing.Optional[Position]	position = None,
		typing.Optional[float]	delay = None,
		typing.Optional[Literal["left", "middle", "right"]]	button = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	force = None,
		typing.Optional[bool]	no_wait_after = None,
		typing.Optional[bool]	trial = None,
		typing.Optional[int]	steps = None
	)

ElementHandle.dblclick

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` to double click in the center of the element, or the specified `position`.

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** `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.

Parameters
----------
modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
    Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
    current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
    "Control" on Windows and Linux and to "Meta" on macOS.
position : Union[{x: float, y: float}, None]
    A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
    the element.
delay : Union[float, None]
    Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
button : Union["left", "middle", "right", None]
    Defaults to `left`.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.
trial : Union[bool, None]
    When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
    to `false`. Useful to wait until the element is ready for the action without performing it.
steps : Union[int, None]
    Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
    position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.

dispatch_event()

None playwright.async_api._generated.ElementHandle.dispatch_event	(		self,
		str	type,
		typing.Optional[typing.Dict]	event_init = None
	)

ElementHandle.dispatch_event

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).

**Usage**

```py
await element_handle.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:
- [DeviceMotionEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent/DeviceMotionEvent)
- [DeviceOrientationEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent/DeviceOrientationEvent)
- [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)
- [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)
- [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)
- [WheelEvent](https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/WheelEvent)

You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:

```py
# note you can only create data_transfer in chromium and firefox
data_transfer = await page.evaluate_handle(\"new DataTransfer()\")
await element_handle.dispatch_event(\"#source\", \"dragstart\", {\"dataTransfer\": data_transfer})
```

Parameters
----------
type : str
    DOM event type: `"click"`, `"dragstart"`, etc.
event_init : Union[Dict, None]
    Optional event-specific initialization properties.

eval_on_selector()

typing.Any playwright.async_api._generated.ElementHandle.eval_on_selector	(		self,
		str	selector,
		str	expression,
		typing.Optional[typing.Any]	arg = None
	)

ElementHandle.eval_on_selector

Returns the return value of `expression`.

The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a
first argument to `expression`. If no elements match the selector, the method throws an error.

If `expression` returns a [Promise], then `element_handle.eval_on_selector()` would wait for the promise to
resolve and return its value.

**Usage**

```py
tweet_handle = await page.query_selector(\".tweet\")
assert await tweet_handle.eval_on_selector(\".like\", \"node => node.innerText\") == \"100\"
assert await tweet_handle.eval_on_selector(\".retweets\", \"node => node.innerText\") == \"10\"
```

Parameters
----------
selector : str
    A selector to query for.
expression : str
    JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
    function is automatically invoked.
arg : Union[Any, None]
    Optional argument to pass to `expression`.

Returns
-------
Any

eval_on_selector_all()

typing.Any playwright.async_api._generated.ElementHandle.eval_on_selector_all	(		self,
		str	selector,
		str	expression,
		typing.Optional[typing.Any]	arg = None
	)

ElementHandle.eval_on_selector_all

Returns the return value of `expression`.

The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array
of matched elements as a first argument to `expression`.

If `expression` returns a [Promise], then `element_handle.eval_on_selector_all()` would wait for the promise to
resolve and return its value.

**Usage**

```html
<div class=\"feed\">
  <div class=\"tweet\">Hello!</div>
  <div class=\"tweet\">Hi!</div>
</div>
```

```py
feed_handle = await page.query_selector(\".feed\")
assert await feed_handle.eval_on_selector_all(\".tweet\", \"nodes => nodes.map(n => n.innerText)\") == [\"hello!\", \"hi!\"]
```

Parameters
----------
selector : str
    A selector to query for.
expression : str
    JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
    function is automatically invoked.
arg : Union[Any, None]
    Optional argument to pass to `expression`.

Returns
-------
Any

fill()

None playwright.async_api._generated.ElementHandle.fill	(		self,
		str	value,
		*typing.Optional[float]	timeout = None,
		typing.Optional[bool]	no_wait_after = None,
		typing.Optional[bool]	force = None
	)

ElementHandle.fill

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.press_sequentially()`.

Parameters
----------
value : str
    Value to set for the `<input>`, `<textarea>` or `[contenteditable]` element.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.

focus()

None playwright.async_api._generated.ElementHandle.focus

(

self

)

ElementHandle.focus

Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the element.

get_attribute()

typing.Optional[str] playwright.async_api._generated.ElementHandle.get_attribute	(		self,
		str	name
	)

ElementHandle.get_attribute

Returns element attribute value.

Parameters
----------
name : str
    Attribute name to get the value for.

Returns
-------
Union[str, None]

hover()

None playwright.async_api._generated.ElementHandle.hover	(		self,
		*typing.Optional[ typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]] ]	modifiers = None,
		typing.Optional[Position]	position = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	no_wait_after = None,
		typing.Optional[bool]	force = None,
		typing.Optional[bool]	trial = None
	)

ElementHandle.hover

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` to hover over the center of the element, or the specified `position`.

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.

Parameters
----------
modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
    Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
    current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
    "Control" on Windows and Linux and to "Meta" on macOS.
position : Union[{x: float, y: float}, None]
    A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
    the element.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
trial : Union[bool, None]
    When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
    to `false`. Useful to wait until the element is ready for the action without performing it.

inner_html()

str playwright.async_api._generated.ElementHandle.inner_html

(

self

)

ElementHandle.inner_html

Returns the `element.innerHTML`.

Returns
-------
str

inner_text()

str playwright.async_api._generated.ElementHandle.inner_text

(

self

)

ElementHandle.inner_text

Returns the `element.innerText`.

Returns
-------
str

input_value()

str playwright.async_api._generated.ElementHandle.input_value	(		self,
		*typing.Optional[float]	timeout = None
	)

ElementHandle.input_value

Returns `input.value` for the selected `<input>` or `<textarea>` or `<select>` element.

Throws for non-input elements. 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), returns the value of the
control.

Parameters
----------
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.

Returns
-------
str

is_checked()

bool playwright.async_api._generated.ElementHandle.is_checked

(

self

)

ElementHandle.is_checked

Returns whether the element is checked. Throws if the element is not a checkbox or radio input.

Returns
-------
bool

is_disabled()

bool playwright.async_api._generated.ElementHandle.is_disabled

(

self

)

ElementHandle.is_disabled

Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).

Returns
-------
bool

is_editable()

bool playwright.async_api._generated.ElementHandle.is_editable

(

self

)

ElementHandle.is_editable

Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).

Returns
-------
bool

is_enabled()

bool playwright.async_api._generated.ElementHandle.is_enabled

(

self

)

ElementHandle.is_enabled

Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).

Returns
-------
bool

is_hidden()

bool playwright.async_api._generated.ElementHandle.is_hidden

(

self

)

ElementHandle.is_hidden

Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).

Returns
-------
bool

is_visible()

bool playwright.async_api._generated.ElementHandle.is_visible

(

self

)

ElementHandle.is_visible

Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible).

Returns
-------
bool

owner_frame()

typing.Optional["Frame"] playwright.async_api._generated.ElementHandle.owner_frame

(

self

)

ElementHandle.owner_frame

Returns the frame containing the given element.

Returns
-------
Union[Frame, None]

press()

None playwright.async_api._generated.ElementHandle.press	(		self,
		str	key,
		*typing.Optional[float]	delay = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	no_wait_after = None
	)

ElementHandle.press

Focuses the element, and then uses `keyboard.down()` and `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`,
`ControlOrMeta`.

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\"`, `key: \"Control++` 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.

Parameters
----------
key : str
    Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
delay : Union[float, None]
    Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
no_wait_after : Union[bool, None]
    Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
    can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
    navigating to inaccessible pages. Defaults to `false`.
    Deprecated: This option will default to `true` in the future.

query_selector()

typing.Optional["ElementHandle"] playwright.async_api._generated.ElementHandle.query_selector	(		self,
		str	selector
	)

ElementHandle.query_selector

The method finds an element matching the specified selector in the `ElementHandle`'s subtree. If no elements match
the selector, returns `null`.

Parameters
----------
selector : str
    A selector to query for.

Returns
-------
Union[ElementHandle, None]

query_selector_all()

typing.List["ElementHandle"] playwright.async_api._generated.ElementHandle.query_selector_all	(		self,
		str	selector
	)

ElementHandle.query_selector_all

The method finds all elements matching the specified selector in the `ElementHandle`s subtree. If no elements match
the selector, returns empty array.

Parameters
----------
selector : str
    A selector to query for.

Returns
-------
List[ElementHandle]

screenshot()

bytes playwright.async_api._generated.ElementHandle.screenshot	(		self,
		*typing.Optional[float]	timeout = None,
		typing.Optional[Literal["jpeg", "png"]]	type = None,
		typing.Optional[typing.Union[pathlib.Path, str]]	path = None,
		typing.Optional[int]	quality = None,
		typing.Optional[bool]	omit_background = None,
		typing.Optional[Literal["allow", "disabled"]]	animations = None,
		typing.Optional[Literal["hide", "initial"]]	caret = None,
		typing.Optional[Literal["css", "device"]]	scale = None,
		typing.Optional[typing.Sequence["Locator"]]	mask = None,
		typing.Optional[str]	mask_color = None,
		typing.Optional[str]	style = None
	)

ElementHandle.screenshot

This method captures a screenshot of the page, clipped to the size and position of this particular element. If the
element is covered by other elements, it will not be actually visible on the screenshot. If the element is a
scrollable container, only the currently scrolled content will be visible on the 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.

Returns the buffer with the captured screenshot.

Parameters
----------
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
type : Union["jpeg", "png", None]
    Specify screenshot type, defaults to `png`.
path : Union[pathlib.Path, str, None]
    The file path to save the image to. The screenshot type will be inferred from file extension. If `path` is a
    relative path, then it is resolved relative to the current working directory. If no path is provided, the image
    won't be saved to the disk.
quality : Union[int, None]
    The quality of the image, between 0-100. Not applicable to `png` images.
omit_background : Union[bool, None]
    Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
    Defaults to `false`.
animations : Union["allow", "disabled", None]
    When set to `"disabled"`, stops CSS animations, CSS transitions and Web Animations. Animations get different
    treatment depending on their duration:
    - finite animations are fast-forwarded to completion, so they'll fire `transitionend` event.
    - infinite animations are canceled to initial state, and then played over after the screenshot.

    Defaults to `"allow"` that leaves animations untouched.
caret : Union["hide", "initial", None]
    When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be
    changed.  Defaults to `"hide"`.
scale : Union["css", "device", None]
    When set to `"css"`, screenshot will have a single pixel per each css pixel on the page. For high-dpi devices, this
    will keep screenshots small. Using `"device"` option will produce a single pixel per each device pixel, so
    screenshots of high-dpi devices will be twice as large or even larger.

    Defaults to `"device"`.
mask : Union[Sequence[Locator], None]
    Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
    box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
    invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
    that.
mask_color : Union[str, None]
    Specify the color of the overlay box for masked elements, in
    [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.
style : Union[str, None]
    Text of the stylesheet to apply while making the screenshot. This is where you can hide dynamic elements, make
    elements invisible or change their properties to help you creating repeatable screenshots. This stylesheet pierces
    the Shadow DOM and applies to the inner frames.

Returns
-------
bytes

scroll_into_view_if_needed()

None playwright.async_api._generated.ElementHandle.scroll_into_view_if_needed	(		self,
		*typing.Optional[float]	timeout = None
	)

ElementHandle.scroll_into_view_if_needed

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`.

Throws when `elementHandle` does not point to an element
[connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.

See [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.

Parameters
----------
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.

select_option()

typing.List[str] playwright.async_api._generated.ElementHandle.select_option	(		self,
		typing.Optional[typing.Union[str, typing.Sequence[str]]]	value = None,
		*typing.Optional[typing.Union[int, typing.Sequence[int]]]	index = None,
		typing.Optional[typing.Union[str, typing.Sequence[str]]]	label = None,
		typing.Optional[ typing.Union["ElementHandle", typing.Sequence["ElementHandle"]] ]	element = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	force = None,
		typing.Optional[bool]	no_wait_after = None
	)

ElementHandle.select_option

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.

**Usage**

```py
# Single selection matching the value or label
await handle.select_option(\"blue\")
# single selection matching the label
await handle.select_option(label=\"blue\")
# multiple selection
await handle.select_option(value=[\"red\", \"green\", \"blue\"])
```

Parameters
----------
value : Union[Sequence[str], str, None]
    Options to select by value. If the `<select>` has the `multiple` attribute, all given options are selected,
    otherwise only the first option matching one of the passed options is selected. Optional.
index : Union[Sequence[int], int, None]
    Options to select by index. Optional.
label : Union[Sequence[str], str, None]
    Options to select by label. If the `<select>` has the `multiple` attribute, all given options are selected,
    otherwise only the first option matching one of the passed options is selected. Optional.
element : Union[ElementHandle, Sequence[ElementHandle], None]
    Option elements to select. Optional.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.

Returns
-------
List[str]

select_text()

None playwright.async_api._generated.ElementHandle.select_text	(		self,
		*typing.Optional[bool]	force = None,
		typing.Optional[float]	timeout = None
	)

ElementHandle.select_text

This method waits for [actionability](https://playwright.dev/python/docs/actionability) checks, then focuses the element and selects all its
text content.

If the element is inside the `<label>` element that has an associated
[control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), focuses and selects text in
the control instead.

Parameters
----------
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.

set_checked()

None playwright.async_api._generated.ElementHandle.set_checked	(		self,
		bool	checked,
		*typing.Optional[Position]	position = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	force = None,
		typing.Optional[bool]	no_wait_after = None,
		typing.Optional[bool]	trial = None
	)

ElementHandle.set_checked

This method checks or unchecks an element by performing the following steps:
1. Ensure that element is a checkbox or a radio input. If not, this method throws.
1. If the element already has the right checked state, this method returns immediately.
1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `force` option is set. If
   the element is detached during the checks, the whole action is retried.
1. Scroll the element into view if needed.
1. Use `page.mouse` to click in the center of the element.
1. Ensure that the element is now checked or unchecked. If not, this method throws.

When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
Passing zero timeout disables this.

Parameters
----------
checked : bool
    Whether to check or uncheck the checkbox.
position : Union[{x: float, y: float}, None]
    A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
    the element.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.
trial : Union[bool, None]
    When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
    to `false`. Useful to wait until the element is ready for the action without performing it.

set_input_files()

None playwright.async_api._generated.ElementHandle.set_input_files	(		self,
		typing.Union[ str, pathlib.Path, FilePayload, typing.Sequence[typing.Union[str, pathlib.Path]], typing.Sequence[FilePayload], ]	files,
		*typing.Optional[float]	timeout = None,
		typing.Optional[bool]	no_wait_after = None
	)

ElementHandle.set_input_files

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 current working directory. For empty array, clears the selected files. For inputs
with a `[webkitdirectory]` attribute, only a single directory path is supported.

This method expects `ElementHandle` to point to an
[input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input). 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), targets the control instead.

Parameters
----------
files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.

tap()

None playwright.async_api._generated.ElementHandle.tap	(		self,
		*typing.Optional[ typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]] ]	modifiers = None,
		typing.Optional[Position]	position = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	force = None,
		typing.Optional[bool]	no_wait_after = None,
		typing.Optional[bool]	trial = None
	)

ElementHandle.tap

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` to tap the center of the element, or the specified `position`.

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** `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.

Parameters
----------
modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
    Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
    current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
    "Control" on Windows and Linux and to "Meta" on macOS.
position : Union[{x: float, y: float}, None]
    A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
    the element.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.
trial : Union[bool, None]
    When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
    to `false`. Useful to wait until the element is ready for the action without performing it.

text_content()

typing.Optional[str] playwright.async_api._generated.ElementHandle.text_content

(

self

)

ElementHandle.text_content

Returns the `node.textContent`.

Returns
-------
Union[str, None]

type()

None playwright.async_api._generated.ElementHandle.type	(		self,
		str	text,
		*typing.Optional[float]	delay = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	no_wait_after = None
	)

ElementHandle.type

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 `element_handle.press()`.

**Usage**

Parameters
----------
text : str
    A text to type into a focused element.
delay : Union[float, None]
    Time to wait between key presses in milliseconds. Defaults to 0.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.

uncheck()

None playwright.async_api._generated.ElementHandle.uncheck	(		self,
		*typing.Optional[Position]	position = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	force = None,
		typing.Optional[bool]	no_wait_after = None,
		typing.Optional[bool]	trial = None
	)

ElementHandle.uncheck

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` to click in the center of the element.
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.

Parameters
----------
position : Union[{x: float, y: float}, None]
    A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
    the element.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
force : Union[bool, None]
    Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
no_wait_after : Union[bool, None]
    This option has no effect.
    Deprecated: This option has no effect.
trial : Union[bool, None]
    When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
    to `false`. Useful to wait until the element is ready for the action without performing it.

wait_for_element_state()

None playwright.async_api._generated.ElementHandle.wait_for_element_state	(		self,
		Literal[ "disabled", "editable", "enabled", "hidden", "stable", "visible" ]	state,
		*typing.Optional[float]	timeout = None
	)

ElementHandle.wait_for_element_state

Returns when the element satisfies the `state`.

Depending on the `state` parameter, this method waits for one of the [actionability](https://playwright.dev/python/docs/actionability) checks to
pass. This method throws when the element is detached while waiting, unless waiting for the `\"hidden\"` state.
- `\"visible\"` Wait until the element is [visible](https://playwright.dev/python/docs/actionability#visible).
- `\"hidden\"` Wait until the element is [not visible](https://playwright.dev/python/docs/actionability#visible) or not attached. Note that
  waiting for hidden does not throw when the element detaches.
- `\"stable\"` Wait until the element is both [visible](https://playwright.dev/python/docs/actionability#visible) and
  [stable](https://playwright.dev/python/docs/actionability#stable).
- `\"enabled\"` Wait until the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
- `\"disabled\"` Wait until the element is [not enabled](https://playwright.dev/python/docs/actionability#enabled).
- `\"editable\"` Wait until the element is [editable](https://playwright.dev/python/docs/actionability#editable).

If the element does not satisfy the condition for the `timeout` milliseconds, this method will throw.

Parameters
----------
state : Union["disabled", "editable", "enabled", "hidden", "stable", "visible"]
    A state to wait for, see below for more details.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.

wait_for_selector()

typing.Optional["ElementHandle"] playwright.async_api._generated.ElementHandle.wait_for_selector	(		self,
		str	selector,
		*typing.Optional[ Literal["attached", "detached", "hidden", "visible"] ]	state = None,
		typing.Optional[float]	timeout = None,
		typing.Optional[bool]	strict = None
	)

ElementHandle.wait_for_selector

Returns element specified by selector when it satisfies `state` option. Returns `null` if waiting for `hidden` or
`detached`.

Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom,
or become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the
method will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the
function will throw.

**Usage**

```py
await page.set_content(\"<div><span></span></div>\")
div = await page.query_selector(\"div\")
# waiting for the \"span\" selector relative to the div.
span = await div.wait_for_selector(\"span\", state=\"attached\")
```

**NOTE** This method does not work across navigations, use `page.wait_for_selector()` instead.

Parameters
----------
selector : str
    A selector to query for.
state : Union["attached", "detached", "hidden", "visible", None]
    Defaults to `'visible'`. Can be either:
    - `'attached'` - wait for element to be present in DOM.
    - `'detached'` - wait for element to not be present in DOM.
    - `'visible'` - wait for element to have non-empty bounding box and no `visibility:hidden`. Note that element
      without any content or with `display:none` has an empty bounding box and is not considered visible.
    - `'hidden'` - wait for element to be either detached from DOM, or have an empty bounding box or
      `visibility:hidden`. This is opposite to the `'visible'` option.
timeout : Union[float, None]
    Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
    be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
strict : Union[bool, None]
    When true, the call requires selector to resolve to a single element. If given selector resolves to more than one
    element, the call throws an exception.

Returns
-------
Union[ElementHandle, None]

---

The documentation for this class was generated from the following file:

• docs/help/help-venv/lib/python3.12/site-packages/playwright/async_api/_generated.py