&hzl%SrSSKJr SSKrSSKrSSKrSSKJr SSK J r SSK J r J r JrJrJrJrJrJrJr SSKJrJr SSKJrJr S S KJrJrJr S S KJ r S S K!J"r" S S KJ#r# \RHS:aSSKJ%r% OSSK J%r% \RLr'\RP"SOSS0\RRD6"SS55r*\RP"SOSS0\RRD6"SS55r+\RP"SOSS0\RRD6"SS55r,\RP"SOSS0\RRD6"SS55r-\ (a"SS\%5r."SS\%5r/"SS\%5r0"S S!\%5r1\\/\Rd\.\Rf4r4\\1\Rj\0\Rl4r7\\8\\\4\9\\4\\4r:S"\;S#'\"S$\\4\:4S%9r<\"S&\\7\:4S%9r=\S'r>S"\;S('\S)S)S*.SPS+jj5r?\S)S)S*.SQS,jj5r?\S)S)S-.SRS.jj5r?S/S\S0.SSS1jjr?\"S25r@\"S3SS49rA"S5S6\R\%\A5rC"S7S8\%\@5rD"S9S:\%\@5rE"S;S<\%5rF"S=S>\%5rG"S?S@\%5rH"SASB\%5rI\\@/\@4rJ\\@\R\/\@4rL\\E\@\D\@4rM\\H\I\F\G4rN\\L\@\J\@4rO\STSCj5rP\SUSDj5rP\SVSEj5rPSWSFjrP\"SG5rQ\ (a\ \QS)4rRO)\RP"SO0\RRD6"SHSI55rR\ (a\ \QS)4rSO)\RP"SO0\RRD6"SJSK55rS\"SL5rT"SMSN5rUg)XzBThis 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)ArbitraryTypeWarning) )ProtocolfrozenTcB\rSrSr%SrS\S'S Sjr\S Sj5rSr g) 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,U"U5n[URS5nU(a8[[RUR5n[R "XSS9$[[R UR5n[R"XSS9$)Nafterschema)_inspect_validatorr"r rWithInfoValidatorFunction"with_info_after_validator_functionNoInfoValidatorFunction no_info_after_validator_function)self source_typehandlerr&info_argr"s N/root/34ku/venv/lib/python3.13/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__+AfterValidator.__get_pydantic_core_schema__Jsm%%dii9  ==tyyIDAA$V V ;;TYYGD??T Tc"U"URS9$)Nr"r5cls decorators r0_from_decoratorAfterValidator._from_decoratorTs ''r3Nr-rr.rreturncore_schema.CoreSchemar8z>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]r=r) __name__ __module__ __qualname____firstlineno____doc____annotations__r1 classmethodr9__static_attributes__r;r3r0rrs+(T VUU((r3rcP\rSrSr%SrS\S'\rS\S'S Sjr\ S Sj5r S r g ) BeforeValidatorYa,!!! 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"rjson_schema_input_typecU"U5nUR[LaSOURUR5n[URS5nU(a:[ [ RUR5n[ R"UUUS9$[ [ RUR5n[ R"XcUS9$)Nbeforer&json_schema_input_schema) rKrgenerate_schemar'r"r rr(#with_info_before_validator_functionr*!no_info_before_validator_functionr,r-r.r& input_schemar/r"s r0r1,BeforeValidator.__get_pydantic_core_schema__~s%**.?? (()D)DE  &dii:  ==tyyIDBB)5   ;;TYYGD@@l r3cLU"URURRS9$N)r"rKr"inforKr6s r0r9BeforeValidator._from_decorator##,>>#H#H  r3r;Nr<r? r@rArBrCrDrErrKr1rFr9rGr;r3r0rIrIYs5@ VU"3C3,  r3rIcP\rSrSr%SrS\S'\rS\S'S Sjr\ S Sj5r S r g ) 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`][]. r!r"rrKc SSKJn U"U5nURS[R"SUUR U5S95nUR UR 5n[URS5nU(a:[[RUR5n[R"UUUS9$[[RUR5n[R"UUUS9$!Ua SnNf=f)NrPydanticSchemaGenerationError serializationcU"U5$Nr;vhs r0=PlainValidator.__get_pydantic_core_schema__..!A$r3)functionr& return_schemaplain)rcrO)pydanticrbgetr#wrap_serializer_function_ser_schemarPrKr'r"r r("with_info_plain_validator_functionr* no_info_plain_validator_function) r,r-r.rbr&rcrTr/r"s r0r1+PlainValidator.__get_pydantic_core_schema__s ; ![)F#JJ??.!")"9"9+"FM..t/J/JK %dii9  ==tyyIDAA+)5   ;;TYYGD??+)5 - ! M !s>C22C=<C=cLU"URURRS9$rWrXr6s r0r9PlainValidator._from_decoratorr[r3r;Nr<r?) r@rArBrCrDrErrKr1rFr9rGr;r3r0r^r^s6,\ VU"%C%'R  r3r^cP\rSrSr%SrS\S'\rS\S'S Sjr\ S Sj5r S r g ) 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.WithInfoWrapValidatorFunctionr"rrKcU"U5nUR[LaSOURUR5n[URS5nU(a:[ [ RUR5n[ R"UUUS9$[ [ RUR5n[ R"UUUS9$)NwraprN) rKrrPr'r"r rWithInfoWrapValidatorFunction!with_info_wrap_validator_functionNoInfoWrapValidatorFunctionno_info_wrap_validator_functionrSs r0r1*WrapValidator.__get_pydantic_core_schema__+s%**.?? (()D)DE  &dii8  AA499MD@@)5   ??KD>>)5 r3cLU"URURRS9$rWrXr6s r0r9WrapValidator._from_decoratorCr[r3r;Nr<r?r\r;r3r0rxrxs5$L ^]"3C30  r3rxc\rSrSrSSjrSrg)_OnlyValueValidatorClsMethodiMcgrer;r,r7values r0__call__%_OnlyValueValidatorClsMethod.__call__NsCr3r;Nr7rrrr=rr@rArBrCrrGr;r3r0rrMs?r3rc\rSrSrSSjrSrg)_V2ValidatorClsMethodiPcgrer;r,r7rrYs r0r_V2ValidatorClsMethod.__call__Qscfr3r;Nr7rrrrYcore_schema.ValidationInfo[Any]r=rrr;r3r0rrPsfr3rc\rSrSrSSjrSrg) _OnlyValueWrapValidatorClsMethodiScgrer;r,r7rr.s r0r)_OnlyValueWrapValidatorClsMethod.__call__Tsorr3r;N)r7rrrr.(core_schema.ValidatorFunctionWrapHandlerr=rrr;r3r0rrSsrr3rc2\rSrSrSSjrSrg)_V2WrapValidatorClsMethodiVcgrer;r,r7rr.rYs r0r"_V2WrapValidatorClsMethod.__call__Wsr3r;N) r7rrrr.rrYrr=rrr;r3r0rrVs7   >   2   r3rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rMr$r{rnFieldValidatorModes.) check_fieldsrKcgrer;fieldmoderrKfieldss r0field_validatorrys>Ar3cgrer;rs r0rrs Z]r3)rrcgrer;)rrrrs r0rrs Z]r3r$)rrrKc^^^^[U[5(a [SSS9eTS;aT[La[ST<3SS9eT[La TS:Xa[mU/TQ7m[ ST55(d [S S S9eS UUUU4S jjnU$) 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-fieldscode)rMrnr{z;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typernc3B# UHn[U[5v M g7fre) isinstancestr).0rs r0 "field_validator..s:6%z%%%6sz`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('', '', ...)`zvalidator-invalid-fieldsc>[R"U5(a [SSS9e[R"U5n[R"TTTTS9n[R "X5$)Nz8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodr)rrrrK)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)fdec_inforrrKrs r0decfield_validator..decsh  2 21 5 5#JQl   = =a @::sr3r;N)rrr=rrr;r3r0rr9s    r3rc.\rSrSrSrSSjrSrg)ModelBeforeValidatorWithoutInfoiHrcgrer;rs r0r(ModelBeforeValidatorWithoutInfo.__call__Mr3r;Nrrr;r3r0rrHs(    r3rc.\rSrSrSrSSjrSrg)FreeModelBeforeValidatoriXUA `@model_validator` decorated function signature. This is used when `mode='before'`.cgrer;)r,rrYs r0r!FreeModelBeforeValidator.__call__[rr3r;N)rrrYrr=rrr;r3r0rrXs(_   .  r3rc2\rSrSrSrSSjrSrg)ModelBeforeValidatorifrcgrer;rs r0rModelBeforeValidator.__call__isr3r;Nrrr;r3r0rrfs0_     .   r3rcgrer;rs r0model_validatorr r3cgrer;rs r0rrrr3cgrer;rs r0rrrr3c^SU4SjjnU$)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. c>TS:wa[R"U5n[R"TS9n[R"X5$)Nr$r)rrModelValidatorDecoratorInfor)rrrs r0rmodel_validator..decs; 7?AA!DA::E221??r3)rrr=rr;)rrs` r0rrsb@ Jr3AnyTypecX\rSrSrSr\SSj5r\SSj5r\Rr Sr g) 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 [X"54$re)rr7items r0__class_getitem__InstanceOf.__class_getitem__sT35[) )r3cSSKJn [R"[R "U5=(d U5nU"U5n[R "SUS9US'[R"XES9$!Ua Us$f=f)NrracU"U5$rer;rfs r0ri9InstanceOf.__get_pydantic_core_schema__..rkr3rlr&rc) python_schema json_schema)rorbris_instance_schemar get_originrqjson_or_python_schema)r7sourcer.rbinstance_of_schemaoriginal_schemas r0r1'InstanceOf.__get_pydantic_core_schema__ s >"-!?!? @T@TU[@\@f`f!g  x")&/ 7B6e6e.7"?3#88GYww1 *)) *sA00A;:A;r;N)rrr=rrrr.rr=r>) r@rArBrCrDrFrr1object__hash__rGr;r3r0rrs= @  *  *  x  x&??r3rcN\rSrSrSrSSjr\SSj5r\Rr Sr g) 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([U[54$re)rr rs r0r SkipValidation.__class_getitem__1sT>#334 4r3c ^[R"5 [R"S[5 U"U5mSSS5 SU4Sj/0n[R "U[R "STS9S9$!,(df  N@=f)Nignore pydantic_js_annotation_functionsc>U"T5$rer;)_crhrs r0ri=SkipValidation.__get_pydantic_core_schema__..9s 1_K]r3cU"U5$rer;rfs r0rir=rkr3r)metadatarc)warningscatch_warnings simplefilterrr any_schemarq)r7rr.rrs @r0r1+SkipValidation.__get_pydantic_core_schema__4sp((*%%h0DE")&/+;=]<^_H))!)MM.  +*s $A55 Br;N)rrr=rr) r@rArBrCrDrrFr1rrrGr;r3r0r r $s+  5    ??r3r  _FromTypeTc,\rSrSrSrSSjrSSjrSrg) ValidateAsiGa-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) ``` cXlX lgre from_typeinstantiation_hook)r,rrs r0__init__ValidateAs.__init__js ""4r3cdU"UR5n[R"URUS9$)Nr%)rrr+r)r,rr.r&s r0r1'ValidateAs.__get_pydantic_core_schema__ns/(;;  # #  r3rN)rzCallable[[_FromTypeT], Any]rztype[_FromTypeT]r=Noner)r@rArBrCrDr r1rGr;r3r0rrGsD5 r3rr;) rrrrrLiteral['wrap']r bool | NonerKrr=z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]) rrrrrzLiteral['before', 'plain']rr&rKrr=RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]) rrrrrLiteral['after']rr&r=r') rrrrrrrr&rKrr=zCallable[[Any], Any])rr%r=z|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rzLiteral['before']r=zrCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rr(r=z}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rz"Literal['wrap', 'before', 'after']r=r)VrD __future__r _annotations dataclassessysr functoolsrtypesrtypingrrrr r r r r r pydantic_corerrtyping_extensionsrr _internalrrrannotated_handlersrerrorsrr version_inforinspect_validatorr' dataclass slots_truerrIr^rxrrrrr(r* _V2Validatorr|r~_V2WrapValidatorrF staticmethodrrErrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrrrr rrr;r3r0rCsH2 #ccc8-BB4%*g* 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 AA  A  A  A<A A !$"% ] ]] % ]  ]  ]X] ] ! # ] ]]  ]  ] X ] ]!( $"3 l ll  l  l  ll^\ " ~6   H H(S_J`  HZ$8" *-  (  h  x  8 "*:, *B!C K,F,Fs,KLjXYZ1*=?\]g?hhi 24WYxx 3J ?A_`jAk kl         8 ,8 8v ) 7C<(J<0;;<9#9#=9#xw|,N<0;;<##=#>\ " , , r3