a _gmB @sUdZddlmZddlZddlmZmZddlmZm Z m Z m Z m Z ddl mZmZddlmZmZmZddlmZmZmZd d lmZd d lmZmZd d lmZejfiej d diGdddZ!ejfiej d diGdddZ"erDdZ#de$d<dZ%de$d<dZ&de$d<dZ'de$d<e de%dZ(e de&dZ)e dddd d!d!d"d#d$d%d&d'd(d)Z*e ddddd*d!d!d+d#d$d%d,d'd-d)Z*d.ed/dd*d!d0d#d$d%d1d2d3d)Z*er\e e ege fZ+de$d4<e e ge fZ,de$d5<d6Z-de$d7<e e eege fZ.de$d8<e e ege fZ/de$d9<d:Z0de$d;<de-dZ2e d?e0dZ3e d>d>d@dAdBZ4e d/ddCd"d$d#dDdEdFdBZ4e dd/ddGd+d$d#dHdEdIdBZ4dQd.d/edGdJd0d$d#dKdLdMdBZ4e dNZ5eree5dfZ6n ejfiej GdOdPdPZ6dS)RzEThis module contains related classes and functions for serialization.) annotationsN)partial partialmethod) TYPE_CHECKINGAnyCallableTypeVaroverload)PydanticUndefined core_schema)SerializationInfoSerializerFunctionWrapHandlerWhenUsed) AnnotatedLiteral TypeAlias)PydanticUndefinedAnnotation) _decorators_internal_dataclass)GetCoreSchemaHandlerfrozenTc@sDeZdZUdZded<eZded<dZded<dd d d d d ZdS)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_typealwaysr when_usedrcore_schema.CoreSchema source_typehandlerreturnc Cs||}ztj|j|j|jd}Wn0tyV}zt||WYd}~n d}~00|t urddn| |}t j |jt |jd||jd|d<|S)zGets the Pydantic core schema. Args: source_type: The source type. handler: The `GetCoreSchemaHandler` instance. Returns: The Pydantic core schema. localnsNplainfunctionZinfo_arg return_schemar serialization)rget_function_return_typerr_get_types_namespacelocals NameErrorrfrom_name_errorr generate_schemar Z$plain_serializer_function_ser_schemainspect_annotated_serializerr)selfrr schemarer'r3m/var/www/html/cobodadashboardai.evdpl.com/venv/lib/python3.9/site-packages/pydantic/functional_serializers.py__get_pydantic_core_schema__7s"  "  z,PlainSerializer.__get_pydantic_core_schema__N __name__ __module__ __qualname____doc____annotations__r rrr5r3r3r3r4rs   rc@sDeZdZUdZded<eZded<dZded<dd d d d d ZdS)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 `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.WrapSerializerFunctionrrrrrrrrrc Cs||}|\}}ztj|j|j|jd}Wn0tyb}zt||WYd}~n d}~00|t urpdn| |}t j |jt |jd||jd|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. r"Nwrapr%r()r*rr)rrr+r,rr-r r.r #wrap_serializer_function_ser_schemar/r) r0rr r1globalnsr#rr2r'r3r3r4r5s$   "  z+WrapSerializer.__get_pydantic_core_schema__Nr6r3r3r3r4r<Ws @  r<z!partial[Any] | partialmethod[Any]r_Partialz)core_schema.SerializerFunction | _PartialFieldPlainSerializerz-core_schema.WrapSerializerFunction | _PartialFieldWrapSerializerz*FieldPlainSerializer | FieldWrapSerializerFieldSerializer_FieldPlainSerializerT)bound_FieldWrapSerializerT.)rr check_fieldsstrzLiteral['wrap']rrz bool | Nonez8Callable[[_FieldWrapSerializerT], _FieldWrapSerializerT])fieldfieldsmoderrrGr!cGsdSNr3rIrKrrrGrJr3r3r4field_serializers rN)rKrrrGzLiteral['plain']z:Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT]cGsdSrLr3rMr3r3r4rNs r$rzLiteral['plain', 'wrap']zuCallable[[_FieldWrapSerializerT], _FieldWrapSerializerT] | Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT])rJrKrrrGr!cs dddfdd }|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(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 [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. rC(_decorators.PydanticDescriptorProxy[Any]fr!cs tjd}t||S)N)rJrKrrrG)rZFieldSerializerDecoratorInfoPydanticDescriptorProxyrQZdec_inforGrJrKrrr3r4decszfield_serializer..decr3)rKrrrGrJrUr3rTr4rNs8 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 [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\rOrPcstjd}t||S)NrKrr)rZModelSerializerDecoratorInforRrSrar3r4rUszmodel_serializer..decNr3)rQrKrrrUr3rar4r_Ys@AnyTypec@s4eZdZdddddZdddddd ZejZd S) SerializeAsAnyr)itemr!cCst|tfSrL)rrc)clsrdr3r3r4__class_getitem__sz SerializeAsAny.__class_getitem__rrrcCsH||}|}|ddkr*|}|d}q tjddtd|d<|S)NtypeZ definitionsr1cSs||SrLr3)xhr3r3r4z=SerializeAsAny.__get_pydantic_core_schema__..)r1r()copyr r>Z any_schema)r0rr r1Zschema_to_updater3r3r4r5s   z+SerializeAsAny.__get_pydantic_core_schema__N)r7r8r9rfr5object__hash__r3r3r3r4rcs rc)N)7r: __future__r dataclasses functoolsrrtypingrrrrr Z pydantic_corer r Zpydantic_core.core_schemar r rZtyping_extensionsrrrr _internalrrZannotated_handlersr dataclassZ slots_truerr<r@r;rArBrCrDrFrNrVrWrXrYrZr[r\r]r^r_rbrcr3r3r3r4s   Df        E      J