Comandos Fetch

Os comandos Fetch fornecem capacidades avançadas de manipulação e interceptação de requisições de rede usando o domínio da API Fetch.

Visão Geral

O módulo de comandos fetch permite o gerenciamento sofisticado de requisições de rede, incluindo modificação de requisições, interceptação de respostas e manipulação de autenticação.

pydoll.commands.fetch_commands

FetchCommands

This class encapsulates the fetch commands of the Chrome DevTools Protocol (CDP).

CDP's Fetch domain allows interception and modification of network requests at the application layer. This enables developers to examine, modify, and control network traffic, which is particularly useful for testing, debugging, and advanced automation scenarios.

The commands defined in this class provide functionality for: - Enabling and disabling fetch request interception - Continuing, fulfilling, or failing intercepted requests - Handling authentication challenges - Retrieving and modifying response bodies - Processing response data as streams

continue_request `staticmethod`

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

Creates a command to continue a paused fetch request.

This command allows the browser to resume a fetch operation that has been intercepted. You can modify the fetch request URL, method, headers, and body before continuing.

PARAMETER	DESCRIPTION
`request_id`	The ID of the fetch request to continue. TYPE: `str`
`url`	The new URL for the fetch request. Defaults to None. TYPE: `Optional[str]` DEFAULT: `None`
`method`	The HTTP method to use (e.g., 'GET', 'POST'). Defaults to None. TYPE: `Optional[RequestMethod]` DEFAULT: `None`
`post_data`	The body data to send with the fetch request. Defaults to None. TYPE: `Optional[dict]` DEFAULT: `None`
`headers`	A list of HTTP headers to include in the fetch request. Defaults to None. TYPE: `Optional[list[HeaderEntry]]` DEFAULT: `None`
`intercept_response`	Indicates if the response should be intercepted. Defaults to None. TYPE: `Optional[bool]` DEFAULT: `None`

RETURNS	DESCRIPTION
`ContinueRequestCommand`	Command[Response]: A command for continuing the fetch request.

continue_request_with_auth `staticmethod`

continue_request_with_auth(request_id, auth_challenge_response, proxy_username=None, proxy_password=None)

Creates a command to continue a paused fetch request with authentication.

This command is used when the fetch operation requires authentication. It provides the necessary credentials to continue the request.

PARAMETER	DESCRIPTION
`request_id`	The ID of the fetch request to continue. TYPE: `str`
`auth_challenge_response`	The authentication challenge response type. TYPE: `AuthChallengeResponseType`
`proxy_username`	The username for proxy authentication. Defaults to None. TYPE: `Optional[str]` DEFAULT: `None`
`proxy_password`	The password for proxy authentication. Defaults to None. TYPE: `Optional[str]` DEFAULT: `None`

RETURNS	DESCRIPTION
`ContinueWithAuthCommand`	Command[Response]: A command for continuing the fetch request with authentication.

disable `staticmethod`

disable()

Creates a command to disable fetch interception.

This command stops the browser from intercepting fetch requests.

RETURNS	DESCRIPTION
`DisableCommand`	Command[Response]: A command for disabling fetch interception.

enable `staticmethod`

enable(handle_auth_requests, url_pattern='*', resource_type=None, request_stage=None)

Creates a command to enable fetch interception.

This command allows the browser to start intercepting fetch requests. You can specify whether to handle authentication challenges and the types of resources to intercept.

PARAMETER	DESCRIPTION
`handle_auth_requests`	Indicates if authentication requests should be handled. TYPE: `bool`
`url_pattern`	Pattern to match URLs for interception. Defaults to ''. TYPE:* `str` DEFAULT: `'*'`
`resource_type`	The type of resource to intercept. Defaults to None. TYPE: `Optional[ResourceType]` DEFAULT: `None`
`request_stage`	The stage of the request to intercept. Defaults to None. TYPE: `Optional[RequestStage]` DEFAULT: `None`

RETURNS	DESCRIPTION
`EnableCommand`	Command[Response]: A command for enabling fetch interception.

