Skip to content

fetch

AuthChallenge dataclass

Authorization challenge for HTTP status code 401 or 407.

Source code in zendriver/cdp/fetch.py 
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
@dataclass
class AuthChallenge:
    """
    Authorization challenge for HTTP status code 401 or 407.
    """

    #: Origin of the challenger.
    origin: str

    #: The authentication scheme used, such as basic or digest
    scheme: str

    #: The realm of the challenge. May be empty.
    realm: str

    #: Source of the authentication challenge.
    source: typing.Optional[str] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["origin"] = self.origin
        json["scheme"] = self.scheme
        json["realm"] = self.realm
        if self.source is not None:
            json["source"] = self.source
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> AuthChallenge:
        return cls(
            origin=str(json["origin"]),
            scheme=str(json["scheme"]),
            realm=str(json["realm"]),
            source=(
                str(json["source"]) if json.get("source", None) is not None else None
            ),
        )

origin: str instance-attribute

realm: str instance-attribute

scheme: str instance-attribute

source: typing.Optional[str] = None class-attribute instance-attribute

__init__(origin, scheme, realm, source=None)

from_json(json) classmethod

Source code in zendriver/cdp/fetch.py 
147
148
149
150
151
152
153
154
155
156
@classmethod
def from_json(cls, json: T_JSON_DICT) -> AuthChallenge:
    return cls(
        origin=str(json["origin"]),
        scheme=str(json["scheme"]),
        realm=str(json["realm"]),
        source=(
            str(json["source"]) if json.get("source", None) is not None else None
        ),
    )

to_json()

Source code in zendriver/cdp/fetch.py 
138
139
140
141
142
143
144
145
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["origin"] = self.origin
    json["scheme"] = self.scheme
    json["realm"] = self.realm
    if self.source is not None:
        json["source"] = self.source
    return json

AuthChallengeResponse dataclass

Response to an AuthChallenge.

Source code in zendriver/cdp/fetch.py 
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
@dataclass
class AuthChallengeResponse:
    """
    Response to an AuthChallenge.
    """

    #: The decision on what to do in response to the authorization challenge.  Default means
    #: deferring to the default behavior of the net stack, which will likely either the Cancel
    #: authentication or display a popup dialog box.
    response: str

    #: The username to provide, possibly empty. Should only be set if response is
    #: ProvideCredentials.
    username: typing.Optional[str] = None

    #: The password to provide, possibly empty. Should only be set if response is
    #: ProvideCredentials.
    password: typing.Optional[str] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["response"] = self.response
        if self.username is not None:
            json["username"] = self.username
        if self.password is not None:
            json["password"] = self.password
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> AuthChallengeResponse:
        return cls(
            response=str(json["response"]),
            username=(
                str(json["username"])
                if json.get("username", None) is not None
                else None
            ),
            password=(
                str(json["password"])
                if json.get("password", None) is not None
                else None
            ),
        )

password: typing.Optional[str] = None class-attribute instance-attribute

response: str instance-attribute

username: typing.Optional[str] = None class-attribute instance-attribute

__init__(response, username=None, password=None)

from_json(json) classmethod

