datastructures#

class litestar.datastructures.Accept#

Bases: object

An Accept header.

__init__(accept_value: str) → None#
best_match(provided_types: List[str], default: str | None = None) → str | None#

Find the best matching media type for the request.

Parameters:

  • provided_types – A list of media types that can be provided as a response. These types can contain a wildcard * character in the main- or subtype part.

  • default – The media type that is returned if none of the provided types match.

Returns:

The best matching media type. If the matching provided type contains wildcard characters, they are replaced with the corresponding part of the accepted type. Otherwise the provided type is returned as-is.

accepts(media_type: str) → bool#

Check if the request accepts the specified media type.

If multiple media types can be provided, it is better to use best_match().

Parameters:

media_type – The media type to check for.

Returns:

True if the request accepts media_type.

class litestar.datastructures.Address#

Bases: NamedTuple

Just a network address.

host: str#

Address host.

port: int#

Address port.

static __new__(_cls, host: str, port: int)#

Create new instance of Address(host, port)

class litestar.datastructures.CacheControlHeader#

Bases: Header

A cache-control header.

max_age: int | None = None#

Accessor for the max-age directive.

s_maxage: int | None = None#

Accessor for the s-maxage directive.

no_cache: bool | None = None#

Accessor for the no-cache directive.

no_store: bool | None = None#

Accessor for the no-store directive.

private: bool | None = None#

Accessor for the private directive.

public: bool | None = None#

Accessor for the public directive.

no_transform: bool | None = None#

Accessor for the no-transform directive.

must_revalidate: bool | None = None#

Accessor for the must-revalidate directive.

proxy_revalidate: bool | None = None#

Accessor for the proxy-revalidate directive.

must_understand: bool | None = None#

Accessor for the must-understand directive.

immutable: bool | None = None#

Accessor for the immutable directive.

stale_while_revalidate: int | None = None#

Accessor for the stale-while-revalidate directive.

classmethod from_header(header_value: str) → CacheControlHeader#

Create a CacheControlHeader instance from the header value.

Parameters:

header_value – the header value as string

Returns:

An instance of CacheControlHeader

classmethod prevent_storing() → CacheControlHeader#

Create a cache-control header with the no-store directive which indicates that any caches of any kind (private or shared) should not store this response.

__init__(documentation_only: bool = False, max_age: int | None = None, s_maxage: int | None = None, no_cache: bool | None = None, no_store: bool | None = None, private: bool | None = None, public: bool | None = None, no_transform: bool | None = None, must_revalidate: bool | None = None, proxy_revalidate: bool | None = None, must_understand: bool | None = None, immutable: bool | None = None, stale_while_revalidate: int | None = None) → None#
class litestar.datastructures.Cookie#

Bases: object

Container class for defining a cookie using the Set-Cookie header.

See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie for more details regarding this header.

key: str#

Key for the cookie.

path: str = '/'#

Path fragment that must exist in the request url for the cookie to be valid.

Defaults to /.

value: str | None = None#

Value for the cookie, if none given defaults to empty string.

max_age: int | None = None#

Maximal age of the cookie before its invalidated.

expires: int | None = None#

Seconds from now until the cookie expires.

domain: str | None = None#

Domain for which the cookie is valid.

secure: bool | None = None#

Https is required for the cookie.

httponly: bool | None = None#

Forbids javascript to access the cookie via document.cookie.

__init__(key: str, path: str = '/', value: str | None = None, max_age: int | None = None, expires: int | None = None, domain: str | None = None, secure: bool | None = None, httponly: bool | None = None, samesite: Literal['lax', 'strict', 'none'] = 'lax', description: str | None = None, documentation_only: bool = False) → None#
samesite: Literal['lax', 'strict', 'none'] = 'lax'#

Controls whether or not a cookie is sent with cross-site requests.

Defaults to ‘lax’.

description: str | None = None#

Description of the response cookie header for OpenAPI documentation.

documentation_only: bool = False#

Defines the Cookie instance as for OpenAPI documentation purpose only.

Get a simple cookie object from the values.

Returns:

A SimpleCookie

to_header(**kwargs: Any) → str#

Return a string representation suitable to be sent as HTTP headers.

Parameters:

**kwargs – Any kwargs to pass to the simple cookie output method.

to_encoded_header() → tuple[bytes, bytes]#

Create encoded header for ASGI send.

Returns:

A two tuple of bytes.

property dict: dict[str, Any]#

Get the cookie as a dict.

