GitHub

HttpClientRequest

API reference for HttpClientRequest.

Attributes

AttributeTypeDescription
methodstr

The method; outside HttpMethod when converted from a received request (PROPFIND).

urlstr
url_params_params.UrlParams
hashstr | None
headersHeaders
body_body.HttpBody

Functions

__init__

__init__(method, url, url_params, hash, headers, body) -> None
ParameterTypeDescription
methodstr
urlstr
url_params_params.UrlParams
hashstr | None
headersHeaders
body_body.HttpBody

to_json

to_json() -> dict[str, object]

Returns dict[str, object]

def to_json(self) -> dict[str, object]:
    return {
        "_id": "HttpClientRequest",
        "method": self.method,
        "url": _params.redact_url(self.url),
        "url_params": self.url_params.to_json(),
        "hash": self.hash,
        "headers": self.headers.to_json(),
        "body": self.body.to_json(),
    }

modify

modify(**options) -> HttpClientRequest
ParameterTypeDescription
optionsUnpack[ModifyOptions] = {}

Returns HttpClientRequest

def modify(self, **options: Unpack[ModifyOptions]) -> HttpClientRequest:
    result = self
    if "method" in options:
        result = result.set_method(options["method"])
    url = options.get("url")
    if url:
        result = result.set_url(url)
    if "headers" in options:
        result = result.set_headers(options["headers"])
    if "url_params" in options:
        result = result.set_url_params(options["url_params"])
    hash = options.get("hash")
    if hash:
        result = result.set_hash(hash)
    if "body" in options:
        result = result.set_body(options["body"])
    accept = options.get("accept")
    if accept:
        result = result.accept(accept)
    if options.get("accept_json"):
        result = result.accept_json()
    return result

set_method

set_method(method) -> HttpClientRequest
ParameterTypeDescription
methodHttpMethod

Returns HttpClientRequest

def set_method(self, method: HttpMethod) -> HttpClientRequest:
    return self._with(method=method)

set_header

set_header(key, value) -> HttpClientRequest
ParameterTypeDescription
keystr
valuestr

Returns HttpClientRequest

def set_header(self, key: str, value: str) -> HttpClientRequest:
    return self._with(headers=self.headers.set(key, value))

set_headers

set_headers(input) -> HttpClientRequest
ParameterTypeDescription
inputHeadersInput

Returns HttpClientRequest

def set_headers(self, input: HeadersInput) -> HttpClientRequest:
    return self._with(headers=self.headers.set_all(input))

update_headers

update_headers(f) -> HttpClientRequest
ParameterTypeDescription
fCallable[[Headers], Headers]

Returns HttpClientRequest

def update_headers(self, f: Callable[[Headers], Headers]) -> HttpClientRequest:
    return self._with(headers=f(self.headers))

remove_header

remove_header(key) -> HttpClientRequest
ParameterTypeDescription
keystr

Returns HttpClientRequest

def remove_header(self, key: str) -> HttpClientRequest:
    return self._with(headers=self.headers.remove(key))

basic_auth

basic_auth(username, password) -> HttpClientRequest
ParameterTypeDescription
usernamestr | Redacted[str]
passwordstr | Redacted[str]

Returns HttpClientRequest

def basic_auth(
    self, username: str | Redacted[str], password: str | Redacted[str]
) -> HttpClientRequest:
    credentials = text_encode(f"{_plain(username)}:{_plain(password)}")
    return self.set_header(
        "Authorization", f"Basic {base64.b64encode(credentials).decode('ascii')}"
    )

bearer_token

bearer_token(token) -> HttpClientRequest
ParameterTypeDescription
tokenstr | Redacted[str]

Returns HttpClientRequest

def bearer_token(self, token: str | Redacted[str]) -> HttpClientRequest:
    return self.set_header("Authorization", f"Bearer {_plain(token)}")

accept

accept(media_type) -> HttpClientRequest
ParameterTypeDescription
media_typestr

Returns HttpClientRequest

def accept(self, media_type: str) -> HttpClientRequest:
    return self.set_header("Accept", media_type)

accept_json

accept_json() -> HttpClientRequest

Returns HttpClientRequest

def accept_json(self) -> HttpClientRequest:
    return self.accept("application/json")

upgrade

upgrade(protocol) -> HttpClientRequest
ParameterTypeDescription
protocolstr

Returns HttpClientRequest

