fastapi_contrib.serializers package

Submodules

fastapi_contrib.serializers.common module

class fastapi_contrib.serializers.common.AbstractMeta

Bases: abc.ABC

exclude: set = {}

model: fastapi_contrib.db.models.MongoDBModel = None

read_only_fields: set = {}

write_only_fields: set = {}

class fastapi_contrib.serializers.common.ModelSerializer

Bases: fastapi_contrib.serializers.common.Serializer

Left as a proxy for correct naming until we figure out how to inherit all the specific to model-handling methods and fields directly in here.

class fastapi_contrib.serializers.common.Serializer

Bases: pydantic.main.BaseModel

Base Serializer class.

Almost ALWAYS should be used in conjunction with fastapi_contrib.serializers.openapi.patch decorator to correctly handle inherited model fields and OpenAPI Schema generation with response_model.

Responsible for sanitizing data & converting JSON to & from MongoDBModel.

Contains supplemental function, related to MongoDBModel, mostly proxied to corresponding functions inside model (ex. save, update)

Heavily uses Meta class for fine-tuning input & output. Main fields are:

• exclude - set of fields that are excluded when serializing to dict

  and sanitizing list of dicts

• model - class of the MongoDBModel to use, inherits fields from it

• write_only_fields - set of fields that can be accepted in request,

  but excluded when serializing to dict

• read_only_fields - set of fields that cannot be accepted in request,

  but included when serializing to dict

Example usage:

app = FastAPI()


class SomeModel(MongoDBModel):
    field1: str


@openapi.patch
class SomeSerializer(Serializer):
    read_only1: str = "const"
    write_only2: int
    not_visible: str = "42"

    class Meta:
        model = SomeModel
        exclude = {"not_visible"}
        write_only_fields = {"write_only2"}
        read_only_fields = {"read_only1"}


@app.get("/", response_model=SomeSerializer.response_model)
async def root(serializer: SomeSerializer):
    model_instance = await serializer.save()
    return model_instance.dict()

POST-ing to this route following JSON:

{"read_only1": "a", "write_only2": 123, "field1": "b"}

Should return following response:

{"id": 1, "field1": "b", "read_only1": "const"}

class Meta

Bases: fastapi_contrib.serializers.common.AbstractMeta

dict(*args, **kwargs) → dict

Removes excluded fields based on Meta and kwargs :return: dict of serializer data fields

classmethod sanitize_list(iterable: Iterable) → List[dict]

Sanitize list of rows that comes from DB to not include exclude set.

Parameters

iterable – sequence of dicts with model fields (from rows in DB)

Returns

list of cleaned, without excluded, dicts with model rows

async save(include: Optional[set] = None, exclude: Optional[set] = None, rewrite_fields: Optional[dict] = None) → fastapi_contrib.db.models.MongoDBModel

If we have model attribute in Meta, it populates model with data and saves it in DB, returning instance of model.

Parameters

• rewrite_fields – dict of fields with values that override any other values for these fields right before inserting into DB. This is useful when you need to set some value explicitly based on request (e.g. user or token).

• include – fields to include from model in DB insert command

• exclude – fields to exclude from model in DB insert command

Returns

model (MongoDBModel) that was saved

async update_many(filter_kwargs: dict, skip_defaults: bool = True, array_fields: Optional[list] = None) → pymongo.results.UpdateResult

If we have model attribute in Meta, it proxies filters & update data and after that returns actual result of update operation.

Returns

result of update many operation

async update_one(filter_kwargs: dict, skip_defaults: bool = True, array_fields: Optional[list] = None) → pymongo.results.UpdateResult

If we have model attribute in Meta, it proxies filters & update data and after that returns actual result of update operation.

Returns

result of update operation

fastapi_contrib.serializers.openapi module

fastapi_contrib.serializers.openapi.patch(cls: Type) → Type

Decorator for Serializer classes to handle inheritance from models, read- and write-only fields, combining `Meta`s.

For more info see gen_model method. :param cls: serializer class (model or regular) :return: wrapped class, which is newly generated pydantic’s BaseModel

fastapi_contrib.serializers.utils module

class fastapi_contrib.serializers.utils.FieldGenerationMode(value)

Bases: int, enum.Enum

Defines modes in which fields of decorated serializer should be generated.

REQUEST = 1

RESPONSE = 2

fastapi_contrib.serializers.utils.gen_model(cls: Type, mode: fastapi_contrib.serializers.utils.FieldGenerationMode)

Generate pydantic.BaseModel based on fields in Serializer class, its Meta class and possible Model class.

Parameters

• cls – serializer class (could be modelserializer or regular one)

• mode – field generation mode

Returns

newly generated BaseModel from fields in Model & Serializer

Module contents