Returns:

A dict of values

__eq__(other: Any) → bool#

Determine whether two cookie instances are equal according to the cookie spec, i.e. hey have a similar path, domain and key.

Parameters:

other – An arbitrary value

Returns:

A boolean

class litestar.datastructures.ETag#

Bases: Header

An etag header.

classmethod from_header(header_value: str) → ETag#

Construct an etag header from its string representation.

Note that this will unquote etag-values

__init__(documentation_only: bool = False, weak: bool = False, value: str | None = None) → None#
class litestar.datastructures.FormMultiDict#

Bases: ImmutableMultiDict[Any]

MultiDict for form data.

async close() → None#

Close all files in the multi-dict.

Returns:

None

class litestar.datastructures.Header#

Bases: ABC

An abstract type for HTTP headers.

documentation_only: bool = False#

Defines the header instance as for OpenAPI documentation purpose only.

abstract classmethod from_header(header_value: str) → Header#

Construct a header from its string representation.

to_header(include_header_name: bool = False) → str#

Get the header as string.

Parameters:

include_header_name – should include the header name in the return value. If set to false the return value will only include the header value. if set to true the return value will be: <header name>: <header value>. Defaults to false.

__init__(documentation_only: bool = False) → None#
class litestar.datastructures.Headers#

Bases: CIMultiDictProxy[str], MultiMixin[str]

An immutable, case-insensitive multi dict for HTTP headers.

__init__(headers: Mapping[str, str] | RawHeaders | MultiMapping | None = None) → None#

Initialize Headers.

Parameters:

headers – Initial value.

classmethod from_scope(scope: Scope) → Headers#

Create headers from a send-message.

Parameters:

scope – The ASGI connection scope.

Returns:

Headers

Raises:

ValueError – If the message does not have a headers key

to_header_list() → RawHeadersList#

Raw header value.

Returns:

A list of tuples contain the header and header-value as bytes

class litestar.datastructures.ImmutableMultiDict#

Bases: MultiDictProxy[T], MultiMixin[T], Generic[T]

Immutable MultiDict, using class:MultiDictProxy <multidict.MultiDictProxy>.

__init__(args: MultiMapping | Mapping[str, Any] | Iterable[tuple[str, Any]] | None = None) → None#

Initialize ImmutableMultiDict from a MultiMapping`, Mapping or an iterable of tuples.

Parameters:

args – Mapping-like structure to create the ImmutableMultiDict from

mutable_copy() → MultiDict[T]#

Create a mutable copy as a MultiDict

Returns:

A mutable multi dict

copy() → Self#

Return a shallow copy

class litestar.datastructures.ImmutableState#

Bases: Mapping[str, Any]

An object meant to store arbitrary state.

It can be accessed using dot notation while exposing dict like functionalities.

__init__(state: ImmutableState | Mapping[str, Any] | Iterable[tuple[str, Any]], deep_copy: bool = True) → None#

Initialize an ImmutableState instance.

Parameters:

  • state – An object to initialize the state from. Can be a dict, an instance of ImmutableState, or a tuple of key value paris.

  • deep_copy – Whether to ‘deepcopy’ the passed in state.

Examples

from litestar.datastructures import ImmutableState

state_dict = {"first": 1, "second": 2, "third": 3, "fourth": 4}
state = ImmutableState(state_dict)

# state implements the Mapping type:
assert len(state) == 3
assert "first" in state
assert not "fourth" in state
assert state["first"] == 1
assert [(k, v) for k, v in state.items()] == [("first", 1), ("second", 2), ("third", 3)]

# state implements __bool__
assert state  # state is true when it has values.
assert not State()  # state is empty when it has no values.

# it has a 'dict' method to retrieve a shallow copy of the underlying dict
inner_dict = state.dict()
assert inner_dict == state_dict

# you can also retrieve a mutable State by calling 'mutable_copy'
mutable_state = state.mutable_copy()
del state["first"]
assert "first" not in state
__bool__() → bool#

Return a boolean indicating whether the wrapped dict instance has values.

__getitem__(key: str) → Any#

Get the value for the corresponding key from the wrapped state object using subscription notation.

Parameters:

key – Key to access.

Raises:

KeyError –

Returns:

A value from the wrapped state instance.

__iter__() → Iterator[str]#

Return an iterator iterating the wrapped state dict.

Returns:

An iterator of strings

__len__() → int#

Return length of the wrapped state dict.

Returns:

An integer

__getattr__(key: str) → Any#

Get the value for the corresponding key from the wrapped state object using attribute notation.

Parameters:

key – Key to retrieve

Raises:

AttributeError – if the given attribute is not set.

Returns:

The retrieved value

__copy__() → Self#

Return a shallow copy of the given state object.

Customizes how the builtin “copy” function will work.

mutable_copy() → State#

Return a mutable copy of the state object.

Returns:

A State

dict() → dict[str, Any]#

Return a shallow copy of the wrapped dict.

Returns:

A dict

classmethod __get_validators__() → Generator[Callable[[ImmutableState | dict[str, Any] | Iterable[tuple[str, Any]]], ImmutableState], None, None]#

Pydantic compatible method to allow custom parsing of state instances in a SignatureModel.

classmethod validate(value: ImmutableState | dict[str, Any] | Iterable[tuple[str, Any]]) → Self#

Parse a value and instantiate state inside a SignatureModel. This allows us to use custom subclasses of state, as well as allows users to decide whether state is mutable or immutable.

Parameters:

value – The value from which to initialize the state instance.

Returns:

An ImmutableState instance

class litestar.datastructures.MultiDict#

Bases: MultiDict[T], MultiMixin[T], Generic[T]

MultiDict, using MultiDict.

__init__(args: MultiMapping | Mapping[str, T] | Iterable[tuple[str, T]] | None = None) → None#

Initialize MultiDict from a`MultiMapping``, Mapping or an iterable of tuples.

