@property

def url(self) -> str:

"""Request.url

URL of the request.

Returns

-------

str

"""

return mapping.from_maybe_impl(self._impl_obj.url)

@property

def resource_type(self) -> str:

"""Request.resource_type

Contains the request's resource type as it was perceived by the rendering engine. ResourceType will be one of the

following: `document`, `stylesheet`, `image`, `media`, `font`, `script`, `texttrack`, `xhr`, `fetch`, `eventsource`,

`websocket`, `manifest`, `other`.

Returns

-------

str

"""

return mapping.from_maybe_impl(self._impl_obj.resource_type)

@property

def method(self) -> str:

"""Request.method

Request's method (GET, POST, etc.)

Returns

-------

str

"""

return mapping.from_maybe_impl(self._impl_obj.method)

@property

def post_data(self) -> typing.Optional[str]:

"""Request.post_data

Request's post body, if any.

Returns

-------

Union[str, NoneType]

"""

return mapping.from_maybe_impl(self._impl_obj.post_data)

@property

def post_data_json(self) -> typing.Optional[typing.Any]:

"""Request.post_data_json

Returns parsed request's body for `form-urlencoded` and JSON as a fallback if any.

When the response is `application/x-www-form-urlencoded` then a key/value object of the values will be returned.

Otherwise it will be parsed as JSON.

Returns

-------

Union[Any, NoneType]

"""

return mapping.from_maybe_impl(self._impl_obj.post_data_json)

@property

def post_data_buffer(self) -> typing.Optional[bytes]:

"""Request.post_data_buffer

Request's post body in a binary form, if any.

Returns

-------

Union[bytes, NoneType]

"""

return mapping.from_maybe_impl(self._impl_obj.post_data_buffer)

@property

def frame(self) -> "Frame":

"""Request.frame

Returns the `Frame` that initiated this request.

Returns

-------

Frame

"""

return mapping.from_impl(self._impl_obj.frame)

@property

def redirected_from(self) -> typing.Optional["Request"]:

"""Request.redirected_from

Request that was redirected by the server to this one, if any.

When the server responds with a redirect, Playwright creates a new `Request` object. The two requests are connected by

`redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to

construct the whole redirect chain by repeatedly calling `redirectedFrom()`.

For example, if the website `http://example.com` redirects to `https://example.com`:

```py

response = page.goto(\"http://example.com\")

print(response.request.redirected_from.url) # \"http://example.com\"

```

If the website `https://google.com` has no redirects:

```py

response = page.goto(\"https://google.com\")

print(response.request.redirected_from) # None

```

Returns

-------

Union[Request, NoneType]

"""

return mapping.from_impl_nullable(self._impl_obj.redirected_from)

@property

def redirected_to(self) -> typing.Optional["Request"]:

"""Request.redirected_to

New request issued by the browser if the server responded with redirect.

This method is the opposite of `request.redirected_from()`:

```py

assert request.redirected_from.redirected_to == request

```

Returns

-------

Union[Request, NoneType]

"""

return mapping.from_impl_nullable(self._impl_obj.redirected_to)

@property

def failure(self) -> typing.Optional[str]:

"""Request.failure

The method returns `null` unless this request has failed, as reported by `requestfailed` event.

Example of logging of all the failed requests:

```py

page.on(\"requestfailed\", lambda request: print(request.url + \" \" + request.failure))

```

Returns

-------

Union[str, NoneType]

"""

return mapping.from_maybe_impl(self._impl_obj.failure)

@property

def timing(self) -> ResourceTiming:

"""Request.timing

Returns resource timing information for given request. Most of the timing values become available upon the response,

`responseEnd` becomes available when request finishes. Find more information at

[Resource Timing API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming).

```py

with page.expect_event(\"requestfinished\") as request_info:

page.goto(\"http://example.com\")

request = request_info.value

print(request.timing)

```

Returns

-------

{startTime: float, domainLookupStart: float, domainLookupEnd: float, connectStart: float, secureConnectionStart: float, connectEnd: float, requestStart: float, responseStart: float, responseEnd: float}

"""