def upgrade(self, protocol: str) -> HttpClientRequest:
    return self._with(
        headers=self.headers.set("connection", "Upgrade").set("upgrade", protocol)
    )

set_url

set_url(url) -> HttpClientRequest

A string URL is kept as written; a parsed URL gives its query to url_params and its fragment to hash.

ParameterTypeDescription
urlUrlInput

Returns HttpClientRequest

def set_url(self, url: UrlInput) -> HttpClientRequest:
    """A string URL is kept as written; a parsed URL gives its query to
    ``url_params`` and its fragment to ``hash``."""
    if isinstance(url, str):
        return self._with(url=url)
    hash = url.hash[1:] or None
    return HttpClientRequest(
        self.method,
        _url.set_hash(_url.set_search(url, ""), "").href,
        _params.UrlParams(url.search_params),
        hash,
        self.headers,
        self.body,
    )

prepend_url

prepend_url(path) -> HttpClientRequest
ParameterTypeDescription
pathstr

Returns HttpClientRequest

def prepend_url(self, path: str) -> HttpClientRequest:
    return self if path == "" else self._with(url=_join_segments(path, self.url))

append_url

append_url(path) -> HttpClientRequest
ParameterTypeDescription
pathstr

Returns HttpClientRequest

def append_url(self, path: str) -> HttpClientRequest:
    return self if path == "" else self._with(url=_join_segments(self.url, path))

update_url

update_url(f) -> HttpClientRequest
ParameterTypeDescription
fCallable[[str], str]

Returns HttpClientRequest

def update_url(self, f: Callable[[str], str]) -> HttpClientRequest:
    return self._with(url=f(self.url))

set_url_param

set_url_param(key, value) -> HttpClientRequest
ParameterTypeDescription
keystr
valuestr | Redacted[str]

Returns HttpClientRequest

def set_url_param(self, key: str, value: str | Redacted[str]) -> HttpClientRequest:
    return self._with(url_params=self.url_params.set(key, value))

set_url_params

set_url_params(input) -> HttpClientRequest
ParameterTypeDescription
input_params.Input

Returns HttpClientRequest

def set_url_params(self, input: _params.Input) -> HttpClientRequest:
    return self._with(url_params=self.url_params.set_all(input))

append_url_param

append_url_param(key, value) -> HttpClientRequest
ParameterTypeDescription
keystr
valuestr | Redacted[str]

Returns HttpClientRequest

def append_url_param(self, key: str, value: str | Redacted[str]) -> HttpClientRequest:
    return self._with(url_params=self.url_params.append(key, value))

append_url_params

append_url_params(input) -> HttpClientRequest
ParameterTypeDescription
input_params.Input

Returns HttpClientRequest

def append_url_params(self, input: _params.Input) -> HttpClientRequest:
    return self._with(url_params=self.url_params.append_all(input))

set_hash

set_hash(hash) -> HttpClientRequest
ParameterTypeDescription
hashstr

Returns HttpClientRequest

def set_hash(self, hash: str) -> HttpClientRequest:
    return HttpClientRequest(
        self.method, self.url, self.url_params, hash, self.headers, self.body
    )

remove_hash

remove_hash() -> HttpClientRequest

Returns HttpClientRequest

def remove_hash(self) -> HttpClientRequest:
    return HttpClientRequest(
        self.method, self.url, self.url_params, None, self.headers, self.body
    )

set_body

set_body(body) -> HttpClientRequest

body, with content-type and content-length set from it.

ParameterTypeDescription
body_body.HttpBody

Returns HttpClientRequest

def set_body(self, body: _body.HttpBody) -> HttpClientRequest:
    """``body``, with ``content-type`` and ``content-length`` set from it."""
    return HttpClientRequest(
        self.method,
        self.url,
        self.url_params,
        self.hash,
        _body.update_headers(self.headers, body),
        body,
    )

compress_body

compress_body(algorithm, *, min_size=1024) -> Effect[HttpClientRequest]

The body compressed with algorithm and content-encoding set; unchanged when it already has a content-encoding, is too short or cannot be compressed.

ParameterTypeDescription
algorithmCompressionAlgorithm
min_sizeint = 1024

Returns Effect[HttpClientRequest]

