o
    f^                     @  s  U d Z ddlmZ ddlZddlZddlmZ ddlm	Z	 ddl
mZmZmZmZmZmZmZ ddlmZ ddlmZ ddlmZmZmZ d	d
lmZ d	dlmZmZmZm Z  d	d
l!mZ d	dl"m#Z# ej$dk roddlm%Z% nddl
m%Z% ej&Z'ej(d[ddie j)G dd dZ*ej(d[ddie j)G dd dZ+ej(d[ddie j)G dd dZ,ej(d[ddie j)G dd dZ-erG dd de%Z.G dd de%Z/G dd de%Z0ee/ej1e.ej2f Z3ee0ej4f Z5ee6eeef e7eef ee f Z8de9d < ed!e3e8Z:ed"e5e8Z;ed#d#d$d\d.d/Z<ed#d0d]d3d/Z<ed4 Z=de9d5< d6dd$d^d8d/Z<ed9Z>ed:dd;Z?G d<d= d=ej@e%e? ZAG d>d? d?e%e> ZBG d@dA dAe%e> ZCG dBdC dCe%ZDG dDdE dEe%ZEG dFdG dGe%ZFG dHdI dIe%ZGee>ge>f ZH	 ee>ejIge>f ZJ	 eeCe> eBe> f ZKeeFeGeDeEf ZLeeJe> eHe> f ZMed_dKdLZNed`dOdLZNedadRdLZNdbdUdLZNedVZOereeOd#f ZPnej(d[i e j)G dWdX dXZPereeOd#f ZQdS ej(d[i e j)G dYdZ dZZQdS )czBThis module contains related classes and functions for validation.    )annotationsN)partialmethod)FunctionType)TYPE_CHECKINGAnyCallableTypeVarUnioncastoverload)core_schema)	AnnotatedLiteral	TypeAlias   )GetCoreSchemaHandler)_core_metadata_decorators	_generics_internal_dataclass)PydanticUserError)      )ProtocolfrozenTc                   @  $   e Zd ZU dZded< dd
dZdS )AfterValidatora8  Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators

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

    Attributes:
        func: The validator function.

    Example:
        ```py
        from typing_extensions 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funcsource_typer   handler_GetCoreSchemaHandlerreturncore_schema.CoreSchemac                 C  T   ||}t | jd}|rttj| j}tj|||jdS ttj| j}tj||dS )Nafterschema
field_namer'   )	_inspect_validatorr   r
   r   WithInfoValidatorFunction"with_info_after_validator_functionr(   NoInfoValidatorFunction no_info_after_validator_functionselfr   r    r'   info_argr    r2   V/var/www/NoticeGen/venv/lib/python3.10/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__I      z+AfterValidator.__get_pydantic_core_schema__Nr   r   r    r!   r"   r#   __name__
__module____qualname____doc____annotations__r4   r2   r2   r2   r3   r      s   
 )r   c                   @  r   )BeforeValidatora  Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators

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

    Attributes:
        func: The validator function.

    Example:
        ```py
        from typing_extensions 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   r   r    r!   r"   r#   c                 C  r$   )Nbeforer&   r)   )	r*   r   r
   r   r+   #with_info_before_validator_functionr(   r-   !no_info_before_validator_functionr/   r2   r2   r3   r4   u   r5   z,BeforeValidator.__get_pydantic_core_schema__Nr6   r7   r2   r2   r2   r3   r=   T   s   
 r=   c                   @  r   )PlainValidatora;  Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators

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

    Attributes:
        func: The validator function.

    Example:
        ```py
        from typing_extensions import Annotated

        from pydantic import BaseModel, PlainValidator

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

        class Model(BaseModel):
            a: MyInt

        print(Model(a='1').a)
        #> 2
        ```
    r   r   r   r   r    r!   r"   r#   c                 C  s   ddl m} z||}tjdd |d}W n |y    d }Y nw t| jd}|r9ttj| j}tj||j	|dS ttj
