GitHub

HttpServerResponse

API reference for HttpServerResponse.

A response. Error reporters skip it when it is a failure (report_ignored).

Attributes

AttributeTypeDescription
report_ignoredbool = True
statusint = status
status_textstr | None = status_text
headersHeaders
cookiesCookies = EMPTY_COOKIES if cookies is None else cookies
body_body.HttpBody = _body.EMPTY if body is None else body

Functions

__init__

__init__(status, status_text=None, headers=None, cookies=None, body=None, *, owned_headers=None) -> None

A response whose content headers follow body; with owned_headers (replacing headers), headers already set there win over the body's.

ParameterTypeDescription
statusint
status_textstr | None = None
headersHeaders | None = None
cookiesCookies | None = None
body_body.HttpBody | None = None
owned_headersHeaders | None = None
def __init__(
    self,
    status: int,
    status_text: str | None = None,
    headers: Headers | None = None,
    cookies: Cookies | None = None,
    body: _body.HttpBody | None = None,
    *,
    owned_headers: Headers | None = None,
) -> None:
    """A response whose content headers follow ``body``; with
    ``owned_headers`` (replacing ``headers``), headers already set there
    win over the body's."""
    self.status = status
    self.status_text = status_text
    self.cookies = EMPTY_COOKIES if cookies is None else cookies
    self.body = _body.EMPTY if body is None else body
    content_type = self.body.content_type
    content_length = self.body.content_length
    base = owned_headers if owned_headers is not None else headers or EMPTY_HEADERS
    if content_type or content_length is not None:
        owned = owned_headers is not None
        added: dict[str, str] = {}
        if content_type and (not owned or "content-type" not in base):
            added["content-type"] = content_type
        if content_length is not None and (not owned or "content-length" not in base):
            added["content-length"] = str(content_length)
        self.headers = base.set_all(added) if added else base
    else:
        self.headers = base

to_json

to_json() -> dict[str, object]

Returns dict[str, object]

def to_json(self) -> dict[str, object]:
    return {
        "_id": "HttpServerResponse",
        "status": self.status,
        "status_text": self.status_text,
        "headers": self.headers.to_json(),
        "cookies": self.cookies.to_json(),
        "body": self.body.to_json(),
    }

set_header

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

Returns HttpServerResponse

def set_header(self, key: str, value: str) -> HttpServerResponse:
    return HttpServerResponse(
        self.status,
        self.status_text,
        cookies=self.cookies,
        body=self.body,
        owned_headers=self.headers.set(key, value),
    )

set_headers

set_headers(headers) -> HttpServerResponse
ParameterTypeDescription
headersHeadersInput

Returns HttpServerResponse

def set_headers(self, headers: HeadersInput) -> HttpServerResponse:
    return HttpServerResponse(
        self.status,
        self.status_text,
        cookies=self.cookies,
        body=self.body,
        owned_headers=self.headers.set_all(headers),
    )

remove_header

remove_header(key) -> HttpServerResponse
ParameterTypeDescription
keystr

Returns HttpServerResponse

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

set_status

set_status(status, status_text=None) -> HttpServerResponse
ParameterTypeDescription
statusint
status_textstr | None = None

Returns HttpServerResponse

def set_status(self, status: int, status_text: str | None = None) -> HttpServerResponse:
    return self._replace(status=status, status_text=status_text)

set_body

set_body(body) -> HttpServerResponse

The response with body, its content headers following it.

ParameterTypeDescription
body_body.HttpBody

Returns HttpServerResponse

def set_body(self, body: _body.HttpBody) -> HttpServerResponse:
    """The response with ``body``, its content headers following it."""
    return HttpServerResponse(
        self.status,
        self.status_text,
        cookies=self.cookies,
        body=body,
        owned_headers=_body.update_headers(self.headers, body),
    )

set_body_keep_headers

set_body_keep_headers(body) -> HttpServerResponse

The response with body and its headers unchanged.

ParameterTypeDescription
body_body.HttpBody

Returns HttpServerResponse

