
    9Cg?                       U d Z ddlmZ ddlZddlmZmZ ddlmZm	Z	m
Z
mZmZ ddlmZmZ ddlmZmZmZ ddlmZmZmZ d	d
lmZ d	dlmZmZ d	dlmZ  ej        dRi ej         ddi G d d                      Z! ej        dRi ej         ddi G d d                      Z"er9dZ#de$d<   dZ%de$d<   	 dZ&de$d<   	 dZ'de$d<   	  ede%          Z( ede&          Z)edddd dSd.            Z*eddddd/dTd2            Z*d3ed4dd/dUd7Z*erye
e	ege	f         Z+de$d8<   	 e
e	ge	f         Z,de$d9<   	 d:Z-de$d;<   	 e
e	eege	f         Z.de$d<<   	 e
e	ege	f         Z/de$d=<   	 d>Z0de$d?<   	 d@Z1de$dA<    edBe-          Z2 edCe0          Z3edVdE            Z4ed4ddFdWdH            Z4edd4ddIdXdK            Z4	 dYd3d4edIdZdNZ4 edO          Z5eree5df         Z6dS  ej        dRi ej          G dP dQ                      Z6dS )[zEThis module contains related classes and functions for serialization.    )annotationsN)partialpartialmethod)TYPE_CHECKINGAnyCallableTypeVaroverload)PydanticUndefinedcore_schema)SerializationInfoSerializerFunctionWrapHandlerWhenUsed)	AnnotatedLiteral	TypeAlias   )PydanticUndefinedAnnotation)_decorators_internal_dataclass)GetCoreSchemaHandlerfrozenTc                  B    e Zd ZU dZded<   eZded<   dZded<   ddZdS )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alwaysr   	when_usedsource_typehandlerr   returncore_schema.CoreSchemac                    ||          }	 t          j        | j        | j        |                                          }n'# t
          $ r}t          j        |          |d}~ww xY w|t          u rdn|	                    |          }t          j        | j        t          j        | j        d          || j                  |d<   |S )zGets 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   selfr   r    schemar   er(   s          Q/var/www/api/venv/lib/python3.11/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 KK  	H 	H 	H-=a@@aG	H +/@ @ @gF]F]^iFjFj"-"RY =diQQ'n	#
 #
 #
    2A   
