UJSONResponse class

esmerald.responses.encoders.UJSONResponse

UJSONResponse(content, status_code=200, headers=None, media_type=None, background=None)

Bases: BaseJSONResponse

An alternative to JSONResponse and performance wise, faster.

In the same way the JSONResponse is used, so is the UJSONResponse.

PARAMETER	DESCRIPTION
content	TYPE: Any
status_code	TYPE: int DEFAULT: 200
headers	TYPE: Optional[Mapping[str, str]] DEFAULT: None
media_type	TYPE: Optional[str] DEFAULT: None
background	TYPE: Optional[BackgroundTask] DEFAULT: None

Source code in .venv/lib/python3.8/site-packages/starlette/responses.py

def __init__(
    self,
    content: typing.Any,
    status_code: int = 200,
    headers: typing.Optional[typing.Mapping[str, str]] = None,
    media_type: typing.Optional[str] = None,
    background: typing.Optional[BackgroundTask] = None,
) -> None:
    super().__init__(content, status_code, headers, media_type, background)

media_type class-attribute instance-attribute

media_type = 'application/json'

charset class-attribute instance-attribute

charset = 'utf-8'

status_code instance-attribute

status_code = status_code

background instance-attribute

background = background

body instance-attribute

body = self.render(content)

headers property

headers

init_headers

init_headers(headers=None)

PARAMETER	DESCRIPTION
headers	TYPE: Optional[Mapping[str, str]] DEFAULT: None

Source code in .venv/lib/python3.8/site-packages/starlette/responses.py

def init_headers(
    self, headers: typing.Optional[typing.Mapping[str, str]] = None
) -> None:
    if headers is None:
        raw_headers: typing.List[typing.Tuple[bytes, bytes]] = []
        populate_content_length = True
        populate_content_type = True
    else:
        raw_headers = [
            (k.lower().encode("latin-1"), v.encode("latin-1"))
            for k, v in headers.items()
        ]
        keys = [h[0] for h in raw_headers]
        populate_content_length = b"content-length" not in keys
        populate_content_type = b"content-type" not in keys

    body = getattr(self, "body", None)
    if (
        body is not None
        and populate_content_length
        and not (self.status_code < 200 or self.status_code in (204, 304))
    ):
        content_length = str(len(body))
        raw_headers.append((b"content-length", content_length.encode("latin-1")))

    content_type = self.media_type
    if content_type is not None and populate_content_type:
        if content_type.startswith("text/"):
            content_type += "; charset=" + self.charset
        raw_headers.append((b"content-type", content_type.encode("latin-1")))

    self.raw_headers = raw_headers

set_cookie

set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=False, httponly=False, samesite='lax')

PARAMETER	DESCRIPTION
key	TYPE: str
value	TYPE: str DEFAULT: ''
max_age	TYPE: Optional[int] DEFAULT: None
expires	TYPE: Optional[Union[datetime, str, int]] DEFAULT: None
path	TYPE: str DEFAULT: '/'
domain	TYPE: Optional[str] DEFAULT: None
secure	TYPE: bool DEFAULT: False
httponly	TYPE: bool DEFAULT: False
samesite	TYPE: Optional[Literal['lax', 'strict', 'none']] DEFAULT: 'lax'

Source code in .venv/lib/python3.8/site-packages/starlette/responses.py

def set_cookie(
    self,
    key: str,
    value: str = "",
    max_age: typing.Optional[int] = None,
    expires: typing.Optional[typing.Union[datetime, str, int]] = None,
    path: str = "/",
    domain: typing.Optional[str] = None,
    secure: bool = False,
    httponly: bool = False,
    samesite: typing.Optional[typing.Literal["lax", "strict", "none"]] = "lax",
) -> 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.raw_headers.append((b"set-cookie", cookie_val.encode("latin-1")))

delete_cookie

delete_cookie(key, path='/', domain=None, secure=False, httponly=False, samesite='lax')

PARAMETER	DESCRIPTION
key	TYPE: str
path	TYPE: str DEFAULT: '/'
domain	TYPE: Optional[str] DEFAULT: None
secure	TYPE: bool DEFAULT: False
httponly	TYPE: bool DEFAULT: False
samesite	TYPE: Optional[Literal['lax', 'strict', 'none']] DEFAULT: 'lax'

Source code in .venv/lib/python3.8/site-packages/starlette/responses.py

def delete_cookie(
    self,
    key: str,
    path: str = "/",
    domain: typing.Optional[str] = None,
    secure: bool = False,
    httponly: bool = False,
    samesite: typing.Optional[typing.Literal["lax", "strict", "none"]] = "lax",
) -> None:
    self.set_cookie(
        key,
        max_age=0,
        expires=0,
        path=path,
        domain=domain,
        secure=secure,
        httponly=httponly,
        samesite=samesite,
    )

transform staticmethod

transform(value)

Makes sure that every value is checked and if it's a pydantic model then parses into a dict().

PARAMETER	DESCRIPTION
value	TYPE: Any

Source code in esmerald/responses/json.py

@staticmethod
def transform(value: Any) -> Dict[str, Any]:  # pragma: no cover
    """
    Makes sure that every value is checked and if it's a pydantic model then parses into
    a dict().
    """
    if isinstance(value, BaseModel):
        return value.model_dump()
    if is_dataclass(value):
        return dataclasses.asdict(value)
    raise TypeError("unsupported type")

render

render(content)

PARAMETER	DESCRIPTION
content	TYPE: Any

Source code in esmerald/responses/encoders.py

def render(self, content: Any) -> bytes:
    assert ujson is not None, "You must install the encoders or ujson to use UJSONResponse"
    return ujson.dumps(content, ensure_ascii=False).encode("utf-8")