a
    “˜ëjì{  ã                	   @  s¨  U d Z ddlmZ ddlZddlZddlZddlmZ ddl	m
Z
mZ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 dd	lmZmZmZ dd
lmZ ddlm Z  ddl!m"Z" ddlm#Z#m$Z$ ej%dk râddlm&Z& nddl	m&Z& ej'Z(ej)f ddiej*¤ŽG dd„ dƒƒZ+ej)f ddiej*¤ŽG dd„ dƒƒZ,ej)f ddiej*¤ŽG dd„ dƒƒZ-ej)f ddiej*¤ŽG dd„ dƒƒZ.e
�rFG dd„ de&ƒZ/G dd„ de&ƒZ0G dd„ de&ƒZ1G d d!„ d!e&ƒZ2ee0ej3e/ej4f Z5ee2ej6e1ej7f Z8ee9eeef e:eef ee f Z;d"e<d#< ed$ee5e;f d%�Z=ed&ee8e;f d%�Z>ed' Z?d"e<d(< ed)d)d*œd+d+d,d-d.d/d0œd1d2„ƒZ@ed)d)d*œd+d+d3d-d.d4d0œd5d2„ƒZ@ed)d)d6œd+d+d7d-d4d8œd9d2„ƒZ@d:ded;œd+d+d(d-d.d<d0œd=d2„Z@ed>ƒZAed?dd@�ZBG dAdB„ dBejCe&eB ƒZDG dCdD„ dDe&eA ƒZEG dEdF„ dFe&eA ƒZFG dGdH„ dHe&ƒZGG dIdJ„ dJe&ƒZHG dKdL„ dLe&ƒZIG dMdN„ dNe&ƒZJeeAgeAf ZKeeAejLe geAf ZMeeFeA eEeA f ZNeeIeJeGeHf ZOeeMeA eKeA f ZPed,dOdPœdQdR„ƒZQedSdTdPœdUdR„ƒZQed7dVdPœdWdR„ƒZQdXd.dPœdYdR„ZQedZƒZRe
�r:eeRd)f ZSn ej)f i ej*¤ŽG d[d\„ d\ƒƒZSe
�rneeRd)f ZTn ej)f i ej*¤ŽG d]d^„ d^ƒƒZTed_ƒZUG d`da„ daƒZVdS )bzBThis module contains related classes and functions for validation.é    )ÚannotationsN)Úpartialmethod)	ÚTYPE_CHECKINGÚ	AnnotatedÚAnyÚCallableÚLiteralÚTypeVarÚUnionÚcastÚoverload)ÚPydanticUndefinedÚcore_schema)ÚSelfÚ	TypeAliasé   )Ú_decoratorsÚ	_genericsÚ_internal_dataclass)ÚGetCoreSchemaHandler)ÚPydanticUserError)Úversion_short)ÚArbitraryTypeWarningÚPydanticDeprecatedSince212)é   é   )ÚProtocolÚfrozenTc                   @  s@   e Zd ZU dZded< ddddœdd	„Zed
ddœdd„ƒZdS )ÚAfterValidatoraT  !!! abstract "Usage Documentation"
        [field *after* validators](../concepts/validators.md#field-after-validator)

    A metadata class that indicates that a validation should be applied **after** the inner validation logic.

    Attributes:
        func: The validator function.

    Example:
        ```python
        from typing import Annotated

        from pydantic import AfterValidator, BaseModel, ValidationError

        MyInt = Annotated[int, AfterValidator(lambda v: v + 1)]

        class Model(BaseModel):
            a: MyInt

        print(Model(a=1).a)
        #> 2

        try:
            Model(a='a')
        except ValidationError as e:
            print(e.json(indent=2))
            '''
            [
              {
                "type": "int_parsing",
                "loc": [
                  "a"
                ],
                "msg": "Input should be a valid integer, unable to parse string as an integer",
                "input": "a",
                "url": "https://errors.pydantic.dev/2/v/int_parsing"
              }
            ]
            '''
        ```
    úKcore_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunctionÚfuncr   r   úcore_schema.CoreSchema©Úsource_typeÚhandlerÚreturnc                 C  sX   ||ƒ}t | jddd�}|r8ttj| jƒ}tj||d�S ttj| jƒ}tj||d�S d S )NÚafterÚfield©ÚmodeÚtype©Úschema)Ú_inspect_validatorr    r   r   ÚWithInfoValidatorFunctionZ"with_info_after_validator_functionÚNoInfoValidatorFunctionÚ no_info_after_validator_function)Úselfr#   r$   r,   Úinfo_argr    © r3   ú]/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/pydantic/functional_validators.pyÚ__get_pydantic_core_schema__J   s    z+AfterValidator.__get_pydantic_core_schema__ú>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]r   ©Ú	decoratorr%   c                 C  s   | |j d�S )N©r    r9   ©Úclsr8   r3   r3   r4   Ú_from_decoratorT   s    zAfterValidator._from_decoratorN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r5   Úclassmethodr<   r3   r3   r3   r4   r      s
   
*
r   c                   @  sL   e Zd ZU dZded< eZded< ddddœd	d
„Zedddœdd„ƒZ	dS )ÚBeforeValidatora„  !!! abstract "Usage Documentation"
        [field *before* validators](../concepts/validators.md#field-before-validator)

    A metadata class that indicates that a validation should be applied **before** the inner validation logic.

    Attributes:
        func: The validator function.
        json_schema_input_type: The input type used to generate the appropriate
            JSON Schema (in validation mode). The actual input type is `Any`.

    Example:
        ```python
        from typing import Annotated

        from pydantic import BaseModel, BeforeValidator

        MyInt = Annotated[int, BeforeValidator(lambda v: v + 1)]

        class Model(BaseModel):
            a: MyInt

        print(Model(a=1).a)
        #> 2

        try:
            Model(a='a')
        except TypeError as e:
            print(e)
            #> can only concatenate str (not "int") to str
        ```
    r   r    r   Újson_schema_input_typer   r!   r"   c                 C  sv   ||ƒ}| j tu rd n
| | j ¡}t| jddd�}|rTttj| jƒ}tj|||d�S ttj	| jƒ}tj
|||d�S d S )NÚbeforer'   r(   ©r,   Újson_schema_input_schema)rD   r   Úgenerate_schemar-   r    r   r   r.   Z#with_info_before_validator_functionr/   Z!no_info_before_validator_function©r1   r#   r$   r,   Úinput_schemar2   r    r3   r3   r4   r5   ~   s"    ÿ
ýýÿz,BeforeValidator.__get_pydantic_core_schema__r6   r   r7   c                 C  s   | |j |jjd�S ©N)r    rD   ©r    ÚinforD   r:   r3   r3   r4   r<   ”   s    þzBeforeValidator._from_decoratorN©
r=   r>   r?   r@   rA   r   rD   r5   rB   r<   r3   r3   r3   r4   rC   Y   s   
 rC   c                   @  sL   e Zd ZU dZded< eZded< ddddœd	d
„Zedddœdd„ƒZ	dS )ÚPlainValidatora„  !!! abstract "Usage Documentation"
        [field *plain* validators](../concepts/validators.md#field-plain-validator)

    A metadata class that indicates that a validation should be applied **instead** of the inner validation logic.

    !!! note
        Before v2.9, `PlainValidator` wasn't always compatible with JSON Schema generation for `mode='validation'`.
        You can now use the `json_schema_input_type` argument to specify the input type of the function
        to be used in the JSON schema when `mode='validation'` (the default). See the example below for more details.

    Attributes:
        func: The validator function.
        json_schema_input_type: The input type used to generate the appropriate
            JSON Schema (in validation mode). The actual input type is `Any`.

    Example:
        ```python
        from typing import Annotated, Union

        from pydantic import BaseModel, PlainValidator

        def validate(v: object) -> int:
            if not isinstance(v, (int, str)):
                raise ValueError(f'Expected int or str, got {type(v)}')

            return int(v) + 1

        MyInt = Annotated[
            int,
            PlainValidator(validate, json_schema_input_type=Union[str, int]),  # (1)!
        ]

        class Model(BaseModel):
            a: MyInt

        print(Model(a='1').a)
        #> 2

        print(Model(a=1).a)
        #> 2
        ```

        1. In this example, we've specified the `json_schema_input_type` as `Union[str, int]` which indicates to the JSON schema
        generator that in validation mode, the input type for the `a` field can be either a [`str`][] or an [`int`][].
    r   r    r   rD   r   r!   r"   c           	   	   C  s²   ddl m} z.||ƒ}| dtjdd„ || |¡d�¡}W n |yP   d }Y n0 | | j¡}t| jddd	�}|r�t	tj
| jƒ}tj|||d
�S t	tj| jƒ}tj|||d
�S d S )Nr   )ÚPydanticSchemaGenerationErrorÚserializationc                 S  s   || ƒS ©Nr3   ©ÚvÚhr3   r3   r4   Ú<lambda>Þ   ó    z=PlainValidator.__get_pydantic_core_schema__.<locals>.<lambda>)Úfunctionr,   Zreturn_schemaÚplainr'   r(   )rQ   rG   )ZpydanticrP   Úgetr   Ú#wrap_serializer_function_ser_schemarH   rD   r-   r    r   r.   Z"with_info_plain_validator_functionr/   Z no_info_plain_validator_function)	r1   r#   r$   rP   r,   rQ   rJ   r2   r    r3   r3   r4   r5   Ï   s8    ýþ
ýýz+PlainValidator.__get_pydantic_core_schema__r6   r   r7   c                 C  s   | |j |jjd�S rK   rL   r:   r3   r3   r4   r<   ø   s    þzPlainValidator._from_decoratorN)
r=   r>   r?   r@   rA   r   rD   r5   rB   r<   r3   r3   r3   r4   rO   œ   s   
.)rO   c                   @  sL   e Zd ZU dZded< eZded< ddddœd	d
„Zedddœdd„ƒZ	dS )ÚWrapValidatoraÒ  !!! abstract "Usage Documentation"
        [field *wrap* validators](../concepts/validators.md#field-wrap-validator)

    A metadata class that indicates that a validation should be applied **around** the inner validation logic.

    Attributes:
        func: The validator function.
        json_schema_input_type: The input type used to generate the appropriate
            JSON Schema (in validation mode). The actual input type is `Any`.

    ```python
    from datetime import datetime
    from typing import Annotated

    from pydantic import BaseModel, ValidationError, WrapValidator

    def validate_timestamp(v, handler):
        if v == 'now':
            # we don't want to bother with further validation, just return the new value
            return datetime.now()
        try:
            return handler(v)
        except ValidationError:
            # validation failed, in this case we want to return a default value
            return datetime(2000, 1, 1)

    MyTimestamp = Annotated[datetime, WrapValidator(validate_timestamp)]

    class Model(BaseModel):
        a: MyTimestamp

    print(Model(a='now').a)
    #> 2032-01-02 03:04:05.000006
    print(Model(a='invalid').a)
    #> 2000-01-01 00:00:00
    ```
    zScore_schema.NoInfoWrapValidatorFunction | core_schema.WithInfoWrapValidatorFunctionr    r   rD   r   r!   r"   c                 C  sv   ||ƒ}| j tu rd n
| | j ¡}t| jddd�}|rTttj| jƒ}tj|||d�S ttj	| jƒ}tj
|||d�S d S )NÚwrapr'   r(   rF   )rD   r   rH   r-   r    r   r   ÚWithInfoWrapValidatorFunctionZ!with_info_wrap_validator_functionÚNoInfoWrapValidatorFunctionZno_info_wrap_validator_functionrI   r3   r3   r4   r5   +  s&    ÿ
ýýýz*WrapValidator.__get_pydantic_core_schema__r6   r   r7   c                 C  s   | |j |jjd�S rK   rL   r:   r3   r3   r4   r<   C  s    þzWrapValidator._from_decoratorNrN   r3   r3   r3   r4   r\      s   
&r\   c                   @  s   e Zd Zddddœdd„ZdS )Ú_OnlyValueValidatorClsMethodr   ©r;   Úvaluer%   c                C  s   d S rR   r3   ©r1   r;   rb   r3   r3   r4   Ú__call__N  rW   z%_OnlyValueValidatorClsMethod.__call__N©r=   r>   r?   rd   r3   r3   r3   r4   r`   M  s   r`   c                   @  s    e Zd Zdddddœdd„ZdS )Ú_V2ValidatorClsMethodr   úcore_schema.ValidationInfo[Any]©r;   rb   rM   r%   c                C  s   d S rR   r3   ©r1   r;   rb   rM   r3   r3   r4   rd   Q  rW   z_V2ValidatorClsMethod.__call__Nre   r3   r3   r3   r4   rf   P  s   rf   c                   @  s    e Zd Zdddddœdd„ZdS )Ú _OnlyValueWrapValidatorClsMethodr   ú(core_schema.ValidatorFunctionWrapHandler©r;   rb   r$   r%   c                C  s   d S rR   r3   ©r1   r;   rb   r$   r3   r3   r4   rd   T  rW   z)_OnlyValueWrapValidatorClsMethod.__call__Nre   r3   r3   r3   r4   rj   S  s   rj   c                   @  s"   e Zd Zddddddœdd„ZdS )Ú_V2WrapValidatorClsMethodr   rk   rg   ©r;   rb   r$   rM   r%   c                C  s   d S rR   r3   ©r1   r;   rb   r$   rM   r3   r3   r4   rd   W  s    z"_V2WrapValidatorClsMethod.__call__Nre   r3   r3   r3   r4   rn   V  s   rn   r   Ú_PartialClsOrStaticMethodÚ"_V2BeforeAfterOrPlainValidatorType)ÚboundÚ_V2WrapValidatorType)rE   r&   r]   rY   ÚFieldValidatorModes.)Úcheck_fieldsrD   ÚstrzLiteral['wrap']zbool | Noner   z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType])r'   Úfieldsr)   rv   rD   r%   c               G  s   d S rR   r3   ©r'   r)   rv   rD   rx   r3   r3   r4   Úfield_validatory  s    rz   zLiteral['before', 'plain']zRCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]c               G  s   d S rR   r3   ry   r3   r3   r4   rz   „  s    )r)   rv   zLiteral['after'])r'   rx   r)   rv   r%   c               G  s   d S rR   r3   )r'   r)   rv   rx   r3   r3   r4   rz   �  s    r&   )r)   rv   rD   zCallable[[Any], Any]c                 sœ   t | ƒst| tƒrtddd�‚ˆdvr@ˆtur@tdˆ›�dd�‚ˆtu rTˆdkrTt‰| gˆ¢R ‰tdd	„ ˆD ƒƒs~td
dd�‚dddœ‡ ‡‡‡fdd„}|S )aƒ  !!! abstract "Usage Documentation"
        [field validators](../concepts/validators.md#field-validators)

    Decorate methods on the class indicating that they should be used to validate fields.

    Example usage:
    ```python
    from typing import Any

    from pydantic import (
        BaseModel,
        ValidationError,
        field_validator,
    )

    class Model(BaseModel):
        a: str

        @field_validator('a')
        @classmethod
        def ensure_foobar(cls, v: Any):
            if 'foobar' not in v:
                raise ValueError('"foobar" not found in a')
            return v

    print(repr(Model(a='this is foobar good')))
    #> Model(a='this is foobar good')

    try:
        Model(a='snap')
    except ValidationError as exc_info:
        print(exc_info)
        '''
        1 validation error for Model
        a
          Value error, "foobar" not found in a [type=value_error, input_value='snap', input_type=str]
        '''
    ```

    For more in depth examples, see [Field Validators](../concepts/validators.md#field-validators).

    Args:
        *fields: The field names the validator should apply to.
        mode: Specifies whether to validate the fields before or after validation.
        check_fields: Whether to check that the fields actually exist on the model.
        json_schema_input_type: The input type of the function. This is only used to generate
            the appropriate JSON Schema (in validation mode) and can only specified
            when `mode` is either `'before'`, `'plain'` or `'wrap'`.

    Raises:
        PydanticUserError:
            - If the decorator is used without any arguments (at least one field name must be provided).
            - If the provided field names are not strings.
            - If `json_schema_input_type` is provided with an unsupported `mode`.
            - If the decorator is applied to an instance method.
    z�The `@field_validator` decorator cannot be used without arguments, at least one field must be provided. For example: `@field_validator('<field_name>', ...)`.zdecorator-missing-arguments©Úcode)rE   rY   r]   z;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typerY   c                 s  s   | ]}t |tƒV  qd S rR   )Ú
isinstancerw   )Ú.0r'   r3   r3   r4   Ú	<genexpr>ê  rW   z"field_validator.<locals>.<genexpr>z™The provided field names to the `@field_validator` decorator should be strings. For example: `@field_validator('<field_name_1>', '<field_name_2>', ...).`zdecorator-invalid-fieldszHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]ú(_decorators.PydanticDescriptorProxy[Any]©Úfr%   c                   s>   t  | ¡rtddd�‚t  | ¡} t jˆˆˆ ˆd�}t  | |¡S )NzFThe `@field_validator` decorator cannot be applied to instance methodszvalidator-instance-methodr{   )rx   r)   rv   rD   )r   Zis_instance_method_from_sigr   Ú%ensure_classmethod_based_on_signatureZFieldValidatorDecoratorInfoÚPydanticDescriptorProxy©r‚   Zdec_info©rv   rx   rD   r)   r3   r4   Údecñ  s    
þ
ÿzfield_validator.<locals>.dec)Úcallabler}   rB   r   r   r   Úall)r'   r)   rv   rD   rx   r‡   r3   r†   r4   rz   ™  s(    @ýþýÚ
_ModelTypeÚ_ModelTypeCo)Ú	covariantc                   @  s$   e Zd ZdZd	ddddœdd„ZdS )
ÚModelWrapValidatorHandlerz]`@model_validator` decorated function handler argument type. This is used when `mode='wrap'`.Nr   zstr | int | Noner‹   )rb   Úouter_locationr%   c                C  s   d S rR   r3   )r1   rb   rŽ   r3   r3   r4   rd     s    z"ModelWrapValidatorHandler.__call__)N©r=   r>   r?   r@   rd   r3   r3   r3   r4   r�   	  s    ýr�   c                   @  s$   e Zd ZdZdddddœdd„Zd	S )
ÚModelWrapValidatorWithoutInfoz‰A `@model_validator` decorated function signature.
    This is used when `mode='wrap'` and the function does not have info argument.
    útype[_ModelType]r   ú%ModelWrapValidatorHandler[_ModelType]rŠ   rl   c                C  s   d S rR   r3   rm   r3   r3   r4   rd     s    	z&ModelWrapValidatorWithoutInfo.__call__Nr�   r3   r3   r3   r4   r�     s   r�   c                   @  s&   e Zd ZdZddddddœdd	„Zd
S )ÚModelWrapValidatorzSA `@model_validator` decorated function signature. This is used when `mode='wrap'`.r‘   r   r’   zcore_schema.ValidationInforŠ   ro   c                C  s   d S rR   r3   rp   r3   r3   r4   rd   )  s    
zModelWrapValidator.__call__Nr�   r3   r3   r3   r4   r“   &  s   r“   c                   @  s    e Zd ZdZdddœdd„ZdS )Ú#FreeModelBeforeValidatorWithoutInfoú‹A `@model_validator` decorated function signature.
    This is used when `mode='before'` and the function does not have info argument.
    r   )rb   r%   c                C  s   d S rR   r3   )r1   rb   r3   r3   r4   rd   ;  s    z,FreeModelBeforeValidatorWithoutInfo.__call__Nr�   r3   r3   r3   r4   r”   6  s   r”   c                   @  s"   e Zd ZdZddddœdd„ZdS )ÚModelBeforeValidatorWithoutInfor•   r   ra   c                C  s   d S rR   r3   rc   r3   r3   r4   rd   J  s    z(ModelBeforeValidatorWithoutInfo.__call__Nr�   r3   r3   r3   r4   r–   E  s   r–   c                   @  s"   e Zd ZdZddddœdd„ZdS )ÚFreeModelBeforeValidatorúUA `@model_validator` decorated function signature. This is used when `mode='before'`.r   rg   )rb   rM   r%   c                C  s   d S rR   r3   )r1   rb   rM   r3   r3   r4   rd   X  s    z!FreeModelBeforeValidator.__call__Nr�   r3   r3   r3   r4   r—   U  s   r—   c                   @  s$   e Zd ZdZdddddœdd„ZdS )ÚModelBeforeValidatorr˜   r   rg   rh   c                C  s   d S rR   r3   ri   r3   r3   r4   rd   f  s    	zModelBeforeValidator.__call__Nr�   r3   r3   r3   r4   r™   c  s   r™   z|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])r)   r%   c                 C  s   d S rR   r3   ©r)   r3   r3   r4   Úmodel_validator�  s    r›   zLiteral['before']zrCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]c                 C  s   d S rR   r3   rš   r3   r3   r4   r›   Š  s    z}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]c                 C  s   d S rR   r3   rš   r3   r3   r4   r›   “  s    z"Literal['wrap', 'before', 'after']c                   s   dddœ‡ fdd„}|S )a@  !!! abstract "Usage Documentation"
        [Model Validators](../concepts/validators.md#model-validators)

    Decorate model methods for validation purposes.

    Example usage:
    ```python
    from typing_extensions import Self

    from pydantic import BaseModel, ValidationError, model_validator

    class Square(BaseModel):
        width: float
        height: float

        @model_validator(mode='after')
        def verify_square(self) -> Self:
            if self.width != self.height:
                raise ValueError('width and height do not match')
            return self

    s = Square(width=1, height=1)
    print(repr(s))
    #> Square(width=1.0, height=1.0)

    try:
        Square(width=1, height=2)
    except ValidationError as e:
        print(e)
        '''
        1 validation error for Square
          Value error, width and height do not match [type=value_error, input_value={'width': 1, 'height': 2}, input_type=dict]
        '''
    ```

    For more in depth examples, see [Model Validators](../concepts/validators.md#model-validators).

    Args:
        mode: A required string literal that specifies the validation mode.
            It can be one of the following: 'wrap', 'before', or 'after'.

    Returns:
        A decorator that can be used to decorate a function to be used as a model validator.
    r   r€   r�   c                   sN   t  | ¡} ˆ dkr6t| tƒr6tjtdtƒ › d�dd� t jˆ d�}t  	| |¡S )Nr&   zŸUsing `@model_validator` with mode='after' on a classmethod is deprecated. Instead, use an instance method. See the documentation at https://docs.pydantic.dev/z,/concepts/validators/#model-after-validator.é   )ÚcategoryÚmessageÚ
stacklevelrš   )
r   rƒ   r}   rB   ÚwarningsÚwarnr   r   ZModelValidatorDecoratorInfor„   r…   rš   r3   r4   r‡   Í  s    
ÿú	zmodel_validator.<locals>.decr3   )r)   r‡   r3   rš   r4   r›   œ  s    1ÚAnyTypec                   @  s@   e Zd ZdZedddœdd„ƒZedddd	œd
d„ƒZejZdS )Ú
InstanceOfuž  Generic type for annotating a type that is an instance of a given class.

        Example:
            ```python
            from pydantic import BaseModel, InstanceOf

            class Foo:
                ...

            class Bar(BaseModel):
                foo: InstanceOf[Foo]

            Bar(foo=Foo())
            try:
                Bar(foo=42)
            except ValidationError as e:
                print(e)
                """
                [
                â”‚   {
                â”‚   â”‚   'type': 'is_instance_of',
                â”‚   â”‚   'loc': ('foo',),
                â”‚   â”‚   'msg': 'Input should be an instance of Foo',
                â”‚   â”‚   'input': 42,
                â”‚   â”‚   'ctx': {'class': 'Foo'},
                â”‚   â”‚   'url': 'https://errors.pydantic.dev/0.38.0/v/is_instance_of'
                â”‚   }
                ]
                """
            ```
        r¢   ©Úitemr%   c                 C  s   t || ƒ f S rR   )r   ©r;   r¥   r3   r3   r4   Ú__class_getitem__  s    zInstanceOf.__class_getitem__r   r   r!   ©Úsourcer$   r%   c                 C  sl   ddl m} t t |¡p|¡}z||ƒ}W n |yB   | Y S 0 tjdd„ |d�|d< tj||d�S d S )Nr   )ÚGENERATE_SCHEMA_ERRORSc                 S  s   || ƒS rR   r3   rS   r3   r3   r4   rV     rW   z9InstanceOf.__get_pydantic_core_schema__.<locals>.<lambda>©rX   r,   rQ   )Zpython_schemaZjson_schema)Z#pydantic._internal._generate_schemarª   r   Zis_instance_schemar   Ú
get_originr[   Zjson_or_python_schema)r;   r©   r$   rª   Zinstance_of_schemaÚoriginal_schemar3   r3   r4   r5     s    
ÿ
z'InstanceOf.__get_pydantic_core_schema__N)	r=   r>   r?   r@   rB   r§   r5   ÚobjectÚ__hash__r3   r3   r3   r4   r£   é  s    r£   c                   @  s<   e Zd ZdZdddœdd„Zeddddœd	d
„ƒZejZdS )ÚSkipValidationa¬  If this is applied as an annotation (e.g., via `x: Annotated[int, SkipValidation]`), validation will be
            skipped. You can also use `SkipValidation[int]` as a shorthand for `Annotated[int, SkipValidation]`.

        This can be useful if you want to use a type annotation for documentation/IDE/type-checking purposes,
        and know that it is safe to skip validation for one or more of the fields.

        Because this converts the validation schema to `any_schema`, subsequent annotation-applied transformations
        may not have the expected effects. Therefore, when used, this annotation should generally be the final
        annotation applied to a type.
        r   r¤   c                 C  s   t |tƒ f S rR   )r   r°   r¦   r3   r3   r4   r§   7  s    z SkipValidation.__class_getitem__r   r!   r¨   c                   sj   t  ¡ �$ t  dt¡ ||ƒ‰ W d   ƒ n1 s20    Y  d‡ fdd„gi}tj|tjdd„ ˆ d�d�S )NÚignoreZ pydantic_js_annotation_functionsc                   s   |ˆ ƒS rR   r3   )Z_crU   ©r­   r3   r4   rV   ?  rW   z=SkipValidation.__get_pydantic_core_schema__.<locals>.<lambda>c                 S  s   || ƒS rR   r3   rS   r3   r3   r4   rV   C  rW   r«   )ÚmetadatarQ   )r    Úcatch_warningsÚsimplefilterr   r   Z
any_schemar[   )r;   r©   r$   r³   r3   r²   r4   r5   :  s    
&ÿþz+SkipValidation.__get_pydantic_core_schema__N)	r=   r>   r?   r@   r§   rB   r5   r®   r¯   r3   r3   r3   r4   r°   *  s
   r°   Ú
_FromTypeTc                   @  s4   e Zd ZdZddddœdd„Zdd	d
dœdd„ZdS )Ú
ValidateAsa…  A helper class to validate a custom type from a type that is natively supported by Pydantic.

    Args:
        from_type: The type natively supported by Pydantic to use to perform validation.
        instantiation_hook: A callable taking the validated type as an argument, and returning
            the populated custom type.

    Example:
        ```python {lint="skip"}
        from typing import Annotated

        from pydantic import BaseModel, TypeAdapter, ValidateAs

        class MyCls:
            def __init__(self, a: int) -> None:
                self.a = a

            def __repr__(self) -> str:
                return f"MyCls(a={self.a})"

        class Model(BaseModel):
            a: int


        ta = TypeAdapter(
            Annotated[MyCls, ValidateAs(Model, lambda v: MyCls(a=v.a))]
        )

        print(ta.validate_python({'a': 1}))
        #> MyCls(a=1)
        ```
    zCallable[[_FromTypeT], Any]ztype[_FromTypeT]ÚNone)Úinstantiation_hookÚ	from_typer%   c                C  s   || _ || _d S rR   )rº   r¹   )r1   rº   r¹   r3   r3   r4   Ú__init__p  s    zValidateAs.__init__r   r   r!   r¨   c                 C  s   || j ƒ}tj| j|d�S )Nr+   )rº   r   r0   r¹   )r1   r©   r$   r,   r3   r3   r4   r5   t  s
    
þz'ValidateAs.__get_pydantic_core_schema__N)r=   r>   r?   r@   r»   r5   r3   r3   r3   r4   r·   M  s   "r·   )Wr@   Ú
__future__r   Z_annotationsZdataclassesÚsysr    Ú	functoolsr   Útypingr   r   r   r   r   r	   r
   r   r   Zpydantic_corer   r   Ztyping_extensionsr   r   Ú	_internalr   r   r   Zannotated_handlersr   Úerrorsr   Úversionr   r   r   Úversion_infor   Zinspect_validatorr-   Z	dataclassZ
slots_truer   rC   rO   r\   r`   rf   rj   rn   r.   r/   Z_V2Validatorr^   r_   Z_V2WrapValidatorrB   Ústaticmethodrq   rA   rr   rt   ru   rz   rŠ   r‹   ZValidatorFunctionWrapHandlerr�   r�   r“   r”   r–   r—   r™   ZModelAfterValidatorWithoutInfoZValidationInfoZModelAfterValidatorZ_AnyModelWrapValidatorZ_AnyModelBeforeValidatorZ_AnyModelAfterValidatorr›   r¢   r£   r°   r¶   r·   r3   r3   r3   r4   Ú<module>   sÊ   ,
<BcJ
ýÿýÿ,
þú
ú
ûúl
ÿD<