Ë
    S>{iÿB  ã                  ó@  — 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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 d	d
lmZ d	dlmZmZ d	dlmZ  ej>                  d<i ej@                  ¤ddi¤Ž G d„ d«      «       Z! ej>                  d<i ej@                  ¤ddi¤Ž G d„ d«      «       Z"er3d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 œ	 	 	 	 	 	 	 	 	 	 	 	 	 d=d!„«       Z*eddddd"œ	 	 	 	 	 	 	 	 	 	 	 	 	 d>d#„«       Z*d$ed%dd"œ	 	 	 	 	 	 	 	 	 	 	 d?d&„Z*ermee
ee
   ge
f   Z+de$d'<   	 ee
ge
f   Z,de$d(<   	 d)Z-de$d*<   	 e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$d0<    ed1e-¬«      Z2 ed2e0¬«      Z3ed@d3„«       Z4ed%dd4œ	 	 	 	 	 	 	 dAd5„«       Z4edd%dd6œ	 	 	 	 	 	 	 dBd7„«       Z4	 dCd$d%ed6œ	 	 	 	 	 	 	 	 	 dDd8„Z4 ed9«      Z5ere	e5df   Z6y ej>                  d<i ej@                  ¤Ž G d:„ d;«      «       Z6y)EzEThis module contains related classes and functions for serialization.é    )ÚannotationsN)ÚpartialÚpartialmethod)ÚTYPE_CHECKINGÚ	AnnotatedÚAnyÚCallableÚLiteralÚTypeVarÚoverload)ÚPydanticUndefinedÚcore_schema)ÚSerializationInfoÚSerializerFunctionWrapHandlerÚWhenUsed)Ú	TypeAliasé   )ÚPydanticUndefinedAnnotation)Ú_decoratorsÚ_internal_dataclass)ÚGetCoreSchemaHandlerÚfrozenTc                  ó@   — e Zd ZU dZded<   eZded<   dZded<   dd	„Zy
)ÚPlainSerializera  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 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_usedc                óè  —  ||«      }| j                   t        ur| j                   }n:	 t        j                  | j                  |j                  «       j                  ¬«      }|t        u rdn|j                  |«      }t        j                  | j                  t        j                  | j                  d«      || j                  ¬«      |d<   |S # t        $ r}t        j                  |«      |‚d}~ww xY w)zÒGets the Pydantic core schema.

        Args:
            source_type: The source type.
            handler: The `GetCoreSchemaHandler` instance.

        Returns:
            The Pydantic core schema.
        ©ÚlocalnsNÚplain©ÚfunctionÚinfo_argÚreturn_schemar   Úserialization)r   r   r   Úget_callable_return_typer   Ú_get_types_namespaceÚlocalsÚ	NameErrorr   Úfrom_name_errorÚgenerate_schemar   Ú$plain_serializer_function_ser_schemaÚinspect_annotated_serializerr   ©ÚselfÚsource_typeÚhandlerÚschemar   Úer&   s          ú]/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/pydantic/functional_serializers.pyÚ__get_pydantic_core_schema__z,PlainSerializer.__get_pydantic_core_schema__5   sÞ   € ñ ˜Ó%ˆØ×ÑÔ#4Ñ4Ø×*Ñ*‰Kð	Lô *×BÑBØ—I‘IØ#×8Ñ8Ó:×AÑAô�ð !,Ô/@Ñ @™Àg×F]ÑF]Ð^iÓFjˆÜ"-×"RÑ"RØ—Y‘YÜ ×=Ñ=¸d¿i¹iÈÓQØ'Ø—n‘nô	#
