+ Ai{a0t$Rt^RIHt^RIt^RIt^RIt^RIH t ^RI H t H t H t HtHtHtHtHtHt^RIHtHt^RIHtHt^RIHtHtHt^RIHt^R I H!t!^R I"H#t#^R IH$t$H%t%]PLRS8d^R IH't'M^R I H't']PPt)]PT!RTR R/]PVB!RR44t,]PT!RTR R/]PVB!RR44t-]PT!RTR R/]PVB!RR44t.]PT!RTR R/]PVB!RR44t/] 'd!RR]'4t0!RR]'4t1!RR]'4t2!RR]'4t3]]1]Ph]0]Pj3,t6]]3]Pn]2]Pp3,t9]]:] ] ] 3,];] ] 3,] ] ,3,t]!R#]]9]<3,R"7t?]RU,t@R]=R%&]R&R'R(R'/R)R*ll4tA]R&R'R(R'/R+R,ll4tA]R-R'R&R'/R.R/ll4tAR-R$R&RR(]/R0R1lltA]!R24tB]!R3RR47tC!R5R6]P]']C,4tE!R7R8]']B,4tF!R9R:]']B,4tG!R;R<]'4tH!R=R>]'4tI!R?R@]'4tJ!RARB]'4tK]]B.]B3,tL]]B]P] ,.]B3,tN]]G]B,]F]B,3,tO]]J]K]H]I3,tP]]N]B,]L]B,3,tQ]RCRDl4tR]RERFl4tR]RGRHl4tRRIRJltR]!RK4tS] 'd ] ]SR'3,tTM)]PT!RT/]PVB!RLRM44tT] 'd ] ]SR'3,tUM)]PT!RT/]PVB!RNRO44tU]!RP4tV!RQRR4tWR#)VzBThis module contains related classes and functions for validation.) annotationsN) partialmethod) TYPE_CHECKING AnnotatedAnyCallableLiteralTypeVarUnioncastoverload)PydanticUndefined core_schema)Self TypeAlias) _decorators _generics_internal_dataclass)GetCoreSchemaHandler)PydanticUserError) version_short)ArbitraryTypeWarningPydanticDeprecatedSince212)ProtocolfrozenTcH]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.CoreSchema)formats"\/var/www/html/photoedit/myenv/lib/python3.14/site-packages/pydantic/functional_validators.py __annotate__AfterValidator.__annotate__Js(UUUFZU_uUc >V!V4p\VPRRR7pV'd<\\PVP4p\P !WSR7#\\P VP4p\P!WSR7#)afterfieldmodetypeschema)_inspect_validatorrr rWithInfoValidatorFunction"with_info_after_validator_functionNoInfoValidatorFunction no_info_after_validator_function)selfr"r#r3info_argrs&&& r(__get_pydantic_core_schema__+AfterValidator.__get_pydantic_core_schema__Jso%%diigGL  ==tyyIDAA$V V ;;TYYGD??T Tr+c V^8dQhRRRR/#r! decoratorz>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]r$rr&)r's"r(r)r*Us(((f(ko(r+c (V!VPR7#)rrAclsr?s&&r(_from_decoratorAfterValidator._from_decoratorTs ''r+r&N) __name__ __module__ __qualname____firstlineno____doc____annotations__r; classmethodrD__static_attributes__r&r+r(rrs+(T VUU((r+rcV]tRt^Yt$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_typec$V^8dQhRRRRRR/#r r&)r's"r(r)BeforeValidator.__annotate__~s#FZ_ur+c V!V4pVP\JdRMVPVP4p\VPRRR7pV'd>\ \ PVP4p\ P!VVVR7#\ \ PVP4p\ P!WcVR7#)Nbeforer.r/r3json_schema_input_schema) rPr generate_schemar4rr rr5#with_info_before_validator_functionr7!no_info_before_validator_functionr9r"r#r3 input_schemar:rs&&& r(r;,BeforeValidator.__get_pydantic_core_schema__~s%**.?? (()D)DE  &diihWM  ==tyyIDBB)5   ;;TYYGD@@l r+c V^8dQhRRRR/#r>r&)r's"r(r)rR  (f ko r+c RV!VPVPPR7#)rrPrinforPrBs&&r(rDBeforeValidator._from_decorator##,>>#H#H  r+r&N rFrGrHrIrJrKr rPr;rLrDrMr&r+r(rOrOYs5@ VU"3C3,  r+rOcV]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, 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`][]. rrrrPc$V^8dQhRRRRRR/#r r&)r's"r(r)PlainValidator.__annotate__s#'''FZ'_u'r+c  ^RIHpV!V4pVPR\P!RVVP V4R74pVP VP 4p\VPRRR7pV'd>\\PVP4p\P!VVVR 7#\\PVP4p\P!VVVR 7# TdRpLi;i) )PydanticSchemaGenerationError serializationcV!V4#Nr&vhs&&r(=PlainValidator.__get_pydantic_core_schema__..!A$r+)functionr3 return_schemaNplainr.r/)rmrV)pydanticrlgetr#wrap_serializer_function_ser_schemarWrPr4rr r5"with_info_plain_validator_functionr7 no_info_plain_validator_function) r9r"r#rlr3rmr[r:rs &&& r(r;+PlainValidator.__get_pydantic_core_schema__s ; ![)F#JJ??.!")"9"9+"FM..t/J/JK %diigGL  ==tyyIDAA+)5   ;;TYYGD??+)5 - ! M !sAC>> D  D c V^8dQhRRRR/#r>r&)r's"r(r)rir^r+c RV!VPVPPR7#r`rarBs&&r(rDPlainValidator._from_decoratorrdr+r&N) rFrGrHrIrJrKrrPr;rLrDrMr&r+r(rgrgs6,\ VU"%C%'R  r+rgcV]tRtRt$RtR]R&]tR]R&RRlt] R R l4t R t R #) WrapValidatorab!!! 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.WithInfoWrapValidatorFunctionrrrPc$V^8dQhRRRRRR/#r r&)r's"r(r)WrapValidator.__annotate__+s#FZ_ur+c V!V4pVP\JdRMVPVP4p\VPRRR7pV'd>\ \ PVP4p\ P!VVVR7#\ \ PVP4p\ P!VVVR7#)Nwrapr.r/rU) rPr rWr4rr rWithInfoWrapValidatorFunction!with_info_wrap_validator_functionNoInfoWrapValidatorFunctionno_info_wrap_validator_functionrZs&&& r(r;*WrapValidator.__get_pydantic_core_schema__+s%**.?? (()D)DE  &diif7K  AA499MD@@)5   ??KD>>)5 r+c V^8dQhRRRR/#r>r&)r's"r(r)rDr^r+c RV!VPVPPR7#r`rarBs&&r(rDWrapValidator._from_decoratorCrdr+r&Nrer&r+r(rrs5$L ^]"3C30  r+rc"]tRtRtRRltRtR#)_OnlyValueValidatorClsMethodiMc$V^8dQhRRRRRR/#r!rCrvaluer$r&)r's"r(r))_OnlyValueValidatorClsMethod.__annotate__Ns???C?s?r+c R#ror&r9rCrs"""r(__call__%_OnlyValueValidatorClsMethod.__call__NsCr+r&NrFrGrHrIrrMr&r+r(rrMs??r+rc"]tRtRtRRltRtR#)_V2ValidatorClsMethodiPc(V^8dQhRRRRRRRR/#r!rCrrrbcore_schema.ValidationInfo[Any]r$r&)r's"r(r)"_V2ValidatorClsMethod.__annotate__QsfffCf7Vf^afr+c R#ror&r9rCrrbs""""r(r_V2ValidatorClsMethod.__call__Qscfr+r&Nrr&r+r(rrPsffr+rc"]tRtRtRRltRtR#) _OnlyValueWrapValidatorClsMethodiSc(V^8dQhRRRRRRRR/#)r!rCrrr#(core_schema.ValidatorFunctionWrapHandlerr$r&)r's"r(r)-_OnlyValueWrapValidatorClsMethod.__annotate__TsrrrCr:brjmrr+c R#ror&r9rCrr#s""""r(r)_OnlyValueWrapValidatorClsMethod.__call__Tsorr+r&Nrr&r+r(rrSsrrr+rc"]tRtRtRRltRtR#)_V2WrapValidatorClsMethodiVc ,V^8dQhRRRRRRRRRR/#) r!rCrrr#rrbrr$r&)r's"r(r)&_V2WrapValidatorClsMethod.__annotate__Ws<    >   2   r+c R#ror&r9rCrr#rbs"""""r(r"_V2WrapValidatorClsMethod.__call__Wsr+r&Nrr&r+r(rrVs   r+rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorTyper-FieldValidatorModes check_fields.rPc 0V^8dQhRRRRRRRRRR R R /#) r!r.strfieldsr0Literal['wrap']r bool | NonerPrr$z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]r&)r's"r(r)r)zsNAA AA  A  A  A<Ar+cR#ror&r.r0rrPrs"$$$*r(field_validatorrys>Ar+c 0V^8dQhRRRRRRRRRR R R /#) r!r.rrr0zLiteral['before', 'plain']rrrPrr$RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]r&)r's"r(r)r)sO]] ]] % ]  ]  ]X]r+cR#ror&rs"$$$*r(rrs Z]r+r0c ,V^8dQhRRRRRRRRRR /#) r!r.rrr0Literal['after']rrr$rr&)r's"r(r)r)sD]] ]]  ]  ] X ]r+cR#ror&)r.r0rrs"$$*r(rrs Z]r+c 0V^8dQhRRRRRRRRRR R R /#) r!r.rrr0rrrrPrr$zCallable[[Any], Any]r&)r's"r(r)r)sNii ii  i  i  iir+caaaa\V4'g\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: *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. zThe `@field_validator` decorator cannot be used without arguments, at least one field must be provided. For example: `@field_validator('', ...)`.zdecorator-missing-argumentscoderxz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typec3B"TFp\V\4xK R#5iro) isinstancer).0r.s& r( "field_validator..s:6%z%%%6sFTzThe provided field names to the `@field_validator` decorator should be strings. For example: `@field_validator('', '', ...).`zdecorator-invalid-fieldsc V^8dQhRRRR/#)r!fzHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]r$(_decorators.PydanticDescriptorProxy[Any]r&)r's"r(r)%field_validator..__annotate__s @@ S@ 1@r+c<\P!V4'd\RRR7h\P!V4p\P!SSSSR7p\P !W4#)zFThe `@field_validator` decorator cannot be applied to instance methodszvalidator-instance-methodr)rr0rrP)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)rdec_inforrrPr0s& r(decfield_validator..decsh  2 21 5 5#X0   = =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. c V^8dQhRRRR/#)r!rrr$rr&)r's"r(r)%model_validator..__annotate__s@@s@?@r+c<\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.)categorymessage stacklevelr) rrrrLwarningswarnrrModelValidatorDecoratorInfor)rrr0s& r(rmodel_validator..decsx  = =a @ 7?z![99 MM3JJW/IZ[GH  ::E221??r+r&)r0rsd r(rrsb@@ Jr+AnyTypec^]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' │ } ] """ ``` c V^8dQhRRRR/#)r!itemr(r$r&)r's"r(r)InstanceOf.__annotate__ s * * *W *r+c (\W!43,#ro)rrCr,s&&r(__class_getitem__InstanceOf.__class_getitem__ sT35[) )r+c$V^8dQhRRRRRR/#r!sourcerr#rr$r%r&)r's"r(r)r-s( x xc xDX x]s xr+c ^RIHp\P!\P !V4;'gT4pV!V4p\P !RVR7VR&\P!WER7# TdTu#i;i)rk)GENERATE_SCHEMA_ERRORScV!V4#ror&rps&&r(rs9InstanceOf.__get_pydantic_core_schema__..rur+rvr3rm) python_schema json_schema)#pydantic._internal._generate_schemar6ris_instance_schemar get_originr{json_or_python_schema)rCr4r#r6instance_of_schemaoriginal_schemas&&& r(r;'InstanceOf.__get_pydantic_core_schema__s R"-!?!? @T@TU[@\@f@f`f!g  x")&/ 7B6e6e.7"?3#88GYww* *)) *sA77 BBr&N) rFrGrHrIrJrLr0r;object__hash__rMr&r+r(r*r*s= @  *  *  x  x&??r+r*cT]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. c V^8dQhRRRR/#)r!r,rr$r&)r's"r(r)SkipValidation.__annotate__7s 5 5 5 5r+c 0\V\43,#ro)rrFr/s&&r(r0 SkipValidation.__class_getitem__7sT>#334 4r+c$V^8dQhRRRRRR/#r3r&)r's"r(r)rH;s#  c DX ]s r+c ,a\P!4;_uu_4\P!R\4V!V4oRRR4RV3Rl./p\P !V\P !RSR7R7# +'giLH;i)ignoreN pydantic_js_annotation_functionsc<V!S4#ror&)_crrrAs&&r(rs=SkipValidation.__get_pydantic_core_schema__..?s 1_K]r+cV!V4#ror&rps&&r(rsrQCrur+r9)metadatarm)r$catch_warnings simplefilterrr any_schemar{)rCr4r#rSrAs&&& @r(r;+SkipValidation.__get_pydantic_core_schema__:ss((**%%h0DE")&/+;=]<^_H))!)MM.  +*s $B B r&N) rFrGrHrIrJr0rLr;rCrDrMr&r+r(rFrF*s+  5    ??r+rF _FromTypeTc2]tRtRtRtRRltRRltRtR#) ValidateAsiMa-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) ``` c$V^8dQhRRRRRR/#)r!instantiation_hookzCallable[[_FromTypeT], Any] from_typeztype[_FromTypeT]r$Noner&)r's"r(r)ValidateAs.__annotate__ps$55Kf5"25ko5r+c WnW nR#ror]r\)r9r]r\s""&r(__init__ValidateAs.__init__ps ""4r+c$V^8dQhRRRRRR/#r3r&)r's"r(r)r_ts#  3 AU Zp r+c jV!VP4p\P!VPVR7#)r2)r]rr8r\)r9r4r#r3s&&& r(r;'ValidateAs.__get_pydantic_core_schema__ts/(;;  # #  r+raN)rFrGrHrIrJrbr;rMr&r+r(rZrZMsD5  r+rZ) r&)rTr-rrx)X__conditional_annotations__rJ __future__r _annotations dataclassessysr$ functoolsrtypingrrrrrr r r r pydantic_corer rtyping_extensionsrr _internalrrrannotated_handlersrerrorsrversionrrr version_inforinspect_validatorr4 dataclass slots_truerrOrgrrrrrr5r7 _V2Validatorrr_V2WrapValidatorrL staticmethodrrKrrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrr(r*rFrXrZ)ris@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 ] !$ ] #& ] ] ]! ] !$ ] ]i!( i !% i #4 iX\ " ~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+