oi_|UdZddlmZddlZddlZddlZddlmZddl m Z ddl m Z m Z mZmZmZmZmZmZmZddlmZmZddlmZmZd d lmZmZmZd d lm Z d d l!m"Z"d d l#m$Z$d dlm%Z%m&Z&ej'dkrddlm(Z(nddl m(Z(ej)Z*ej+ddddiej,GddZ-ej+ddddiej,GddZ.ej+ddddiej,GddZ/ej+ddddiej,GddZ0e rGdde(Z1Gdde(Z2Gdd e(Z3Gd!d"e(Z4ee2ej5e1ej6fZ7ee4ej8e3ej9fZ:ee;eeefed$<ed%ee7e=f&Z?ed'ee:e=f&Z@ed(ZAd#e>d)<ed*d*d+ded7ZBed*d*d+dfd:ZBed*d*d;dgd=ZBd>ded?dhdAZBedBZCedCdDZDGdEdFejEe(eDZFGdGdHe(eCZGGdIdJe(eCZHGdKdLe(ZIGdMdNe(ZJGdOdPe(ZKGdQdRe(ZLeeCgeCfZM eeCejNegeCfZO eeHeCeGeCfZPeeKeLeIeJfZQeeOeCeMeCfZRedidTZSedjdWZSedkdYZSdld[ZSed\ZTe r e eTd*fZUn%ej+ddiej,Gd]d^ZUe r e eTd*fZVn%ej+ddiej,Gd_d`ZVedaZWGdbdcZXdS)mzBThis 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) )ProtocolfrozenTc>eZdZUdZded<dd ZeddZdS)AfterValidatoraT!!! 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.WithInfoValidatorFunctionfunc source_typerhandlerrreturncore_schema.CoreSchemac||}t|jdd}|r5ttj|j}tj||Sttj|j}tj||S)Nafterfieldmodetypeschema)_inspect_validatorr#r rWithInfoValidatorFunction"with_info_after_validator_functionNoInfoValidatorFunction no_info_after_validator_function)selfr$r%r/info_argr#s U/var/www/findabus/venv/lib/python3.11/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__z+AfterValidator.__get_pydantic_core_schema__Ks%%%digGLLL  U =tyIIDA$vVVV V ;TYGGD?VTTT T decorator>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]rc$||jS)Nr#r=clsr:s r7_from_decoratorzAfterValidator._from_decoratorUss ''''r9Nr$rr%rr&r'r:r;r&r)__name__ __module__ __qualname____doc____annotations__r8 classmethodr@r9r7r!r!sh((TVUUUUUUU((([(((r9r!cLeZdZUdZded<eZded<dd ZeddZ dS)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 ``` r"r#rjson_schema_input_typer$r%rr&r'cv||}|jturdn||j}t|jdd}|r6t t j|j}t j|||St t j |j}t j |||S)Nbeforer*r+r/json_schema_input_schema) rLrgenerate_schemar0r#r rr1#with_info_before_validator_functionr3!no_info_before_validator_functionr5r$r%r/ input_schemar6r#s r7r8z,BeforeValidator.__get_pydantic_core_schema__s%%*.??? D(()DEE  &dihWMMM   =tyIIDB)5   ;TYGGD@Vl r9r:r;rc:||j|jjSN)r#rLr#inforLr>s r7r@zBeforeValidator._from_decorator(s#,>#H    r9NrArB rCrDrErFrGrrLr8rHr@rIr9r7rKrKZsv@VUUU"33333,   [   r9rKcLeZdZUdZded<eZded<dd ZeddZ dS)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#rrLr$r%rr&r'c ddlm} ||}|dtjd|||}n #|$rd}YnwxYw||j}t|jdd}|r6ttj |j}tj ||| Sttj |j}tj ||| S) NrPydanticSchemaGenerationError serializationc||SNrIvhs r7z=PlainValidator.__get_pydantic_core_schema__..!!A$$r9)functionr/ return_schemaplainr*r+)rarP)pydanticr`getr#wrap_serializer_function_ser_schemarQrLr0r#r r1"with_info_plain_validator_functionr3 no_info_plain_validator_function) r5r$r%r`r/rarUr6r#s r7r8z+PlainValidator.__get_pydantic_core_schema__s? ;::::: !W[))F#JJ?..!")"9"9+"F"FMM- ! ! ! MMM !..t/JKK %digGLLL   =tyIIDA+)5   ;TYGGD?+)5 sA AAAr:r;rc:||j|jjSrWrXr>s r7r@zPlainValidator._from_decoratorrZr9NrArB) rCrDrErFrGrrLr8rHr@rIr9r7r]r]sw,,\VUUU"%%%%%''''R   [   r9r]cLeZdZUdZded<eZded<dd ZeddZ dS) 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 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#rrLr$r%rr&r'cv||}|jturdn||j}t|jdd}|r6t t j|j}t j|||St t j |j}t j |||S)Nwrapr*r+rO) rLrrQr0r#r rWithInfoWrapValidatorFunction!with_info_wrap_validator_functionNoInfoWrapValidatorFunctionno_info_wrap_validator_functionrTs r7r8z*WrapValidator.__get_pydantic_core_schema__,s%%*.??? D(()DEE  &dif7KKK   A49MMD@)5   ?KKD>)5 r9r:r;rc:||j|jjSrWrXr>s r7r@zWrapValidator._from_decoratorDrZr9NrArBr[rIr9r7rsrssv$$L^]]]"333330   [   r9rsceZdZddZdS)_OnlyValueValidatorClsMethodr?rvaluer&cdSrcrIr5r?r}s r7__call__z%_OnlyValueValidatorClsMethod.__call__Or9Nr?rr}rr&rrCrDrErrIr9r7r|r|Ns??????r9r|ceZdZd dZdS) _V2ValidatorClsMethodr?rr}rYcore_schema.ValidationInfo[Any]r&cdSrcrIr5r?r}rYs r7rz_V2ValidatorClsMethod.__call__Rrr9Nr?rr}rrYrr&rrrIr9r7rrQsffffffr9rceZdZd dZdS) _OnlyValueWrapValidatorClsMethodr?rr}r%(core_schema.ValidatorFunctionWrapHandlerr&cdSrcrIr5r?r}r%s r7rz)_OnlyValueWrapValidatorClsMethod.__call__Urr9N)r?rr}rr%rr&rrrIr9r7rrTsrrrrrrr9rceZdZd d Zd S) _V2WrapValidatorClsMethodr?rr}r%rrYrr&cdSrcrIr5r?r}r%rYs r7rz"_V2WrapValidatorClsMethod.__call__Xs #r9N) r?rr}rr%rrYrr&rrrIr9r7rrWs(      r9rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rNr)rurkFieldValidatorModes.) check_fieldsrLr*strfieldsr,Literal['wrap']r bool | NonerLrr&6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cdSrcrIr*r,rrLrs r7field_validatorrzs >ASr9Literal['before', 'plain']RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cdSrcrIrs r7rrs Z]Y\r9)r,rLiteral['after']cdSrcrI)r*r,rrs r7rrs Z]Y\r9r))r,rrLCallable[[Any], Any]c:t|trtdddvrturtddtur dkrt|gRt dDstd d dfd }|S)aO!!! 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)rNrkruz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typerkc3@K|]}t|tVdSrc) isinstancer).0r*s r7 z"field_validator..s,::%z%%%::::::r9z`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('', '', ...)`zvalidator-invalid-fieldsfHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]r&(_decorators.PydanticDescriptorProxy[Any]ctj|rtddtj|}tj}tj||S)Nz8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodr)rr,rrL)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)rdec_inforrrLr,s r7deczfield_validator..decs}  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. rrr&rctj|}dkrAt|tr,t jt dtddtj}tj ||S)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) rrrrHwarningswarnrrModelValidatorDecoratorInfor)rrr,s r7rzmodel_validator..decs  =a @ @ 7??z![99? M3HJW//HHH     :EEE21h???r9)rrr&rrI)r,rs` r7rrs/b@@@@@@ Jr9AnyTypecPeZdZdZed dZedd ZejZd S) InstanceOfuGeneric 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' │ } ] """ ``` itemrr&c0t||fSrc)rr?rs r7__class_getitem__zInstanceOf.__class_getitem__sT3355[) )r9sourcerr%rr'cddlm}tjt j|p|} ||}tjd||d<tj||S#|$r|cYSwxYw)Nrr_c||SrcrIrds r7rgz9InstanceOf.__get_pydantic_core_schema__..#rhr9rir/ra) python_schema json_schema)rlr`ris_instance_schemar get_originrnjson_or_python_schema)r?rr%r`instance_of_schemaoriginal_schemas r7r8z'InstanceOf.__get_pydantic_core_schema__s > > > > > >"-!? @TU[@\@\@f`f!g!g  x")'&// 7B6e..777"?3#8GYgvwwww1 * * *)))) *s A++A54A5N)rrr&rrrr%rr&r') rCrDrErFrHrr8object__hash__rIr9r7rrsf  @  * * *  *  x x x  x&?r9rc@eZdZdZd dZed d ZejZd S)SkipValidationaIf 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. rrr&c8t|tfSrc)rrrs r7rz SkipValidation.__class_getitem__;sT>#3#334 4r9rr%rr'c tj5tjdt||dddn #1swxYwYdfdgi}t j|t jdS)Nignore pydantic_js_annotation_functionsc|SrcrI)_crfrs r7rgz=SkipValidation.__get_pydantic_core_schema__..Cs11_K]K]r9c||SrcrIrds r7rgz=SkipValidation.__get_pydantic_core_schema__..Grhr9r)metadatara)rcatch_warnings simplefilterrr any_schemarn)r?rr%r rs @r7r8z+SkipValidation.__get_pydantic_core_schema__>s(** 2 2%h0DEEE")'&// 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2;=]=]=]=]<^_H)!)M.. s&AA A N)rrr&rr) rCrDrErFrrHr8rrrIr9r7rr.sU  5 5 5 5      ?r9r _FromTypeTc"eZdZdZddZddZdS) ValidateAsaA 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) ``` instantiation_hookCallable[[_FromTypeT], Any] from_typetype[_FromTypeT]r&Nonec"||_||_dSrc)rr)r5rrs r7__init__zValidateAs.__init__ts""4r9rrr%rr'cX||j}tj|j|S)Nr.)rrr4r)r5rr%r/s r7r8z'ValidateAs.__get_pydantic_core_schema__xs6((;  #    r9N)rrrrr&rr)rCrDrErFrr8rIr9r7rrQsGD5555      r9rrI) r*rrrr,rrrrLrr&r) r*rrrr,rrrrLrr&r) r*rrrr,rrrr&r) r*rrrr,rrrrLrr&r)r,rr&r)r,rr&r)r,rr&r)r,rr&r)YrF __future__r _annotations dataclassessysr functoolsrtypesrtypingrrrr r r r r r pydantic_corerrtyping_extensionsrr _internalrrrannotated_handlersrerrorsrversionrrr version_inforinspect_validatorr0 dataclass slots_truer!rKr]rsr|rrrr1r3 _V2Validatorrvrx_V2WrapValidatorrH staticmethodrrGrrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrrrrrrrIr9r7r6sHHH222222 ######cccccccccccccccccccccc88888888--------BBBBBBBBBB444444%%%%%%""""""FFFFFFFFg******* 2EEdE&9&DEE9(9(9(9(9(9(9(FE9(xEEdE&9&DEE? ? ? ? ? ? ? FE? DEEdE&9&DEE` ` ` ` ` ` ` FE` FEEdE&9&DEEG G G G G G G FEG T)u@@@@@x@@@ggggggggsssss8sssH-$+ -L!1(/ 1,1S#s]1K\Z]_bZbMcersvew1w+xxxxx)0,L";;<***&#7#9GWYrGrAsttt!()K!LLLLL !$"% AAAAA A !$"% ]]]]] ] ! # ]]]]] ]!( $"3 llllll^W\ " " w~666       H(S_J`    HZ$8"     *-        (        h        x        8   "*:, *B!C K,Fs,KLjXYZ1*=?\]g?hhi 24WYxx 3J ?A_`jAk kl      AAAAH ')  @#7C<(JJ[<<0;<<9#9#9#9#9#9#9#=<9#x!#w|,NN[<<0;<<#######=<#>W\ " " , , , , , , , , , , r9