return mapping.from_impl(self._impl_obj.timing)

@property

def headers(self) -> typing.Dict[str, str]:

"""Request.headers

**DEPRECATED** Incomplete list of headers as seen by the rendering engine. Use `request.all_headers()` instead.

Returns

-------

Dict[str, str]

"""

return mapping.from_maybe_impl(self._impl_obj.headers)

def sizes(self) -> RequestSizes:

"""Request.sizes

Returns resource size information for given request.

Returns

-------

{requestBodySize: int, requestHeadersSize: int, responseBodySize: int, responseHeadersSize: int}

"""

return mapping.from_impl(self._sync("request.sizes", self._impl_obj.sizes()))

def response(self) -> typing.Optional["Response"]:

"""Request.response

Returns the matching `Response` object, or `null` if the response was not received due to error.

Returns

-------

Union[Response, NoneType]

"""

return mapping.from_impl_nullable(

self._sync("request.response", self._impl_obj.response())

)

def is_navigation_request(self) -> bool:

"""Request.is_navigation_request

Whether this request is driving frame's navigation.

Returns

-------

bool

"""

return mapping.from_maybe_impl(self._impl_obj.is_navigation_request())

def all_headers(self) -> typing.Dict[str, str]:

"""Request.all_headers

An object with all the request HTTP headers associated with this request. The header names are lower-cased.

Returns

-------

Dict[str, str]

"""

return mapping.from_maybe_impl(

self._sync("request.all_headers", self._impl_obj.all_headers())

)

def headers_array(self) -> typing.List[NameValue]:

"""Request.headers_array

An array with all the request HTTP headers associated with this request. Unlike `request.all_headers()`, header

names are NOT lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.

Returns

-------

List[{name: str, value: str}]

"""

return mapping.from_impl_list(

self._sync("request.headers_array", self._impl_obj.headers_array())

)

def header_value(self, name: str) -> typing.Optional[str]:

"""Request.header_value

Returns the value of the header matching the name. The name is case insensitive.

Parameters

----------

name : str

Name of the header.

Returns

-------

Union[str, NoneType]

"""