| j}tj||dS )	Nr   PydanticSchemaGenerationErrorc                 S     || S Nr2   vhr2   r2   r3   <lambda>       z=PlainValidator.__get_pydantic_core_schema__.<locals>.<lambda>functionr'   plain)r(   serialization)rN   )pydanticrC   r   #wrap_serializer_function_ser_schemar*   r   r
   r+   "with_info_plain_validator_functionr(   r-    no_info_plain_validator_function)r0   r   r    rC   r'   rN   r1   r   r2   r2   r3   r4      s   z+PlainValidator.__get_pydantic_core_schema__Nr6   r7   r2   r2   r2   r3   rA      s   
 rA   c                   @  r   )WrapValidatora  Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators

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

    Attributes:
        func: The validator function.

    ```py
    from datetime import datetime

    from typing_extensions 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   r   r    r!   r"   r#   c                 C  r$   )Nwrapr&   r)   )	r*   r   r
   r   WithInfoWrapValidatorFunction!with_info_wrap_validator_functionr(   NoInfoWrapValidatorFunctionno_info_wrap_validator_functionr/   r2   r2   r3   r4      r5   z*WrapValidator.__get_pydantic_core_schema__Nr6   r7   r2   r2   r2   r3   rS      s   
 $rS   c                   @  s   e Zd ZdddZdS )	_OnlyValueValidatorClsMethodclsr   valuer"   c                C     d S rE   r2   r0   rZ   r[   r2   r2   r3   __call__       z%_OnlyValueValidatorClsMethod.__call__NrZ   r   r[   r   r"   r   r8   r9   r:   r^   r2   r2   r2   r3   rY          rY   c                   @  s   e Zd Zd
ddZd	S )_V2ValidatorClsMethodrZ   r   r[   info_core_schema.ValidationInfor"   c                C  r\   rE   r2   r0   rZ   r[   rd   r2   r2   r3   r^      r_   z_V2ValidatorClsMethod.__call__NrZ   r   r[   r   rd   re   r"   r   ra   r2   r2   r2   r3   rc      rb   rc   c                   @  s   e Zd Zdd	d
ZdS )_V2WrapValidatorClsMethodrZ   r   r[   r    )_core_schema.ValidatorFunctionWrapHandlerrd   re   r"   c                C  r\   rE   r2   r0   rZ   r[   r    rd   r2   r2   r3   r^         z"_V2WrapValidatorClsMethod.__call__N)
rZ   r   r[   r   r    ri   rd   re   r"   r   ra   r2   r2   r2   r3   rh      rb   rh   r   _PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType_V2WrapValidatorType.)modecheck_fieldsfieldstrfieldsro   #Literal['before', 'after', 'plain']rp   bool | Noner"   RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]c               G  r\   rE   r2   rq   ro   rp   rs   r2   r2   r3   field_validator  rk   rx   )rp   Literal['wrap']6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]c               G  r\   rE   r2   rw   r2   r2   r3   rx     rk   )r>   r%   rT   rM   FieldValidatorModesr%   Callable[[Any], Any]c                 sV   t | trtddd| gR tdd D s tdddd fdd}|S )a:  Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#field-validators

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

    Example usage:
    ```py
    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:
        field: The first field the `field_validator` should be called on; this is separate
            from `fields` to ensure an error is raised if you don't pass at least one.
        *fields: Additional field(s) the `field_validator` should be called on.
        mode: Specifies whether to validate the fields before or after validation.
        check_fields: Whether to check that the fields actually exist on the model.

    Returns:
        A decorator that can be used to decorate a function to be used as a field_validator.

    Raises:
        PydanticUserError:
            - If `@field_validator` is used bare (with no fields).
            - If the args passed to `@field_validator` as fields are not strings.
            - If `@field_validator` applied to instance methods.
    z`@field_validator` should be used with fields and keyword arguments, not bare. E.g. usage should be `@validator('<field_name>', ...)`zvalidator-no-fieldscodec                 s  s    | ]}t |tV  qd S rE   )
