+ NV-jF |a0t$Rt^RIHt^RIt^RIHtHt^RIH t H t H t H t H t HtHt^RIHtHt^RIHtHtHt^RIHt^RIHt^R IHtHt^R IHt^R I H!t!]PD!RB/]PFBR R /B!RR44t$]PD!RB/]PFBR R /B!RR44t%] 'd4Rt&R]'R&Rt(R]'R&Rt)R]'R&Rt*R]'R&]!R](R7t+]!R])R7t,]RRR RR!R/R"R#ll4t-]R$RRRR RR!R/R%R&ll4t-R$R'R]R R(R!R/R)R*llt-] 'd] ] ]] ,.] 3,t.R]'R+&] ] .] 3,t/R]'R,&R-t0R]'R.&] ] ]]] ,.] 3,t1R]'R/&] ] ].] 3,t2R]'R0&R1t3R]'R2&R3t4R]'R4&]!R5]0R7t5]!R6]3R7t6]R7R8l4t7]R R(RR/R9R:ll4t7]R$RR R(RR/R;R<ll4t7RCR$R'R R(R]/R=R>lllt7]!R?4t8] 'd] ]8R3,t9R#]PD!RB/]PFB!R@RA44t9R#)DzEThis module contains related classes and functions for serialization.) annotationsN)partial partialmethod) TYPE_CHECKING AnnotatedAnyCallableLiteralTypeVaroverload)PydanticUndefined core_schema)SerializationInfoSerializerFunctionWrapHandlerWhenUsed) TypeAlias)PydanticUndefinedAnnotation) _decorators_internal_dataclass)GetCoreSchemaHandler)PydanticUserErrorfrozenTcN]tRt^t$RtR]R&]tR]R&RtR]R&R R lt R t R #) PlainSerializeraPlain 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. ```python from typing 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'} ``` Attributes: func: The serializer function. return_type: The return type for the function. If omitted it will be inferred from the type annotation. when_used: Determines when this serializer should be used. Accepts a string with values `'always'`, `'unless-none'`, `'json'`, and `'json-unless-none'`. Defaults to 'always'. zcore_schema.SerializerFunctionfuncr return_typealwaysr when_usedc$V^8dQhRRRRRR/# source_typerhandlerrreturnzcore_schema.CoreSchema)formats"p/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/lib/python3.14/site-packages/pydantic/functional_serializers.py __annotate__PlainSerializer.__annotate__6#   FZ _u c V!V4pVP\JdVPpM;\P!VPVP 4P R7pV\JdRMVPV4p\P!VP\P!VPR4VVPR7VR&V# \dp\P!T4ThRp?ii;i)zGets the Pydantic core schema. Args: source_type: The source type. handler: The `GetCoreSchemaHandler` instance. Returns: The Pydantic core schema. localnsNplainfunctioninfo_arg return_schemar serialization)rr rget_callable_return_typer_get_types_namespacelocals NameErrorrfrom_name_errorgenerate_schemar $plain_serializer_function_ser_schemainspect_annotated_serializerrselfr!r"schemarer2s&&& r&__get_pydantic_core_schema__,PlainSerializer.__get_pydantic_core_schema__6s%   #4 4**K L*BBII#88:AA !,/@ @gF]F]^iFj "-"R"RYY ==diiQ'nn #    L1AA!D!K L:C C;C66C;r$N __name__ __module__ __qualname____firstlineno____doc____annotations__r rrr@__static_attributes__r$r*r&rrs-: )((K("Ix"  r*rcN]tRt^Yt$RtR]R&]tR]R&RtR]R&R R lt R t R #) WrapSerializera*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. ```python from datetime import datetime, timezone from typing import Annotated, Any 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 `handler` 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"}} ''' ``` Attributes: func: The serializer function to be wrapped. return_type: The return type for the function. If omitted it will be inferred from the type annotation. when_used: Determines when this serializer should be used. Accepts a string with values `'always'`, `'unless-none'`, `'json'`, and `'json-unless-none'`. Defaults to 'always'. z"core_schema.WrapSerializerFunctionrrrrrrc$V^8dQhRRRRRR/#rr$)r%s"r&r'WrapSerializer.__annotate__r)r*c V!V4pVP\JdVPpM;\P!VPVP 4P R7pV\JdRMVPV4p\P!VP\P!VPR4VVPR7VR&V# \dp\P!T4ThRp?ii;i)zThis method is used to get the Pydantic core schema of the class. Args: source_type: Source type. handler: Core schema handler. Returns: The generated core schema of the class. r,Nwrapr/r3)rr rr4rr5r6r7rr8r9r #wrap_serializer_function_ser_schemar;rr<s&&& r&r@+WrapSerializer.__get_pydantic_core_schema__s%   #4 4**K L*BBII#88:AA !,/@ @gF]F]^iFj "-"Q"QYY ==diiP'nn #    L1AA!D!K LrBr$NrCr$r*r&rLrLYs.<| -,(K("Ix"  r*rLz!partial[Any] | partialmethod[Any]r_Partialz)core_schema.SerializerFunction | _PartialFieldPlainSerializerz-core_schema.WrapSerializerFunction | _PartialFieldWrapSerializerz*FieldPlainSerializer | FieldWrapSerializerFieldSerializer_FieldPlainSerializerT)bound_FieldWrapSerializerTr.r check_fieldsc4V^8dQhRRRRRRRRRR R R R R /#)r fieldstrfieldsmodeLiteral['wrap']rrrrrZ bool | Noner#z8Callable[[_FieldWrapSerializerT], _FieldWrapSerializerT]r$)r%s"r&r'r'sYCC CC  C  C  CC>Cr*cR#Nr$r\r_rrrZr^s"$$$$*r&field_serializerres @Cr*r_c4V^8dQhRRRRRRRRRR R R R R /#)r r\r]r^r_Literal['plain']rrrrrZrar#z:Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT]r$)r%s"r&r'r'sZEE EE  E  E  EE@Er*cR#rcr$rds"$$$$*r&reres BEr*r.rc4V^8dQhRRRRRRRRRR R R R R /#)r r\r]r^r_Literal['plain', 'wrap']rrrrrZrar#zuCallable[[_FieldWrapSerializerT], _FieldWrapSerializerT] | Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT]r$)r%s"r&r'r'sZSS SS # S  SSSASr*c,aaaaa\V4'g\V\4'd\RRR7hV.SO5o\;QJdRS4F 'dK RM RM !RS44'g\RRR7hR VVVVV3R llpV#) a5Decorator 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. ```python 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(self, courses: set[str]): return sorted(courses) student = StudentModel(courses={'Math', 'Chemistry', 'English'}) print(student.model_dump_json()) #> {"name":"Jane","courses":["Chemistry","English","Math"]} ``` See [the usage documentation](../concepts/serialization.md#serializers) for more information. Four signatures are supported for the decorated serializer: - `(self, value: Any, info: FieldSerializationInfo)` - `(self, value: Any, nxt: SerializerFunctionWrapHandler, info: FieldSerializationInfo)` - `(value: Any, info: SerializationInfo)` - `(value: Any, nxt: SerializerFunctionWrapHandler, info: SerializationInfo)` Args: *fields: The field names the serializer should apply to. mode: 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. return_type: Optional return type for the function, if omitted it will be inferred from the type annotation. when_used: Determines the serializer will be used for serialization. check_fields: Whether to check that the fields actually exist on the model. Raises: PydanticUserError: - If the decorator is used without any arguments (at least one field name must be provided). - If the provided field names are not strings. zThe `@field_serializer` decorator cannot be used without arguments, at least one field must be provided. For example: `@field_serializer('', ...)`.zdecorator-missing-arguments)codec3B"TFp\V\4xK R#5irc) isinstancer]).0r\s& r& #field_serializer..*s:6%z%%%6sFTzThe provided field names to the `@field_serializer` decorator should be strings. For example: `@field_serializer('', '', ...).`zdecorator-invalid-fieldsc V^8dQhRRRR/#)r frVr#(_decorators.PydanticDescriptorProxy[Any]r$)r%s"r&r'&field_serializer..__annotate__1s@@@#K@r*cf<\P!SSSSSR7p\P!W4#))r^r_rrrZ)rFieldSerializerDecoratorInfoPydanticDescriptorProxy)rsdec_inforZr^r_rrs& r&decfield_serializer..dec1s5;;#%  221??r*)callablern classmethodrall)r\r_rrrZr^rzs"ddddj r&rerest*UK88 E.  ^V^F 3:6:333:6: : : Y+  @@ Jr*ModelPlainSerializerWithInfoModelPlainSerializerWithoutInfoz>ModelPlainSerializerWithInfo | ModelPlainSerializerWithoutInfoModelPlainSerializerModelWrapSerializerWithInfoModelWrapSerializerWithoutInfoz {'unit': 'C', 'value': 100} ``` Two signatures are supported for `mode='plain'`, which is the default: - `(self)` - `(self, info: SerializationInfo)` And two other signatures for `mode='wrap'`: - `(self, nxt: SerializerFunctionWrapHandler)` - `(self, nxt: SerializerFunctionWrapHandler, info: SerializationInfo)` See [the usage documentation](../concepts/serialization.md#serializers) for more information. Args: f: The function to be decorated. mode: 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. when_used: Determines when this serializer should be used. return_type: The return type for the function. If omitted it will be inferred from the type annotation. Returns: The decorator function. c V^8dQhRRRR/#)r rsrr#rtr$)r%s"r&r'&model_serializer..__annotate__s@@@#K@r*cb<\P!SSSR7p\P!W4#))r_rr)rModelSerializerDecoratorInforx)rsryr_rrs& r&rzmodel_serializer..decs*;;S^jst221??r*r$)rsr_rrrzs"ddd r&rrls%@@@ y 1v r*AnyTypecJ]tRtRtRtRRltRRlt]PtRt R#) SerializeAsAnyizAnnotation used to mark a type as having duck-typing serialization behavior. See [usage documentation](../concepts/serialization.md#serializing-with-duck-typing) for more details. c V^8dQhRRRR/#)r itemrr#r$)r%s"r&r'SerializeAsAny.__annotate__s 5 5 5 5r*c 0\V\43,#rc)rr)clsrs&&r&__class_getitem__ SerializeAsAny.__class_getitem__sT>#334 4r*c$V^8dQhRRRRRR/#rr$)r%s"r&r'rs$  " -A  # r*c V!V4pTpVR,R8XdVP4pVR,pK)\P!R4VR&V#)type definitionsr>anyr3)copyr simple_ser_schema)r=r!r"r>schema_to_updates&&& r&r@+SerializeAsAny.__get_pydantic_core_schema__sV[)F% "6*m;#3#8#8#: #3H#= 0;0M0Me0T _ -Mr*r$N) rDrErFrGrHrr@object__hash__rJr$r*r&rrs  5 ??r*rr$rc):__conditional_annotations__rH __future__r dataclasses functoolsrrtypingrrrrr r r pydantic_corer r pydantic_core.core_schemarrrtyping_extensionsrr _internalrrannotated_handlersrerrorsr dataclass slots_truerrLrSrIrTrUrVrWrYrerrrrrrrrrrrr)rs@r&rsaK",VVV8``')74% E,77EEBBFBJ E,77EEccFcL=Hi=&Q)Q@%TT?!MOYM0$%=EYZ#$;CVW C  C  C!$C C E! E  E  E!$E ES&- S ) S#S!%Sl/7=Ns=S7TVY7Y.Z )ZN193%*1E#YEQ&f)f4-5s