fail_request `staticmethod`

fail_request(request_id, error_reason)

Creates a command to simulate a failure in a fetch request.

This command allows you to simulate a failure for a specific fetch operation, providing a reason for the failure.

PARAMETER	DESCRIPTION
`request_id`	The ID of the fetch request to fail. TYPE: `str`
`error_reason`	The reason for the failure. TYPE: `ErrorReason`

RETURNS	DESCRIPTION
`FailRequestCommand`	Command[Response]: A command for failing the fetch request.

fulfill_request `staticmethod`

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

Creates a command to fulfill a fetch request with a custom response.

This command allows you to provide a custom response for a fetch operation, including the HTTP status code, headers, and body content.

PARAMETER	DESCRIPTION
`request_id`	The ID of the fetch request to fulfill. TYPE: `str`
`response_code`	The HTTP status code to return. TYPE: `int`
`response_headers`	A list of response headers. Defaults to None. TYPE: `Optional[list[HeaderEntry]]` DEFAULT: `None`
`body`	The body content of the response. Defaults to None. TYPE: `Optional[dict]` DEFAULT: `None`
`response_phrase`	The response phrase (e.g., 'OK', 'Not Found'). Defaults to None. TYPE: `Optional[str]` DEFAULT: `None`

RETURNS	DESCRIPTION
`FulfillRequestCommand`	Command[Response]: A command for fulfilling the fetch request.

get_response_body `staticmethod`

get_response_body(request_id)

Creates a command to retrieve the response body of a fetch request.

This command allows you to access the body of a completed fetch operation, which can be useful for analyzing the response data.

PARAMETER	DESCRIPTION
`request_id`	The ID of the fetch request to retrieve the body from. TYPE: `str`

RETURNS	DESCRIPTION
`GetResponseBodyCommand`	Command[GetResponseBodyResponse]: A command for getting the response body.

continue_response `staticmethod`

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

Creates a command to continue a fetch response for an intercepted request.

This command allows the browser to continue the response flow for a specific fetch request, including customizing the HTTP status code, headers, and response phrase.

PARAMETER	DESCRIPTION
`request_id`	The ID of the fetch request to continue the response for. TYPE: `str`
`response_code`	The HTTP status code to send. Defaults to None. TYPE: `Optional[int]` DEFAULT: `None`
`response_headers`	A list of response headers. Defaults to None. TYPE: `Optional[list[HeaderEntry]]` DEFAULT: `None`
`response_phrase`	The response phrase (e.g., 'OK'). Defaults to None. TYPE: `Optional[str]` DEFAULT: `None`

RETURNS	DESCRIPTION
`ContinueResponseCommand`	Command[Response]: A command for continuing the fetch response.

take_response_body_as_stream `staticmethod`

take_response_body_as_stream(request_id)

Creates a command to take the response body as a stream.

This command allows you to receive the response body as a stream which can be useful for handling large responses.

PARAMETER	DESCRIPTION
`request_id`	The ID of the fetch request to take the response body stream from. TYPE: `str`

RETURNS	DESCRIPTION
`TakeResponseBodyAsStreamCommand`	Command[TakeResponseBodyAsStreamResponse]: A command for taking the response body as a stream.

Uso

Os comandos Fetch são usados para interceptação avançada de rede e manipulação de requisições:

from pydoll.commands.fetch_commands import enable, request_paused, continue_request
from pydoll.connection.connection_handler import ConnectionHandler

# Habilitar domínio fetch
connection = ConnectionHandler()
await enable(connection, patterns=[{
    "urlPattern": "*",
    "requestStage": "Request"
}])

# Lidar com requisições pausadas
async def handle_paused_request(request_id, request):
    # Modificar requisição ou continuar como está
    await continue_request(connection, request_id=request_id)

Funcionalidades Principais

O módulo de comandos fetch fornece funções para:

Interceptação de Requisição

enable() - Habilitar domínio fetch com padrões
disable() - Desabilitar domínio fetch
continue_request() - Continuar requisições interceptadas
fail_request() - Falhar requisições com erros específicos

