Xi{p%SrSSKJr SSKrSSKrSSKrSSKJr SSK J r J r J r J r JrJrJrJrJr SSKJrJr SSKJrJr SS KJrJrJr SS KJr SS KJ r SS K!J"r" SS KJ#r#J$r$ \RJS:aSSKJ&r& OSSK J&r& \RNr(\RR"SOSS0\RTD6"SS55r+\RR"SOSS0\RTD6"SS55r,\RR"SOSS0\RTD6"SS55r-\RR"SOSS0\RTD6"SS55r.\ (a"SS\&5r/"SS\&5r0"SS\&5r1"S S!\&5r2\\0\Rf\/\Rh4r5\\2\Rl\1\Rn4r8\\9\ \ \ 4\:\ \ 4\\ 4r;S"\\S'r?S"\\&5rH"S?S@\&5rI"SASB\&5rJ\ \A/\A4rK\ \A\R\ /\A4rM\\F\A\E\A4rN\\I\J\G\H4rO\\M\A\K\A4rP\STSCj5rQ\SUSDj5rQ\SVSEj5rQSWSFjrQ\"SG5rR\ (a\ \RS)4rSO)\RR"SO0\RTD6"SHSI55rS\ (a\ \RS)4rTO)\RR"SO0\RTD6"SJSK55rT\"SL5rU"SMSN5rVg)XzBThis 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) )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[URSSS9nU(a8[[RUR5n[R "XSS9$[[R UR5n[R"XSS9$)Nafterfieldmodetypeschema)_inspect_validatorr#r rWithInfoValidatorFunction"with_info_after_validator_functionNoInfoValidatorFunction no_info_after_validator_function)self source_typehandlerr+info_argr#s Q/var/www/html/venv/lib/python3.13/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__+AfterValidator.__get_pydantic_core_schema__Jso%%diigGL  ==tyyIDAA$V V ;;TYYGD??T Tc"U"URS9$)Nr#r:cls decorators r5_from_decoratorAfterValidator._from_decoratorTs ''r8Nr2rr3rreturncore_schema.CoreSchemar=z>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]rBr) __name__ __module__ __qualname____firstlineno____doc____annotations__r6 classmethodr>__static_attributes__r@r8r5r r s+(T VUU((r8r cP\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[URSSS9nU(a:[ [ RUR5n[ R"UUUS9$[ [ RUR5n[ R"XcUS9$)Nbeforer&r'r+json_schema_input_schema) rPrgenerate_schemar,r#r rr-#with_info_before_validator_functionr/!no_info_before_validator_functionr1r2r3r+ input_schemar4r#s r5r6,BeforeValidator.__get_pydantic_core_schema__~s%**.?? (()D)DE  &diihWM  ==tyyIDBB)5   ;;TYYGD@@l r8cLU"URURRS9$N)r#rPr#inforPr;s r5r>BeforeValidator._from_decorator##,>>#H#H  r8r@NrArD rErFrGrHrIrJrrPr6rKr>rLr@r8r5rNrNYs5@ VU"3C3,  r8rNcP\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, 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`][]. r"r#rrPc SSKJn U"U5nURS[R"SUUR U5S95nUR UR 5n[URSSS9nU(a:[[RUR5n[R"UUUS 9$[[RUR5n[R"UUUS 9$!Ua SnNf=f) Nr)PydanticSchemaGenerationError serializationcU"U5$Nr@vhs r5=PlainValidator.__get_pydantic_core_schema__..!A$r8)functionr+ return_schemaplainr&r')rgrT)pydanticrfgetr#wrap_serializer_function_ser_schemarUrPr,r#r r-"with_info_plain_validator_functionr/ no_info_plain_validator_function) r1r2r3rfr+rgrYr4r#s r5r6+PlainValidator.__get_pydantic_core_schema__s ; ![)F#JJ??.!")"9"9+"FM..t/J/JK %diigGL  ==tyyIDAA+)5   ;;TYYGD??+)5 - ! M !s>C11C<;C<cLU"URURRS9$r\r]r;s r5r>PlainValidator._from_decoratorr`r8r@NrArD) rErFrGrHrIrJrrPr6rKr>rLr@r8r5rcrcs6,\ VU"%C%'R  r8rccP\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#rrPcU"U5nUR[LaSOURUR5n[URSSS9nU(a:[ [ RUR5n[ R"UUUS9$[ [ RUR5n[ R"UUUS9$)Nwrapr&r'rS) rPrrUr,r#r rWithInfoWrapValidatorFunction!with_info_wrap_validator_functionNoInfoWrapValidatorFunctionno_info_wrap_validator_functionrXs r5r6*WrapValidator.__get_pydantic_core_schema__+s%**.?? (()D)DE  &diif7K  AA499MD@@)5   ??KD>>)5 r8cLU"URURRS9$r\r]r;s r5r>WrapValidator._from_decoratorCr`r8r@NrArDrar@r8r5r|r|s5$L ^]"3C30  r8r|c\rSrSrSSjrSrg)_OnlyValueValidatorClsMethodiMcgrir@r1r<values r5__call__%_OnlyValueValidatorClsMethod.__call__NsCr8r@Nr<rrrrBrrErFrGrHrrLr@r8r5rrMs?r8rc\rSrSrSSjrSrg)_V2ValidatorClsMethodiPcgrir@r1r<rr^s r5r_V2ValidatorClsMethod.__call__Qscfr8r@Nr<rrrr^core_schema.ValidationInfo[Any]rBrrr@r8r5rrPsfr8rc\rSrSrSSjrSrg) _OnlyValueWrapValidatorClsMethodiScgrir@r1r<rr3s r5r)_OnlyValueWrapValidatorClsMethod.__call__Tsorr8r@N)r<rrrr3(core_schema.ValidatorFunctionWrapHandlerrBrrr@r8r5rrSsrr8rc2\rSrSrSSjrSrg)_V2WrapValidatorClsMethodiVcgrir@r1r<rr3r^s r5r"_V2WrapValidatorClsMethod.__call__Wsr8r@N) r<rrrr3rr^rrBrrr@r8r5rrVs7   >   2   r8rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rRr%rrrFieldValidatorModes.) check_fieldsrPcgrir@r&r(rrPfieldss r5field_validatorrys>Ar8cgrir@rs r5rrs Z]r8)r(rcgrir@)r&r(rrs r5rrs Z]r8r%)r(rrPc<^^^^[U5(d[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: *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-argumentscode)rRrrrz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typerrc3B# UHn[U[5v M g7fri) isinstancestr).0r&s r5 "field_validator..s:6%z%%%6szThe provided field names to the `@field_validator` decorator should be strings. For example: `@field_validator('', '', ...).`zdecorator-invalid-fieldsc>[R"U5(a [SSS9e[R"U5n[R"TTTTS9n[R "X5$)NzFThe `@field_validator` decorator cannot be applied to instance methodszvalidator-instance-methodr)rr(rrP)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)fdec_inforrrPr(s r5decfield_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>[R"U5nTS:Xa;[U[5(a&[R "[ S[5S3SS9 [R"TS9n[R"X5$)Nr%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) rrrrKwarningswarnrrModelValidatorDecoratorInfor)rrr(s r5rmodel_validator..decsx  = =a @ 7?z![99 MM3JJW/IZ[GH  ::E221??r8)rrrBrr@)r(rs` r5rrsb@ Jr8AnyTypecX\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$ri)rr<items r5__class_getitem__InstanceOf.__class_getitem__ sT35[) )r8cSSKJn [R"[R "U5=(d U5nU"U5n[R "SUS9US'[R"XES9$!Ua Us$f=f)Nr)GENERATE_SCHEMA_ERRORScU"U5$rir@rjs r5rm9InstanceOf.__get_pydantic_core_schema__..ror8rpr+rg) python_schema json_schema)#pydantic._internal._generate_schemarris_instance_schemar get_originrujson_or_python_schema)r<sourcer3rinstance_of_schemaoriginal_schemas r5r6'InstanceOf.__get_pydantic_core_schema__s R"-!?!? @T@TU[@\@f`f!g  x")&/ 7B6e6e.7"?3#88GYww* *)) *sA00A;:A;r@N)rrrBrr rr3rrBrC) rErFrGrHrIrKrr6object__hash__rLr@r8r5rrs= @  *  *  x  x&??r8rcN\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$ri)rrrs r5r SkipValidation.__class_getitem__7sT>#334 4r8c ^[R"5 [R"S[5 U"U5mSSS5 SU4Sj/0n[R "U[R "STS9S9$!,(df  N@=f)Nignore pydantic_js_annotation_functionsc>U"T5$rir@)_crlrs r5rm=SkipValidation.__get_pydantic_core_schema__..?s 1_K]r8cU"U5$rir@rjs r5rmrCror8r)metadatarg)rcatch_warnings simplefilterrr any_schemaru)r<r r3rrs @r5r6+SkipValidation.__get_pydantic_core_schema__:sp((*%%h0DE")&/+;=]<^_H))!)MM.  +*s $A55 Br@N)rrrBrr) rErFrGrHrIrrKr6rrrLr@r8r5rr*s+  5    ??r8r _FromTypeTc,\rSrSrSrSSjrSSjrSrg) 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) ``` cXlX lgri from_typeinstantiation_hook)r1r(r)s r5__init__ValidateAs.__init__ps ""4r8cdU"UR5n[R"URUS9$)Nr*)r(rr0r))r1r r3r+s r5r6'ValidateAs.__get_pydantic_core_schema__ts/(;;  # #  r8r'N)r)zCallable[[_FromTypeT], Any]r(ztype[_FromTypeT]rBNoner)rErFrGrHrIr*r6rLr@r8r5r%r%MsD5 r8r%r@) r&rrrr(Literal['wrap']r bool | NonerPrrBz6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]) r&rrrr(zLiteral['before', 'plain']rr0rPrrBRCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]) r&rrrr(Literal['after']rr0rBr1) r&rrrr(rrr0rPrrBzCallable[[Any], Any])r(r/rBz|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])r(zLiteral['before']rBzrCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])r(r2rBz}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])r(z"Literal['wrap', 'before', 'after']rBr)WrI __future__r _annotations dataclassessysr functoolsrtypingrrrrr r r r r pydantic_corerrtyping_extensionsrr _internalrrrannotated_handlersrerrorsrversionrrr version_inforinspect_validatorr, dataclass slots_truer rNrcr|rrrrr-r/ _V2Validatorrr_V2WrapValidatorrK staticmethodrrJrrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrrrrr#r%r@r8r5rMsH2 #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 AA  A  A  A<A A !$"% ] ]] % ]  ]  ]X] ] ! # ] ]]  ]  ] X ] ]!( $"3 i ii  i  i  iiX\ " ~6   H H(S_J`  HZ$8" *-  (  h  x  8 "*:, *B!C K,F,Fs,KLjXYZ1*=?\]g?hhi 24WYxx 3J ?A_`jAk kl         A ,A AH ) 7C<(J<0;;<9#9#=9#xw|,N<0;;<##=#>\ " , , r8