
    gmB                    V   % S r SSKJr  SSKrSSKJrJr  SSKJrJ	r	J
r
JrJr  SSKJrJr  SSKJrJrJr  SSKJrJrJr  S	S
KJr  S	SKJrJr  S	SKJr  \R>                  " S<0 \R@                  DSS0D6 " S S5      5       r!\R>                  " S<0 \R@                  DSS0D6 " S S5      5       r"\(       a-  Sr#S\$S'   Sr%S\$S'    Sr&S\$S'    Sr'S\$S'    \" S\%S9r(\" S\&S9r)\SSSS .             S=S! jj5       r*\SSSSS".             S>S# jj5       r*S$\S%SS".           S?S& jjr*\(       aa  \
\	\/\	4   r+S\$S''    \
\	/\	4   r,S\$S('    S)r-S\$S*'    \
\	\\/\	4   r.S\$S+'    \
\	\/\	4   r/S\$S,'    S-r0S\$S.'    S/r1S\$S0'   \" S1\-S9r2\" S2\0S9r3\S@S3 j5       r4\S%SS4.       SAS5 jj5       r4\SS%SS6.       SBS7 jj5       r4 SCS$S%\S6.         SDS8 jjjr4\" S95      r5\(       a  \\5S4   r6g\R>                  " S<0 \R@                  D6 " S: S;5      5       r6g)EzEThis 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                  J    \ rS rSr% SrS\S'   \rS\S'   SrS\S	'   SS
 jr	Sr
g)PlainSerializer   a  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_usedc                   U" U5      n [         R                  " U R                  U R                  UR	                  5       R
                  S9nU[        L a  SOUR                  U5      n[        R                  " U R                  [         R                  " U R                  S5      UU R                  S9US'   U$ ! [         a  n[        R                  " U5      UeSnAff = f)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   get_function_return_typer   r   _get_types_namespacelocals	NameErrorr   from_name_errorr   generate_schemar   $plain_serializer_function_ser_schemainspect_annotated_serializerr   )selfsource_typehandlerschemar   er'   s          X/home/matz/Project1/venv/lib/python3.13/site-packages/pydantic/functional_serializers.py__get_pydantic_core_schema__,PlainSerializer.__get_pydantic_core_schema__7   s     %
	H &>>		  446==K !,/@ @gF]F]^iFj"-"R"RYY ==diiQ'nn	#
   	H-==a@aG	Hs   AB7 7
