Skip to content

DictSerializable

Convert to/from dictionaries to the appropriate class/instance.

Currently, it will try to (de)serialize the following types:

  1. dict
  2. dataclasses
  3. attrs (if installed)
  4. pydantic (if installed)
  5. msgspec (if installed)

In the future, you will be able to plug in your own (de)serializers instead.

Source code in quickapi/serializers/base.py
Python
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
class DictSerializable:
    """
    Convert to/from dictionaries to the appropriate class/instance.

    Currently, it will try to (de)serialize the following types:

    1. dict
    2. dataclasses
    3. attrs (if installed)
    4. pydantic (if installed)
    5. msgspec (if installed)

    In the future, you will be able to plug in your own (de)serializers instead.
    """

    # TODO: Maybe make the (de)serializer pluggable and configurable instead
    serializers: Sequence[type[BaseSerializer]] = (
        DataclassSerializer,
        AttrsSerializer,
        PydanticSerializer,
        MsgspecSerializer,
    )
    deserializers: Sequence[type[BaseDeserializer]] = (  # type: ignore [assignment]
        DataclassDeserializer,
        AttrsDeserializer,
        PydanticDeserializer,
        MsgspecDeserializer,
    )

    @classmethod
    def from_dict(
        cls, klass: type[FromDictSerializableT], values: dict
    ) -> FromDictSerializableT:
        for serializer in cls.serializers:
            if serializer.can_apply(klass):
                return serializer.from_dict(klass, values)
        raise DictSerializationError(expected_type=klass.__name__)

    @classmethod
    def to_dict(cls, instance: DictSerializableT) -> dict | None:
        for deserializer in cls.deserializers:
            if deserializer.can_apply(instance):
                return deserializer.to_dict(instance)
        raise DictDeserializationError(expected_type=str(DictSerializableT))

Dataclasses

DataclassDeserializer

Convert from dataclass model to dict.

Source code in quickapi/serializers/dataclass.py
Python
33
34
35
36
37
38
39
40
41
42
43
44
class DataclassDeserializer:
    """
    Convert from dataclass model to dict.
    """

    @classmethod
    def can_apply(cls, instance: "DataclassInstance") -> bool:
        return dataclasses.is_dataclass(instance)

    @classmethod
    def to_dict(cls, instance: "DataclassInstance") -> dict | None:
        return dataclasses.asdict(instance)

DataclassSerializer

Convert from dict to attrs model.

Source code in quickapi/serializers/dataclass.py
Python
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class DataclassSerializer:
    """
    Convert from dict to attrs model.

    """

    @classmethod
    def can_apply(cls, klass: type[FromDictSerializableT]) -> bool:
        return dataclasses.is_dataclass(klass)

    @classmethod
    def from_dict(
        cls, klass: type[FromDictSerializableT], values: dict
    ) -> FromDictSerializableT:
        try:
            return chili.decode(values, klass)
        except ValueError as e:
            raise DictSerializationError(expected_type=klass.__name__) from e

Attrs

AttrsDeserializer

Convert from attrs model to dict.

Source code in quickapi/serializers/attrs.py
Python
33
34
35
36
37
38
39
40
41
42
43
44
class AttrsDeserializer:
    """
    Convert from attrs model to dict.
    """

    @classmethod
    def can_apply(cls, instance: "attrs.AttrsInstance") -> bool:
        return attrs_installed and attrs.has(type(instance))

    @classmethod
    def to_dict(cls, instance: "attrs.AttrsInstance") -> dict | None:
        return attrs.asdict(instance)

AttrsSerializer

Convert from dict to attrs model.

Source code in quickapi/serializers/attrs.py
Python
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class AttrsSerializer:
    """
    Convert from dict to attrs model.

    """

    @classmethod
    def can_apply(cls, klass: type[FromDictSerializableT]) -> bool:
        return attrs_installed and attrs.has(klass)

    @classmethod
    def from_dict(
        cls, klass: type[FromDictSerializableT], values: dict
    ) -> FromDictSerializableT:
        try:
            return cattrs.structure(values, klass)
        except cattrs.ClassValidationError as e:
            raise DictSerializationError(expected_type=klass.__name__) from e

Pydantic

PydanticDeserializer

Convert from pydantic model to dict.

Source code in quickapi/serializers/pydantic.py
Python
32
33
34
35
36
37
38
39
40
41
class PydanticDeserializer:
    """Convert from pydantic model to dict."""

    @classmethod
    def can_apply(cls, instance: "pydantic.BaseModel") -> bool:
        return pydantic_installed and isinstance(instance, pydantic.BaseModel)

    @classmethod
    def to_dict(cls, instance: "pydantic.BaseModel") -> dict | None:
        return instance.model_dump()

PydanticSerializer

Convert from dict to pydantic model.

Source code in quickapi/serializers/pydantic.py
Python
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class PydanticSerializer:
    """
    Convert from dict to pydantic model.
    """

    @classmethod
    def can_apply(cls, klass: type[FromDictSerializableT]) -> bool:
        # TODO: Is this correct?
        return pydantic_installed and issubclass(klass, pydantic.BaseModel)

    @classmethod
    def from_dict(
        cls, klass: type[FromDictSerializableT], values: dict
    ) -> FromDictSerializableT:
        try:
            return klass(**values)
        except pydantic.ValidationError as e:
            raise DictSerializationError(expected_type=klass.__name__) from e

Msgspec

MsgspecDeserializer

Convert from msgspec.Struct to dict.

Source code in quickapi/serializers/msgspec.py
Python
33
34
35
36
37
38
39
40
41
42
class MsgspecDeserializer:
    """Convert from msgspec.Struct to dict."""

    @classmethod
    def can_apply(cls, instance: "msgspec.Struct") -> bool:
        return msgspec_installed and isinstance(instance, msgspec.Struct)

    @classmethod
    def to_dict(cls, instance: "msgspec.Struct") -> Any:
        return msgspec.to_builtins(instance, builtin_types=[dict])

MsgspecSerializer

Convert from dict to msgspec.Struct.

Source code in quickapi/serializers/msgspec.py
Python
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class MsgspecSerializer:
    """
    Convert from dict to msgspec.Struct.
    """

    @classmethod
    def can_apply(cls, klass: type[FromDictSerializableT]) -> bool:
        return msgspec_installed and issubclass(klass, msgspec.Struct)

    @classmethod
    def from_dict(
        cls, klass: type[FromDictSerializableT], values: dict
    ) -> FromDictSerializableT:
        try:
            return msgspec.convert(values, klass)
        except msgspec.ValidationError as e:
            raise DictSerializationError(expected_type=klass.__name__) from e