def compress_body(
    self, algorithm: CompressionAlgorithm, *, min_size: int = 1024
) -> Effect[HttpClientRequest]:
    """The body compressed with ``algorithm`` and ``content-encoding``
    set; unchanged when it already has a ``content-encoding``, is too
    short or cannot be compressed."""
    if "content-encoding" in self.headers:
        return succeed(self)
    return compress_body(self.body, algorithm, min_size).map(
        lambda body: (
            self
            if body is self.body
            # The headers keep the caller's content-type; only the length changes.
            else HttpClientRequest(
                self.method,
                self.url,
                self.url_params,
                self.hash,
                _body.update_content_length(self.headers, body).set(
                    "content-encoding", algorithm
                ),
                body,
            )
        )
    )

body_bytes

body_bytes(body, content_type=None) -> HttpClientRequest
ParameterTypeDescription
bodybytes
content_typestr | None = None

Returns HttpClientRequest

def body_bytes(self, body: bytes, content_type: str | None = None) -> HttpClientRequest:
    return self.set_body(_body.bytes_(body, content_type))

body_text

body_text(body, content_type=None) -> HttpClientRequest
ParameterTypeDescription
bodystr
content_typestr | None = None

Returns HttpClientRequest

def body_text(self, body: str, content_type: str | None = None) -> HttpClientRequest:
    return self.set_body(_body.text(body, content_type))

body_json

body_json(body) -> Effect[HttpClientRequest, _body.HttpBodyError]
ParameterTypeDescription
bodyobject

Returns Effect[HttpClientRequest, _body.HttpBodyError]

def body_json(self, body: object) -> Effect[HttpClientRequest, _body.HttpBodyError]:
    return _body.json(body).map(self.set_body)

body_json_unsafe

body_json_unsafe(body) -> HttpClientRequest
ParameterTypeDescription
bodyobject

Returns HttpClientRequest

def body_json_unsafe(self, body: object) -> HttpClientRequest:
    return self.set_body(_body.json_unsafe(body))

body_url_params

body_url_params(input) -> HttpClientRequest
ParameterTypeDescription
input_params.Input

Returns HttpClientRequest

def body_url_params(self, input: _params.Input) -> HttpClientRequest:
    return self.set_body(_body.url_params(input))

body_form_data

body_form_data(body) -> HttpClientRequest
ParameterTypeDescription
body_body.FormData

Returns HttpClientRequest

def body_form_data(self, body: _body.FormData) -> HttpClientRequest:
    return self.set_body(body)

body_form_data_record

body_form_data_record(entries) -> HttpClientRequest
ParameterTypeDescription
entries_body.FormDataInput

Returns HttpClientRequest

def body_form_data_record(self, entries: _body.FormDataInput) -> HttpClientRequest:
    return self.set_body(_body.form_data_record(entries))

body_stream

body_stream(body, *, content_type=None, content_length=None) -> HttpClientRequest
ParameterTypeDescription
bodyStream[bytes, object]
content_typestr | None = None
content_lengthint | None = None

Returns HttpClientRequest

def body_stream(
    self,
    body: Stream[bytes, object],
    *,
    content_type: str | None = None,
    content_length: int | None = None,
) -> HttpClientRequest:
    streamed = _body.stream(body, content_type, content_length)
    return self.set_body(streamed)

body_file

body_file(path, *, bytes_to_read=None, chunk_size=None, offset=None, content_type=None) -> Effect[HttpClientRequest, PlatformError, FileSystem]
ParameterTypeDescription
pathstr
bytes_to_readbyte_size.Input | None = None
chunk_sizeint | None = None
offsetbyte_size.Input | None = None
content_typestr | None = None

Returns Effect[HttpClientRequest, PlatformError, FileSystem]

def body_file(
    self,
    path: str,
    *,
    bytes_to_read: byte_size.Input | None = None,
    chunk_size: int | None = None,
    offset: byte_size.Input | None = None,
    content_type: str | None = None,
) -> Effect[HttpClientRequest, PlatformError, FileSystem]:
    return _body.file(
        path,
        bytes_to_read=bytes_to_read,
        chunk_size=chunk_size,
        offset=offset,
        content_type=content_type,
    ).map(self.set_body)

to_url

to_url() -> _url.Url | None

The URL the request is sent to, or None when it is invalid.

Returns _url.Url | None

def to_url(self) -> _url.Url | None:
    """The URL the request is sent to, or ``None`` when it is invalid."""
    match _url.make(self.url, self.url_params, self.hash):
        case Ok(url):
            return url
        case _:
            return None