9Cgqp8UdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZddlmZmZddlmZdd lmZmZmZmZd d lmZmZmZmZd d l m!Z!d d l"m#Z#ej$dkrddlm%Z%nddl m%Z%ej&Z'ej(d`ddiej)GddZ*ej(d`ddiej)GddZ+ej(d`ddiej)GddZ,ej(d`ddiej)GddZ-e rGdde%Z.Gdde%Z/Gdde%Z0Gd d!e%Z1ee/ej2e.ej3fZ4ee1ej5e0ej6fZ7ee8e e e fe9e e fee fZ:d"e;d#<ed$ee4e:f%Z<ed&ee7e:f%Z=ed'Z>d"e;d(<ed)d)d*dad6Z?ed)d)d*dbd9Z?ed)d)d:dcd<Z?d=ded>ddd@Z?edAZ@edBdCZAGdDdEejBe%eAZCGdFdGe%e@ZDGdHdIe%e@ZEGdJdKe%ZFGdLdMe%ZGGdNdOe%ZHGdPdQe%ZIe e@ge@fZJ e e@ejKge@fZL eeEe@eDe@fZMeeHeIeFeGfZNeeLe@eJe@fZOededSZPedfdVZPedgdXZPdhdZZPed[ZQe r eeQd)fZRn%ej(d`iej)Gd\d]ZRe r eeQd)fZSdSej(d`iej)Gd^d_ZSdS)izBThis module contains related classes and functions for validation.) annotationsN) partialmethod) FunctionType) TYPE_CHECKINGAnyCallableTypeVarUnioncastoverload)PydanticUndefined core_schema)r) AnnotatedLiteralSelf TypeAlias)_core_metadata _decorators _generics_internal_dataclass)GetCoreSchemaHandler)PydanticUserError) )ProtocolfrozenTc>eZdZUdZded<dd ZeddZdS)AfterValidatora8Usage docs: https://docs.pydantic.dev/2.9/concepts/validators/#annotated-validators A metadata class that indicates that a validation should be applied **after** the inner validation logic. Attributes: func: The validator function. Example: ```py from typing_extensions 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|jd}|r;ttj|j}tj|||jSttj|j}tj||S)Nafter)schema field_name)r() _inspect_validatorr!r rWithInfoValidatorFunction"with_info_after_validator_functionr)NoInfoValidatorFunction no_info_after_validator_function)selfr"r#r(info_argr!s P/var/www/api/venv/lib/python3.11/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__z+AfterValidator.__get_pydantic_core_schema__Hs%%%di99  U =tyIIDA$vbibtuuu u ;TYGGD?VTTT T decorator>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]rc$||jS)Nr!r7clsr4s r1_from_decoratorzAfterValidator._from_decoratorRss ''''r3Nr"rr#rr$r%r4r5r$r)__name__ __module__ __qualname____doc____annotations__r2 classmethodr:r3r1rrsh''RVUUUUUUU((([(((r3rcLeZdZUdZded<eZded<dd ZeddZ dS)BeforeValidatoradUsage docs: https://docs.pydantic.dev/2.9/concepts/validators/#annotated-validators 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: ```py from typing_extensions 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%c||}|jturdn||j}tj|}t |jd}|r#H    r3Nr;r< r=r>r?r@rAr rFr2rBr:rCr3r1rErEWsy>VUUU"33333iiii,   [   r3rEcLeZdZUdZded<eZded<dd ZeddZ dS)PlainValidatoraUsage docs: https://docs.pydantic.dev/2.9/concepts/validators/#annotated-validators A metadata class that indicates that a validation should be applied **instead** of 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). If not provided, will default to `Any`. Example: ```py from typing_extensions import Annotated from pydantic import BaseModel, PlainValidator MyInt = Annotated[int, PlainValidator(lambda v: int(v) + 1)] class Model(BaseModel): a: MyInt print(Model(a='1').a) #> 2 ``` r r!rrFr"r#rr$r%c 0ddlm} ||}|dtjd|||}n #|$rd}YnwxYw||j}tj|}t|j d}|rz=PlainValidator.__get_pydantic_core_schema__..!!A$$r3)functionr( return_schemarHplain)r)r_rL)r_rL)pydanticr^getr#wrap_serializer_function_ser_schemarNrFrrOr*r!r r+"with_info_plain_validator_functionr)r- no_info_plain_validator_function) r/r"r#r^r(r_rSrLr0r!s r1r2z+PlainValidator.__get_pydantic_core_schema__sS ;::::: !W[))F#JJ?..!")"9"9+"F"FMM- ! ! ! MMM !..t/JKK !5<XXX%di99   =tyIIDA"-+!   ;TYGGD?+! sA AAAr4r5rc:||j|jjSrUrVr8s r1r:zPlainValidator._from_decoratorrXr3Nr;r<) r=r>r?r@rArrFr2rBr:rCr3r1r[r[sv2VUUU"%%%%%))))V   [   r3r[cLeZdZUdZded<eZded<dd ZeddZ dS) WrapValidatoraUsage docs: https://docs.pydantic.dev/2.9/concepts/validators/#annotated-validators 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). ```py from datetime import datetime from typing_extensions 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!rrFr"r#rr$r%c||}|jturdn||j}tj|}t |jd}|r! r3r4r5rc:||j|jjSrUrVr8s r1r:zWrapValidator._from_decorator/rXr3Nr;r<rYrCr3r1rqrqsv$$L^]]]"333334   [   r3rqceZdZddZdS)_OnlyValueValidatorClsMethodr9rvaluer$cdSrarCr/r9r{s r1__call__z%_OnlyValueValidatorClsMethod.__call__:r3Nr9rr{rr$rr=r>r?r~rCr3r1rzrz9s??????r3rzceZdZd dZdS) _V2ValidatorClsMethodr9rr{rW_core_schema.ValidationInfor$cdSrarCr/r9r{rWs r1r~z_V2ValidatorClsMethod.__call__=rr3Nr9rr{rrWrr$rrrCr3r1rr<sbbbbbbr3rceZdZd dZdS) _OnlyValueWrapValidatorClsMethodr9rr{r#)_core_schema.ValidatorFunctionWrapHandlerr$cdSrarCr/r9r{r#s r1r~z)_OnlyValueWrapValidatorClsMethod.__call__@rr3N)r9rr{rr#rr$rrrCr3r1rr?sssssssr3rceZdZd d Zd S) _V2WrapValidatorClsMethodr9rr{r#rrWrr$cdSrarCr/r9r{r#rWs r1r~z"_V2WrapValidatorClsMethod.__call__Cs #r3N) r9rr{rr#rrWrr$rrrCr3r1rrBs(      r3rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rJr'rsriFieldValidatorModes.) check_fieldsrFfieldstrfieldsmodeLiteral['wrap']r bool | NonerFrr$6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cdSrarCrrrrFrs r1field_validatorres >ASr3Literal['before', 'plain']RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cdSrarCrs r1rrps Z]Y\r3)rrLiteral['after']cdSrarC)rrrrs r1rr{s Z]Y\r3r')rrrFCallable[[Any], Any]c:t|trtdddvrturtddtur dkrt|gRt dDstd d dfd }|S)a1Usage docs: https://docs.pydantic.dev/2.9/concepts/validators/#field-validators Decorate methods on the class indicating that they should be used to validate fields. Example usage: ```py 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)rJrirsz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typeric3@K|]}t|tVdSra) isinstancer).0rs r1 z"field_validator..s,::%z%%%::::::r3z`@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)rrrrF)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)rdec_inforrrFrs r1deczfield_validator..decs}  21 5 5 #JQl   =a @ @:r?r@r~rCr3r1rrs8gg ,0       r3rceZdZdZd d Zd S) ModelWrapValidatorWithoutInfozA `@model_validator` decorated function signature. This is used when `mode='wrap'` and the function does not have info argument. r9type[_ModelType]r{rr#%ModelWrapValidatorHandler[_ModelType]r$rcdSrarCrs r1r~z&ModelWrapValidatorWithoutInfo.__call__s Sr3N)r9rr{rr#rr$rrrCr3r1rrs2      r3rceZdZdZdd Zd S)ModelWrapValidatorzSA `@model_validator` decorated function signature. This is used when `mode='wrap'`.r9rr{rr#rrWrr$rcdSrarCrs r1r~zModelWrapValidator.__call__s Sr3N) r9rr{rr#rrWrr$rrrCr3r1rrs.]]      r3rceZdZdZddZdS)#FreeModelBeforeValidatorWithoutInfoA `@model_validator` decorated function signature. This is used when `mode='before'` and the function does not have info argument. r{rr$cdSrarC)r/r{s r1r~z,FreeModelBeforeValidatorWithoutInfo.__call__)s cr3N)r{rr$rrrCr3r1rr$s2r3rceZdZdZddZdS) ModelBeforeValidatorWithoutInforr9rr{r$cdSrarCr}s r1r~z(ModelBeforeValidatorWithoutInfo.__call__8 cr3NrrrCr3r1rr3s2r3rceZdZdZd dZdS) FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.r{rrWrr$cdSrarC)r/r{rWs r1r~z!FreeModelBeforeValidator.__call__Frr3N)r{rrWrr$rrrCr3r1rrCs.__r3rceZdZdZd dZd S) ModelBeforeValidatorrr9rr{rWrr$cdSrarCrs r1r~zModelBeforeValidator.__call__Ts cr3NrrrCr3r1rrQs.__      r3r|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSrarCrs r1model_validatorro 3r3Literal['before']rCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSrarCrs r1rrxrr3}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSrarCrs r1rrrr3"Literal['wrap', 'before', 'after']cdfd }|S)a"Usage docs: https://docs.pydantic.dev/2.9/concepts/validators/#model-validators Decorate model methods for validation purposes. Example usage: ```py 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. rrr$rctj|}tj}tj||S)Nr)rrModelValidatorDecoratorInfor)rrrs r1rzmodel_validator..decs9  =a @ @:EEE21h???r3)rrr$rrC)rrs` r1rrs/`@@@@@@ Jr3AnyTypecPeZdZdZed dZedd ZejZd S) InstanceOfuGeneric type for annotating a type that is an instance of a given class. Example: ```py 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||fSra)rr9rs r1__class_getitem__zInstanceOf.__class_getitem__sT3355[) )r3sourcerr#rr%cddlm}tjt j|p|} ||}tjd||d<tj||S#|$r|cYSwxYw)Nrr]c||SrarCrbs r1rez9InstanceOf.__get_pydantic_core_schema__..rfr3rgr(r_) python_schema json_schema)rjr^ris_instance_schemar get_originrljson_or_python_schema)r9rr#r^instance_of_schemaoriginal_schemas r1r2z'InstanceOf.__get_pydantic_core_schema__s > > > > > >"-!? @TU[@\@\@f`f!g!g  x")'&// 7B6e..777"?3#8GYgvwwww1 * * *)))) *s A++A54A5N)rrr$rrrr#rr$r%) r=r>r?r@rBrr2object__hash__rCr3r1rrsf  @  * * *  *  x x x  x&?r3rc@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|tfSra)rrrs r1rz SkipValidation.__class_getitem__sT>#3#334 4r3rr#rr%c||tjfdg}tj|tjdS)Nc|SrarC)_crdrs r1rez=SkipValidation.__get_pydantic_core_schema__.. sababcrasasr3)js_annotation_functionsc||SrarCrbs r1rez=SkipValidation.__get_pydantic_core_schema__..$rfr3r)rLr_)rrOr any_schemarl)r9rr#rLrs @r1r2z+SkipValidation.__get_pydantic_core_schema__sj%gfooO%9SsSsSsSsRtuuuH)!)M.. r3N)rrr$rr) r=r>r?r@rrBr2rrrCr3r1rr sU  5 5 5 5      ?r3rrC) rrrrrrrrrFrr$r) rrrrrrrrrFrr$r) rrrrrrrrr$r) rrrrrrrrrFrr$r)rrr$r)rrr$r)rrr$r)rrr$r)Tr@ __future__r _annotations dataclassessys functoolsrtypesrtypingrrrr r r r pydantic_corer r _core_schematyping_extensionsrrrr _internalrrrrannotated_handlersrerrorsr version_inforinspect_validatorr* dataclass slots_truerrEr[rqrzrrrr+r- _V2Validatorrtrv_V2WrapValidatorrB staticmethodrrArrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrrrrrCr3r1r sHHH222222 ######OOOOOOOOOOOOOOOOOO88888888555555AAAAAAAAAAAARRRRRRRRRRRR444444%%%%%%g******* 2EEdE&9&DEE8(8(8(8(8(8(8(FE8(vEEdE&9&DEE> > > > > > > FE> BEEdE&9&DEEM M M M M M M FEM `EEdE&9&DEEI I I I I I I FEI X)u@@@@@x@@@ccccccccttttt8tttH.$, .L!2(0 2,1S#s]1K\Z]_bZbMcersvew1w+xxxxx)0,L";;<***&#7#9GWYrGrAsttt!()K!LLLLL !$"% AAAAA A !$"% ]]]]] ] ! # ]]]]] ]!( $"3 kkkkkk\W\ " " w~666       I8T`Ka    HZ$8"     *-        (        h        x        8   "*:, *B!C L,GH*TUZ1*=?\]g?hhi 24WYxx 3J ?A_`jAk kl      6666r ')  @#7C<(JJ[<<0;<<9#9#9#9#9#9#9#=<9#x#w|,NNN[<<0;<<#######=<###r3