Parameters:

args – Mapping-like structure to create the MultiDict from

immutable() → ImmutableMultiDict[T]#

Create an.

ImmutableMultiDict view.

Returns:

An immutable multi dict

copy() → Self#

Return a shallow copy

class litestar.datastructures.MultiMixin#

Bases: Generic[T], MultiMapping[T], ABC

Mixin providing common methods for multi dicts, used by ImmutableMultiDict and MultiDict

dict() → dict[str, list[Any]]#

Return the multi-dict as a dict of lists.

Returns:

A dict of lists

multi_items() → Generator[tuple[str, T], None, None]#

Get all keys and values, including duplicates.

Returns:

A list of tuples containing key-value pairs

class litestar.datastructures.MutableScopeHeaders#

Bases: MutableMapping

A case-insensitive, multidict-like structure that can be used to mutate headers within a Scope

__init__(scope: HeaderScope | None = None) → None#

Initialize MutableScopeHeaders from a HeaderScope.

Parameters:

scope – The ASGI connection scope.

classmethod from_message(message: Message) → MutableScopeHeaders#

Construct a header from a message object.

Parameters:

message – Message.

Returns:

MutableScopeHeaders.

Raises:

ValueError – If the message does not have a headers key.

add(key: str, value: str) → None#

Add a header to the scope.

Notes

  • This method keeps duplicates.

Parameters:

  • key – Header key.

  • value – Header value.

Returns:

None.

getall(key: str, default: List[str] | None = None) → List[str]#

Get all values of a header.

Parameters:

  • key – Header key.

  • default – Default value to return if name is not found.

Returns:

A list of strings.

Raises:

KeyError – if no header for name was found and default is not given.

extend_header_value(key: str, value: str) → None#

Extend a multivalued header.

Notes

  • A multivalues header is a header that can take a comma separated list.

  • If the header previously did not exist, it will be added.

Parameters:

  • key – Header key.

  • value – Header value to add,

Returns:

None

__getitem__(key: str) → str#

Get the first header matching name

__setitem__(key: str, value: str) → None#

Set a header in the scope, overwriting duplicates.

__delitem__(key: str) → None#

Delete all headers matching name

__len__() → int#

Return the length of the internally stored headers, including duplicates.

__iter__() → Iterator[str]#

Create an iterator of header names including duplicates.

class litestar.datastructures.ResponseHeader#

Bases: object

Container type for a response header.

name: str#

Header name

documentation_only: bool = False#

Defines the ResponseHeader instance as for OpenAPI documentation purpose only.

value: str | None = None#

Value to set for the response header.

description: str | None = None#

A brief description of the parameter. This could contain examples of use.

