+ 7*i_|csa0t$Rt^RIHt^RIt^RIt^RIt^RIH t ^RI H t ^RI H t HtHtHtHtHtHtHtHt^RIHtHt^RIHtHt^RIHtHtHt^R I H!t!^R I"H#t#^R I$H%t%^R IH&t&H't']PPRT8d^R IH)t)M^R I H)t)]PTt+]PX!RURR/]PZB!RR44t.]PX!RURR/]PZB!RR44t/]PX!RURR/]PZB!RR44t0]PX!RURR/]PZB!RR44t1] 'd!RR])4t2!RR])4t3!RR])4t4!RR])4t5]]3]Pl]2]Pn3,t8]]5]Pr]4]Pt3,t;]]<]]]3,]=]]3,] ],3,t>R ]?R!&]!R"]]8]>3,R#7t@]!R$]];]>3,R#7tA]RV,tBR ]?R&&]R'R(R)R(/R*R+ll4tC]R'R(R)R(/R,R-ll4tC]R.R(R'R(/R/R0ll4tCR.R%R'RR)]/R1R2lltC]!R34tD]!R4RR57tE!R6R7]P])]E,4tG!R8R9])]D,4tH!R:R;])]D,4tI!R<R=])4tJ!R>R?])4tK!R@RA])4tL!RBRC])4tM]]D.]D3,tN]]D]P],.]D3,tP]]I]D,]H]D,3,tQ]]L]M]J]K3,tR]]P]D,]N]D,3,tS]RDREl4tT]RFRGl4tT]RHRIl4tTRJRKltT]!RL4tU] 'd ]]UR(3,tVM)]PX!RU/]PZB!RMRN44tV] 'd ]]UR(3,tWM)]PX!RU/]PZB!RORP44tW]!RQ4tX!RRRS4tYR#)WzBThis module contains related classes and functions for validation.) annotationsN) partialmethod) FunctionType) TYPE_CHECKING AnnotatedAnyCallableLiteralTypeVarUnioncastoverload)PydanticUndefined core_schema)Self TypeAlias) _decorators _generics_internal_dataclass)GetCoreSchemaHandler)PydanticUserError) version_short)ArbitraryTypeWarningPydanticDeprecatedSince212)ProtocolZfrozenTcsH]tRt^t$RtR]R&RRlt]RRl4tRt R #) AfterValidatora!!! 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.WithInfoValidatorFunctionfuncc$V^8dQhRRRRRR/# source_typerhandlerrreturncore_schema.CoreSchemaZformat"C/usr/lib/python3.14/site-packages/pydantic/functional_validators.py __annotate__AfterValidator.__annotate__Ks(UUUFZU_uUc s>V!V4p\VPRRR7pV'd<\\PVP4p\P !WSR7#\\P VP4p\P!WSR7#)afterfieldmodeZtypeschema)_inspect_validatorrr r WithInfoValidatorFunctionZ"with_info_after_validator_functionNoInfoValidatorFunction no_info_after_validator_function)selfrr r/info_argr&&& r&__get_pydantic_core_schema__Z+AfterValidator.__get_pydantic_core_schema__Kso%%diigGL  ==tyyIDAA$V V ;;TYYGD??T Tr)c V^8dQhRRRR/#r decoratorz>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]r!rr#r$r%r&r'r(Vs(((f(ko(r)c s(V!VPR7#)rr;clsr:&&r&_from_decoratorZAfterValidator._from_decoratorUs ''r)r#N) __name__ __module__ __qualname____firstlineno____doc____annotations__r7 classmethodr?__static_attributes__r#r)r&rrs+(T VUU((r)rcsV]tRt^Zt$RtR]R&]tR]R&RRlt] RR l4t R t R #) 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 ``` rrrjson_schema_input_typecrrr#r$r%r&r'BeforeValidator.__annotate__s#FZ_ur)c sV!V4pVP\JdRMVPVP4p\VPRRR7pV'd>\ \ PVP4p\ P!VVVR7#\ \ PVP4p\ P!WcVR7#)Nbeforer+r,r/json_schema_input_schema) rIr generate_schemar0rr r r1Z#with_info_before_validator_functionr2Z!no_info_before_validator_functionr4rr r/ input_schemar5r&&& r&r7Z,BeforeValidator.__get_pydantic_core_schema__s%**.?? (()D)DE  &diihWM  ==tyyIDBB)5   ;;TYYGD@@l r)cr8r9r#r$r%r&r'rJ  (f ko r)c RV!VPVPPR7#)rrIrinforIr<r>r&r?ZBeforeValidator._from_decorator##,>>#H#H  r)r#N r@rArBrCrDrEr rIr7rFr?rGr#r)r&rHrHZs5@ VU"3C3,  r)rHcsV]tRt^t$RtR]R&]tR]R&RRlt] RR l4t R t R #) 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, go {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`][]. rrrrIcrrr#r$r%r&r'PlainValidator.__annotate__s#'''FZ'_u'r)c  s^RIHpV!V4pVPR\P!RVVP V4R74pVP VP 4p\VPRRR7pV'd>\\PVP4p\P!VVVR 7#\\PVP4p\P!VVVR 7# TdRpLi;i) PydanticSchemaGenerationError serializationcV!V4#Nr#Zvhr>r&Z=PlainValidator.__get_pydantic_core_schema__..!A$r))functionr/Z return_schemaNplainr+r,)r^rM)pydanticr]Zgetr #wrap_serializer_function_ser_schemarNrIr0rr r1Z"with_info_plain_validator_functionr2Z no_info_plain_validator_function) r4rr r]r/r^rPr5rs &&& r&r7Z+PlainValidator.__get_pydantic_core_schema__s ; ![)F#JJ??.!")"9"9+"FM..t/J/JK %diigGL  ==tyyIDAA+)5   ;;TYYGD??+)5 - ! M !sAC>> D  D cr8r9r#r$r%r&r'rZrRr)c rSrTrUr<r>r&r?ZPlainValidator._from_decoratorrWr)r#N) r@rArBrCrDrErrIr7rFr?rGr#r)r&rYrYs6,\ VU"%C%'R  r)rYcsV]tRtRt$RtR]R&]tR]R&RRlt] R R l4t R t R #) WrapValidatoriab!!! 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.WithInfoWrapValidatorFunctionrrrIcrrr#r$r%r&r'WrapValidator.__annotate__,s#FZ_ur)c sV!V4pVP\JdRMVPVP4p\VPRRR7pV'd>\ \ PVP4p\ P!VVVR7#\ \ PVP4p\ P!VVVR7#)Nwrapr+r,rL) rIr rNr0rr r WithInfoWrapValidatorFunctionZ!with_info_wrap_validator_functionNoInfoWrapValidatorFunctionZno_info_wrap_validator_functionrOrQr&r7Z*WrapValidator.__get_pydantic_core_schema__,s%**.?? (()D)DE  &diif7K  AA499MD@@)5   ??KD>>)5 r)cr8r9r#r$r%r&r'rjErRr)c rSrTrUr<r>r&r?ZWrapValidator._from_decoratorDrWr)r#NrXr#r)r&riris5$L ^]"3C30  r)ric"]tRtRtRRltRtR#)_OnlyValueValidatorClsMethodiNc$V^8dQhRRRRRR/#rr=rvaluer!r#r$r%r&r'Z)_OnlyValueValidatorClsMethod.__annotate__Os???C?s?r)c R#r`r#r4r=rr"""r&__call__Z%_OnlyValueValidatorClsMethod.__call__OsCr)r#Nr@rArBrCrvrGr#r)r&roroNs??r)rocrn)_V2ValidatorClsMethodiQc(V^8dQhRRRRRRRR/#rr=rrrrVcore_schema.ValidationInfo[Any]r!r#r$r%r&r'Z"_V2ValidatorClsMethod.__annotate__RsfffCf7Vf^afr)c rsr`r#r4r=rrrV""""r&rvZ_V2ValidatorClsMethod.__call__Rscfr)r#Nrwr#r)r&rxrxQsffr)rxcrn) _OnlyValueWrapValidatorClsMethodiTcry)rr=rrrr (core_schema.ValidatorFunctionWrapHandlerr!r#r$r%r&r'Z-_OnlyValueWrapValidatorClsMethod.__annotate__UsrrrCr:brjmrr)c rsr`r#r4r=rrr r}r&rvZ)_OnlyValueWrapValidatorClsMethod.__call__Usorr)r#Nrwr#r)r&r~r~Tsrrr)r~crn)_V2WrapValidatorClsMethodiWc s,V^8dQhRRRRRRRRRR/#) rr=rrrr rrVr{r!r#r$r%r&r'Z&_V2WrapValidatorClsMethod.__annotate__Xs<    >   2   r)c rsr`r#r4r=rrr rV"""""r&rvZ"_V2WrapValidatorClsMethod.__call__Xsr)r#Nrwr#r)r&rrWs   r)rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)Zbound_V2WrapValidatorTyper*FieldValidatorModes check_fields.rIc 0V^8dQhRRRRRRRRRR R R /#) rr+strfieldsr-Literal['wrap']r bool | NonerIrr!z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]r#r$r%r&r'r'{sNAA AA  A  A  A<Ar)crsr`r#r+r-rrIr"$$$*r&field_validatorrzs>Ar)c r) rr+rrr-zLiteral['before', 'plain']rrrIrr!RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]r#r$r%r&r'r'sO]] ]] % ]  ]  ]X]r)crsr`r#rrr&rrs Z]r)r-c s,V^8dQhRRRRRRRRRR /#) rr+rrr-Literal['after']rrr!rr#r$r%r&r'r'sD]] ]]  ]  ] X ]r)crsr`r#)r+r-rrs"$$*r&rrs Z]r)c r) rr+rrr-rrrrIrr!zCallable[[Any], Any]r#r$r%r&r'r'sNll ll  l  l  llr)csxaaaa\V\4'd\RRR7hSR9dS\Jd\RS: 2RR7hS\JdSR8Xd\oV.SO5o\ ;QJdRS4F 'dK RM R M !RS44'g\R R R7hR VVVV3R llpV#)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: 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-fieldsZcoderfz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typec3sB"TFp\V\4xK R#5ir`) isinstancer)Z.0r+s& r&Z Z"field_validator..s:6%z%%%6sFTz`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('', '', ...)`zvalidator-invalid-fieldscr8)rfzHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]r!(_decorators.PydanticDescriptorProxy[Any]r#r$r%r&r'Z%field_validator..__annotate__s @@ S@ 1@r)cs<\P!V4'd\RRR7h\P!V4p\P!SSSSR7p\P !W4#)z8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodr)rr-rrI)rZis_instance_method_from_sigr%ensure_classmethod_based_on_signatureZFieldValidatorDecoratorInfoPydanticDescriptorProxy)rdec_inforrrIr-s& r&decZfield_validator..decsh  2 21 5 5#JQl   = =a @:: 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. cr8)rrrr!rr#r$r%r&r'Z%model_validator..__annotate__s@@s@?@r)cs<\P!V4pSR8Xd@\V\4'd*\P !\ R\4 R2^R7\P!SR7p\P!W4#)r*zUsing `@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.)ZcategoryZmessageZ stacklevelr) rrrrFwarningsZwarnrrZModelValidatorDecoratorInfor)rrr-s& r&rZmodel_validator..decsx  = =a @ 7?z![99 MM3JJW/IZ[GH  ::E221??r)r#)r-rsd r&rrsb@@ Jr)AnyTypecs^]tRtRtRt]RRl4t]RRl4t]Pt Rt R#) InstanceOfiuGeneric 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' │ } ] """ ``` cr)ritemrr!r#r$r%r&r'InstanceOf.__annotate__s * * *W *r)c s(\W!43,#r`)rr=rr>r&__class_getitem__ZInstanceOf.__class_getitem__sT35[) )r)crrsourcerr rr!r"r#r$r%r&r'rs( x xc xDX x]s xr)c s ^RIHp\P!\P !V4;'gT4pV!V4p\P !RVR7VR&\P!WER7# TdTu#i;i)r[r\cr_r`r#rar>r&rcZ9InstanceOf.__get_pydantic_core_schema__..#rdr)rer/r^)Z python_schemaZ json_schema)rgr]r Zis_instance_schemarZ get_originrhZjson_or_python_schema)r=rr r]Zinstance_of_schemaoriginal_schemar6r&r7Z'InstanceOf.__get_pydantic_core_schema__s >"-!?!? @T@TU[@\@f@f`f!g  x")&/ 7B6e6e.7"?3#88GYww1 *)) *sA77 BBr#N) r@rArBrCrDrFrr7object__hash__rGr#r)r&rrs= @  *  *  x  x&??r)rcsT]tRtRtRtRRlt]RRl4t]Pt Rt R#) SkipValidationi.atIf 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. cr)rrrr!r#r$r%r&r'SkipValidation.__annotate__;s 5 5 5 5r)c s0\V\43,#r`)rrrr>r&rZ SkipValidation.__class_getitem__;sT>#334 4r)crrr#r$r%r&r'r?s#  c DX ]s r)c s,a\P!4;_uu_4\P!R\4V!V4oRRR4RV3Rl./p\P !V\P !RSR7R7# +'giLH;i)ZignoreNZ pydantic_js_annotation_functionscs<V!S4#r`r#)Z_crbrs&&r&rc=SkipValidation.__get_pydantic_core_schema__..Cs 1_K]r)cr_r`r#rar>r&rcrGrdr)r)metadatar^)rZcatch_warningsZ simplefilterrr Z any_schemarh)r=rr rrs&&& @r&r7Z+SkipValidation.__get_pydantic_core_schema__>ss((**%%h0DE")&/+;=]<^_H))!)MM.  +*s $B B r#N) r@rArBrCrDrrFr7rrrGr#r)r&rr.s+  5    ??r)r _FromTypeTcs2]tRtRtRtRRltRRltRtR#) ValidateAsiQa-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) ``` cr)rinstantiation_hookzCallable[[_FromTypeT], Any] from_typeztype[_FromTypeT]r!ZNoner#r$r%r&r'ValidateAs.__annotate__ts$55Kf5"25ko5r)c sWnW nR#r`rr)r4rrs""&r&__init__ZValidateAs.__init__ts ""4r)crrr#r$r%r&r'rxs#  3 AU Zp r)c sjV!VP4p\P!VPVR7#)r.)rr r3r)r4rr r/s&&& r&r7Z'ValidateAs.__get_pydantic_core_schema__xs/(;;  # #  r)rN)r@rArBrCrDrr7rGr#r)r&rrQsD5  r)r)ii r#)rKr*rkrf)Z__conditional_annotations__rDZ __future__rZ _annotationsZ dataclassesZsysrZ functoolsrZtypesrZtypingrrrrrrr r r Z pydantic_corer r Ztyping_extensionsrrZ _internalrrrZannotated_handlersrZerrorsrZversionrrrZ version_inforZinspect_validatorr0Z dataclassZ slots_truerrHrYrirorxr~rr1r2Z _V2ValidatorrlrmZ_V2WrapValidatorrFZ staticmethodrrErrrrrrZValidatorFunctionWrapHandlerrrrrrrrZModelAfterValidatorWithoutInfoZValidationInfoZModelAfterValidatorZ_AnyModelWrapValidatorZ_AnyModelBeforeValidatorZ_AnyModelAfterValidatorrrrrrr)rs@r&rsH2 #ccc8-BB4%"Fg* 22 EdE&9&D&DE9(9(F9(x EdE&9&D&DE? ? F? D EdE&9&D&DE` ` F` F EdE&9&D&DEG G FG T@x@ggs8sH--$++ -L!11(// 1,1S#s]1K\Z]_bZbMcersvew1w+xyx)0,L";;<*&##9GWYrGrAst!()K!LYL A !$ A #& A A ] !$ ] #& ] ] ]! ] !$ ] ]l!( l !% l #4 l^\ " ~6   H H(S_J`  HZ$8" *-  (  h  x  8 "*:, *B!C K,F,Fs,KLjXYZ1*=?\]g?hhi 24WYxx 3J ?A_`jAk kl      AH ) 7C<(J<0;;<9#9#=9#xw|,N<0;;<##=#>\ " , , r)