UJSONResponse class¶

def make_response(self, content: Any) -> bytes:
    assert ujson is not None, "You must install the encoders or ujson to use UJSONResponse"
    # UJSON is actually in maintainance mode, recommends switch to ORJSON
    # https://github.com/ultrajson/ultrajson
    return ujson.dumps(content, ensure_ascii=False).encode("utf-8")

async def execute_cleanup_handler(self) -> None:
    if self.cleanup_handler is None:
        return
    res = self.cleanup_handler()
    if isawaitable(res):
        await res

async def resolve_async_content(self) -> None:
    if getattr(self, "async_content", None) is not None:
        self.body = self.make_response(await self.async_content)
        self.async_content = None  # type: ignore[assignment]
        if (
            self.status_code is not None
            and HeaderHelper.has_body_message(self.status_code)
            and "content-length" not in self.headers
        ):
            self.headers["content-length"] = str(len(self.body))
        if self.deduce_media_type_from_body:
            if self.deduce_media_type_from_body == "force" or self.media_type is None:
                self.media_type = self.find_media_type()
                self.headers["content-type"] = HeaderHelper.get_content_type(
                    charset=self.charset, media_type=self.media_type
                )

def find_media_type(self) -> str:
    require_magic()
    return magic.from_buffer(self.body[:2048], mime=True) or self.media_type or MediaType.OCTET

@classmethod
@contextlib.contextmanager
def with_transform_kwargs(cls, params: dict | None, /) -> Generator[None, None, None]:
    token = RESPONSE_TRANSFORM_KWARGS.set(params)
    try:
        yield
    finally:
        RESPONSE_TRANSFORM_KWARGS.reset(token)

@classmethod
def transform(cls, content: Any) -> Any:
    transform_kwargs = RESPONSE_TRANSFORM_KWARGS.get()
    if transform_kwargs is None:
        transform_kwargs = {}
    return json_encode(content, **transform_kwargs)

def make_headers(
    self, content_headers: Mapping[str, str] | dict[str, str] | None = None
) -> None:
    """
    Initializes the headers based on RFC specifications by setting appropriate conditions and restrictions.

    Args:
        content_headers (Union[Mapping[str, str], Dict[str, str], None], optional): Additional headers to include (default is None).
    """
    headers: dict[str, str] = {} if content_headers is None else content_headers  # type: ignore

    if self.status_code is not None and HeaderHelper.has_entity_header_status(
        self.status_code
    ):
        headers = HeaderHelper.remove_entity_headers(headers)
    if self.status_code is not None and HeaderHelper.has_body_message(self.status_code):
        if getattr(self, "body", None) is not None:
            headers.setdefault("content-length", str(len(self.body)))

        # Populates the content type if exists and either a body was found or deduce_media_type_from_body was not force
        if (
            self.deduce_media_type_from_body != "force"
            or getattr(self, "body", None) is not None
        ):
            content_type = HeaderHelper.get_content_type(
                charset=self.charset, media_type=self.media_type
            )
            if content_type is not None:
                headers.setdefault("content-type", content_type)
    self.headers = Header(headers)

def set_cookie(
    self,
    key: str,
    value: str = "",
    *,
    path: str = "/",
    domain: str | None = None,
    secure: bool = False,
    max_age: int | None = None,
    expires: datetime | str | int | None = None,
    httponly: bool = False,
    samesite: Literal["lax", "strict", "none"] = "lax",
) -> None:
    """
    Sets a cookie in the response headers.

    Args:
        key (str): The name of the cookie.
        value (str, optional): The value of the cookie.
        path (str, optional): The path for which the cookie is valid (default is '/').
        domain (Union[str, None], optional): The domain to which the cookie belongs.
        secure (bool, optional): If True, the cookie should only be sent over HTTPS.
        max_age (Union[int, None], optional): The maximum age of the cookie in seconds.
        expires (Union[Union[datetime, str, int], None], optional): The expiration date of the cookie.
        httponly (bool, optional): If True, the cookie should only be accessible through HTTP.
        samesite (Literal["lax", "strict", "none"], optional): SameSite attribute of the cookie.

    Raises:
        AssertionError: If samesite is not one of 'strict', 'lax', or 'none'.
    """
    cookie: http.cookies.BaseCookie[str] = http.cookies.SimpleCookie()
    cookie[key] = value
    if max_age is not None:
        cookie[key]["max-age"] = max_age
    if expires is not None:
        if isinstance(expires, datetime):
            cookie[key]["expires"] = format_datetime(expires, usegmt=True)
        else:
            cookie[key]["expires"] = expires
    if path is not None:
        cookie[key]["path"] = path
    if domain is not None:
        cookie[key]["domain"] = domain
    if secure:
        cookie[key]["secure"] = True
    if httponly:
        cookie[key]["httponly"] = True
    if samesite is not None:
        assert samesite.lower() in [
            "strict",
            "lax",
            "none",
        ], "samesite must be either 'strict', 'lax' or 'none'"
        cookie[key]["samesite"] = samesite
    cookie_val = cookie.output(header="").strip()
    self.headers.add("set-cookie", cookie_val)

def delete_cookie(
    self,
    key: str,
    path: str = "/",
    domain: str | None = None,
    secure: bool = False,
    httponly: bool = False,
    samesite: Literal["lax", "strict", "none"] = "lax",
) -> None:
    """
    Deletes a cookie in the response headers by setting its max age and expiration to 0.

    Args:
        key (str): The name of the cookie to delete.
        path (str, optional): The path for which the cookie is valid (default is '/').
        domain (Union[str, None], optional): The domain to which the cookie belongs.
        secure (bool, optional): If True, the cookie should only be sent over HTTPS.
        httponly (bool, optional): If True, the cookie should only be accessible through HTTP.
        samesite (Literal["lax", "strict", "none"], optional): SameSite attribute of the cookie.
    """
    self.set_cookie(
        key,
        max_age=0,
        expires=0,
        path=path,
        domain=domain,
        secure=secure,
        httponly=httponly,
        samesite=samesite,
    )

def message(self, prefix: str) -> dict[str, Any]:
    return {
        "type": prefix + "http.response.start",
        "status": self.status_code,
        # some tests add headers dirty and assume a list
        "headers": self.headers,
    }