DictSerializable

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

Source code in quickapi/serializers/base.py

class DictSerializable:
    """
    Convert to/from dictionaries to the appropriate class/instance.

    """

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

    @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

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

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

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

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

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

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