[CommonMark syntax](https://spec.commonmark.org/) MAY be used for rich text representation.

required: bool = False#

Determines whether this parameter is mandatory.

If the [parameter location](https://spec.openapis.org/oas/v3.1.0#parameterIn) is “path”, this property is REQUIRED and its value MUST be true. Otherwise, the property MAY be included and its default value is false.

deprecated: bool = False#

Specifies that a parameter is deprecated and SHOULD be transitioned out of usage.

Default value is false.

allow_empty_value: bool = False#

Sets the ability to pass empty-valued parameters. This is valid only for query parameters and allows sending a parameter with an empty value. Default value is false. If.

[style](https://spec.openapis.org/oas/v3.1.0#parameterStyle) is used, and if behavior is n/a (cannot be serialized), the value of allowEmptyValue SHALL be ignored. Use of this property is NOT RECOMMENDED, as it is likely to be removed in a later revision.

The rules for serialization of the parameter are specified in one of two ways. For simpler scenarios, a [schema](https://spec.openapis.org/oas/v3.1.0#parameterSchema) and [style](https://spec.openapis.org/oas/v3.1.0#parameterStyle) can describe the structure and syntax of the parameter.

__init__(name: str, documentation_only: bool = False, value: str | None = None, description: str | None = None, required: bool = False, deprecated: bool = False, allow_empty_value: bool = False, style: str | None = None, explode: bool | None = None, allow_reserved: bool = False, example: Any | None = None, examples: dict[str, Example] | None = None) → None#
style: str | None = None#

Describes how the parameter value will be serialized depending on the type of the parameter value. Default values (based on value of in):

  • for query - form;

  • for path - simple;

  • for header - simple;

  • for cookie - form.

explode: bool | None = None#

When this is true, parameter values of type array or object generate separate parameters for each value of the array or key-value pair of the map.

For other types of parameters this property has no effect. When [style](https://spec.openapis.org/oas/v3.1.0#parameterStyle) is form, the default value is true. For all other styles, the default value is false.

allow_reserved: bool = False#

Determines whether the parameter value SHOULD allow reserved characters, as defined by.

[RFC3986](https://tools.ietf.org/html/rfc3986#section-2.2) :/?#[]@!$&’()*+,;= to be included without percent- encoding.

This property only applies to parameters with an in value of query. The default value is false.

example: Any | None = None#

Example of the parameter’s potential value.

The example SHOULD match the specified schema and encoding properties if present. The example field is mutually exclusive of the examples field. Furthermore, if referencing a schema that contains an example, the example value SHALL _override_ the example provided by the schema. To represent examples of media types that cannot naturally be represented in JSON or YAML, a string value can contain the example with escaping where necessary.

examples: dict[str, Example] | None = None#

Examples of the parameter’s potential value. Each example SHOULD contain a value in the correct format as specified in the parameter encoding. The examples field is mutually exclusive of the example field. Furthermore, if referencing a schema that contains an example, the examples value SHALL _override_ the example provided by the schema.

For more complex scenarios, the [content](https://spec.openapis.org/oas/v3.1.0#parameterContent) property can define the media type and schema of the parameter. A parameter MUST contain either a schema property, or a content property, but not both. When example or examples are provided in conjunction with the schema object, the example MUST follow the prescribed serialization strategy for the parameter.

__post_init__() → None#

Ensure that either value is set or the instance is for documentation_only.

class litestar.datastructures.SecretBytes#

Bases: SecretValue[bytes]

Represents a secret bytes value.

get_obscured() → bytes#

Overrides the base class method to return the hidden bytes value.

Returns:

The hidden bytes representation of the secret value.

Return type:

bytes

class litestar.datastructures.SecretString#

Bases: SecretValue[str]

Represents a secret string value.

get_obscured() → str#

Overrides the base class method to return the hidden string value.

Returns:

The hidden string representation of the secret value.

Return type:

str

class litestar.datastructures.State#

Bases: ImmutableState, MutableMapping[str, Any]

An object meant to store arbitrary state.

It can be accessed using dot notation while exposing dict like functionalities.

__init__(state: ImmutableState | Mapping[str, Any] | Iterable[tuple[str, Any]] | None = None, deep_copy: bool = False) → None#

Initialize a State instance with an optional value.

Parameters:

  • state – An object to initialize the state from. Can be a dict, an instance of ‘ImmutableState’, or a tuple of key value paris.

  • deep_copy – Whether to ‘deepcopy’ the passed in state.

Examples#
from litestar.datastructures import State

state_dict = {"first": 1, "second": 2, "third": 3, "fourth": 4}
state = State(state_dict)

# state can be accessed using '.' notation
assert state.fourth == 4
del state.fourth

# state implements the Mapping type:
assert len(state) == 3
assert "first" in state
assert not "fourth" in state
assert state["first"] == 1
assert [(k, v) for k, v in state.items()] == [("first", 1), ("second", 2), ("third", 3)]

state["fourth"] = 4
assert "fourth" in state
del state["fourth"]

# state implements __bool__
assert state  # state is true when it has values.
assert not State()  # state is empty when it has no values.

# it has shallow copy
copied_state = state.copy()
del copied_state.first
assert state.first

# it has a 'dict' method to retrieve a shallow copy of the underlying dict
inner_dict = state.dict()
assert inner_dict == state_dict

# you can get an immutable copy of the state by calling 'immutable_immutable_copy'
immutable_copy = state.immutable_copy()
del immutable_copy.first  #  raises AttributeError
__delitem__(key: str) → None#

Delete the value from the key from the wrapped state object using subscription notation.

Parameters:

key – Key to delete

Raises:

KeyError – if the given attribute is not set.

Returns:

None

__setitem__(key: str, value: Any) → None#

Set an item in the state using subscription notation.

Parameters:

  • key – Key to set.

  • value – Value to set.

Returns:

None

__setattr__(key: str, value: Any) → None#

Set an item in the state using attribute notation.

Parameters:

  • key – Key to set.

  • value – Value to set.

Returns:

None

__delattr__(key: str) → None#

Delete the value from the key from the wrapped state object using attribute notation.

Parameters:

key – Key to delete

Raises:

AttributeError – if the given attribute is not set.

Returns:

None

copy() → Self#

Return a shallow copy of the state object.

Returns:

A State

immutable_copy() → ImmutableState#

Return a shallow copy of the state object, setting it to be frozen.

Returns:

A State

class litestar.datastructures.UploadFile#

Bases: object

Representation of a file upload

__init__(content_type: str, filename: str, file_data: bytes | None = None, headers: dict[str, str] | None = None, max_spool_size: int = 1048576) → None#

Upload file in-memory container.

Parameters:

  • content_type – Content type for the file.

  • filename – The filename.

  • file_data – File data.

  • headers – Any attached headers.

  • max_spool_size – The size above which the temporary file will be rolled to disk.

property rolled_to_disk: bool#

Determine whether the spooled file exceeded the rolled-to-disk threshold and is no longer in memory.

Returns:

A boolean flag

async write(data: bytes) → int#

Proxy for data writing.

Parameters:

data – Byte string to write.

Returns:

None

async read(size: int = -1) → bytes#

Proxy for data reading.

Parameters:

size – position from which to read.

Returns:

Byte string.

async seek(offset: int) → int#

Async proxy for file seek.

Parameters:

offset – start position..

Returns:

None.

async close() → None#

Async proxy for file close.

Returns:

None.

class litestar.datastructures.URL#

Bases: object

Representation and modification utilities of a URL.

scheme: str#

URL scheme.

netloc: str#

Network location.

path: str#

Hierarchical path.

fragment: str#

Fragment component.

query: str#

Query string.

username: str | None#

Username if specified.

password: str | None#

Password if specified.

port: int | None#

Port if specified.

hostname: str | None#

Hostname if specified.

static __new__(cls, url: str | SplitResult) → URL#

Create a new instance.

Parameters:

url – url string or split result to represent.

classmethod from_components(scheme: str = '', netloc: str = '', path: str = '', fragment: str = '', query: str = '') → Self#

Create a new URL from components.

Parameters:

  • scheme – URL scheme

  • netloc – Network location

  • path – Hierarchical path

  • query – Query component

  • fragment – Fragment identifier

Returns:

A new URL with the given components

classmethod from_scope(scope: Scope) → Self#

Construct a URL from a Scope

Parameters:

scope – A scope

Returns:

A URL

with_replacements(scheme: str = '', netloc: str = '', path: str = '', query: str | MultiDict | None | EmptyType = _EmptyEnum.EMPTY, fragment: str = '') → Self#

Create a new URL, replacing the given components.

Parameters:

  • scheme – URL scheme

  • netloc – Network location

  • path – Hierarchical path

  • query – Raw query string

  • fragment – Fragment identifier

Returns:

A new URL with the given components replaced

property query_params: MultiDict#

Query parameters of a URL as a MultiDict

Returns:

A MultiDict with query parameters

Notes

  • The returned MultiDict is mutable, URL itself is immutable,

    therefore mutating the query parameters will not directly mutate the URL. If you want to modify query parameters, make modifications in the multidict and pass them back to with_replacements()