관리-도구
편집 파일: functional_serializers.cpython-38.pyc
U /?�f9 � @ s� U d Z ddlmZ ddlZddlmZ ddlmZmZm Z m Z m Z m Z ddl mZmZ ddl mZ ddlmZmZmZ d d lmZ d d lmZmZ d d lmZ ej f ej d di��G dd� d��Z ej f ej d di��G dd� d��Z e�rLe e eeef e!eef ee f Z"de#d< e ej$e"f Z%e ej&e"f Z'e de%d�Z(e de'd�Z)e dddd�dddd d d d �d d!��Z*e dddd�ddd"dd d d d#�d$d!��Z*e dddd�ddd%dd d d&d#�d'd!��Z*d(ed)dd*�dd+dd d d,d-�d.d!�Z*e d/e def d�Z+e d/d/d0�d1d2��Z,e dd)dd3�d+d dd4d5�d6d2��Z,d=d(d)ed3�d7d+d dd,d8�d9d2�Z,e d:�Z-e�rnee-df Z.n ej f ej �G d;d<� d<��Z.dS )>zEThis module contains related classes and functions for serialization.� )� annotationsN)� partialmethod)� TYPE_CHECKING�Any�Callable�TypeVar�Union�overload)�PydanticUndefined� core_schema)r )� Annotated�Literal� TypeAlias� )�PydanticUndefinedAnnotation)� _decorators�_internal_dataclass)�GetCoreSchemaHandler�frozenTc @ sD e Zd ZU dZded< eZded< dZded< dd d d �d d �ZdS )�PlainSerializeraC Plain 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'. z core_schema.SerializerFunction�funcr � return_type�always�>Literal[('always', 'unless-none', 'json', 'json-unless-none')]� when_usedr �core_schema.CoreSchema�� source_type�handler�returnc C s� ||�}zt �| j| j|�� �}W n. tk rP } zt�|�|�W 5 d}~X Y nX |tkr^dn|� |�}t j | jt � | jd�|| j d�|d< |S )z�Gets the Pydantic core schema. Args: source_type: The source type. handler: The `GetCoreSchemaHandler` instance. Returns: The Pydantic core schema. N�plain��functionZinfo_arg� return_schemar � serialization)r �get_function_return_typer r �_get_types_namespace� NameErrorr �from_name_errorr �generate_schemar Z$plain_serializer_function_ser_schema� inspect_annotated_serializerr ��selfr r �schemar �er# � r/ �M/opt/hc_python/lib/python3.8/site-packages/pydantic/functional_serializers.py� __get_pydantic_core_schema__7 s" � � z,PlainSerializer.__get_pydantic_core_schema__N� �__name__� __module__� __qualname__�__doc__�__annotations__r r r r1 r/ r/ r/ r0 r s r c @ sD e Zd ZU dZded< 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 `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.WrapSerializerFunctionr r r r r r r r r c C s� ||�}zt �| j| j|�� �}W n. tk rP } zt�|�|�W 5 d}~X Y nX |tkr^dn|� |�}t j | jt � | jd�|| j d�|d< |S )z�This 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. N�wrapr! r$ )r r% r r r& r' r r( r r) r �#wrap_serializer_function_ser_schemar* r r+ r/ r/ r0 r1 � s" � � z+WrapSerializer.__get_pydantic_core_schema__Nr2 r/ r/ r/ r0 r8 R s ? r8 r �_PartialClsOrStaticMethod�_PlainSerializeMethodType)�bound�_WrapSerializeMethodType.)r r � check_fields�strr r z bool | Nonez@Callable[[_PlainSerializeMethodType], _PlainSerializeMethodType])�field�fieldsr r r? r c G s d S �Nr/ )rA r r r? rB r/ r/ r0 �field_serializer� s rD zLiteral['plain'])rA rB �moder r r? r c G s d S rC r/ �rA rE r r r? rB r/ r/ r0 rD � s zLiteral['wrap']z>Callable[[_WrapSerializeMethodType], _WrapSerializeMethodType]c G s d S rC r/ rF r/ r/ r0 rD � s r r )rE r r r? zLiteral[('plain', 'wrap')]zCallable[[Any], Any])rB rE r r r? r c s ddd�� ����fdd� }|S )a Decorator 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. zHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]�(_decorators.PydanticDescriptorProxy[Any]��fr c s t j����� d�}t �| |�S )N)rB rE r r r? )r Z FieldSerializerDecoratorInfo�PydanticDescriptorProxy�rI Zdec_info�r? rB rE r r r/ r0 �dec s �z field_serializer.<locals>.decr/ )rE r r r? rB rM r/ rL r0 rD � s 5 �FuncType)�__fr c C s d S rC r/ )rO r/ r/ r0 �model_serializer$ s rP �rE r r z Callable[[FuncType], FuncType])rE r r r c C s d S rC r/ rQ r/ r/ r0 rP ( s zCallable[..., Any] | None)rI rE r r r c s0 ddd�� ��fdd� }| dkr$|S || �S dS )a� Decorator 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. zCallable[..., Any]rG rH c s t j� ��d�}t �| |�S )N�rE r r )r Z ModelSerializerDecoratorInforJ rK rR r/ r0 rM c s z model_serializer.<locals>.decNr/ )rI rE r r rM r/ rR r0 rP 1 s 2�AnyTypec @ s4 e Zd Zddd�dd�Zdddd�dd �ZejZd S ) �SerializeAsAnyr )�itemr c C s t |t� f S rC )r rT )�clsrU r/ r/ r0 �__class_getitem__{ s z SerializeAsAny.__class_getitem__r r r c C sH ||�}|}|d dkr*|� � }|d }q tjdd� t�� d�|d< |S )N�typeZ definitionsr- c S s || �S rC r/ )�x�hr/ r/ r0 �<lambda>� � z=SerializeAsAny.__get_pydantic_core_schema__.<locals>.<lambda>)r- r$ )�copyr r: Z any_schema)r, r r r- Zschema_to_updater/ r/ r0 r1 ~ s � z+SerializeAsAny.__get_pydantic_core_schema__N)r3 r4 r5 rW r1 �object�__hash__r/ r/ r/ r0 rT y s rT )N)/r6 � __future__r � dataclasses� functoolsr �typingr r r r r r Z pydantic_corer r Z _core_schema�typing_extensionsr r r � r � _internalr r Zannotated_handlersr � dataclassZ slots_truer r8 � classmethod� staticmethodr; r7 ZSerializerFunctionZ_PlainSerializationFunctionZWrapSerializerFunctionZ_WrapSerializationFunctionr< r> rD rN rP rS rT r/ r/ r/ r0 �<module> sx ?_, � � � � D� ��<