A$
AA$Nr   r   r    r   r!   r"   	__name__
__module____qualname____doc____annotations__r   r   r   r6        r5   r   r      sd          > )((((K(((("I""""     r@   r   c                  B    e Zd ZU dZded<   eZded<   dZded<   ddZdS )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.WrapSerializerFunctionr   r   r   r   r   r   r   r    r   r!   r"   c                    ||          }	 t          j        | j        | j        |                                          }n'# t
          $ r}t          j        |          |d}~ww xY w|t          u rdn|	                    |          }t          j        | j        t          j        | j        d          || 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.
        Nwrapr%   r)   )r   r*   r   r   r+   r,   r   r-   r   r.   r   #wrap_serializer_function_ser_schemar0   r   r1   s          r5   r6   z+WrapSerializer.__get_pydantic_core_schema__   s     %%	H%>	4+W-I-I-K-K KK  	H 	H 	H-=a@@aG	H +/@ @ @gF]F]^iFjFj"-"QY =diPP'n	#
 #
 #
 r7   Nr8   r9   r?   r@   r5   rB   rB   R   se         > >@ -,,,(K(((("I""""     r@   rB   z!partial[Any] | partialmethod[Any]r   _Partialz)core_schema.SerializerFunction | _PartialFieldPlainSerializerz-core_schema.WrapSerializerFunction | _PartialFieldWrapSerializerz*FieldPlainSerializer | FieldWrapSerializerFieldSerializer_FieldPlainSerializerT)bound_FieldWrapSerializerT.)r   r   check_fieldsfieldstrfieldsmodeLiteral['wrap']r   r   r   r   rM   bool | Noner!   8Callable[[_FieldWrapSerializerT], _FieldWrapSerializerT]c                  d S Nr?   rN   rQ   r   r   rM   rP   s         r5   field_serializerrX      s     @Csr@   )rQ   r   r   rM   Literal['plain']:Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT]c                  d S rV   r?   rW   s         r5   rX   rX      s     BEr@   r$   r   Literal['plain', 'wrap']uCallable[[_FieldWrapSerializerT], _FieldWrapSerializerT] | Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT]c                $     d fd}|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(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.
    frI   r!   (_decorators.PydanticDescriptorProxy[Any]c                `    t          j                  }t          j        | |          S )N)rP   rQ   r   r   rM   )r   FieldSerializerDecoratorInfoPydanticDescriptorProxy)r_   dec_inforM   rP   rQ   r   r   s     r5   deczfield_serializer.<locals>.dec  s>    ;#%
 
 
 21h???r@   )r_   rI   r!   r`   r?   )rQ   r   r   rM   rP   re   s   ````` r5   rX   rX      sK    p@ @ @ @ @ @ @ @ @ @ Jr@   ModelPlainSerializerWithInfoModelPlainSerializerWithoutInfoz>ModelPlainSerializerWithInfo | ModelPlainSerializerWithoutInfoModelPlainSerializerModelWrapSerializerWithInfoModelWrapSerializerWithoutInfoz<ModelWrapSerializerWithInfo | ModelWrapSerializerWithoutInfoModelWrapSerializerz*ModelPlainSerializer | ModelWrapSerializerModelSerializer_ModelPlainSerializerT_ModelWrapSerializerTr_   c                   d S rV   r?   )r_   s    r5   model_serializerrp   ;  s    NQcr@   )r   r   8Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT]c                    d S rV   r?   rQ   r   r   s      r5   rp   rp   ?  s     @Csr@   rs   :Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT]c                    d S rV   r?   rs   s      r5   rp   rp   E  s     BEr@   5_ModelPlainSerializerT | _ModelWrapSerializerT | None_ModelPlainSerializerT | Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT] | Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT]c              6    dfd}| |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}
    ```

    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_   rl   r!   r`   c                \    t          j                  }t          j        | |          S )N)rQ   r   r   )r   ModelSerializerDecoratorInforc   )r_   rd   rQ   r   r   s     r5   re   zmodel_serializer.<locals>.dec  s/    ;S^jsttt21h???r@   N)r_   rl   r!   r`   r?   )r_   rQ   r   r   re   s    ``` r5   rp   rp   N  sO    @@ @ @ @ @ @ @ @ 	y
s1vvr@   AnyTypec                  ,    e Zd ZddZdd	Zej        Zd
S )SerializeAsAnyitemr   r!   c                8    t           |t                      f         S rV   )r   r}   )clsr~   s     r5   __class_getitem__z SerializeAsAny.__class_getitem__  s    T>#3#3344r@   r   r    r   r"   c                     ||          }|}|d         dk    r(|                                 }|d         }|d         dk    (t          j        d t          j                              |d<   |S )Ntypedefinitionsr3   c                     ||           S rV   r?   )xhs     r5   <lambda>z=SerializeAsAny.__get_pydantic_core_schema__.<locals>.<lambda>  s    QQqTT r@   )r3   r)   )copyr   rE   
any_schema)r2   r   r    r3   schema_to_updates        r5   r6   z+SerializeAsAny.__get_pydantic_core_schema__  s     W[))F%"6*m;;#3#8#8#:#: #3H#=  #6*m;; 1<0_!!+*@*B*B1 1 1_- Mr@   N)r~   r   r!   r   r8   )r:   r;   r<   r   r6   object__hash__r?   r@   r5   r}   r}     s?        	5 	5 	5 	5	 	 	 	 ?r@   r}   r?   )rN   rO   rP   rO   rQ   rR   r   r   r   r   rM   rS   r!   rT   )rN   rO   rP   rO   rQ   rY   r   r   r   r   rM   rS   r!   rZ   )rP   rO   rQ   r\   r   r   r   r   rM   rS   r!   r]   )r_   rm   r!   rm   )rQ   rR   r   r   r   r   r!   rq   )rQ   rY   r   r   r   r   r!   rt   rV   )
r_   rv   rQ   r\   r   r   r   r   r!   rw   )7r=   
__future__r   dataclasses	functoolsr   r   typingr   r   r   r	   r
   pydantic_corer   r   pydantic_core.core_schemar   r   r   typing_extensionsr   r   r    r   	_internalr   r   annotated_handlersr   	dataclass
slots_truer   rB   rF   r>   rG   rH   rI   rJ   rL   rX   rf   rg   rh   ri   rj   rk   rl   rm   rn   rp   r{   r}   r?   r@   r5   <module>r      sF   K K K " " " " " "     , , , , , , , , B B B B B B B B B B B B B B 8 8 8 8 8 8 8 8 ` ` ` ` ` ` ` ` ` ` ; ; ; ; ; ; ; ; ; ; ) ) ) ) ) ) 7 7 7 7 7 7 7 7 4 4 4 4 4 4 EE,7EEEEE< < < < < < < FE<~ EE,7EEEEE] ] ] ] ] ] ] FE]@  X=H====&QQQQQ@%TTTTT?!MOMMMM0$W%=EYZZZ#G$;CVWWW 
  #C C C C C 
C 

 ! #E E E E E 
E &-(" $B B B B B BJ  X /7=N7OQT7T.U UUUUN193%*1E#EEEEQ&fffff4-5s<Y[l6mor6r-sssssM08#?\9]_b9b0c"ccccP%ccccc3!MOMMMM$W%=EYZZZ#G$;CVWWW 
 Q Q Q 
 Q 
4<QTC C C C C 
C
 
 !"	E E E E E 
E @DG &-"(G G G G G GT ')

  #w|,N  [<<0;<<# # # # # # # =<# # #r@   