GitHub

WebRequest

API reference for WebRequest.

A request a server received: an absolute url, and a signal that fires when the client goes away.

Attributes

AttributeTypeDescription
url= url
method= method.upper()
signal= signal
remote_address= remote_address
headersHeaders

Functions

__init__

__init__(url, *, method='GET', headers=None, body=None, signal=None, remote_address=None) -> None
ParameterTypeDescription
urlstr
methodstr = 'GET'
headersHeaderLines | None = None
bodybytes | str | AsyncIterable[bytes] | None = None
signalAbortSignal | None = None
remote_addressstr | None = None
def __init__(
    self,
    url: str,
    *,
    method: str = "GET",
    headers: HeaderLines | None = None,
    body: bytes | str | AsyncIterable[bytes] | None = None,
    signal: AbortSignal | None = None,
    remote_address: str | None = None,
) -> None:
    super().__init__(headers, body)
    self.url = url
    self.method = method.upper()
    self.signal = signal
    self.remote_address = remote_address

get

get(name) -> str | None

Header name, repeated values joined with ", ".

ParameterTypeDescription
namestr

Returns str | None

def get(self, name: str) -> str | None:
    """Header ``name``, repeated values joined with ``", "``."""
    name = name.lower()
    values = [value for key, value in self.header_lines if key == name]
    return ", ".join(values) if values else None

has

has(name) -> bool
ParameterTypeDescription
namestr

Returns bool

def has(self, name: str) -> bool:
    name = name.lower()
    return any(key == name for key, _ in self.header_lines)

read

read() -> bytes

The whole body (it can be read once).

Returns bytes

async def read(self) -> bytes:
    """The whole body (it can be read once)."""
    if self._used:
        raise RuntimeError("body already read")
    self._used = True
    return await _read(self.body)

buffer

buffer() -> bytes

Read the body into memory, so it can be read again (what Web Response.clone allows).

Returns bytes

async def buffer(self) -> bytes:
    """Read the body into memory, so it can be read again (what Web
    ``Response.clone`` allows)."""
    if self._used:
        raise RuntimeError("body already read")
    if not (self.body is None or isinstance(self.body, bytes)):
        self.body = await _read(self.body)
    return self.body or b""

text

text() -> str

Returns str

async def text(self) -> str:
    return (await self.read()).decode("utf-8", "replace")

json

json() -> Any

Returns Any

async def json(self) -> Any:
    return _json_text.parse(await self.read())

chunks

chunks() -> AsyncIterator[bytes]

The body, chunk by chunk.

Returns AsyncIterator[bytes]

def chunks(self) -> AsyncIterator[bytes]:
    """The body, chunk by chunk."""

    self._used = True
    body = self.body
    if body is None or isinstance(body, bytes):
        return _once(body)
    # The body itself, so closing the iterator closes it.
    return aiter(body)