iF&UdZddlmZddlZddlmZmZddlmZm Z m Z m Z m Z m Z mZddlmZmZddlmZmZmZddlmZd d lmZd d lmZmZd d lmZd d lm Z ej!dSiej"ddiGddZ#ej!dSiej"ddiGddZ$er9dZ%de&d<dZ'de&d< dZ(de&d< dZ)de&d< e de'Z*e de(Z+ed d d d!dTd/Z,ed d d d d0dUd3Z,d4ed5dd0dVd8Z,ere e ee ge fZ-de&d9< e e ge fZ.de&d:< d;Z/de&d<< e e eee ge fZ0de&d=< e e ege fZ1de&d>< d?Z2de&d@< dAZ3de&dB<e dCe/Z4e dDe2Z5edWdFZ6ed5d dGdXdIZ6ed d5d dJdYdLZ6 dZd4d5edJd[dOZ6e dPZ7er e e7d fZ8dSej!dSiej"GdQdRZ8dS)\zEThis module contains related classes and functions for serialization.) annotationsN)partial partialmethod) TYPE_CHECKING AnnotatedAnyCallableLiteralTypeVaroverload)PydanticUndefined core_schema)SerializationInfoSerializerFunctionWrapHandlerWhenUsed) TypeAlias)PydanticUndefinedAnnotation) _decorators_internal_dataclass)GetCoreSchemaHandler)PydanticUserErrorfrozenTcBeZdZUdZded<eZded<dZded<ddZdS)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_used source_typehandlerrreturncore_schema.CoreSchemac||}|jtur|j}n[ tj|j|j}n'#t$r}tj ||d}~wwxYw|turdn| |}tj |jtj |jd||j|d<|S)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!schemarer+s e/var/www/html/crypto-bot/backend/venv/lib/python3.11/site-packages/pydantic/functional_serializers.py__get_pydantic_core_schema__z,PlainSerializer.__get_pydantic_core_schema__6s%%  #4 4 4*KK L*BI#88::A  L L L1A!DD!K L!,/@ @ @gF]F]^iFjFj "-"RY =diQQ'n # # #   2A A: A55A:Nr rr!rr"r# __name__ __module__ __qualname____doc____annotations__r rrr:r9rrsd:)((((K(((("I""""      rDrcBeZdZUdZded<eZded<dZded<ddZdS)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, 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.WrapSerializerFunctionrrrrrrr r!rr"r#c||}|jtur|j}n[ tj|j|j}n'#t$r}tj ||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. r%Nwrapr(r,)rr rr-rr.r/r0rr1r2r#wrap_serializer_function_ser_schemar4rr5s r9r:z+WrapSerializer.__get_pydantic_core_schema__s%%  #4 4 4*KK L*BI#88::A  L L L1A!DD!K L!,/@ @ @gF]F]^iFjFj "-"QY =diPP'n # # #   r;Nr<r=rCrDr9rFrFYse<<|-,,,(K(((("I""""      rDrFz!partial[Any] | partialmethod[Any]r_Partialz)core_schema.SerializerFunction | _PartialFieldPlainSerializerz-core_schema.WrapSerializerFunction | _PartialFieldWrapSerializerz*FieldPlainSerializer | FieldWrapSerializerFieldSerializer_FieldPlainSerializerT)bound_FieldWrapSerializerT.)rr check_fieldsfieldstrfieldsmodeLiteral['wrap']rrrrrQ bool | Noner"8Callable[[_FieldWrapSerializerT], _FieldWrapSerializerT]cdSNrCrRrUrrrQrTs r9field_serializerr\s @CsrD)rUrrrQLiteral['plain']:Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT]cdSrZrCr[s r9r\r\s BErDr'rLiteral['plain', 'wrap']uCallable[[_FieldWrapSerializerT], _FieldWrapSerializerT] | Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT]ct|st|trtdd|gRt dDstddd fd }|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|tVdSrZ) isinstancerS).0rRs r9 z#field_serializer..*s,::%z%%%::::::rDzThe provided field names to the `@field_serializer` decorator should be strings. For example: `@field_serializer('', '', ...).`zdecorator-invalid-fieldsfrMr"(_decorators.PydanticDescriptorProxy[Any]c`tj}tj||S)N)rTrUrrrQ)rFieldSerializerDecoratorInfoPydanticDescriptorProxy)rhdec_inforQrTrUrrs r9deczfield_serializer..dec1s>;#%    21h???rD)rhrMr"ri)callablere classmethodrall)rRrUrrrQrTrns ````` r9r\r\st *UK88  E.    ^V^^F ::6::: : :  Y+    @@@@@@@@@@ JrDModelPlainSerializerWithInfoModelPlainSerializerWithoutInfoz>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. rhrxr"ric\tj}tj||S)N)rUrr)rModelSerializerDecoratorInforl)rhrmrUrrs r9rnzmodel_serializer..decs/;S^jsttt21h???rDN)rhrxr"rirC)rhrUrrrns ``` r9r|r|lsO@@@@@@@@@ y s1vv rDAnyTypec0eZdZdZd dZd d ZejZd S)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. itemrr"c8t|tfSrZ)rr)clsrs r9__class_getitem__z SerializeAsAny.__class_getitem__sT>#3#334 4rDr r!rr#c||}|}|ddkr(|}|d}|ddk(tjd|d<|S)Ntype definitionsr7anyr,)copyrsimple_ser_schema)r6r r!r7schema_to_updates r9r:z+SerializeAsAny.__get_pydantic_core_schema__suW[))F% "6*m;;#3#8#8#:#: #3H#= #6*m;;1<0Me0T0T _ -MrDN)rrr"rr<)r>r?r@rArr:object__hash__rCrDr9rrsI   5 5 5 5    ?rDrrC)rRrSrTrSrUrVrrrrrQrWr"rX)rRrSrTrSrUr]rrrrrQrWr"r^)rRrSrTrSrUr`rrrrrQrWr"ra)rhryr"ry)rUrVrrrrr"r})rUr]rrrrr"rrZ) rhrrUr`rrrrr"r)9rA __future__r dataclasses functoolsrrtypingrrrr r r r pydantic_corer rpydantic_core.core_schemarrrtyping_extensionsrr _internalrrannotated_handlersrerrorsr dataclass slots_truerrFrJrBrKrLrMrNrPr\rrrsrtrurvrwrxryrzr|rrrCrDr9rskKKK"""""",,,,,,,,VVVVVVVVVVVVVVVVVV88888888``````````''''''))))))77777777444444%%%%%%EE,7EEEEEBBBBBBBFEBJEE,7EEEEEcccccccFEcL X=H====&QQQQQ@%TTTTT?!MOMMMM0$W%=EYZZZ#G$;CVWWW  #CCCCC C ! #EEEEE E&-(" $SSSSSSlX/7=Ns=S7TVY7Y.Z ZZZZN193%*1E#EEEEQ&fffff4-5s