CCC Nr2   r   r3   r   returnzcore_schema.CoreSchema__name__
__module____qualname____firstlineno____doc____annotations__r   r   r   r7   __static_attributes__r9       r6   r   r      s(    > )((K("Ix"rD   r   c                  J    \ rS rSr% SrS\S'   \rS\S'   SrS\S	'   SS
 jr	Sr
g)WrapSerializerW   aN  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   c                   U" U5      nUR                  5       u  pE [        R                  " U R                  U R                  UR                  5       R
                  S9nU[        L a  SOUR                  U5      n[        R                  " U R                  [        R                  " U R                  S5      UU R                  S9US'   U$ ! [         a  n[        R                  " U5      UeSnAff = f)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_schemar0   r   )	r1   r2   r3   r4   globalnsr"   r   r5   r'   s	            r6   r7   +WrapSerializer.__get_pydantic_core_schema__   s     %#88:
	H &>>		  446==K !,/@ @gF]F]^iFj"-"Q"QYY ==diiP'nn	#
   	H-==a@aG	Hs   AC	 	
C/C**C/r9   Nr:   r<   r9   rD   r6   rF   rF   W   s)    >@ -,(K("Ix"rD   rF   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                  g Nr9   fieldmoder   r   rT   fieldss         r6   field_serializerr[      s	     @CrD   )rY   r   r   rT   c                  g rV   r9   rW   s         r6   r[   r[      s	     BErD   r#   r   c                (   ^ ^^^^ SUUU UU4S jjnU$ )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                `   > [         R                  " TTTTTS9n[         R                  " X5      $ )N)rZ   rY   r   r   rT   )r   FieldSerializerDecoratorInfoPydanticDescriptorProxy)fdec_inforT   rZ   rY   r   r   s     r6   decfield_serializer.<locals>.dec  s5    ;;#%
 221??rD   )ra   rP   r;   (_decorators.PydanticDescriptorProxy[Any]r9   )rY   r   r   rT   rZ   rc   s   ````` r6   r[   r[      s    p@ @ JrD   ModelPlainSerializerWithInfoModelPlainSerializerWithoutInfoz>ModelPlainSerializerWithInfo | ModelPlainSerializerWithoutInfoModelPlainSerializerModelWrapSerializerWithInfoModelWrapSerializerWithoutInfoz<ModelWrapSerializerWithInfo | ModelWrapSerializerWithoutInfoModelWrapSerializerz*ModelPlainSerializer | ModelWrapSerializerModelSerializer_ModelPlainSerializerT_ModelWrapSerializerTc                   g rV   r9   )ra   s    r6   model_serializerrp   F  s    NQrD   )r   r   c                    g rV   r9   rY   r   r   s      r6   rp   rp   J  s	     @CrD   rr   c                    g rV   r9   rr   s      r6   rp   rp   P  s	     BErD   c              6   ^^^ SUUU4S jjnU c  U$ U" U 5      $ )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                \   > [         R                  " TTTS9n[         R                  " X5      $ )N)rY   r   r   )r   ModelSerializerDecoratorInfor`   )ra   rb   rY   r   r   s     r6   rc   model_serializer.<locals>.dec  s*    ;;S^jst221??rD   )ra   rl   r;   re   r9   )ra   rY   r   r   rc   s    ``` r6   rp   rp   Y  s%    @@ @ 	y
1vrD   AnyTypec                  L    \ rS rSrSS jr      SS jr\R                  rSrg)SerializeAsAnyi  c                (    [         U[        5       4   $ rV   )r   rz   )clsitems     r6   __class_getitem__ SerializeAsAny.__class_getitem__  s    T>#3344rD   c                    U" U5      nUnUS   S:X  a   UR                  5       nUS   nUS   S:X  a  M   [        R                  " S [        R                  " 5       S9US'   U$ )Ntypedefinitionsr4   c                    U" U 5      $ rV   r9   )xhs     r6   <lambda>=SerializeAsAny.__get_pydantic_core_schema__.<locals>.<lambda>  s    QqTrD   )r4   r(   )copyr   rJ   
any_schema)r1   r2   r3   r4   schema_to_updates        r6   r7   +SerializeAsAny.__get_pydantic_core_schema__  sw     [)F%"6*m;#3#8#8#: #3H#=  #6*m; 1<0_0_!+*@*@*B1_- MrD   r9   N)r}   r   r;   r   r:   )	r=   r>   r?   r@   r~   r7   object__hash__rC   r9   rD   r6   rz   rz     s/    	5	"	-A	#	 ??rD   rz   r9   )rX   strrZ   r   rY   Literal['wrap']r   r   r   r   rT   bool | Noner;   z8Callable[[_FieldWrapSerializerT], _FieldWrapSerializerT])rX   r   rZ   r   rY   Literal['plain']r   r   r   r   rT   r   r;   z:Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT])rZ   r   rY   Literal['plain', 'wrap']r   r   r   r   rT   r   r;   zuCallable[[_FieldWrapSerializerT], _FieldWrapSerializerT] | Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT])ra   rm   r;   rm   )rY   r   r   r   r   r   r;   z8Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT])rY   r   r   r   r   r   r;   z:Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT]rV   )
ra   z5_ModelPlainSerializerT | _ModelWrapSerializerT | NonerY   r   r   r   r   r   r;   z_ModelPlainSerializerT | Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT] | Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT])7rA   
__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   rF   rM   rB   rN   rO   rP   rQ   rS   r[   rf   rg   rh   ri   rj   rk   rl   rm   rn   rp   rx   rz   r9   rD   r6   <module>r      s,   K "  , B B 8 ` ` ; ; ) 7 4 E,77EEA A FAH 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;;<# # =#rD   