oPj FUdZddlmZddlZddlmZddlmZmZddl m Z m Z m Z m Z mZmZmZddlmZmZddlmZmZmZdd lmZd d lmZd d lmZd d lmZd dl m!Z!ejDddGddZ#ejDddGddZ$e r3dZ%de&d<dZ'de&d< dZ(de&d< dZ)de&d< ede'Z*ed e(Z+ed!d!d!d" d?d#Z,ed!d!d!d!d$ d@d%Z,d&ed'dd$ dAd(Z,e rmee ee ge fZ-de&d)< ee ge fZ.de&d*< d+Z/de&d,< ee eee ge fZ0de&d-< ee ege fZ1de&d.< d/Z2de&d0< d1Z3de&d2<ed3e/Z4ed4e2Z5edBd5Z6ed'd!d6 dCd7Z6ed!d'd!d8 dDd9Z6 dEd&d'ed8 dFd:Z6ed;Z7e re e7d!fZ8yejDd<Gd=d>Z8y)GzEThis module contains related classes and functions for serialization.) annotationsN)Callable)partial partialmethod) TYPE_CHECKING AnnotatedAnyLiteral TypeAliasTypeVaroverload)PydanticUndefined core_schema)SerializationInfoSerializerFunctionWrapHandlerWhenUsed)TypeForm)PydanticUndefinedAnnotation) _decorators)GetCoreSchemaHandler)PydanticUserErrorT)slotsfrozenc@eZdZUdZded<eZded<dZded<d d Zy ) 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.SerializerFunctionfunc TypeForm[Any] return_typealwaysr when_usedc||}|jtur |j}n: tj|j|j j }|turdn|j|}tj|jtj|jd||j|d<|S#t$r}tj||d}~wwxYw)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)rrrget_callable_return_typer_get_types_namespacelocals NameErrorrfrom_name_errorgenerate_schemar$plain_serializer_function_ser_schemainspect_annotated_serializerr!self source_typehandlerschemarer)s d/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/pydantic/functional_serializers.py__get_pydantic_core_schema__z,PlainSerializer.__get_pydantic_core_schema__7s%   #4 4**K L*BBII#88:AA !,/@ @gF]F]^iFj "-"R"RYY ==diiQ'nn #    L1AA!D!K L9C C1C,,C1Nr5r r6rreturnzcore_schema.CoreSchema __name__ __module__ __qualname____doc____annotations__rrr!r:r9rrs(: )(!2K2"Ix" rErc@eZdZUdZded<eZded<dZded<d d Zy ) WrapSerializeraWrap 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, SerializationInfo, SerializerFunctionWrapHandler, WrapSerializer, ) def convert_to_utc( value: Any, handler: SerializerFunctionWrapHandler, info: SerializationInfo ): # Note that `handler` can actually help serialize the `value` for # further custom serialization in case it's a subclass. serialized = handler(value) if info.mode == 'json': return datetime.fromisoformat(serialized).astimezone(timezone.utc) else: return serialized.astimezone(timezone.utc) UTCDatetime = Annotated[datetime, WrapSerializer(convert_to_utc)] class EventModel(BaseModel): event_datetime: UTCDatetime event = EventModel(event_datetime='2024-01-01T07:00:00-08:00') print(event.model_dump()) ''' { 'event_datetime': datetime.datetime( 2024, 1, 1, 15, 0, tzinfo=datetime.timezone.utc ) } ''' print(event.model_dump_json()) #> {"event_datetime":"2024-01-01T15: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.WrapSerializerFunctionrrrr rr!c||}|jtur |j}n: tj|j|j j }|turdn|j|}tj|jtj|jd||j|d<|S#t$r}tj||d}~wwxYw)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*)rrrr+rr,r-r.rr/r0r#wrap_serializer_function_ser_schemar2r!r3s r9r:z+WrapSerializer.__get_pydantic_core_schema__s%   #4 4**K L*BBII#88:AA !,/@ @gF]F]^iFj "-"Q"QYY ==diiP'nn #    L1AA!D!K Lr;Nr<r>rDrEr9rGrGZs)3j -,!2K2"Ix" rErGz!partial[Any] | partialmethod[Any]r _Partialz)core_schema.SerializerFunction | _PartialFieldPlainSerializerz-core_schema.WrapSerializerFunction | _PartialFieldWrapSerializerz*FieldPlainSerializer | FieldWrapSerializerFieldSerializer_FieldPlainSerializerT)bound_FieldWrapSerializerT.)rr! check_fieldscyNrDfieldmoderr!rRfieldss r9field_serializerrYs @CrE)rWrr!rRcyrTrDrUs r9rYrYs BErEr%r ct|st|tr tdd|gt dDs tdddfd }|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 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)codec3<K|]}t|tywrT) isinstancestr).0rVs r9 z#field_serializer..!s:%z%%:szThe provided field names to the `@field_serializer` decorator should be strings. For example: `@field_serializer('', '', ...).`zdecorator-invalid-fieldscdtj}tj||S)N)rXrWrr!rR)rFieldSerializerDecoratorInfoPydanticDescriptorProxy)fdec_inforRrXrWrr!s r9deczfield_serializer..dec(s7;;#%  221h??rE)rerNr=(_decorators.PydanticDescriptorProxy[Any])callabler^ classmethodrall)rVrWrr!rRrXrgs ````` r9rYrYspr*UK8 E.  ^V^F :6: : Y+  @@ JrEModelPlainSerializerWithInfoModelPlainSerializerWithoutInfoz>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`tj}tj||S)N)rWrr!)rModelSerializerDecoratorInford)rerfrWrr!s r9rgzmodel_serializer..decs,;;S^jst221h??rE)rerrr=rhrD)rerWr!rrgs ``` r9rvrvcs@@ y 1v rEAnyType)rcDeZdZdZddZ ddZejZy)SerializeAsAnyzAnnotation 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(t|tfSrT)rr)clsitems r9__class_getitem__z SerializeAsAny.__class_getitem__sT>#334 4rEc||}|}|ddk(r|j}|d}|ddk(rtjd|d<|S)Ntype definitionsr7anyr*)copyrsimple_ser_schema)r4r5r6r7schema_to_updates r9r:z+SerializeAsAny.__get_pydantic_core_schema__sg[)F% "6*m;#3#8#8#: #3H#= #6*m;1<0M0Me0T _ -MrEN)rr r=r r<)r?r@rArBrr:object__hash__rDrEr9rrs4  5 " -A  # ??rEr)rVr_rXr_rWLiteral['wrap']rrr!rrR bool | Noner=z8Callable[[_FieldWrapSerializerT], _FieldWrapSerializerT])rVr_rXr_rWLiteral['plain']rrr!rrRrr=z:Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT])rVr_rXr_rWLiteral['plain', 'wrap']rrr!rrRrr=zuCallable[[_FieldWrapSerializerT], _FieldWrapSerializerT] | Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT])rersr=rs)rWrr!rrrr=z8Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT])rWrr!rrrr=z:Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT]rT) rez5_ModelPlainSerializerT | _ModelWrapSerializerT | NonerWrr!rrrr=z_ModelPlainSerializerT | Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT] | Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT])9rB __future__r dataclassescollections.abcr functoolsrrtypingrrr r r r r pydantic_corerrpydantic_core.core_schemarrrtyping_extensionsrr _internalrannotated_handlersrerrorsr dataclassrrGrKrCrLrMrNrOrQrYrlrmrnrorprqrrrsrtrvr}rrDrEr9rs*K"$,WWW8``&)"4%T$/BB0BJT$/ZZ0Zz=Hi=&Q)Q@%TT?!MOYM0$%=EYZ#$;CVW "% #C CC  C  C  CC>C C !!$ #E EE  E  E  EE@E E&-!2" $R RR # R  R  RRARj/7=Ns=S7TVY7Y.Z )ZN193%*1E#YEQ&f)f4-5s