return mapping.from_maybe_impl(

self._sync("request.header_value", self._impl_obj.header_value(name=name))

@property

def url(self) -> str:

"""Response.url

Contains the URL of the response.

Returns

-------

str

"""

return mapping.from_maybe_impl(self._impl_obj.url)

@property

def ok(self) -> bool:

"""Response.ok

Contains a boolean stating whether the response was successful (status in the range 200-299) or not.

Returns

-------

bool

"""

return mapping.from_maybe_impl(self._impl_obj.ok)

@property

def status(self) -> int:

"""Response.status

Contains the status code of the response (e.g., 200 for a success).

Returns

-------

int

"""

return mapping.from_maybe_impl(self._impl_obj.status)

@property

def status_text(self) -> str:

"""Response.status_text

Contains the status text of the response (e.g. usually an \"OK\" for a success).

Returns

-------

str

"""

return mapping.from_maybe_impl(self._impl_obj.status_text)

@property

def headers(self) -> typing.Dict[str, str]:

"""Response.headers

**DEPRECATED** Incomplete list of headers as seen by the rendering engine. Use `response.all_headers()` instead.

Returns

-------

Dict[str, str]

"""

return mapping.from_maybe_impl(self._impl_obj.headers)

@property

def request(self) -> "Request":

"""Response.request

Returns the matching `Request` object.

Returns

-------

Request

"""

return mapping.from_impl(self._impl_obj.request)

@property

def frame(self) -> "Frame":

"""Response.frame

Returns the `Frame` that initiated this response.

Returns

-------

Frame

"""

return mapping.from_impl(self._impl_obj.frame)

def all_headers(self) -> typing.Dict[str, str]:

"""Response.all_headers

An object with all the response HTTP headers associated with this response.

Returns

-------

Dict[str, str]

"""

return mapping.from_maybe_impl(

self._sync("response.all_headers", self._impl_obj.all_headers())

)

def headers_array(self) -> typing.List[NameValue]:

"""Response.headers_array

An array with all the request HTTP headers associated with this response. Unlike `response.all_headers()`, header

names are NOT lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.

Returns

-------

List[{name: str, value: str}]

"""

return mapping.from_impl_list(

self._sync("response.headers_array", self._impl_obj.headers_array())

)

def header_value(self, name: str) -> typing.Optional[str]:

"""Response.header_value

Returns the value of the header matching the name. The name is case insensitive. If multiple headers have the same name

(except `set-cookie`), they are returned as a list separated by `, `. For `set-cookie`, the `\\n` separator is used. If

no headers are found, `null` is returned.

Parameters

----------

name : str

Name of the header.

Returns

-------

Union[str, NoneType]

"""

return mapping.from_maybe_impl(

self._sync("response.header_value", self._impl_obj.header_value(name=name))

)

def header_values(self, name: str) -> typing.List[str]:

"""Response.header_values

Returns all values of the headers matching the name, for example `set-cookie`. The name is case insensitive.

Parameters

----------

name : str

Name of the header.

Returns

-------

List[str]

"""

return mapping.from_maybe_impl(

self._sync(

"response.header_values", self._impl_obj.header_values(name=name)

)

)

def server_addr(self) -> typing.Optional[RemoteAddr]:

"""Response.server_addr

Returns the IP address and port of the server.

Returns

-------

Union[{ipAddress: str, port: int}, NoneType]

"""

return mapping.from_impl_nullable(

self._sync("response.server_addr", self._impl_obj.server_addr())

)

def security_details(self) -> typing.Optional[SecurityDetails]:

"""Response.security_details

Returns SSL and other security information.

Returns

-------

Union[{issuer: Union[str, NoneType], protocol: Union[str, NoneType], subjectName: Union[str, NoneType], validFrom: Union[float, NoneType], validTo: Union[float, NoneType]}, NoneType]

"""

return mapping.from_impl_nullable(

self._sync("response.security_details", self._impl_obj.security_details())

)

def finished(self) -> NoneType:

"""Response.finished

Waits for this response to finish, returns always `null`.

"""

return mapping.from_maybe_impl(

self._sync("response.finished", self._impl_obj.finished())

)

def body(self) -> bytes:

"""Response.body

Returns the buffer with response body.

Returns

-------

bytes

"""

return mapping.from_maybe_impl(

self._sync("response.body", self._impl_obj.body())

)

def text(self) -> str:

"""Response.text

Returns the text representation of response body.

Returns

-------

str

"""

return mapping.from_maybe_impl(

self._sync("response.text", self._impl_obj.text())

)

def json(self) -> typing.Any:

"""Response.json

Returns the JSON representation of response body.

This method will throw if the response body is not parsable via `JSON.parse`.

Returns

-------

Any

"""

return mapping.from_maybe_impl(

self._sync("response.json", self._impl_obj.json())

@property

def request(self) -> "Request":

"""Route.request

A request to be routed.

Returns

-------

Request

"""

return mapping.from_impl(self._impl_obj.request)

def abort(self, error_code: str = None) -> NoneType:

"""Route.abort

Aborts the route's request.

Parameters

----------

error_code : Union[str, NoneType]

Optional error code. Defaults to `failed`, could be one of the following:

- `'aborted'` - An operation was aborted (due to user action)

- `'accessdenied'` - Permission to access a resource, other than the network, was denied

- `'addressunreachable'` - The IP address is unreachable. This usually means that there is no route to the specified

host or network.

- `'blockedbyclient'` - The client chose to block the request.

- `'blockedbyresponse'` - The request failed because the response was delivered along with requirements which are not

met ('X-Frame-Options' and 'Content-Security-Policy' ancestor checks, for instance).

- `'connectionaborted'` - A connection timed out as a result of not receiving an ACK for data sent.

- `'connectionclosed'` - A connection was closed (corresponding to a TCP FIN).

- `'connectionfailed'` - A connection attempt failed.

- `'connectionrefused'` - A connection attempt was refused.

- `'connectionreset'` - A connection was reset (corresponding to a TCP RST).

- `'internetdisconnected'` - The Internet connection has been lost.

- `'namenotresolved'` - The host name could not be resolved.

- `'timedout'` - An operation timed out.

- `'failed'` - A generic failure occurred.

"""

return mapping.from_maybe_impl(

self._sync("route.abort", self._impl_obj.abort(errorCode=error_code))

)

def fulfill(

self,

*,

status: int = None,

headers: typing.Optional[typing.Dict[str, str]] = None,

body: typing.Union[str, bytes] = None,

path: typing.Union[str, pathlib.Path] = None,

content_type: str = None

) -> NoneType:

"""Route.fulfill

Fulfills route's request with given response.

An example of fulfilling all requests with 404 responses:

```py

page.route(\"**/*\", lambda route: route.fulfill(

status=404,

content_type=\"text/plain\",

body=\"not found!\"))

```

An example of serving static file:

```py

page.route(\"**/xhr_endpoint\", lambda route: route.fulfill(path=\"mock_data.json\"))

```

Parameters

----------

status : Union[int, NoneType]

Response status code, defaults to `200`.

headers : Union[Dict[str, str], NoneType]

Response headers. Header values will be converted to a string.

body : Union[bytes, str, NoneType]

Response body.

path : Union[pathlib.Path, str, NoneType]

File path to respond with. The content type will be inferred from file extension. If `path` is a relative path, then it

is resolved relative to the current working directory.

content_type : Union[str, NoneType]

If set, equals to setting `Content-Type` response header.

"""

return mapping.from_maybe_impl(

self._sync(

"route.fulfill",

self._impl_obj.fulfill(

status=status,

headers=mapping.to_impl(headers),

body=body,

path=path,

contentType=content_type,

),

)

)

def continue_(

self,

*,

url: str = None,

method: str = None,

headers: typing.Optional[typing.Dict[str, str]] = None,

post_data: typing.Union[str, bytes] = None

) -> NoneType:

"""Route.continue_

Continues route's request with optional overrides.

```py

def handle(route, request):

# override headers

headers = {

**request.headers,

\"foo\": \"bar\" # set \"foo\" header

\"origin\": None # remove \"origin\" header

}

route.continue_(headers=headers)

}

page.route(\"**/*\", handle)

```

Parameters

----------

url : Union[str, NoneType]

If set changes the request URL. New URL must have same protocol as original one.

method : Union[str, NoneType]

If set changes the request method (e.g. GET or POST)

headers : Union[Dict[str, str], NoneType]

If set changes the request HTTP headers. Header values will be converted to a string.

post_data : Union[bytes, str, NoneType]

If set changes the post data of request

"""

return mapping.from_maybe_impl(

self._sync(

"route.continue_",

self._impl_obj.continue_(

url=url,

method=method,

headers=mapping.to_impl(headers),

postData=post_data,

),

)

@typing.overload

def on(

self, event: Literal["close"], f: typing.Callable[["WebSocket"], "None"]

) -> None:

"""

Fired when the websocket closes."""

@typing.overload

def on(

self,

event: Literal["framereceived"],

f: typing.Callable[["typing.Dict"], "None"],

) -> None:

"""

Fired when the websocket receives a frame."""

@typing.overload

def on(

self, event: Literal["framesent"], f: typing.Callable[["typing.Dict"], "None"]

) -> None:

"""

Fired when the websocket sends a frame."""

@typing.overload

def on(

self, event: Literal["socketerror"], f: typing.Callable[["str"], "None"]

) -> None:

"""

Fired when the websocket has an error."""

def on(self, event: str, f: typing.Callable[..., None]) -> None:

return super().on(event=event, f=f)

@typing.overload

def once(

self, event: Literal["close"], f: typing.Callable[["WebSocket"], "None"]

) -> None:

"""

Fired when the websocket closes."""

@typing.overload

def once(

self,

event: Literal["framereceived"],

f: typing.Callable[["typing.Dict"], "None"],

) -> None:

"""

Fired when the websocket receives a frame."""

@typing.overload

def once(

self, event: Literal["framesent"], f: typing.Callable[["typing.Dict"], "None"]

) -> None:

"""

Fired when the websocket sends a frame."""

@typing.overload

def once(

self, event: Literal["socketerror"], f: typing.Callable[["str"], "None"]

) -> None:

"""

Fired when the websocket has an error."""

def once(self, event: str, f: typing.Callable[..., None]) -> None:

return super().once(event=event, f=f)

@property

def url(self) -> str:

"""WebSocket.url

Contains the URL of the WebSocket.

Returns

-------

str

"""

return mapping.from_maybe_impl(self._impl_obj.url)

def expect_event(

self, event: str, predicate: typing.Callable = None, *, timeout: float = None

) -> EventContextManager:

"""WebSocket.expect_event

Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy

value. Will throw an error if the webSocket is closed before the event is fired. Returns the event data value.

Parameters

----------

event : str

Event name, same one would pass into `webSocket.on(event)`.

predicate : Union[Callable, NoneType]

Receives the event data and resolves to truthy value when the waiting should resolve.

timeout : Union[float, NoneType]

Maximum time to wait for 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()`.

Returns

-------

EventContextManager

"""

return EventContextManager(

self,

self._impl_obj.expect_event(

event=event, predicate=self._wrap_handler(predicate), timeout=timeout

).future,

)

def wait_for_event(

self, event: str, predicate: typing.Callable = None, *, timeout: float = None

) -> typing.Any:

"""WebSocket.wait_for_event

> NOTE: In most cases, you should use `web_socket.expect_event()`.

Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function and

waits for `predicate(event)` to return a truthy value. Will throw an error if the socket is closed before the `event` is

fired.

Parameters

----------

event : str

Event name, same one typically passed into `*.on(event)`.

predicate : Union[Callable, NoneType]

Receives the event data and resolves to truthy value when the waiting should resolve.

timeout : Union[float, NoneType]

Maximum time to wait for 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()`.

Returns

-------

Any

"""

return mapping.from_maybe_impl(

self._sync(

"web_socket.wait_for_event",

self._impl_obj.wait_for_event(

event=event,

predicate=self._wrap_handler(predicate),

timeout=timeout,

),

)

)

def is_closed(self) -> bool:

"""WebSocket.is_closed

Indicates that the web socket has been closed.

Returns

-------

bool

"""

def down(self, key: str) -> NoneType:

"""Keyboard.down

Dispatches a `keydown` event.

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

If `key` is a modifier key, `Shift`, `Meta`, `Control`, or `Alt`, subsequent key presses will be sent with that modifier

active. To release the modifier key, use `keyboard.up()`.

After the key is pressed once, subsequent calls to `keyboard.down()` will have

[repeat](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat) set to true. To release the key, use

`keyboard.up()`.

> NOTE: Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.

Parameters

----------

key : str

Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.

"""

return mapping.from_maybe_impl(

self._sync("keyboard.down", self._impl_obj.down(key=key))

)

def up(self, key: str) -> NoneType:

"""Keyboard.up

Dispatches a `keyup` event.

Parameters

----------

key : str

Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.

"""

return mapping.from_maybe_impl(

self._sync("keyboard.up", self._impl_obj.up(key=key))

)

def insert_text(self, text: str) -> NoneType:

"""Keyboard.insert_text

Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.

```py

page.keyboard.insert_text(\"嗨\")

```

> NOTE: Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper case.

Parameters

----------

text : str

Sets input to the specified text value.

"""

return mapping.from_maybe_impl(

self._sync("keyboard.insert_text", self._impl_obj.insert_text(text=text))

)

def type(self, text: str, *, delay: float = None) -> NoneType:

"""Keyboard.type

Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.