]f9zUdZddlmZddlZddlmZddlmZmZm Z m Z m Z m Z ddl mZmZddl mZddlmZmZmZd d lmZd d lmZmZd d lmZejd>iejd diGddZejd>iejd diGddZer_e e eeefe!eefeefZ"de#d<e ej$e"fZ%e ej&e"fZ'e de%Z(e de'Z)e ddddd?d%Z*e ddddd@d(Z*e dddddAd+Z*d,ed-dd.dBd1Z*e d2e defZ+e dCd4Z,e dd-dd5dDd7Z, dEd,d-ed5dFd:Z,e d;Z-er ee-dfZ.dSejd>iejGd<d=Z.dS)GzEThis module contains related classes and functions for serialization.) annotationsN) partialmethod) TYPE_CHECKINGAnyCallableTypeVarUnionoverload)PydanticUndefined core_schema)r ) AnnotatedLiteral TypeAlias)PydanticUndefinedAnnotation) _decorators_internal_dataclass)GetCoreSchemaHandlerfrozenTcBeZdZUdZded<eZded<dZded<ddZdS)PlainSerializeraCPlain 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 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'} ``` 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_typealways 4+W-I-I-K-KKK H H H-=a@@a G H +/@ @ @gF]F]^iFjFj "-"RY =diQQ'n # # #   2A A$ AA$Nrrrrrr __name__ __module__ __qualname____doc____annotations__r rrr4r3rrsd>)((((K((((NVIVVVVr>rcBeZdZUdZded<eZded<dZded<ddZdS)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 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"}} ''' ``` 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.WrapSerializerFunctionrrrrrrrrrrr c||} tj|j|j|}n'#t $r}t j||d}~wwxYw|turdn| |}tj |jtj |jd||j |d<|S)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. Nwrapr#r')rr(rrr)r*rr+r r,r #wrap_serializer_function_ser_schemar.rr/s r3r4z+WrapSerializer.__get_pydantic_core_schema__s%% H%> 4+W-I-I-K-KKK H H H-=a@@a G H +/@ @ @gF]F]^iFjFj "-"QY =diPP'n # # #   r5Nr6r7r=r>r3r@r@Rse==~-,,,(K((((NVIVVVVr>r@r_PartialClsOrStaticMethod_PlainSerializeMethodType)bound_WrapSerializeMethodType.)rr check_fieldsfieldstrfieldsrrrrrH bool | Noner@Callable[[_PlainSerializeMethodType], _PlainSerializeMethodType]cdSNr=)rIrrrHrKs r3field_serializerrPs HKsr>modeLiteral['plain']cdSrOr=rIrQrrrHrKs r3rPrPs HKsr>Literal['wrap']>Callable[[_WrapSerializeMethodType], _WrapSerializeMethodType]cdSrOr=rTs r3rPrPs FISr>r"r)rQrrrHLiteral['plain', 'wrap']Callable[[Any], Any]c$dfd }|S)aDecorator 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 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](../concepts/serialization.md#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)` Args: fields: Which field(s) the method should be called on. 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. Returns: The decorator function. fHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]r(_decorators.PydanticDescriptorProxy[Any]c`tj}tj||S)N)rKrQrrrH)rFieldSerializerDecoratorInfoPydanticDescriptorProxy)r[dec_inforHrKrQrrs r3deczfield_serializer..decs@;#%    21h???r>)r[r\rr]r=)rQrrrHrKrbs````` r3rPrPsKj @ @ @ @ @ @ @ @ @ @ Jr>FuncType__fcdSrOr=)rds r3model_serializerrf$s14r>rQrrCallable[[FuncType], FuncType]cdSrOr=rgs r3rfrf(s &)Sr>r[Callable[..., Any] | Nonec6dfd }||S||S)aDecorator 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. ```python 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](../concepts/serialization.md#custom-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. r[Callable[..., Any]rr]c\tj}tj||S)N)rQrr)rModelSerializerDecoratorInfor`)r[rarQrrs r3rbzmodel_serializer..deccs/;S^jsttt21h???r>N)r[rlrr]r=)r[rQrrrbs ``` r3rfrf1sOd@@@@@@@@ y s1vv r>AnyTypec,eZdZd dZd d ZejZd S) SerializeAsAnyitemrrc8t|tfSrO)r rq)clsrrs r3__class_getitem__z SerializeAsAny.__class_getitem__{sT>#3#334 4r>rrrr c||}|}|ddkr(|}|d}|ddk(tjdtj|d<|S)Ntype definitionsr1c||SrOr=)xhs r3z=SerializeAsAny.__get_pydantic_core_schema__..sQQqTTr>)r1r')copyr rC any_schema)r0rrr1schema_to_updates r3r4z+SerializeAsAny.__get_pydantic_core_schema__~sW[))F% "6*m;;#3#8#8#:#: #3H#= #6*m;;1<0_!!+*@*B*B111 _ -Mr>N)rrrrrr6)r8r9r:rur4object__hash__r=r>r3rqrqys? 5 5 5 5    ?r>rqr=) rIrJrKrJrrrrrHrLrrM)rIrJrKrJrQrRrrrrrHrLrrM)rIrJrKrJrQrUrrrrrHrLrrV) rKrJrQrXrrrrrHrLrrY)rdrcrrc)rQrXrrrrrrhrO) r[rjrQrXrrrrrrY)/r; __future__r dataclasses functoolsrtypingrrrrr r pydantic_corer r _core_schematyping_extensionsr rrr _internalrrannotated_handlersr dataclass slots_truerr@ classmethod staticmethodrDr<SerializerFunction_PlainSerializationFunctionWrapSerializerFunction_WrapSerializationFunctionrErGrPrcrfrorqr=r>r3rsVKKK""""""######IIIIIIIIIIIIIIII88888888555555;;;;;;;;;;))))))77777777444444EE,7EEEEE<<<<<<<FE<~EE,7EEEEE\\\\\\\FE\~e+0S#s]1K\Z]_bZbMcersvew1w+xxxxx"' (GIb(b"c!&|'JLe'e!f '(CKf g g g&w'AIcddd NQ # KKKKK K NQ #KKKKK K NQ #IIIII I&-(NV $ AAAAAAH 7:Xc3h%7 8 8 8 444 4 &)NV ))))) )$(9&-NV( 999999x ')  #w|,N[<<0;<<#######=<###r>