GitHub

API reference for Cookies.

Cookies by name. Updates give a new Cookies.

Attributes

AttributeTypeDescription
cookiesMapping[str, Cookie] = dict(cookies or {})

Functions

__init__

__init__(cookies=None) -> None
ParameterTypeDescription
cookiesMapping[str, Cookie] | None = None
def __init__(self, cookies: Mapping[str, Cookie] | None = None) -> None:
    self.cookies: Mapping[str, Cookie] = dict(cookies or {})

is_empty

is_empty() -> bool

Returns bool

def is_empty(self) -> bool:
    return not self.cookies

get

get(name) -> Cookie | None
ParameterTypeDescription
namestr

Returns Cookie | None

def get(self, name: str) -> Cookie | None:
    return self.cookies.get(name)

get_value

get_value(name) -> str | None
ParameterTypeDescription
namestr

Returns str | None

def get_value(self, name: str) -> str | None:
    cookie = self.cookies.get(name)
    return None if cookie is None else cookie.value
set_cookie(cookie) -> Cookies
ParameterTypeDescription
cookieCookie

Returns Cookies

def set_cookie(self, cookie: Cookie) -> Cookies:
    return Cookies({**self.cookies, cookie.name: cookie})
set_all_cookie(cookies) -> Cookies
ParameterTypeDescription
cookiesIterable[Cookie]

Returns Cookies

def set_all_cookie(self, cookies: Iterable[Cookie]) -> Cookies:
    return Cookies({**self.cookies, **{c.name: c for c in cookies}})

merge

merge(that) -> Cookies
ParameterTypeDescription
thatCookies

Returns Cookies

def merge(self, that: Cookies) -> Cookies:
    return Cookies({**self.cookies, **that.cookies})

remove

remove(name) -> Cookies
ParameterTypeDescription
namestr

Returns Cookies

def remove(self, name: str) -> Cookies:
    return Cookies({k: v for k, v in self.cookies.items() if k != name})

set

set(name, value, **options) -> Result[Cookies, CookiesError]
ParameterTypeDescription
namestr
valuestr
optionsUnpack[CookieOptionsInput] = {}

Returns Result[Cookies, CookiesError]

def set(
    self, name: str, value: str, **options: Unpack[CookieOptionsInput]
) -> Result[Cookies, CookiesError]:
    return make_cookie(name, value, **options).map(self.set_cookie)

set_unsafe

set_unsafe(name, value, **options) -> Cookies
ParameterTypeDescription
namestr
valuestr
optionsUnpack[CookieOptionsInput] = {}

Returns Cookies

def set_unsafe(self, name: str, value: str, **options: Unpack[CookieOptionsInput]) -> Cookies:
    return self.set_cookie(make_cookie_unsafe(name, value, **options))
expire_cookie(name, **options) -> Result[Cookies, CookiesError]

Set name to an empty cookie that has already expired.

ParameterTypeDescription
namestr
optionsUnpack[CookieOptionsInput] = {}

Returns Result[Cookies, CookiesError]

def expire_cookie(
    self, name: str, **options: Unpack[CookieOptionsInput]
) -> Result[Cookies, CookiesError]:
    """Set ``name`` to an empty cookie that has already expired."""
    return self.set(name, "", **{**options, "max_age": 0, "expires": _EPOCH})
expire_cookie_unsafe(name, **options) -> Cookies
ParameterTypeDescription
namestr
optionsUnpack[CookieOptionsInput] = {}

Returns Cookies

def expire_cookie_unsafe(self, name: str, **options: Unpack[CookieOptionsInput]) -> Cookies:
    return self.set_unsafe(name, "", **{**options, "max_age": 0, "expires": _EPOCH})

set_all

set_all(cookies) -> Result[Cookies, CookiesError]

Set each (name, value[, options]); the first invalid cookie's error stops it.

ParameterTypeDescription
cookiesIterable[tuple[str, str] | tuple[str, str, CookieOptionsInput]]

Returns Result[Cookies, CookiesError]

def set_all(
    self, cookies: Iterable[tuple[str, str] | tuple[str, str, CookieOptionsInput]]
) -> Result[Cookies, CookiesError]:
    """Set each ``(name, value[, options])``; the first invalid cookie's
    error stops it."""
    out = dict(self.cookies)
    for entry in cookies:
        options: CookieOptionsInput = entry[2] if len(entry) == 3 else {}
        match make_cookie(entry[0], entry[1], **options):
            case Ok(cookie):
                out[cookie.name] = cookie
            case Err(error):
                return Err(error)
    return Ok(Cookies(out))

set_all_unsafe

set_all_unsafe(cookies) -> Cookies
ParameterTypeDescription
cookiesIterable[tuple[str, str] | tuple[str, str, CookieOptionsInput]]

Returns Cookies

def set_all_unsafe(
    self, cookies: Iterable[tuple[str, str] | tuple[str, str, CookieOptionsInput]]
) -> Cookies:
    match self.set_all(cookies):
        case Ok(result):
            return result
        case Err(error):
            raise error
to_cookie_header() -> str

The Cookie request header value.

Returns str

def to_cookie_header(self) -> str:
    """The ``Cookie`` request header value."""
    return "; ".join(f"{c.name}={c.value_encoded}" for c in self.cookies.values())

to_record

to_record() -> dict[str, str]

Returns dict[str, str]

def to_record(self) -> dict[str, str]:
    return {c.name: c.value for c in self.cookies.values()}
to_set_cookie_headers() -> list[str]

Returns list[str]

def to_set_cookie_headers(self) -> list[str]:
    return [serialize_cookie(c) for c in self.cookies.values()]

to_json

to_json() -> dict[str, object]

Returns dict[str, object]

def to_json(self) -> dict[str, object]:
    return {
        "_id": "effect/Cookies",
        "cookies": {k: c.to_json() for k, c in self.cookies.items()},
    }