def set_body_keep_headers(self, body: _body.HttpBody) -> HttpServerResponse:
    """The response with ``body`` and its headers unchanged."""
    response = object.__new__(HttpServerResponse)
    response.status = self.status
    response.status_text = self.status_text
    response.headers = self.headers
    response.cookies = self.cookies
    response.body = body
    return response
remove_cookie(name) -> HttpServerResponse
ParameterTypeDescription
namestr

Returns HttpServerResponse

def remove_cookie(self, name: str) -> HttpServerResponse:
    return self._replace(cookies=self.cookies.remove(name))

replace_cookies

replace_cookies(cookies) -> HttpServerResponse
ParameterTypeDescription
cookiesCookies

Returns HttpServerResponse

def replace_cookies(self, cookies: Cookies) -> HttpServerResponse:
    return self._replace(cookies=cookies)

merge_cookies

merge_cookies(cookies) -> HttpServerResponse
ParameterTypeDescription
cookiesCookies

Returns HttpServerResponse

def merge_cookies(self, cookies: Cookies) -> HttpServerResponse:
    return self._replace(cookies=self.cookies.merge(cookies))

update_cookies

update_cookies(f) -> HttpServerResponse
ParameterTypeDescription
fCallable[[Cookies], Cookies]

Returns HttpServerResponse

def update_cookies(self, f: Callable[[Cookies], Cookies]) -> HttpServerResponse:
    return self._replace(cookies=f(self.cookies))
set_cookie(name, value, **options) -> Effect[HttpServerResponse, CookiesError]
ParameterTypeDescription
namestr
valuestr
optionsUnpack[CookieOptionsInput] = {}

Returns Effect[HttpServerResponse, CookiesError]

def set_cookie(
    self, name: str, value: str, **options: Unpack[CookieOptionsInput]
) -> Effect[HttpServerResponse, CookiesError]:
    return from_result(self.cookies.set(name, value, **options)).map(
        lambda cookies: self._replace(cookies=cookies)
    )
set_cookie_unsafe(name, value, **options) -> HttpServerResponse
ParameterTypeDescription
namestr
valuestr
optionsUnpack[CookieOptionsInput] = {}

Returns HttpServerResponse

def set_cookie_unsafe(
    self, name: str, value: str, **options: Unpack[CookieOptionsInput]
) -> HttpServerResponse:
    return self._replace(cookies=self.cookies.set_unsafe(name, value, **options))
expire_cookie(name, **options) -> Effect[HttpServerResponse, CookiesError]
ParameterTypeDescription
namestr
optionsUnpack[CookieOptionsInput] = {}

Returns Effect[HttpServerResponse, CookiesError]

def expire_cookie(
    self, name: str, **options: Unpack[CookieOptionsInput]
) -> Effect[HttpServerResponse, CookiesError]:
    return from_result(self.cookies.expire_cookie(name, **options)).map(
        lambda cookies: self._replace(cookies=cookies)
    )
expire_cookie_unsafe(name, **options) -> HttpServerResponse
ParameterTypeDescription
namestr
optionsUnpack[CookieOptionsInput] = {}

Returns HttpServerResponse

def expire_cookie_unsafe(
    self, name: str, **options: Unpack[CookieOptionsInput]
) -> HttpServerResponse:
    return self._replace(cookies=self.cookies.expire_cookie_unsafe(name, **options))

set_cookies

set_cookies(cookies) -> Effect[HttpServerResponse, CookiesError]
ParameterTypeDescription
cookiesIterable[CookieEntry]

Returns Effect[HttpServerResponse, CookiesError]

def set_cookies(
    self, cookies: Iterable[CookieEntry]
) -> Effect[HttpServerResponse, CookiesError]:
    return from_result(self.cookies.set_all(cookies)).map(
        lambda cookies: self._replace(cookies=cookies)
    )

set_cookies_unsafe

set_cookies_unsafe(cookies) -> HttpServerResponse
ParameterTypeDescription
cookiesIterable[CookieEntry]

Returns HttpServerResponse

def set_cookies_unsafe(self, cookies: Iterable[CookieEntry]) -> HttpServerResponse:
    return self._replace(cookies=self.cookies.set_all_unsafe(cookies))