Functional Serializers
This module contains related classes and functions for serialization.
Bases: PydanticErrorMixin, NameError
A subclass of NameError raised when handling undefined annotations during CoreSchema generation.
Default: name
@classmethod
def from_name_error(cls, name_error: NameError) -> Self
Convert a NameError to a PydanticUndefinedAnnotation error.
Self — Converted PydanticUndefinedAnnotation error.
NameError to be converted.
Handler to call into the next CoreSchema schema generation function.
Get the name of the closest field to this validator.
Type: str | None
def __call__(__source_type: Any) -> core_schema.CoreSchema
Call the inner handler and get the CoreSchema it returns.
This will call the next CoreSchema modifying function up until it calls
into Pydantic’s internal schema generation machinery, which will raise a
pydantic.errors.PydanticSchemaGenerationError error if it cannot generate
a CoreSchema for the given source type.
core_schema.CoreSchema — The pydantic-core CoreSchema generated.
The input type.
def generate_schema(__source_type: Any) -> core_schema.CoreSchema
Generate a schema unrelated to the current context.
Use this function if e.g. you are handling schema generation for a sequence
and want to generate a schema for its items.
Otherwise, you may end up doing something like applying a min_length constraint
that was intended for the sequence itself to its items!
core_schema.CoreSchema — The pydantic-core CoreSchema generated.
The input type.
def resolve_ref_schema(
__maybe_ref_schema: core_schema.CoreSchema,
) -> core_schema.CoreSchema
Get the real schema for a definition-ref schema.
If the schema given is not a definition-ref schema, it will be returned as is.
This means you don’t have to check before calling this function.
core_schema.CoreSchema — A concrete CoreSchema.
A CoreSchema, ref-based or not.
LookupError— If therefis not found.
Plain serializers use a function to modify the output of serialization.
This is particularly helpful when you want to customize the serialization for annotated types.
Consider an input of list, which will be serialized into a space-delimited string.
from typing import List
from typing_extensions import Annotated
from pydantic import BaseModel, PlainSerializer
CustomStr = Annotated[
List, PlainSerializer(lambda x: ' '.join(x), return_type=str)
]
class StudentModel(BaseModel):
courses: CustomStr
student = StudentModel(courses=['Math', 'Chemistry', 'English'])
print(student.model_dump())
#> {'courses': 'Math Chemistry English'}
Type: core_schema.SerializerFunction
Type: Any Default: PydanticUndefined
Type: Literal['always', 'unless-none', 'json', 'json-unless-none'] Default: 'always'
def __get_pydantic_core_schema__(
source_type: Any,
handler: GetCoreSchemaHandler,
) -> core_schema.CoreSchema
Gets the Pydantic core schema.
core_schema.CoreSchema — The Pydantic core schema.
The source type.
The GetCoreSchemaHandler instance.
Wrap serializers receive the raw inputs along with a handler function that applies the standard serialization logic, and can modify the resulting value before returning it as the final output of serialization.
For example, here’s a scenario in which a wrap serializer transforms timezones to UTC and utilizes the existing datetime serialization logic.
from datetime import datetime, timezone
from typing import Any, Dict
from typing_extensions import Annotated
from pydantic import BaseModel, WrapSerializer
class EventDatetime(BaseModel):
start: datetime
end: datetime
def convert_to_utc(value: Any, handler, info) -> Dict[str, datetime]:
# Note that `helper` can actually help serialize the `value` for further custom serialization in case it's a subclass.
partial_result = handler(value, info)
if info.mode == 'json':
return {
k: datetime.fromisoformat(v).astimezone(timezone.utc)
for k, v in partial_result.items()
}
return {k: v.astimezone(timezone.utc) for k, v in partial_result.items()}
UTCEventDatetime = Annotated[EventDatetime, WrapSerializer(convert_to_utc)]
class EventModel(BaseModel):
event_datetime: UTCEventDatetime
dt = EventDatetime(
start='2024-01-01T07:00:00-08:00', end='2024-01-03T20:00:00+06:00'
)
event = EventModel(event_datetime=dt)
print(event.model_dump())
'''
{
'event_datetime': {
'start': datetime.datetime(
2024, 1, 1, 15, 0, tzinfo=datetime.timezone.utc
),
'end': datetime.datetime(
2024, 1, 3, 14, 0, tzinfo=datetime.timezone.utc
),
}
}
'''
print(event.model_dump_json())
'''
{"event_datetime":{"start":"2024-01-01T15:00:00Z","end":"2024-01-03T14:00:00Z"}}
'''
Type: core_schema.WrapSerializerFunction
Type: Any Default: PydanticUndefined
Type: Literal['always', 'unless-none', 'json', 'json-unless-none'] Default: 'always'
def __get_pydantic_core_schema__(
source_type: Any,
handler: GetCoreSchemaHandler,
) -> core_schema.CoreSchema
This method is used to get the Pydantic core schema of the class.
core_schema.CoreSchema — The generated core schema of the class.
Source type.
Core schema handler.
def field_serializer(
__field: str,
fields: str = (),
return_type: Any = ...,
when_used: Literal['always', 'unless-none', 'json', 'json-unless-none'] = ...,
check_fields: bool | None = ...,
) -> Callable[[_PlainSerializeMethodType], _PlainSerializeMethodType]
def field_serializer(
__field: str,
fields: str = (),
mode: Literal['plain'],
return_type: Any = ...,
when_used: Literal['always', 'unless-none', 'json', 'json-unless-none'] = ...,
check_fields: bool | None = ...,
) -> Callable[[_PlainSerializeMethodType], _PlainSerializeMethodType]
def field_serializer(
__field: str,
fields: str = (),
mode: Literal['wrap'],
return_type: Any = ...,
when_used: Literal['always', 'unless-none', 'json', 'json-unless-none'] = ...,
check_fields: bool | None = ...,
) -> Callable[[_WrapSerializeMethodType], _WrapSerializeMethodType]
Decorator that enables custom field serialization.
In the below example, a field of type set is used to mitigate duplication. A field_serializer is used to serialize the data as a sorted list.
from typing import Set
from pydantic import BaseModel, field_serializer
class StudentModel(BaseModel):
name: str = 'Jane'
courses: Set[str]
@field_serializer('courses', when_used='json')
def serialize_courses_in_order(courses: Set[str]):
return sorted(courses)
student = StudentModel(courses={'Math', 'Chemistry', 'English'})
print(student.model_dump_json())
#> {"name":"Jane","courses":["Chemistry","English","Math"]}
See Custom serializers for more information.
Four signatures are supported:
(self, value: Any, info: FieldSerializationInfo)(self, value: Any, nxt: SerializerFunctionWrapHandler, info: FieldSerializationInfo)(value: Any, info: SerializationInfo)(value: Any, nxt: SerializerFunctionWrapHandler, info: SerializationInfo)
Callable[[Any], Any] — The decorator function.
Which field(s) the method should be called on.
The serialization mode.
plainmeans the function will be called instead of the default serialization logic,wrapmeans the function will be called with an argument to optionally call the default serialization logic.
Optional return type for the function, if omitted it will be inferred from the type annotation.
Determines the serializer will be used for serialization.
Whether to check that the fields actually exist on the model.
def model_serializer(__f: FuncType) -> FuncType
def model_serializer(
mode: Literal['plain', 'wrap'] = ...,
when_used: Literal['always', 'unless-none', 'json', 'json-unless-none'] = 'always',
return_type: Any = ...,
) -> Callable[[FuncType], FuncType]
Decorator that enables custom model serialization.
This is useful when a model need to be serialized in a customized manner, allowing for flexibility beyond just specific fields.
An example would be to serialize temperature to the same temperature scale, such as degrees Celsius.
from typing import Literal
from pydantic import BaseModel, model_serializer
class TemperatureModel(BaseModel):
unit: Literal['C', 'F']
value: int
@model_serializer()
def serialize_model(self):
if self.unit == 'F':
return {'unit': 'C', 'value': int((self.value - 32) / 1.8)}
return {'unit': self.unit, 'value': self.value}
temperature = TemperatureModel(unit='F', value=212)
print(temperature.model_dump())
#> {'unit': 'C', 'value': 100}
See Custom serializers for more information.
Callable[[Any], Any] — The decorator function.
The function to be decorated.
The serialization mode.
'plain'means the function will be called instead of the default serialization logic'wrap'means the function will be called with an argument to optionally call the default serialization logic.
Determines when this serializer should be used.
The return type for the function. If omitted it will be inferred from the type annotation.
Default: TypeVar('FuncType', bound=(Callable[..., Any]))
Default: TypeVar('AnyType')