drf-pydantic

By default, drf-pydantic only uses DRF's validation. To run your complex Pydantic validators (e.g., @field_validator) during the DRF .is_valid() call, set "validate_pydantic": True in the drf_config dictionary of your model.

from drf_pydantic import BaseModel


class MyModel(BaseModel):
    name: str
    addresses: list[str]

    drf_config = {"validate_pydantic": True}


my_serializer = MyModel.drf_serializer(data={"name": "Van", "addresses": []})
my_serializer.is_valid()  # This will also trigger Pydantic validation

Replace pydantic.BaseModel with drf_pydantic.BaseModel to automatically generate a DRF serializer via the .drf_serializer attribute. The generated serializer is equivalent to a standard DRF Serializer class based on your Pydantic field definitions.

from drf_pydantic import BaseModel


class MyModel(BaseModel):
    name: str
    addresses: list[str]

# Access the generated DRF serializer class
serializer_class = MyModel.drf_serializer

# Use it like a normal DRF serializer
my_value = MyModel.drf_serializer(data={"name": "Van", "addresses": ["Gym"]})
my_value.is_valid(raise_exception=True)

To add DRF serializer support to existing Pydantic models without rewriting them, use multiple inheritance. Important: drf_pydantic.BaseModel must come before pydantic.BaseModel in the inheritance list.

from drf_pydantic import BaseModel as DRFBaseModel
from pydantic import BaseModel


class Pet(BaseModel):
    name: str


class Dog(DRFBaseModel, Pet):
    breed: str

# Now Dog has .drf_serializer
serializer = Dog.drf_serializer

Install the package using pip to use Pydantic models as Django REST framework serializers.

pip install drf-pydantic

You can explicitly specify which DRF field should be used for a Pydantic field by including the DRF field instance in the field's metadata. This allows you to bypass the automatic mapping logic.

Note: Only one DRF field instance can be provided per Pydantic field. Providing multiple will raise a FieldConversionError.

from pydantic import BaseModel, Field
from rest_framework import serializers
from drf_pydantic.parse import create_serializer_from_model

class CustomSchema(BaseModel):
    # Manually force the use of CharField with specific DRF arguments
    custom_field: str = Field(..., json_schema_extra=serializers.CharField(allow_blank=True))

Serializer = create_serializer_from_model(CustomSchema)

The drf_config dictionary allows you to control how the generated DRF serializer interacts with the Pydantic model. All drf_config values are inherited by child classes.

Available keys:

• validate_pydantic (bool): If True, runs Pydantic validation during DRF .is_valid(). Defaults to False.
• backpopulate_after_validation (bool): If True (default), updates the DRF serializer's validated_data with values modified by Pydantic validators. Set to False to prevent this.
• validation_error (str): Determines the exception type raised. Set to "pydantic" to raise pydantic.ValidationError directly instead of wrapping it in DRF's ValidationError.

If validate_pydantic is enabled and .is_valid() has been called successfully, you can access the actual Pydantic model instance (including any mutations from validators) via the .pydantic_instance property on the serializer.

serializer = MyModel.drf_serializer(data={"name": "Van", "addresses": []})
serializer.is_valid(raise_exception=True)
# Access the Pydantic model directly
print(serializer.pydantic_instance)  # MyModel(name='Van', addresses=[])

When backpopulate_after_validation is set to True in _drf_config, the serializer will attempt to update the validated data dictionary (serializer.validated_data) with the values from the Pydantic model after validation.

If a field in the Pydantic model is itself a pydantic.BaseModel, it will be automatically converted to a dictionary using .model_dump() before being placed back into the DRF validated data.

The DrfPydanticSerializer allows you to control how Pydantic ValidationError exceptions are handled via the _drf_config dictionary. You can choose between two modes for the validation_error key:

• "pydantic": The original pydantic.ValidationError is raised directly.
• "drf": Pydantic errors are caught and transformed into standard DRF serializers.ValidationError objects, mapping errors to specific fields or non_field_errors.

You can customize how the Pydantic model integrates with Django REST Framework by defining a drf_config attribute of type DrfConfigDict on your model class.

When multiple classes in an inheritance hierarchy define drf_config, the configuration is merged using the following priority (highest to lowest):

1. The Pydantic model itself (cls)
2. The parent class of the Pydantic model
3. Default values

Default values for drf_config are:

• validate_pydantic=False
• validation_error="drf"
• backpopulate_after_validation=True

from drf_pydantic.base_model import BaseModel
from drf_pydantic.config import DrfConfigDict

class MyModel(BaseModel):
    drf_config = DrfConfigDict(validation_error="custom_error")
    # ... fields ...