U njr @szUdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZddlmZmZddlmZdd lmZmZmZmZd d lmZmZmZd d lm Z d d l!m"Z"ej#dkrddlm$Z$n ddl m$Z$ej%Z&ej'fddiej(GdddZ)ej'fddiej(GdddZ*ej'fddiej(GdddZ+ej'fddiej(GdddZ,e r:Gddde$Z-Gddde$Z.Gddde$Z/Gd d!d!e$Z0ee.ej1e-ej2fZ3ee0ej4e/ej5fZ6ee7e e e fe8e e fee fZ9d"e:d#<ed$ee3e9fd%Z;ed&ee6e9fd%Zed)d)d*d+d+d3d-d.d4d0d5d2Z>ed)d)d6d+d+d7d-d4d8d9d2Z>d:ded;d+d+d(d-d.ded>Z?ed?dd@Z@GdAdBdBejAe$e@ZBGdCdDdDe$e?ZCGdEdFdFe$e?ZDGdGdHdHe$ZEGdIdJdJe$ZFGdKdLdLe$ZGGdMdNdNe$ZHe e?ge?fZIe e?ejJge?fZKeeDe?eCe?fZLeeGeHeEeFfZMeeKe?eIe?fZNed,dOdPdQdRZOedSdTdPdUdRZOed7dVdPdWdRZOdXd.dPdYdRZOedZZPe r*eePd)fZQnej'fej(Gd[d\d\ZQe rZeePd)fZRnej'fej(Gd]d^d^ZRdS)_zBThis module contains related classes and functions for validation.) annotationsN) partialmethod) FunctionType) TYPE_CHECKINGAnyCallableTypeVarUnioncastoverload)PydanticUndefined core_schema)r ) AnnotatedLiteralSelf TypeAlias) _decorators _generics_internal_dataclass)GetCoreSchemaHandler)PydanticUserError) )ProtocolfrozenTc@s@eZdZUdZded<dddddd Zed d d d dZdS)AfterValidatora9Usage docs: https://docs.pydantic.dev/2.10/concepts/validators/#field-validators 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_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.WithInfoValidatorFunctionfuncrrcore_schema.CoreSchema source_typehandlerreturncCsX||}t|jd}|r8ttj|j}tj|||jdSttj|j}tj||dSdS)Nafter)schema field_name)r%) _inspect_validatorrr r WithInfoValidatorFunctionZ"with_info_after_validator_functionr&NoInfoValidatorFunctionZ no_info_after_validator_function)selfr!r"r%info_argrr,B/tmp/pip-unpacked-wheel-zvl9l234/pydantic/functional_validators.py__get_pydantic_core_schema__Hs z+AfterValidator.__get_pydantic_core_schema__>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]r decoratorr#cCs ||jdS)Nrr2clsr1r,r,r-_from_decoratorRszAfterValidator._from_decoratorN)__name__ __module__ __qualname____doc____annotations__r. classmethodr5r,r,r,r-rs ) rc@sLeZdZUdZded<eZded<ddddd d Zed d d ddZ dS)BeforeValidatoraeUsage docs: https://docs.pydantic.dev/2.10/concepts/validators/#field-validators 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 of the function. This is only used to generate the appropriate JSON Schema (in validation mode). Example: ```python 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 ``` rrrjson_schema_input_typerrr cCsv||}|jtkrdn ||j}t|jd}|rTttj|j}tj|||j |dSttj |j}tj |||dSdS)Nbeforer%r&json_schema_input_schemar%r@) r=r generate_schemar'rr r r(Z#with_info_before_validator_functionr&r)Z!no_info_before_validator_functionr*r!r"r% input_schemar+rr,r,r-r.{s(  z,BeforeValidator.__get_pydantic_core_schema__r/rr0cCs||j|jjdSN)rr=rinfor=r3r,r,r-r5szBeforeValidator._from_decoratorN r6r7r8r9r:r r=r.r;r5r,r,r,r-r<Ws  r<c@sLeZdZUdZded<eZded<ddddd d Zed d d ddZ dS)PlainValidatoraUsage docs: https://docs.pydantic.dev/2.10/concepts/validators/#field-validators 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 of the function. This is only used to generate the appropriate JSON Schema (in validation mode). If not provided, will default to `Any`. Example: ```python from typing import Union from typing_extensions import Annotated from pydantic import BaseModel, PlainValidator MyInt = Annotated[ int, PlainValidator( lambda v: int(v) + 1, 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`. rrrr=rrr c Csddlm}z.||}|dtjdd|||d}Wn|k rRd}YnX||j}t|jd}|rt tj |j}tj ||j ||dSt tj |j}tj|||d SdS) NrPydanticSchemaGenerationError serializationcSs||SNr,vhr,r,r-z=PlainValidator.__get_pydantic_core_schema__..)functionr%Z return_schemaplain)r&rLr@)rLr@)pydanticrKgetr #wrap_serializer_function_ser_schemarBr=r'rr r(Z"with_info_plain_validator_functionr&r)Z no_info_plain_validator_function) r*r!r"rKr%rLrDr+rr,r,r-r.s:    z+PlainValidator.__get_pydantic_core_schema__r/rr0cCs||j|jjdSrErFr3r,r,r-r5szPlainValidator._from_decoratorN) r6r7r8r9r:rr=r.r;r5r,r,r,r-rIs + *rIc@sLeZdZUdZded<eZded<ddddd d Zed d d ddZ dS) WrapValidatoraUsage docs: https://docs.pydantic.dev/2.10/concepts/validators/#field-validators 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 of the function. This is only used to generate the appropriate JSON Schema (in validation mode). ```python 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.WithInfoWrapValidatorFunctionrrr=rrr cCsv||}|jtkrdn ||j}t|jd}|rTttj|j}tj|||j |dSttj |j}tj |||dSdS)Nwrapr?rA) r=r rBr'rr r WithInfoWrapValidatorFunctionZ!with_info_wrap_validator_functionr&NoInfoWrapValidatorFunctionZno_info_wrap_validator_functionrCr,r,r-r.'s(  z*WrapValidator.__get_pydantic_core_schema__r/rr0cCs||j|jjdSrErFr3r,r,r-r5@szWrapValidator._from_decoratorNrHr,r,r,r-rXs & rXc@seZdZddddddZdS)_OnlyValueValidatorClsMethodrr4valuer#cCsdSrMr,r*r4r^r,r,r-__call__KrRz%_OnlyValueValidatorClsMethod.__call__Nr6r7r8r`r,r,r,r-r\Jsr\c@s eZdZdddddddZdS)_V2ValidatorClsMethodr_core_schema.ValidationInfor4r^rGr#cCsdSrMr,r*r4r^rGr,r,r-r`NrRz_V2ValidatorClsMethod.__call__Nrar,r,r,r-rbMsrbc@s eZdZdddddddZdS) _OnlyValueWrapValidatorClsMethodr)_core_schema.ValidatorFunctionWrapHandlerr4r^r"r#cCsdSrMr,r*r4r^r"r,r,r-r`QrRz)_OnlyValueWrapValidatorClsMethod.__call__Nrar,r,r,r-rfPsrfc@s"eZdZddddddddZdS)_V2WrapValidatorClsMethodrrgrcr4r^r"rGr#cCsdSrMr,r*r4r^r"rGr,r,r-r`Tsz"_V2WrapValidatorClsMethod.__call__Nrar,r,r,r-rjSsrjr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)r>r$rYrTFieldValidatorModes.) check_fieldsr=strzLiteral['wrap']z bool | Nonerz6Callable[[_V2WrapValidatorType], _V2WrapValidatorType])fieldfieldsmoderrr=r#cGsdSrMr,rtrvrrr=rur,r,r-field_validatorvsrxzLiteral[('before', 'plain')]zRCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cGsdSrMr,rwr,r,r-rxs)rvrrzLiteral['after'])rtrurvrrr#cGsdSrMr,)rtrvrrrur,r,r-rxsr$)rvrrr=zCallable[[Any], Any]cst|trtddddkr8tk r8tdddtkrLdkrLt|ftdd Dsttd d dd d dfdd }|S)a6Usage docs: https://docs.pydantic.dev/2.10/concepts/validators/#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: 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. 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'`. 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('', ...)`zvalidator-no-fieldscode)r>rTrYz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typerTcss|]}t|tVqdSrM) isinstancers).0rtr,r,r- sz"field_validator..z`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('', '', ...)`zvalidator-invalid-fieldszHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any](_decorators.PydanticDescriptorProxy[Any]fr#cs>t|rtdddt|}tjd}t||S)Nz8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodry)rurvrrr=)rZis_instance_method_from_sigr%ensure_classmethod_based_on_signatureZFieldValidatorDecoratorInfoPydanticDescriptorProxyrZdec_inforrrur=rvr,r-decs  zfield_validator..dec)r{rrr rall)rtrvrrr=rurr,rr-rxs(C   _ModelType _ModelTypeCo) covariantc@s$eZdZdZd ddddddZdS) ModelWrapValidatorHandlerz]`@model_validator` decorated function handler argument type. This is used when `mode='wrap'`.Nrzstr | int | Noner)r^outer_locationr#cCsdSrMr,)r*r^rr,r,r-r` sz"ModelWrapValidatorHandler.__call__)Nr6r7r8r9r`r,r,r,r-rsrc@s$eZdZdZdddddddZd S) ModelWrapValidatorWithoutInfozA `@model_validator` decorated function signature. This is used when `mode='wrap'` and the function does not have info argument. type[_ModelType]r%ModelWrapValidatorHandler[_ModelType]rrhcCsdSrMr,rir,r,r-r`s z&ModelWrapValidatorWithoutInfo.__call__Nrr,r,r,r-rsrc@s&eZdZdZdddddddd Zd S) ModelWrapValidatorzSA `@model_validator` decorated function signature. This is used when `mode='wrap'`.rrrrcrrkcCsdSrMr,rlr,r,r-r`(s zModelWrapValidator.__call__Nrr,r,r,r-r%src@s eZdZdZdddddZdS)#FreeModelBeforeValidatorWithoutInfoA `@model_validator` decorated function signature. This is used when `mode='before'` and the function does not have info argument. r)r^r#cCsdSrMr,)r*r^r,r,r-r`:sz,FreeModelBeforeValidatorWithoutInfo.__call__Nrr,r,r,r-r5src@s"eZdZdZddddddZdS)ModelBeforeValidatorWithoutInforrr]cCsdSrMr,r_r,r,r-r`Isz(ModelBeforeValidatorWithoutInfo.__call__Nrr,r,r,r-rDsrc@s"eZdZdZddddddZdS)FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.rrc)r^rGr#cCsdSrMr,)r*r^rGr,r,r-r`Wsz!FreeModelBeforeValidator.__call__Nrr,r,r,r-rTsrc@s$eZdZdZdddddddZdS)ModelBeforeValidatorrrrcrdcCsdSrMr,rer,r,r-r`es zModelBeforeValidator.__call__Nrr,r,r,r-rbsrz|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rvr#cCsdSrMr,rvr,r,r-model_validatorsrzLiteral['before']zrCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCsdSrMr,rr,r,r-rsz}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCsdSrMr,rr,r,r-rsz$Literal[('wrap', 'before', 'after')]csdddfdd }|S)a'Usage docs: https://docs.pydantic.dev/2.10/concepts/validators/#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. rr~rcs"t|}tjd}t||S)Nr)rrZModelValidatorDecoratorInforrrr,r-rs  zmodel_validator..decr,)rvrr,rr-rs0AnyTypec@s@eZdZdZedddddZedddd d d ZejZd S) InstanceOfuGeneric 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' │ } ] """ ``` ritemr#cCst||fSrM)rr4rr,r,r-__class_getitem__szInstanceOf.__class_getitem__rrrsourcer"r#cCsnddlm}tt|p|}z ||}Wn|k rD|YSXtjdd|d|d<tj||dSdS)NrrJcSs||SrMr,rNr,r,r-rQrRz9InstanceOf.__get_pydantic_core_schema__..rSr%rL)Z python_schemaZ json_schema)rUrKr Zis_instance_schemar get_originrWZjson_or_python_schema)r4rr"rKZinstance_of_schemaoriginal_schemar,r,r-r.s    z'InstanceOf.__get_pydantic_core_schema__N) r6r7r8r9r;rr.object__hash__r,r,r,r-rs  rc@s<eZdZdZdddddZeddddd d ZejZd S) SkipValidationaIf 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. rrcCst|tfSrM)rrrr,r,r-r+sz SkipValidation.__class_getitem__rrrcs6||dfddgi}tj|tjddddS)NZ pydantic_js_annotation_functionscs|SrMr,)Z_crPrr,r-rQ1rRz=SkipValidation.__get_pydantic_core_schema__..cSs||SrMr,rNr,r,r-rQ5rRr)metadatarL)r Z any_schemarW)r4rr"rr,rr-r..sz+SkipValidation.__get_pydantic_core_schema__N) r6r7r8r9rr;r.rrr,r,r,r-rs   r)Sr9 __future__rZ _annotationsZ dataclassessys functoolsrtypesrtypingrrrrr r r Z pydantic_corer r Z _core_schemaZtyping_extensionsrrrr _internalrrrZannotated_handlersrerrorsr version_inforZinspect_validatorr'Z dataclassZ slots_truerr<rIrXr\rbrfrjr(r)Z _V2ValidatorrZr[Z_V2WrapValidatorr; staticmethodrmr:rnrprqrxrrZValidatorFunctionWrapHandlerrrrrrrrZModelAfterValidatorWithoutInfoZValidationInfoZModelAfterValidatorZ_AnyModelWrapValidatorZ_AnyModelBeforeValidatorZ_AnyModelAfterValidatorrrrrr,r,r,r-s   $     ;BaK ,    n   9 <