isinstancerr   ).0rq   r2   r2   r3   	<genexpr>l  s    z"field_validator.<locals>.<genexpr>z`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('<field_name_1>', '<field_name_2>', ...)`zvalidator-invalid-fieldsfHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]r"   (_decorators.PydanticDescriptorProxy[Any]c                   s<   t | rtdddt | } t j d}t | |S )Nz8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodr}   )rs   ro   rp   )r   is_instance_method_from_sigr   %ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxyr   dec_inforp   rs   ro   r2   r3   decs  s   

zfield_validator.<locals>.decN)r   r   r"   r   )r   r   r   all)rq   ro   rp   rs   r   r2   r   r3   rx   &  s   
?
_ModelType_ModelTypeCo)	covariantc                   @  s   e Zd ZdZ	ddd	d
ZdS )ModelWrapValidatorHandlerz[@model_validator decorated function handler argument type. This is used when `mode='wrap'`.Nr[   r   outer_locationstr | int | Noner"   r   c                C  r\   rE   r2   )r0   r[   r   r2   r2   r3   r^        z"ModelWrapValidatorHandler.__call__rE   )r[   r   r   r   r"   r   r8   r9   r:   r;   r^   r2   r2   r2   r3   r     s    r   c                   @  s   e Zd ZdZdd
dZdS )ModelWrapValidatorWithoutInfozA @model_validator decorated function signature.
    This is used when `mode='wrap'` and the function does not have info argument.
    rZ   type[_ModelType]r[   r   r    %ModelWrapValidatorHandler[_ModelType]r"   r   c                C  r\   rE   r2   )r0   rZ   r[   r    r2   r2   r3   r^        	z&ModelWrapValidatorWithoutInfo.__call__N)rZ   r   r[   r   r    r   r"   r   r   r2   r2   r2   r3   r         r   c                   @  s   e Zd ZdZdddZdS )ModelWrapValidatorzQA @model_validator decorated function signature. This is used when `mode='wrap'`.rZ   r   r[   r   r    r   rd   re   r"   r   c                C  r\   rE   r2   rj   r2   r2   r3   r^     s   
zModelWrapValidator.__call__N)
rZ   r   r[   r   r    r   rd   re   r"   r   r   r2   r2   r2   r3   r         r   c                   @  s   e Zd ZdZdddZdS )	#FreeModelBeforeValidatorWithoutInfoA @model_validator decorated function signature.
    This is used when `mode='before'` and the function does not have info argument.
    r[   r   r"   c                C  r\   rE   r2   )r0   r[   r2   r2   r3   r^     rk   z,FreeModelBeforeValidatorWithoutInfo.__call__N)r[   r   r"   r   r   r2   r2   r2   r3   r     r   r   c                   @  s   e Zd ZdZd	ddZdS )
ModelBeforeValidatorWithoutInfor   rZ   r   r[   r"   c                C  r\   rE   r2   r]   r2   r2   r3   r^        z(ModelBeforeValidatorWithoutInfo.__call__Nr`   r   r2   r2   r2   r3   r     r   r   c                   @  s   e Zd ZdZd
ddZd	S )FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.r[   r   rd   re   r"   c                C  r\   rE   r2   )r0   r[   rd   r2   r2   r3   r^     r   z!FreeModelBeforeValidator.__call__N)r[   r   rd   re   r"   r   r   r2   r2   r2   r3   r     r   r   c                   @  s   e Zd ZdZddd	Zd
S )ModelBeforeValidatorr   rZ   r   r[   rd   re   r"   c                C  r\   rE   r2   rf   r2   r2   r3   r^     r   zModelBeforeValidator.__call__Nrg   r   r2   r2   r2   r3   r     r   r   |Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]c                 C  r\   rE   r2   ro   r2   r2   r3   model_validator   r   r   Literal['before']qCallable[[_AnyModeBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]c                 C  r\   rE   r2   r   r2   r2   r3   r   	  r   Literal['after']}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]c                 C  r\   rE   r2   r   r2   r2   r3   r     r   "Literal['wrap', 'before', 'after']r   c                   s   d fdd}|S )	a"  Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#model-validators

    Decorate model methods for validation purposes.

    Example usage:
    ```py
    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"   r   c                   s"   t | } t j d}t | |S )Nr   )r   r   ModelValidatorDecoratorInfor   r   r   r2   r3   r   K  s   
zmodel_validator.<locals>.decN)r   r   r"   r   r2   )ro   r   r2   r   r3   r     s   0AnyTypec                   @  s2   e Zd ZdZedddZe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:
            ```py
            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'
                │   }
                ]
                """
            ```
        itemr   r"   c                 C  s   t ||  f S rE   )r   rZ   r   r2   r2   r3   __class_getitem__  s   zInstanceOf.__class_getitem__sourcer   r    r   r#   c                 C  sh   ddl m} tt|p|}z||}W n |y!   | Y S w tjdd |d|d< tj||dS )Nr   rB   c                 S  rD   rE   r2   rF   r2   r2   r3   rI     rJ   z9InstanceOf.__get_pydantic_core_schema__.<locals>.<lambda>rK   rN   )python_schemajson_schema)rO   rC   r   is_instance_schemar   
get_originrP   json_or_python_schema)rZ   r   r    rC   instance_of_schemaoriginal_schemar2   r2   r3   r4     s   
z'InstanceOf.__get_pydantic_core_schema__N)r   r   r"   r   r   r   r    r   r"   r#   )	r8   r9   r:   r;   classmethodr   r4   object__hash__r2   r2   r2   r3   r   ]  s     
r   c                   @  s.   e Zd ZdZdddZe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   r"   c                 C  s   t |t f S rE   )r   r   r   r2   r2   r3   r     s   z SkipValidation.__class_getitem__r   r    r   r#   c                   s:   || t j fddgd}tj|tjdd  ddS )Nc                   s   | S rE   r2   )_crH   r   r2   r3   rI     rJ   z=SkipValidation.__get_pydantic_core_schema__.<locals>.<lambda>)js_annotation_functionsc                 S  rD   rE   r2   rF   r2   r2   r3   rI     rJ   rK   )metadatarN   )r   build_metadata_dictr   
any_schemarP   )rZ   r   r    r   r2   r   r3   r4     s   z+SkipValidation.__get_pydantic_core_schema__N)r   r   r"   r   r   )	r8   r9   r:   r;   r   r   r4   r   r   r2   r2   r2   r3   r     s    


r   r2   )
rq   rr   rs   rr   ro   rt   rp   ru   r"   rv   )
rq   rr   rs   rr   ro   ry   rp   ru   r"   rz   )
rq   rr   rs   rr   ro   r{   rp   ru   r"   r|   )ro   ry   r"   r   )ro   r   r"   r   )ro   r   r"   r   )ro   r   r"   r   )Rr;   
__future__r   _annotationsdataclassessys	functoolsr   typesr   typingr   r   r   r   r	   r
   r   pydantic_corer   _core_schematyping_extensionsr   r   r    r   r!   	_internalr   r   r   r   annotated_handlerserrorsr   version_infor   inspect_validatorr*   	dataclass
slots_truer   r=   rA   rS   rY   rc   rh   r+   r-   _V2ValidatorrU   _V2WrapValidatorr   staticmethodrl   r<   rm   rn   rx   r{   r   r   ValidatorFunctionWrapHandlerr   r   r   r   r   r   r   ModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModeBeforeValidator_AnyModelAfterValidatorr   r   r   r   r2   r2   r2   r3   <module>   s    $
7+32
,		^

9<