OwlCyberSecurity - MANAGER
Edit File: functional_serializers.cpython-312.pyc
� I��g9 � � � 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 ej8 d)i ej: �d di�� G d� d� � Z ej8 d)i ej: �d di�� G d� d� � Z erQe e eeef e!eef ee f Z"de#d< e ejH e"f Z%e ejL e"f Z' e de%�� Z( e de'�� Z)e dddd� d*d�� Z*e dddd� d+d�� Z*e dddd� d,d �� Z*d ed dd � d-d �Z* e d!e def �� Z+e d.d"�� Z,e dd dd#� d/d$�� Z, d0d d ed#� d1d%�Z, e d&� Z-eree-df Z.y ej8 d)i ej: �� G d'� d(� � Z.y)2zEThis 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 �@ � e Zd ZU dZded< eZded< dZded< d d �Zy ) �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_usedc � � ||� } t j | j | j |j � � }|t u rdn|j |� }t j | j t j | j d� || j �� |d< |S # t $ r}t j |� |�d}~ww xY w)z�Gets the Pydantic core schema. Args: source_type: The source type. handler: The `GetCoreSchemaHandler` instance. Returns: The Pydantic core schema. N�plain��function�info_arg� return_schemar � serialization)r �get_function_return_typer r �_get_types_namespace� NameErrorr �from_name_errorr �generate_schemar �$plain_serializer_function_ser_schema� inspect_annotated_serializerr ��self� source_type�handler�schemar �er" s �N/opt/hc_python/lib/python3.12/site-packages/pydantic/functional_serializers.py� __get_pydantic_core_schema__z,PlainSerializer.__get_pydantic_core_schema__7 s� � � ��%�� H�%�>�>�� � �4�+�+�W�-I�-I�-K��K� !,�/@� @��g�F]�F]�^i�Fj� �"-�"R�"R��Y�Y� �=�=�d�i�i��Q�'��n�n� # ��� � � �� � H�-�=�=�a�@�a� G�� H�� �9B. �. C�7C � CN�r- r r. r �returnzcore_schema.CoreSchema� �__name__� __module__� __qualname__�__doc__�__annotations__r r r r2 � � r1 r r s) � � �> )�(�(�K��(�NV�I�K�V�r= r c �@ � e Zd ZU dZded< eZded< dZded< d d �Zy ) �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 c � � ||� } t j | j | j |j � � }|t u rdn|j |� }t j | j t j | j d� || j �� |d< |S # t $ r}t j |� |�d}~ww xY w)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+ s r1 r2 z+WrapSerializer.__get_pydantic_core_schema__� s� � � ��%�� H�%�>�>�� � �4�+�+�W�-I�-I�-K��K� !,�/@� @��g�F]�F]�^i�Fj� �"-�"Q�"Q��Y�Y� �=�=�d�i�i��P�'��n�n� # ��� � � �� � H�-�=�=�a�@�a� G�� H�r3 Nr4 r6 r< r= r1 r? r? R s* � �=�~ -�,�(�K��(�NV�I�K�V�r= r? r �_PartialClsOrStaticMethod�_PlainSerializeMethodType)�bound�_WrapSerializeMethodType.)r r � check_fieldsc � � y �Nr< )�fieldr r rG �fieldss r1 �field_serializerrL � s � � HKr= c � � y rI r< �rJ �moder r rG rK s r1 rL rL � s � � HKr= c � � y rI r< rN s r1 rL rL � s � � FIr= r r )rO r r rG c �, � ����� d��� ��fd� }|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. c �d �� t j ������� }t j | |� S )N)rK rO r r rG )r � FieldSerializerDecoratorInfo�PydanticDescriptorProxy)�f�dec_inforG rK rO r r s �����r1 �decz field_serializer.<locals>.dec s9 �� � �;�;���#� �%� �� �2�2�1�h�?�?r= )rU zHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]r5 �(_decorators.PydanticDescriptorProxy[Any]r< )rO r r rG rK rW s ````` r1 rL rL � s) �� �j @� S� @� 1� @� @� �Jr= �FuncTypec � � y rI r< )�__fs r1 �model_serializerr\ $ s � �14r= �rO r r c � � y rI r< r] s r1 r\ r\ ( s � � &)r= c �0 ���� d���fd� }| �|S || � S )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. c �` �� t j ����� }t j | |� S )N)rO r r )r � ModelSerializerDecoratorInforT )rU rV rO r r s ���r1 rW z model_serializer.<locals>.decc s, �� � �;�;��S^�js�t���2�2�1�h�?�?r= )rU zCallable[..., Any]r5 rX r< )rU rO r r rW s ``` r1 r\ r\ 1 s �� �d@� �y�� ��1�v� r= �AnyTypec �@ � e Zd Zdd�Z dd�Zej Zy)�SerializeAsAnyc �( � t |t � f S rI )r rd )�cls�items r1 �__class_getitem__z SerializeAsAny.__class_getitem__{ s � � �T�>�#3� 3�4� 4r= c � � ||� }|}|d dk( r |j � }|d }|d dk( r� t j d� t j � �� |d< |S )N�type� definitionsr/ c � � || � S rI r< )�x�hs r1 �<lambda>z=SerializeAsAny.__get_pydantic_core_schema__.<locals>.<lambda>� s � �Q�q�Tr= )r/ r# )�copyr rB � any_schema)r, r- r. r/ �schema_to_updates r1 r2 z+SerializeAsAny.__get_pydantic_core_schema__~ sw � � �[�)�F� %� �"�6�*�m�;�#3�#8�#8�#:� �#3�H�#=� � #�6�*�m�;� 1<�0_�0_�!�+�*@�*@�*B�1� �_� -� �Mr= N)rg r r5 r r4 )r7 r8 r9 rh r2 �object�__hash__r< r= r1 rd rd y s/ � � 5� � "� �-A� � #� � �?�?�r= rd r< ) rJ �strrK ru r r r r rG � bool | Noner5 �@Callable[[_PlainSerializeMethodType], _PlainSerializeMethodType])rJ ru rK ru rO zLiteral['plain']r r r r rG rv r5 rw )rJ ru rK ru rO zLiteral['wrap']r r r r rG rv r5 z>Callable[[_WrapSerializeMethodType], _WrapSerializeMethodType]) rK ru rO �Literal['plain', 'wrap']r r r r rG rv r5 �Callable[[Any], Any])r[ rY r5 rY )rO rx r r r r r5 z Callable[[FuncType], FuncType]rI ) rU zCallable[..., Any] | NonerO rx r r r r r5 ry )/r: � __future__r � dataclasses� functoolsr �typingr r r r r r � pydantic_corer r � _core_schema�typing_extensionsr r r � r � _internalr r �annotated_handlersr � dataclass� slots_truer r? � classmethod� staticmethodrC r; �SerializerFunction�_PlainSerializationFunction�WrapSerializerFunction�_WrapSerializationFunctionrD rF rL rY r\ rb rd r< r= r1 �<module>r� s� �� K� "� � #� I� I� 8� 5� ;� ;� )� 7� 4� ����E�,�7�7�E��E�<� <� F�<�~ ����E�,�7�7�E��E�\� \� F�\�~ �+0��S�#�s�]�1K�\�Z]�_b�Zb�Mc�er�sv�ew�1w�+x� �y�x�"'� �(G�(G�Ib�(b�"c� �!&�|�'J�'J�Le�'e�!f� � '�(C�Kf� g� � &�'A�Ic� d� � � �NQ� #� K� �K� �K� � K� L� K� � K� F�K� �K� � �NQ� #�K� �K� �K� � K� � K� L� K� �K� F�K� �K� � �NQ� #�I� �I� �I� � I� � I� L� I� �I� D�I� �I� &-�(�NV� $� A� �A� "�A� �A� L� A� � A� � A�H �:�X�c�3�h�%7� 8�� � 4� � 4� � &)�NV�� )� "�)� L�)� � )� $� )� �)� $(�9� &-�NV�(� 9� �9� #� 9� L� 9� � 9� �9�x �)� �� � �w��|�,�N�� �[���<� 0� ;� ;�<�#� #� =�#r=