
    ,hB                    4   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rge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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)zGets 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          a/var/www/html/Resume-Scraper/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II#88:AA !,/@ @gF]F]^iFj"-"R"RYY ==diiQ'nn	#
   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("Ix" 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)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    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II#88:AA !,/@ @gF]F]^iFj"-"Q"QYY ==diiP'nn	#
   L1AA!D!KLr8   Nr9   r;   rA   rB   r6   rD   rD   X   s)    <| -,(K("Ix" 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 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.
    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21h??rB   )r\   rK   r:   (_decorators.PydanticDescriptorProxy[Any]rA   )rT   r   r   rO   rU   r^   s   ````` r6   rV   rV      s    p@ @ JrB   ModelPlainSerializerWithInfoModelPlainSerializerWithoutInfoz>ModelPlainSerializerWithInfo | ModelPlainSerializerWithoutInfoModelPlainSerializerModelWrapSerializerWithInfoModelWrapSerializerWithoutInfoz<ModelWrapSerializerWithInfo | ModelWrapSerializerWithoutInfoModelWrapSerializerz*ModelPlainSerializer | ModelWrapSerializerModelSerializer_ModelPlainSerializerT_ModelWrapSerializerTc                    y rQ   rA   )r\   s    r6   model_serializerrj   G  s    NQrB   )r   r   c                     y rQ   rA   rT   r   r   s      r6   rj   rj   K  s	     @CrB   rl   c                     y rQ   rA   rl   s      r6   rj   rj   Q  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 [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)rT   r   r   )r   ModelSerializerDecoratorInfor[   )r\   r]   rT   r   r   s     r6   r^   zmodel_serializer.<locals>.dec  s,    ;;S^jst221h??rB   )r\   rf   r:   r_   rA   )r\   rT   r   r   r^   s    ``` r6   rj   rj   Z  s    @@ 	y
1vrB   AnyTypec                  @    e Zd ZddZ	 	 	 	 	 	 ddZej                  Zy)SerializeAsAnyc                (    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 t        j                               |d<   |S )Ntypedefinitionsr4   c                     ||       S rQ   rA   )xhs     r6   <lambda>z=SerializeAsAny.__get_pydantic_core_schema__.<locals>.<lambda>  s
    QqT rB   )r4   r'   )copyr   rG   
any_schema)r1   r2   r3   r4   schema_to_updates        r6   r7   z+SerializeAsAny.__get_pydantic_core_schema__  sw     [)F%"6*m;#3#8#8#: #3H#=  #6*m; 1<0_0_!+*@*@*B1_- MrB   N)rv   r   r:   r   r9   )r<   r=   r>   rw   r7   object__hash__rA   rB   r6   rs   rs     s/    	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      s2   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 =Hi=&Q)Q@%TT?!MOYM0$%=EYZ#$;CVW 
  #CC C 	C
 C C C >C 
C 

 ! #EE E 	E
 E E E @E 
E &-(" $BB
"B B 	B
 BABJ  /7=N7OQT7T.U )UN193%*1E#YEQ&f)f4-5s<Y[l6mor6r-ssM08#?\9]_b9b0c"IcP%cc3!MOY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   