hxs:%SrSSKJr SSKrSSKrSSKJr SSKJ r SSK J r J r J r JrJrJrJrJrJr SSKJrJr SSKJr SS KJrJr S S KJrJrJr S S KJ r S S K!J"r" \RFS:aSSKJ$r$ OSSK J$r$ \RJr&\RN"SLSS0\RPD6"SS55r)\RN"SLSS0\RPD6"SS55r*\RN"SLSS0\RPD6"SS55r+\RN"SLSS0\RPD6"SS55r,\ (a"SS\$5r-"SS\$5r."SS\$5r/"S S!\$5r0\\.\Rb\-\Rd4r3\\0\Rh\/\Rj4r6\\7\ \ \ 4\8\ \ 4\\ 4r9S"\:S#'\"S$\\3\94S%9r;\"S&\\6\94S%9r<\S'r=S"\:S('\S)S)S*.SMS+jj5r>\S)S)S*.SNS,jj5r>\S)S)S-.SOS.jj5r>S/S\S0.SPS1jjr>\"S25r?\"S3SS49r@"S5S6\R\$\@5rB"S7S8\$\?5rC"S9S:\$\?5rD"S;S<\$5rE"S=S>\$5rF"S?S@\$5rG"SASB\$5rH\\?/\?4rI\\?\R/\?4rK\\D\?\C\?4rL\\G\H\E\F4rM\\K\?\I\?4rN\SQSCj5rO\SRSDj5rO\SSSEj5rOSTSFjrO\"SG5rP\ (a\ \PS)4rQO)\RN"SL0\RPD6"SHSI55rQ\ (a\ \PS)4rRg\RN"SL0\RPD6"SJSK55rRg)UzBThis module contains related classes and functions for validation.) annotationsN) partialmethod) FunctionType) TYPE_CHECKING AnnotatedAnyCallableLiteralTypeVarUnioncastoverload)PydanticUndefined core_schema)r)Self TypeAlias) _decorators _generics_internal_dataclass)GetCoreSchemaHandler)PydanticUserError) )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.WithInfoValidatorFunctionfunccBU"U5n[URS5nU(aC[[RUR5n[R "XSUR S9$[[RUR5n[R"XSS9$)Nafter)schema field_name)r$) _inspect_validatorr!r rWithInfoValidatorFunction"with_info_after_validator_functionr%NoInfoValidatorFunction no_info_after_validator_function)self source_typehandlerr$info_argr!s P/var/www/html/env/lib/python3.13/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__+AfterValidator.__get_pydantic_core_schema__Isv%%dii9  ==tyyIDAA$bibtbtu u ;;TYYGD??T Tc"U"URS9$)Nr!r4cls decorators r/_from_decoratorAfterValidator._from_decoratorSs ''r2Nr,rr-rreturncore_schema.CoreSchemar7z>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]r<r) __name__ __module__ __qualname____firstlineno____doc____annotations__r0 classmethodr8__static_attributes__r:r2r/rrs+(T VUU((r2rcP\rSrSr%SrS\S'\rS\S'S Sjr\ S Sj5r S r g ) BeforeValidatorXa*!!! 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 of the function. This is only used to generate the appropriate JSON Schema (in validation mode). 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(aE[ [ RUR5n[ R"UUURUS9$[ [ RUR5n[ R"XcUS9$)Nbeforer$r%json_schema_input_schemar$rN) rJrgenerate_schemar&r!r rr'#with_info_before_validator_functionr%r)!no_info_before_validator_functionr+r,r-r$ input_schemar.r!s r/r0,BeforeValidator.__get_pydantic_core_schema__}s%**.?? (()D)DE  &dii:  ==tyyIDBB"--)5   ;;TYYGD@@l r2cLU"URURRS9$N)r!rJr!inforJr5s r/r8BeforeValidator._from_decorator##,>>#H#H  r2r:Nr;r> r?r@rArBrCrDrrJr0rEr8rFr:r2r/rHrHXs5@ VU"3C3.  r2rHcP\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 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 Annotated, Union 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`. r r!rrJc SSKJn U"U5nURS[R"SUUR U5S95nUR UR 5n[URS5nU(aE[[RUR5n[R"UURUUS9$[[RUR5n[R"UUUS9$!Ua SnNf=f) NrPydanticSchemaGenerationError serializationcU"U5$Nr:vhs r/=PlainValidator.__get_pydantic_core_schema__..!A$r2)functionr$ return_schemaplain)r%rcrN)rcrN)pydanticrbgetr#wrap_serializer_function_ser_schemarPrJr&r!r r'"with_info_plain_validator_functionr%r) no_info_plain_validator_function) r+r,r-rbr$rcrTr.r!s r/r0+PlainValidator.__get_pydantic_core_schema__s ; ![)F#JJ??.!")"9"9+"FM..t/J/JK %dii9  ==tyyIDAA"--+)5   ;;TYYGD??+)5 !- ! M !s>C==DDcLU"URURRS9$rWrXr5s r/r8PlainValidator._from_decoratorr[r2r:Nr;r>) r?r@rArBrCrDrrJr0rEr8rFr:r2r/r^r^s6(T VU"%C%(T  r2r^cP\rSrSr%SrS\S'\rS\S'S Sjr\ S Sj5r S r g ) WrapValidatora`!!! 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 of the function. This is only used to generate the appropriate JSON Schema (in validation mode). ```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!rrJcU"U5nUR[LaSOURUR5n[URS5nU(aE[ [ RUR5n[ R"UUURUS9$[ [ RUR5n[ R"UUUS9$)NwraprMrO) rJrrPr&r!r rWithInfoWrapValidatorFunction!with_info_wrap_validator_functionr%NoInfoWrapValidatorFunctionno_info_wrap_validator_functionrSs r/r0*WrapValidator.__get_pydantic_core_schema__(s%**.?? (()D)DE  &dii8  AA499MD@@"--)5   ??KD>>)5 r2cLU"URURRS9$rWrXr5s r/r8WrapValidator._from_decoratorAr[r2r:Nr;r>r\r:r2r/rxrxs5$L ^]"3C32  r2rxc\rSrSrSSjrSrg)_OnlyValueValidatorClsMethodiKcgrer:r+r6values r/__call__%_OnlyValueValidatorClsMethod.__call__LsCr2r:Nr6rrrr<rr?r@rArBrrFr:r2r/rrKs?r2rc\rSrSrSSjrSrg)_V2ValidatorClsMethodiNcgrer:r+r6rrYs r/r_V2ValidatorClsMethod.__call__Os_br2r:Nr6rrrrY_core_schema.ValidationInfor<rrr:r2r/rrNsbr2rc\rSrSrSSjrSrg) _OnlyValueWrapValidatorClsMethodiQcgrer:r+r6rr-s r/r)_OnlyValueWrapValidatorClsMethod.__call__Rspsr2r:N)r6rrrr-)_core_schema.ValidatorFunctionWrapHandlerr<rrr:r2r/rrQssr2rc2\rSrSrSSjrSrg)_V2WrapValidatorClsMethodiTcgrer:r+r6rr-rYs r/r"_V2WrapValidatorClsMethod.__call__Usr2r:N) r6rrrr-rrYrr<rrr:r2r/rrTs7   ?   .   r2rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rLr#r{rnFieldValidatorModes.) check_fieldsrJcgrer:fieldmoderrJfieldss r/field_validatorrws>Ar2cgrer:rs r/rrs Z]r2)rrcgrer:)rrrrs r/rrs Z]r2r#)rrrJc^^^^[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)rLrnr{z;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typernc3B# UHn[U[5v M g7fre) isinstancestr).0rs r/ "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)rrrrJ)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)fdec_inforrrJrs r/decfield_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. c>[R"U5n[R"TS9n[R"X5$)Nr)rrModelValidatorDecoratorInfor)rrrs r/rmodel_validator..decs4  = =a @::E221??r2)rrr<rr:)rrs` r/rrsb@ Jr2AnyTypecX\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)rr6items r/__class_getitem__InstanceOf.__class_getitem__sT35[) )r2cSSKJn [R"[R "U5=(d U5nU"U5n[R "SUS9US'[R"XES9$!Ua Us$f=f)NrracU"U5$rer:rfs r/ri9InstanceOf.__get_pydantic_core_schema__..rkr2rlr$rc) python_schema json_schema)rorbris_instance_schemar get_originrqjson_or_python_schema)r6sourcer-rbinstance_of_schemaoriginal_schemas r/r0'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?r@rArBrCrErr0object__hash__rFr:r2r/rrs= @  *  *  x  x&??r2rcN\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 r/r SkipValidation.__class_getitem__.sT>#334 4r2cx^U"U5mSU4Sj/0n[R"U[R"STS9S9$)N pydantic_js_annotation_functionsc>U"T5$rer:)_crhrs r/ri=SkipValidation.__get_pydantic_core_schema__..4s 1_K]r2cU"U5$rer:rfs r/rir8rkr2r)metadatarc)r any_schemarq)r6rr-rrs @r/r0+SkipValidation.__get_pydantic_core_schema__1sC%foO:=]<^_H))!)MM. r2r:N)rrr<rr) r?r@rArBrCrrEr0rrrFr:r2r/r r !s+  5    ??r2r r:) rrrrrLiteral['wrap']r bool | NonerJrr<z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]) rrrrrzLiteral['before', 'plain']rrrJrr<RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]) rrrrrLiteral['after']rrr<r) rrrrrrrrrJrr<zCallable[[Any], Any])rrr<z|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rzLiteral['before']r<zrCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rrr<z}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rz"Literal['wrap', 'before', 'after']r<r)SrC __future__r _annotations dataclassessys functoolsrtypesrtypingrrrr r r r r r pydantic_corerr _core_schematyping_extensionsrr _internalrrrannotated_handlersrerrorsr version_inforinspect_validatorr& dataclass slots_truerrHr^rxrrrrr'r) _V2Validatorr|r~_V2WrapValidatorrE staticmethodrrDrrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrrrr r:r2r/r4sH2 #ccc85-BB4%g* 22 EdE&9&D&DE9(9(F9(x EdE&9&D&DE@ @ F@ F EdE&9&D&DE] ] F] @ EdE&9&D&DEH H FH V@x@cct8tH..$,, .L!22(00 2,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   I I8T`Ka  HZ$8" *-  (  h  x  8 "*:, *B!C L,G,GH*TUZ1*=?\]g?hhi 24WYxx 3J ?A_`jAk kl         7 ,7 7t ) 7C<(J<0;;<9#9#=9#xw|,N<0;;<##=#r2