Modificação de Requisição

Modificar cabeçalhos da requisição
Alterar URLs da requisição
Alterar métodos da requisição (GET, POST, etc.)
Modificar corpos (bodies) da requisição

Manipulação de Resposta

fulfill_request() - Fornecer respostas customizadas
get_response_body() - Obter conteúdo da resposta
Modificação de cabeçalho de resposta
Controle do código de status da resposta

Autenticação

continue_with_auth() - Lidar com desafios de autenticação
Suporte a autenticação básica
Fluxos de autenticação customizados

Recursos Avançados

Interceptação Baseada em Padrões

# Interceptar padrões de URL específicos
patterns = [
    {"urlPattern": "*/api/*", "requestStage": "Request"},
    {"urlPattern": "*.js", "requestStage": "Response"},
    {"urlPattern": "https://example.com/*", "requestStage": "Request"}
]

await enable(connection, patterns=patterns)

Modificação de Requisição

# Modificar requisições interceptadas
async def modify_request(request_id, request):
    # Adicionar cabeçalho de autenticação
    headers = request.headers.copy()
    headers["Authorization"] = "Bearer token123"

    # Continuar com cabeçalhos modificados
    await continue_request(
        connection,
        request_id=request_id,
        headers=headers
    )

Simulação de Resposta (Mocking)

# Simular (mockar) respostas de API
await fulfill_request(
    connection,
    request_id=request_id,
    response_code=200,
    response_headers=[
        {"name": "Content-Type", "value": "application/json"},
        {"name": "Access-Control-Allow-Origin", "value": "*"}
    ],
    body='{"status": "success", "data": {"mocked": true}}'
)

Manipulação de Autenticação

# Lidar com desafios de autenticação
await continue_with_auth(
    connection,
    request_id=request_id,
    auth_challenge_response={
        "response": "ProvideCredentials",
        "username": "user",
        "password": "pass"
    }
)

Estágios da Requisição

Os comandos Fetch podem interceptar requisições em diferentes estágios:

Estágio	Descrição	Casos de Uso
Requisição	Antes da requisição ser enviada	Modificar cabeçalhos, URL, método
Resposta	Após a resposta ser recebida	Simular respostas, modificar conteúdo

Manipulação de Erros

# Falhar requisições com erros específicos
await fail_request(
    connection,
    request_id=request_id,
    error_reason="ConnectionRefused"  # ou "AccessDenied", "TimedOut", etc.
)

Integração com Comandos de Rede (Network)

Os comandos Fetch trabalham em conjunto com os comandos de rede (Network), mas fornecem controle mais granular:

Comandos de Rede (Network): Monitoramento e controle de rede mais amplos
Comandos Fetch: Interceptação e modificação específicas de requisição/resposta

Considerações de Performance

A interceptação do Fetch pode impactar a performance de carregamento da página. Use padrões de URL específicos e desabilite quando não for necessário para minimizar a sobrecarga (overhead).

Comandos Fetch

Visão Geral

pydoll.commands.fetch_commands

FetchCommands

continue_request staticmethod

continue_request_with_auth staticmethod

disable staticmethod

enable staticmethod

fail_request staticmethod

fulfill_request staticmethod

get_response_body staticmethod

continue_response staticmethod

take_response_body_as_stream staticmethod

Uso

Funcionalidades Principais

Interceptação de Requisição

Modificação de Requisição

Manipulação de Resposta

Autenticação

Recursos Avançados

Interceptação Baseada em Padrões

Modificação de Requisição

Simulação de Resposta (Mocking)

Manipulação de Autenticação

Estágios da Requisição

Manipulação de Erros

Integração com Comandos de Rede (Network)

continue_request `staticmethod`

continue_request_with_auth `staticmethod`

disable `staticmethod`

enable `staticmethod`

fail_request `staticmethod`

fulfill_request `staticmethod`

get_response_body `staticmethod`

continue_response `staticmethod`

take_response_body_as_stream `staticmethod`