ˆˆÑð ˆøô ò LÜ1×AÑAÀ!ÓDÈ!ÐKûðLúó   ©9C Ã	C1ÃC,Ã,C1N©r2   r   r3   r   Úreturnzcore_schema.CoreSchema©	Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r   r   r   r7   © ó    r6   r   r      s(   … ñð: )Ó(Ø(€K�Ó(Ø"€IˆxÓ"ô rB   r   c                  ó@   — e Zd ZU dZded<   eZded<   dZded<   dd	„Zy
)Ú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 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.WrapSerializerFunctionr   r   r   r   r   r   c                óè  —  ||«      }| j                   t        ur| j                   }n:	 t        j                  | j                  |j                  «       j                  ¬«      }|t        u rdn|j                  |«      }t        j                  | j                  t        j                  | j                  d«      || j                  ¬«      |d<   |S # t        $ r}t        j                  |«      |‚d}~ww xY 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.
        r    NÚwrapr#   r'   )r   r   r   r(   r   r)   r*   r+   r   r,   r-   r   Ú#wrap_serializer_function_ser_schemar/   r   r0   s          r6   r7   z+WrapSerializer.__get_pydantic_core_schema__œ   sÞ   € ñ ˜Ó%ˆØ×ÑÔ#4Ñ4Ø×*Ñ*‰Kð	Lô *×BÑBØ—I‘IØ#×8Ñ8Ó:×AÑAô�ð !,Ô/@Ñ @™Àg×F]ÑF]Ð^iÓFjˆÜ"-×"QÑ"QØ—Y‘YÜ ×=Ñ=¸d¿i¹iÈÓPØ'Ø—n‘nô	#
ˆˆÑð ˆøô ò LÜ1×AÑAÀ!ÓDÈ!ÐKûðLúr8   Nr9   r;   rA   rB   r6   rD   rD   X   s)   … ñ<ð| -Ó,Ø(€K�Ó(Ø"€IˆxÓ"ô rB   rD   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_fieldsc               ó   — y ©NrA   ©ÚfieldÚmoder   r   rO   Úfieldss         r6   Úfield_serializerrV   Ï   s	   € ð @CrB   )rT   r   r   rO   c               ó   — y rQ   rA   rR   s         r6   rV   rV   Û   s	   € ð BErB   r"   r   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 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:

    - `(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)rU   rT   r   r   rO   )r   ÚFieldSerializerDecoratorInfoÚPydanticDescriptorProxy)ÚfÚdec_inforO   rU   rT   r   r   s     €€€€€r6   Údeczfield_serializer.<locals>.dec  s7   ø€ Ü×;Ñ;ØØØ#ØØ%ô
ˆô ×2Ñ2°1°hÓ?Ð?rB   )r\   rK   r:   ú(_decorators.PydanticDescriptorProxy[Any]rA   )rT   r   r   rO   rU   r^   s   ````` r6   rV   rV   ç   s   ü€ ÷n@ñ @ð €JrB   ÚModelPlainSerializerWithInfoÚModelPlainSerializerWithoutInfoz>ModelPlainSerializerWithInfo | ModelPlainSerializerWithoutInfoÚModelPlainSerializerÚModelWrapSerializerWithInfoÚModelWrapSerializerWithoutInfoz<ModelWrapSerializerWithInfo | ModelWrapSerializerWithoutInfoÚModelWrapSerializerz*ModelPlainSerializer | ModelWrapSerializerÚModelSerializerÚ_ModelPlainSerializerTÚ_ModelWrapSerializerTc                ó   — y rQ   rA   )r\   s    r6   Úmodel_serializerrj   F  s   € ØNQrB   )r   r   c                 ó   — y rQ   rA   ©rT   r   r   s      r6   rj   rj   J  s	   € ð @CrB   rl   c                 ó   — y rQ   rA   rl   s      r6   rj   rj   P  s	   € ð BErB   c              ó0   ‡‡‡— 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 [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                ó`   •— t        j                  ‰‰‰¬«      }t        j                  | |«      S )N)rT   r   r   )r   ÚModelSerializerDecoratorInfor[   )r\   r]   rT   r   r   s     €€€r6   r^   zmodel_serializer.<locals>.dec™  s,   ø€ Ü×;Ñ;ÀÐS^ÐjsÔtˆÜ×2Ñ2°1°hÓ?Ð?rB   )r\   rf   r:   r_   rA   )r\   rT   r   r   r^   s    ``` r6   rj   rj   Y  s   ú€ ÷@@ð 	€yØˆ
á�1‹vˆrB   ÚAnyTypec                  óD   — e Zd ZdZdd„Z	 	 	 	 	 	 dd„Zej                  Zy)ÚSerializeAsAnyzÅAnnotation 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         |t        «       f   S rQ   )r   rs   )ÚclsÚitems     r6   Ú__class_getitem__z SerializeAsAny.__class_getitem__µ  s   € Ü˜T¤>Ó#3Ð3Ñ4Ð4rB   c                ó–   —  ||«      }|}|d   dk(  r|j                  «       }|d   }|d   dk(  rŒt        j                  d«      |d<   |S )NÚtypeÚdefinitionsr4   Úanyr'   )Úcopyr   Úsimple_ser_schema)r1   r2   r3   r4   Úschema_to_updates        r6   r7   z+SerializeAsAny.__get_pydantic_core_schema__¸  sg   € ñ ˜[Ó)ˆFØ%ÐØ" 6Ñ*¨mÒ;Ø#3×#8Ñ#8Ó#:Ð Ø#3°HÑ#=Ð ð # 6Ñ*¨mÓ;ô 1<×0MÑ0MÈeÓ0TÐ˜_Ñ-ØˆMrB   N)rv   r   r:   r   r9   )r<   r=   r>   r?   rw   r7   ÚobjectÚ__hash__rA   rB   r6   rs   rs   ®  s4   „ ñ	ó
	5ð		Ø"ð		Ø-Að		à#ó		ð —?‘?‰rB   rs   rA   )rS   ÚstrrU   r�   rT   úLiteral['wrap']r   r   r   r   rO   úbool | Noner:   z8Callable[[_FieldWrapSerializerT], _FieldWrapSerializerT])rS   r�   rU   r�   rT   úLiteral['plain']r   r   r   r   rO   rƒ   r:   z:Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT])rU   r�   rT   úLiteral['plain', 'wrap']r   r   r   r   rO   rƒ   r:   zuCallable[[_FieldWrapSerializerT], _FieldWrapSerializerT] | Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT])r\   rg   r:   rg   )rT   r‚   r   r   r   r   r:   z8Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT])rT   r„   r   r   r   r   r:   z:Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT]rQ   )