Source code in zendriver/cdp/fetch.py 
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
@classmethod
def from_json(cls, json: T_JSON_DICT) -> AuthChallengeResponse:
    return cls(
        response=str(json["response"]),
        username=(
            str(json["username"])
            if json.get("username", None) is not None
            else None
        ),
        password=(
            str(json["password"])
            if json.get("password", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/fetch.py 
178
179
180
181
182
183
184
185
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["response"] = self.response
    if self.username is not None:
        json["username"] = self.username
    if self.password is not None:
        json["password"] = self.password
    return json

AuthRequired dataclass

Issued when the domain is enabled with handleAuthRequests set to true. The request is paused until client responds with continueWithAuth.

Source code in zendriver/cdp/fetch.py 
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
@event_class("Fetch.authRequired")
@dataclass
class AuthRequired:
    """
    Issued when the domain is enabled with handleAuthRequests set to true.
    The request is paused until client responds with continueWithAuth.
    """

    #: Each request the page makes will have a unique id.
    request_id: RequestId
    #: The details of the request.
    request: network.Request
    #: The id of the frame that initiated the request.
    frame_id: page.FrameId
    #: How the requested resource will be used.
    resource_type: network.ResourceType
    #: Details of the Authorization Challenge encountered.
    #: If this is set, client should respond with continueRequest that
    #: contains AuthChallengeResponse.
    auth_challenge: AuthChallenge

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> AuthRequired:
        return cls(
            request_id=RequestId.from_json(json["requestId"]),
            request=network.Request.from_json(json["request"]),
            frame_id=page.FrameId.from_json(json["frameId"]),
            resource_type=network.ResourceType.from_json(json["resourceType"]),
            auth_challenge=AuthChallenge.from_json(json["authChallenge"]),
        )

auth_challenge: AuthChallenge instance-attribute

frame_id: page.FrameId instance-attribute

request: network.Request instance-attribute

request_id: RequestId instance-attribute

resource_type: network.ResourceType instance-attribute

__init__(request_id, request, frame_id, resource_type, auth_challenge)

from_json(json) classmethod

Source code in zendriver/cdp/fetch.py 
545
546
547
548
549
550
551
552
553
@classmethod
def from_json(cls, json: T_JSON_DICT) -> AuthRequired:
    return cls(
        request_id=RequestId.from_json(json["requestId"]),
        request=network.Request.from_json(json["request"]),
        frame_id=page.FrameId.from_json(json["frameId"]),
        resource_type=network.ResourceType.from_json(json["resourceType"]),
        auth_challenge=AuthChallenge.from_json(json["authChallenge"]),
    )

HeaderEntry dataclass

Response HTTP header entry

Source code in zendriver/cdp/fetch.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
@dataclass
class HeaderEntry:
    """
    Response HTTP header entry
    """

    name: str

    value: str

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["name"] = self.name
        json["value"] = self.value
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> HeaderEntry:
        return cls(
            name=str(json["name"]),
            value=str(json["value"]),
        )

name: str instance-attribute

value: str instance-attribute

__init__(name, value)

from_json(json) classmethod

Source code in zendriver/cdp/fetch.py 
112
113
114
115
116
117
@classmethod
def from_json(cls, json: T_JSON_DICT) -> HeaderEntry:
    return cls(
        name=str(json["name"]),
        value=str(json["value"]),
    )

to_json()

Source code in zendriver/cdp/fetch.py 
106
107
108
109
110
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["name"] = self.name
    json["value"] = self.value
    return json

RequestId

Bases: str

Unique request identifier.

Source code in zendriver/cdp/fetch.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class RequestId(str):
    """
    Unique request identifier.
    """

    def to_json(self) -> str:
        return self

    @classmethod
    def from_json(cls, json: str) -> RequestId:
        return cls(json)

    def __repr__(self):
        return "RequestId({})".format(super().__repr__())

__repr__()

Source code in zendriver/cdp/fetch.py 
31
32
def __repr__(self):
    return "RequestId({})".format(super().__repr__())

from_json(json) classmethod

Source code in zendriver/cdp/fetch.py 
27
28
29
@classmethod
def from_json(cls, json: str) -> RequestId:
    return cls(json)

to_json()

Source code in zendriver/cdp/fetch.py 
24
25
def to_json(self) -> str:
    return self

RequestPattern dataclass

Source code in zendriver/cdp/fetch.py 
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
@dataclass
class RequestPattern:
    #: Wildcards (``'*'`` -> zero or more, ``'?'`` -> exactly one) are allowed. Escape character is
    #: backslash. Omitting is equivalent to ``"*"``.
    url_pattern: typing.Optional[str] = None

    #: If set, only requests for matching resource types will be intercepted.
    resource_type: typing.Optional[network.ResourceType] = None

    #: Stage at which to begin intercepting requests. Default is Request.
    request_stage: typing.Optional[RequestStage] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        if self.url_pattern is not None:
            json["urlPattern"] = self.url_pattern
        if self.resource_type is not None:
            json["resourceType"] = self.resource_type.to_json()
        if self.request_stage is not None:
            json["requestStage"] = self.request_stage.to_json()
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> RequestPattern:
        return cls(
            url_pattern=(
                str(json["urlPattern"])
                if json.get("urlPattern", None) is not None
                else None
            ),
            resource_type=(
                network.ResourceType.from_json(json["resourceType"])
                if json.get("resourceType", None) is not None
                else None
            ),
            request_stage=(
                RequestStage.from_json(json["requestStage"])
                if json.get("requestStage", None) is not None
                else None
            ),
        )

request_stage: typing.Optional[RequestStage] = None class-attribute instance-attribute

resource_type: typing.Optional[network.ResourceType] = None class-attribute instance-attribute

url_pattern: typing.Optional[str] = None class-attribute instance-attribute

__init__(url_pattern=None, resource_type=None, request_stage=None)

from_json(json) classmethod

Source code in zendriver/cdp/fetch.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
@classmethod
def from_json(cls, json: T_JSON_DICT) -> RequestPattern:
    return cls(
        url_pattern=(
            str(json["urlPattern"])
            if json.get("urlPattern", None) is not None
            else None
        ),
        resource_type=(
            network.ResourceType.from_json(json["resourceType"])
            if json.get("resourceType", None) is not None
            else None
        ),
        request_stage=(
            RequestStage.from_json(json["requestStage"])
            if json.get("requestStage", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/fetch.py 
65
66
67
68
69
70
71
72
73
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    if self.url_pattern is not None:
        json["urlPattern"] = self.url_pattern
    if self.resource_type is not None:
        json["resourceType"] = self.resource_type.to_json()
    if self.request_stage is not None:
        json["requestStage"] = self.request_stage.to_json()
    return json

RequestPaused dataclass

Issued when the domain is enabled and the request URL matches the specified filter. The request is paused until the client responds with one of continueRequest, failRequest or fulfillRequest. The stage of the request can be determined by presence of responseErrorReason and responseStatusCode -- the request is at the response stage if either of these fields is present and in the request stage otherwise. Redirect responses and subsequent requests are reported similarly to regular responses and requests. Redirect responses may be distinguished by the value of responseStatusCode (which is one of 301, 302, 303, 307, 308) along with presence of the location header. Requests resulting from a redirect will have redirectedRequestId field set.

Source code in zendriver/cdp/fetch.py 
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
@event_class("Fetch.requestPaused")
@dataclass
class RequestPaused:
    """
    Issued when the domain is enabled and the request URL matches the
    specified filter. The request is paused until the client responds
    with one of continueRequest, failRequest or fulfillRequest.
    The stage of the request can be determined by presence of responseErrorReason
    and responseStatusCode -- the request is at the response stage if either
    of these fields is present and in the request stage otherwise.
    Redirect responses and subsequent requests are reported similarly to regular
    responses and requests. Redirect responses may be distinguished by the value
    of ``responseStatusCode`` (which is one of 301, 302, 303, 307, 308) along with
    presence of the ``location`` header. Requests resulting from a redirect will
    have ``redirectedRequestId`` field set.
    """

    #: Each request the page makes will have a unique id.
    request_id: RequestId
    #: The details of the request.
    request: network.Request
    #: The id of the frame that initiated the request.
    frame_id: page.FrameId
    #: How the requested resource will be used.
    resource_type: network.ResourceType
    #: Response error if intercepted at response stage.
    response_error_reason: typing.Optional[network.ErrorReason]
    #: Response code if intercepted at response stage.
    response_status_code: typing.Optional[int]
    #: Response status text if intercepted at response stage.
    response_status_text: typing.Optional[str]
    #: Response headers if intercepted at the response stage.
    response_headers: typing.Optional[typing.List[HeaderEntry]]
    #: If the intercepted request had a corresponding Network.requestWillBeSent event fired for it,
    #: then this networkId will be the same as the requestId present in the requestWillBeSent event.
    network_id: typing.Optional[network.RequestId]
    #: If the request is due to a redirect response from the server, the id of the request that
    #: has caused the redirect.
    redirected_request_id: typing.Optional[RequestId]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> RequestPaused:
        return cls(
            request_id=RequestId.from_json(json["requestId"]),
            request=network.Request.from_json(json["request"]),
            frame_id=page.FrameId.from_json(json["frameId"]),
            resource_type=network.ResourceType.from_json(json["resourceType"]),
            response_error_reason=(
                network.ErrorReason.from_json(json["responseErrorReason"])
                if json.get("responseErrorReason", None) is not None
                else None
            ),
            response_status_code=(
                int(json["responseStatusCode"])
                if json.get("responseStatusCode", None) is not None
                else None
            ),
            response_status_text=(
                str(json["responseStatusText"])
                if json.get("responseStatusText", None) is not None
                else None
            ),
            response_headers=(
                [HeaderEntry.from_json(i) for i in json["responseHeaders"]]
                if json.get("responseHeaders", None) is not None
                else None
            ),
            network_id=(
                network.RequestId.from_json(json["networkId"])
                if json.get("networkId", None) is not None
                else None
            ),
            redirected_request_id=(
                RequestId.from_json(json["redirectedRequestId"])
                if json.get("redirectedRequestId", None) is not None
                else None
            ),
        )

frame_id: page.FrameId instance-attribute

network_id: typing.Optional[network.RequestId] instance-attribute

redirected_request_id: typing.Optional[RequestId] instance-attribute

request: network.Request instance-attribute

request_id: RequestId instance-attribute

resource_type: network.ResourceType instance-attribute

response_error_reason: typing.Optional[network.ErrorReason] instance-attribute

response_headers: typing.Optional[typing.List[HeaderEntry]] instance-attribute

response_status_code: typing.Optional[int] instance-attribute

response_status_text: typing.Optional[str] instance-attribute

__init__(request_id, request, frame_id, resource_type, response_error_reason, response_status_code, response_status_text, response_headers, network_id, redirected_request_id)

from_json(json) classmethod

Source code in zendriver/cdp/fetch.py 
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
@classmethod
def from_json(cls, json: T_JSON_DICT) -> RequestPaused:
    return cls(
        request_id=RequestId.from_json(json["requestId"]),
        request=network.Request.from_json(json["request"]),
        frame_id=page.FrameId.from_json(json["frameId"]),
        resource_type=network.ResourceType.from_json(json["resourceType"]),
        response_error_reason=(
            network.ErrorReason.from_json(json["responseErrorReason"])
            if json.get("responseErrorReason", None) is not None
            else None
        ),
        response_status_code=(
            int(json["responseStatusCode"])
            if json.get("responseStatusCode", None) is not None
            else None
        ),
        response_status_text=(
            str(json["responseStatusText"])
            if json.get("responseStatusText", None) is not None
            else None
        ),
        response_headers=(
            [HeaderEntry.from_json(i) for i in json["responseHeaders"]]
            if json.get("responseHeaders", None) is not None
            else None
        ),
        network_id=(
            network.RequestId.from_json(json["networkId"])
            if json.get("networkId", None) is not None
            else None
        ),
        redirected_request_id=(
            RequestId.from_json(json["redirectedRequestId"])
            if json.get("redirectedRequestId", None) is not None
            else None
        ),
    )

RequestStage

Bases: Enum

Stages of the request to handle. Request will intercept before the request is sent. Response will intercept after the response is received (but before response body is received).

Source code in zendriver/cdp/fetch.py 
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
class RequestStage(enum.Enum):
    """
    Stages of the request to handle. Request will intercept before the request is
    sent. Response will intercept after the response is received (but before response
    body is received).
    """

    REQUEST = "Request"
    RESPONSE = "Response"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> RequestStage:
        return cls(json)

REQUEST = 'Request' class-attribute instance-attribute

RESPONSE = 'Response' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/fetch.py 
48
49
50
@classmethod
def from_json(cls, json: str) -> RequestStage:
    return cls(json)

to_json()

Source code in zendriver/cdp/fetch.py 
45
46
def to_json(self) -> str:
    return self.value

continue_request(request_id, url=None, method=None, post_data=None, headers=None, intercept_response=None)

Continues the request, optionally modifying some of its parameters.

Parameters:

Name Type Description Default
request_id RequestId

An id the client received in requestPaused event.

 required
url Optional[str]

(Optional) If set, the request url will be modified in a way that's not observable by page.

 None
method Optional[str]

(Optional) If set, the request method is overridden.

 None
post_data Optional[str]

(Optional) If set, overrides the post data in the request. (Encoded as a base64 string when passed over JSON)

 None
headers Optional[List[HeaderEntry]]

(Optional) If set, overrides the request headers. Note that the overrides do not extend to subsequent redirect hops, if a redirect happens. Another override may be applied to a different request produced by a redirect.

 None
intercept_response Optional[bool]

(EXPERIMENTAL) (Optional) If set, overrides response interception behavior for this request.

 None
Source code in zendriver/cdp/fetch.py 
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
def continue_request(
    request_id: RequestId,
    url: typing.Optional[str] = None,
    method: typing.Optional[str] = None,
    post_data: typing.Optional[str] = None,
    headers: typing.Optional[typing.List[HeaderEntry]] = None,
    intercept_response: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Continues the request, optionally modifying some of its parameters.

    :param request_id: An id the client received in requestPaused event.
    :param url: *(Optional)* If set, the request url will be modified in a way that's not observable by page.
    :param method: *(Optional)* If set, the request method is overridden.
    :param post_data: *(Optional)* If set, overrides the post data in the request. (Encoded as a base64 string when passed over JSON)
    :param headers: *(Optional)* If set, overrides the request headers. Note that the overrides do not extend to subsequent redirect hops, if a redirect happens. Another override may be applied to a different request produced by a redirect.
    :param intercept_response: **(EXPERIMENTAL)** *(Optional)* If set, overrides response interception behavior for this request.
    """
    params: T_JSON_DICT = dict()
    params["requestId"] = request_id.to_json()
    if url is not None:
        params["url"] = url
    if method is not None:
        params["method"] = method
    if post_data is not None:
        params["postData"] = post_data
    if headers is not None:
        params["headers"] = [i.to_json() for i in headers]
    if intercept_response is not None:
        params["interceptResponse"] = intercept_response
    cmd_dict: T_JSON_DICT = {
        "method": "Fetch.continueRequest",
        "params": params,
    }
    json = yield cmd_dict

continue_response(request_id, response_code=None, response_phrase=None, response_headers=None, binary_response_headers=None)

Continues loading of the paused response, optionally modifying the response headers. If either responseCode or headers are modified, all of them must be present.

EXPERIMENTAL

Parameters:

Name Type Description Default
request_id RequestId

An id the client received in requestPaused event.

 required
response_code Optional[int]

(Optional) An HTTP response code. If absent, original response code will be used.

 None
response_phrase Optional[str]

(Optional) A textual representation of responseCode. If absent, a standard phrase matching responseCode is used.

 None
response_headers Optional[List[HeaderEntry]]

(Optional) Response headers. If absent, original response headers will be used.

 None
binary_response_headers Optional[str]

(Optional) Alternative way of specifying response headers as a \0-separated series of name: value pairs. Prefer the above method unless you need to represent some non-UTF8 values that can't be transmitted over the protocol as text. (Encoded as a base64 string when passed over JSON)

 None
Source code in zendriver/cdp/fetch.py 
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
def continue_response(
    request_id: RequestId,
    response_code: typing.Optional[int] = None,
    response_phrase: typing.Optional[str] = None,
    response_headers: typing.Optional[typing.List[HeaderEntry]] = None,
    binary_response_headers: typing.Optional[str] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    r"""
    Continues loading of the paused response, optionally modifying the
    response headers. If either responseCode or headers are modified, all of them
    must be present.

    **EXPERIMENTAL**

    :param request_id: An id the client received in requestPaused event.
    :param response_code: *(Optional)* An HTTP response code. If absent, original response code will be used.
    :param response_phrase: *(Optional)* A textual representation of responseCode. If absent, a standard phrase matching responseCode is used.
    :param response_headers: *(Optional)* Response headers. If absent, original response headers will be used.
    :param binary_response_headers: *(Optional)* Alternative way of specifying response headers as a \0-separated series of name: value pairs. Prefer the above method unless you need to represent some non-UTF8 values that can't be transmitted over the protocol as text. (Encoded as a base64 string when passed over JSON)
    """
    params: T_JSON_DICT = dict()
    params["requestId"] = request_id.to_json()
    if response_code is not None:
        params["responseCode"] = response_code
    if response_phrase is not None:
        params["responsePhrase"] = response_phrase
    if response_headers is not None:
        params["responseHeaders"] = [i.to_json() for i in response_headers]
    if binary_response_headers is not None:
        params["binaryResponseHeaders"] = binary_response_headers
    cmd_dict: T_JSON_DICT = {
        "method": "Fetch.continueResponse",
        "params": params,
    }
    json = yield cmd_dict

continue_with_auth(request_id, auth_challenge_response)

Continues a request supplying authChallengeResponse following authRequired event.

Parameters:

Name Type Description Default
request_id RequestId

An id the client received in authRequired event.

 required
auth_challenge_response AuthChallengeResponse

Response to with an authChallenge.

 required
Source code in zendriver/cdp/fetch.py 
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
def continue_with_auth(
    request_id: RequestId, auth_challenge_response: AuthChallengeResponse
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Continues a request supplying authChallengeResponse following authRequired event.

    :param request_id: An id the client received in authRequired event.
    :param auth_challenge_response: Response to  with an authChallenge.
    """
    params: T_JSON_DICT = dict()
    params["requestId"] = request_id.to_json()
    params["authChallengeResponse"] = auth_challenge_response.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Fetch.continueWithAuth",
        "params": params,
    }
    json = yield cmd_dict

disable()

Disables the fetch domain.

Source code in zendriver/cdp/fetch.py 
204
205
206
207
208
209
210
211
def disable() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Disables the fetch domain.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "Fetch.disable",
    }
    json = yield cmd_dict

enable(patterns=None, handle_auth_requests=None)

Enables issuing of requestPaused events. A request will be paused until client calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.

Parameters:

Name Type Description Default
patterns Optional[List[RequestPattern]]

(Optional) If specified, only requests matching any of these patterns will produce fetchRequested event and will be paused until clients response. If not set, all requests will be affected.

 None
handle_auth_requests Optional[bool]

(Optional) If true, authRequired events will be issued and requests will be paused expecting a call to continueWithAuth.

 None
Source code in zendriver/cdp/fetch.py 
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
def enable(
    patterns: typing.Optional[typing.List[RequestPattern]] = None,
    handle_auth_requests: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Enables issuing of requestPaused events. A request will be paused until client
    calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.

    :param patterns: *(Optional)* If specified, only requests matching any of these patterns will produce fetchRequested event and will be paused until clients response. If not set, all requests will be affected.
    :param handle_auth_requests: *(Optional)* If true, authRequired events will be issued and requests will be paused expecting a call to continueWithAuth.
    """
    params: T_JSON_DICT = dict()
    if patterns is not None:
        params["patterns"] = [i.to_json() for i in patterns]
    if handle_auth_requests is not None:
        params["handleAuthRequests"] = handle_auth_requests
    cmd_dict: T_JSON_DICT = {
        "method": "Fetch.enable",
        "params": params,
    }
    json = yield cmd_dict

fail_request(request_id, error_reason)

Causes the request to fail with specified reason.

Parameters:

Name Type Description Default
request_id RequestId

An id the client received in requestPaused event.

 required
error_reason ErrorReason

Causes the request to fail with the given reason.

 required
Source code in zendriver/cdp/fetch.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
def fail_request(
    request_id: RequestId, error_reason: network.ErrorReason
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Causes the request to fail with specified reason.

    :param request_id: An id the client received in requestPaused event.
    :param error_reason: Causes the request to fail with the given reason.
    """
    params: T_JSON_DICT = dict()
    params["requestId"] = request_id.to_json()
    params["errorReason"] = error_reason.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Fetch.failRequest",
        "params": params,
    }
    json = yield cmd_dict

fulfill_request(request_id, response_code, response_headers=None, binary_response_headers=None, body=None, response_phrase=None)

Provides response to the request.

Parameters:

Name Type Description Default
request_id RequestId

An id the client received in requestPaused event.

 required
response_code int

An HTTP response code.

 required
response_headers Optional[List[HeaderEntry]]

(Optional) Response headers.

 None
binary_response_headers Optional[str]

(Optional) Alternative way of specifying response headers as a \0-separated series of name: value pairs. Prefer the above method unless you need to represent some non-UTF8 values that can't be transmitted over the protocol as text. (Encoded as a base64 string when passed over JSON)

 None
body Optional[str]

(Optional) A response body. If absent, original response body will be used if the request is intercepted at the response stage and empty body will be used if the request is intercepted at the request stage. (Encoded as a base64 string when passed over JSON)

 None
response_phrase Optional[str]

(Optional) A textual representation of responseCode. If absent, a standard phrase matching responseCode is used.

 None
Source code in zendriver/cdp/fetch.py 
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
def fulfill_request(
    request_id: RequestId,
    response_code: int,
    response_headers: typing.Optional[typing.List[HeaderEntry]] = None,
    binary_response_headers: typing.Optional[str] = None,
    body: typing.Optional[str] = None,
    response_phrase: typing.Optional[str] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    r"""
    Provides response to the request.

    :param request_id: An id the client received in requestPaused event.
    :param response_code: An HTTP response code.
    :param response_headers: *(Optional)* Response headers.
    :param binary_response_headers: *(Optional)* Alternative way of specifying response headers as a \0-separated series of name: value pairs. Prefer the above method unless you need to represent some non-UTF8 values that can't be transmitted over the protocol as text. (Encoded as a base64 string when passed over JSON)
    :param body: *(Optional)* A response body. If absent, original response body will be used if the request is intercepted at the response stage and empty body will be used if the request is intercepted at the request stage. (Encoded as a base64 string when passed over JSON)
    :param response_phrase: *(Optional)* A textual representation of responseCode. If absent, a standard phrase matching responseCode is used.
    """
    params: T_JSON_DICT = dict()
    params["requestId"] = request_id.to_json()
    params["responseCode"] = response_code
    if response_headers is not None:
        params["responseHeaders"] = [i.to_json() for i in response_headers]
    if binary_response_headers is not None:
        params["binaryResponseHeaders"] = binary_response_headers
    if body is not None:
        params["body"] = body
    if response_phrase is not None:
        params["responsePhrase"] = response_phrase
    cmd_dict: T_JSON_DICT = {
        "method": "Fetch.fulfillRequest",
        "params": params,
    }
    json = yield cmd_dict

get_response_body(request_id)

Causes the body of the response to be received from the server and returned as a single string. May only be issued for a request that is paused in the Response stage and is mutually exclusive with takeResponseBodyForInterceptionAsStream. Calling other methods that affect the request or disabling fetch domain before body is received results in an undefined behavior. Note that the response body is not available for redirects. Requests paused in the redirect received state may be differentiated by responseCode and presence of location response header, see comments to requestPaused for details.

Parameters:

Name Type Description Default
request_id RequestId

Identifier for the intercepted request to get body for.

 required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[str, bool]]

A tuple with the following items: 0. body - Response body. 1. base64Encoded - True, if content was sent as base64.
Source code in zendriver/cdp/fetch.py 
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
def get_response_body(
    request_id: RequestId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.Tuple[str, bool]]:
    """
    Causes the body of the response to be received from the server and
    returned as a single string. May only be issued for a request that
    is paused in the Response stage and is mutually exclusive with
    takeResponseBodyForInterceptionAsStream. Calling other methods that
    affect the request or disabling fetch domain before body is received
    results in an undefined behavior.
    Note that the response body is not available for redirects. Requests
    paused in the _redirect received_ state may be differentiated by
    ``responseCode`` and presence of ``location`` response header, see
    comments to ``requestPaused`` for details.

    :param request_id: Identifier for the intercepted request to get body for.
    :returns: A tuple with the following items:

        0. **body** - Response body.
        1. **base64Encoded** - True, if content was sent as base64.
    """
    params: T_JSON_DICT = dict()
    params["requestId"] = request_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Fetch.getResponseBody",
        "params": params,
    }
    json = yield cmd_dict
    return (str(json["body"]), bool(json["base64Encoded"]))

take_response_body_as_stream(request_id)

Returns a handle to the stream representing the response body. The request must be paused in the HeadersReceived stage. Note that after this command the request can't be continued as is -- client either needs to cancel it or to provide the response body. The stream only supports sequential read, IO.read will fail if the position is specified. This method is mutually exclusive with getResponseBody. Calling other methods that affect the request or disabling fetch domain before body is received results in an undefined behavior.

Parameters:

Name Type Description Default
request_id RequestId
required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, StreamHandle]
Source code in zendriver/cdp/fetch.py 
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
def take_response_body_as_stream(
    request_id: RequestId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, io.StreamHandle]:
    """
    Returns a handle to the stream representing the response body.
    The request must be paused in the HeadersReceived stage.
    Note that after this command the request can't be continued
    as is -- client either needs to cancel it or to provide the
    response body.
    The stream only supports sequential read, IO.read will fail if the position
    is specified.
    This method is mutually exclusive with getResponseBody.
    Calling other methods that affect the request or disabling fetch
    domain before body is received results in an undefined behavior.

    :param request_id:
    :returns:
    """
    params: T_JSON_DICT = dict()
    params["requestId"] = request_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Fetch.takeResponseBodyAsStream",
        "params": params,
    }
    json = yield cmd_dict
    return io.StreamHandle.from_json(json["stream"])