r\   z5_ModelPlainSerializerT | _ModelWrapSerializerT | NonerT   r…   r   r   r   r   r:   zŽ_ModelPlainSerializerT | Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT] | Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT])7r?   Ú
__future__r   ÚdataclassesÚ	functoolsr   r   Útypingr   r   r   r	   r
   r   r   Úpydantic_corer   r   Úpydantic_core.core_schemar   r   r   Útyping_extensionsr   Ú r   Ú	_internalr   r   Úannotated_handlersr   Ú	dataclassÚ
slots_truer   rD   rH   r@   rI   rJ   rK   rL   rN   rV   r`   ra   rb   rc   rd   re   rf   rg   rh   rj   rq   rs   rA   rB   r6   ú<module>r’      s=  ðÚ Kå "ã ß ,ß V× VÑ Vç 8ß `Ñ `Ý 'å )ß 7Ý 4ð €×ÑÑEÐ,×7Ñ7ÑEÀÒE÷Bð Bó FðBðJ €×ÑÑEÐ,×7Ñ7ÑEÀÒE÷cð có FðcñL Ø=€HˆiÓ=à&QÐ˜)ÓQØ@à%TÐ˜ÓTØ?à!M€O�YÓMØ0á$Ð%=ÐEYÔZÐÙ#Ð$;ÐCVÔWÐð 
ð ØØ #ñCØðCð ðCð ð	Cð
 ðCð ðCð ðCð >òCó 
ðCð 
ð
 !ØØØ #ñEØðEð ðEð ð	Eð
 ðEð ðEð ðEð @òEó 
ðEð &-à(Ø"Ø $ñAØðAà
"ðAð ð	Að
 ðAð ðAðAóAñH ð /7¸Ð=NÈsÑ=SÐ7TÐVYÐ7YÑ.ZÐ  )ÓZØNà19¸3¸%À¸*Ñ1EÐ# YÓEØQà&fÐ˜)ÓfØ4à-5°sÐ<YÐ[lÐmpÑ[qÐ6rÐtwÐ6wÑ-xÐ ÓxØMà08¸#Ð?\Ð9]Ð_bÐ9bÑ0cÐ" IÓcØPà%cÐ˜ÓcØ3à!M€O�YÓMá$Ð%=ÐEYÔZÐÙ#Ð$;ÐCVÔWÐð 
Ú Qó 
Ø Qð 
à4<ÐQTñCØðCØ)1ðCØKNðCà=òCó 
ðCð
 
ð !Ø"Øñ	Eà
ðEð ðEð ð	Eð
 @òEó 
ðEð @DðGð &-Ø"Ø(ñGØ<ðGð #ð	Gð
 ðGð ðGðAóGñT �)Ó
€ñ Ø˜w¨˜|Ñ,€Nðð €[×ÑÑ<Ð0×;Ñ;Ñ<÷#ð #ó =ñ#rB   