bMhxs4UdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZmZmZddlmZmZddlmZdd lmZmZd d lmZmZmZd d lm 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$Z/Gd d!e$Z0ee.ej1e-ej2fZ3ee0ej4e/ej5fZ6ee7e e e fe8e e fee fZ9d"e:d#<ed$ee3e9f%Z;ed&ee6e9f%Zed)d)d*dbd9Z>ed)d)d:dcd<Z>d=ded>ddd@Z>edAZ?edBdCZ@GdDdEejAe$e@ZBGdFdGe$e?ZCGdHdIe$e?ZDGdJdKe$ZEGdLdMe$ZFGdNdOe$ZGGdPdQe$ZHee?ge?fZI ee?ejJge?fZK eeDe?eCe?fZLeeGeHeEeFfZMeeKe?eIe?fZNededSZOedfdVZOedgdXZOdhdZZOed[ZPe r e ePd)fZQn%ej'd`iej(Gd\d]ZQe r e ePd)fZRdSej'd`iej(Gd^d_ZRdS)izBThis 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) )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|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 ^/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__z+AfterValidator.__get_pydantic_core_schema__Is%%%di99  U =tyIIDA$vbibtuuu u ;TYGGD?VTTT T decorator>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]rc$||jS)Nr r6clsr3s r0_from_decoratorzAfterValidator._from_decoratorSss ''''r2Nr!rr"rr#r$r3r4r#r)__name__ __module__ __qualname____doc____annotations__r1 classmethodr9r2r0rrsh((TVUUUUUUU((([(((r2rcLeZdZUdZded<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 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 ``` rr rjson_schema_input_typer!r"rr#r$c~||}|jturdn||j}t|jd}|r#H    r2Nr:r; r<r=r>r?r@rrEr1rAr9rBr2r0rDrDXsv@VUUU"33333.   [   r2rDcLeZdZUdZded<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 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`. rr rrEr!r"rr#r$c ddlm} ||}|dtjd|||}n #|$rd}YnwxYw||j}t|jd}|rz=PlainValidator.__get_pydantic_core_schema__..!!A$$r2)functionr' return_schemaplain)r(r[rI)r[rI)pydanticrZgetr#wrap_serializer_function_ser_schemarKrEr)r r r*"with_info_plain_validator_functionr(r, no_info_plain_validator_function) r.r!r"rZr'r[rOr/r s r0r1z+PlainValidator.__get_pydantic_core_schema__s@ ;::::: !W[))F#JJ?..!")"9"9+"F"FMM- ! ! ! MMM !..t/JKK %di99   =tyIIDA"-+)5   ;TYGGD?+)5 sA AAAr3r4rc:||j|jjSrQrRr7s r0r9zPlainValidator._from_decoratorrTr2Nr:r;) r<r=r>r?r@rrEr1rAr9rBr2r0rWrWsw((TVUUU"%%%%%((((T   [   r2rWcLeZdZUdZded<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 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 rrEr!r"rr#r$c~||}|jturdn||j}t|jd}|r)5 r2r3r4rc:||j|jjSrQrRr7s r0r9zWrapValidator._from_decoratorArTr2Nr:r;rUrBr2r0rmrmsv$$L^]]]"333332   [   r2rmceZdZddZdS)_OnlyValueValidatorClsMethodr8rvaluer#cdSr]rBr.r8rws r0__call__z%_OnlyValueValidatorClsMethod.__call__Lr2Nr8rrwrr#rr<r=r>rzrBr2r0rvrvKs??????r2rvceZdZd dZdS) _V2ValidatorClsMethodr8rrwrS_core_schema.ValidationInfor#cdSr]rBr.r8rwrSs r0rzz_V2ValidatorClsMethod.__call__Or{r2Nr8rrwrrSrr#rr}rBr2r0rrNsbbbbbbr2rceZdZd dZdS) _OnlyValueWrapValidatorClsMethodr8rrwr")_core_schema.ValidatorFunctionWrapHandlerr#cdSr]rBr.r8rwr"s r0rzz)_OnlyValueWrapValidatorClsMethod.__call__Rr{r2N)r8rrwrr"rr#rr}rBr2r0rrQsssssssr2rceZdZd d Zd S) _V2WrapValidatorClsMethodr8rrwr"rrSrr#cdSr]rBr.r8rwr"rSs r0rzz"_V2WrapValidatorClsMethod.__call__Us #r2N) r8rrwrr"rrSrr#rr}rBr2r0rrTs(      r2rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rGr&roreFieldValidatorModes.) check_fieldsrEfieldstrfieldsmodeLiteral['wrap']r bool | NonerErr#6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cdSr]rBrrrrErs r0field_validatorrws >ASr2Literal['before', 'plain']RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cdSr]rBrs r0rrs Z]Y\r2)rrLiteral['after']cdSr]rB)rrrrs r0rrs Z]Y\r2r&)rrrECallable[[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)rGreroz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typerec3@K|]}t|tVdSr]) isinstancer).0rs r0 z"field_validator..s,::%z%%%::::::r2z`@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)rrrrE)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)rdec_inforrrErs r0deczfield_validator..decs}  21 5 5 #JQl   =a @ @:r?rzrBr2r0rr s8gg ,0       r2rceZdZdZd d Zd S) ModelWrapValidatorWithoutInfozA `@model_validator` decorated function signature. This is used when `mode='wrap'` and the function does not have info argument. r8type[_ModelType]rwrr"%ModelWrapValidatorHandler[_ModelType]r#rcdSr]rBrs r0rzz&ModelWrapValidatorWithoutInfo.__call__s Sr2N)r8rrwrr"rr#rrrBr2r0rrs2      r2rceZdZdZdd Zd S)ModelWrapValidatorzSA `@model_validator` decorated function signature. This is used when `mode='wrap'`.r8rrwrr"rrSrr#rcdSr]rBrs r0rzzModelWrapValidator.__call__*s Sr2N) r8rrwrr"rrSrr#rrrBr2r0rr's.]]      r2rceZdZdZddZdS)#FreeModelBeforeValidatorWithoutInfoA `@model_validator` decorated function signature. This is used when `mode='before'` and the function does not have info argument. rwrr#cdSr]rB)r.rws r0rzz,FreeModelBeforeValidatorWithoutInfo.__call__<s cr2N)rwrr#rrrBr2r0rr7s2r2rceZdZdZddZdS) ModelBeforeValidatorWithoutInforr8rrwr#cdSr]rBrys r0rzz(ModelBeforeValidatorWithoutInfo.__call__K cr2Nr|rrBr2r0rrFs2r2rceZdZdZd dZdS) FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.rwrrSrr#cdSr]rB)r.rwrSs r0rzz!FreeModelBeforeValidator.__call__Yrr2N)rwrrSrr#rrrBr2r0rrVs.__r2rceZdZdZd dZd S) ModelBeforeValidatorrr8rrwrSrr#cdSr]rBrs r0rzzModelBeforeValidator.__call__gs cr2NrrrBr2r0rrds.__      r2r|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSr]rBrs r0model_validatorr 3r2Literal['before']rCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSr]rBrs r0rrrr2}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSr]rBrs r0rrrr2"Literal['wrap', 'before', 'after']cdfd }|S)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. rrr#rctj|}tj}tj||S)Nr)rrModelValidatorDecoratorInfor)rrrs r0rzmodel_validator..decs9  =a @ @:EEE21h???r2)rrr#rrB)rrs` r0rrs/b@@@@@@ Jr2AnyTypecPeZdZdZed 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||fSr])rr8rs r0__class_getitem__zInstanceOf.__class_getitem__sT3355[) )r2sourcerr"rr$cddlm}tjt j|p|} ||}tjd||d<tj||S#|$r|cYSwxYw)NrrYc||Sr]rBr^s r0raz9InstanceOf.__get_pydantic_core_schema__..rbr2rcr'r[) python_schema json_schema)rfrZris_instance_schemar get_originrhjson_or_python_schema)r8rr"rZinstance_of_schemaoriginal_schemas r0r1z'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?rArr1object__hash__rBr2r0rrsf  @  * * *  *  x x x  x&?r2rc@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|tfSr])rrrs r0rz SkipValidation.__class_getitem__.sT>#3#334 4r2rr"rr$c||dfdgi}tj|tjdS)N pydantic_js_annotation_functionsc|Sr]rB)_cr`rs r0raz=SkipValidation.__get_pydantic_core_schema__..4s11_K]K]r2c||Sr]rBr^s r0raz=SkipValidation.__get_pydantic_core_schema__..8rbr2r)metadatar[)r any_schemarh)r8rr"rrs @r0r1z+SkipValidation.__get_pydantic_core_schema__1sa%gfooO:=]=]=]=]<^_H)!)M.. r2N)rrr#rr) r<r=r>r?rrAr1rrrBr2r0rr!sU  5 5 5 5      ?r2rrB) rrrrrrrrrErr#r) rrrrrrrrrErr#r) rrrrrrrrr#r) rrrrrrrrrErr#r)rrr#r)rrr#r)rrr#r)rrr#r)Sr? __future__r _annotations dataclassessys functoolsrtypesrtypingrrrr r r r r r pydantic_corerr _core_schematyping_extensionsrr _internalrrrannotated_handlersrerrorsr version_inforinspect_validatorr) dataclass slots_truerrDrWrmrvrrrr*r, _V2Validatorrprr_V2WrapValidatorrA staticmethodrr@rrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrrrrrBr2r0rsHHH222222 ######cccccccccccccccccccccc88888888555555--------BBBBBBBBBB444444%%%%%%g******* 2EEdE&9&DEE9(9(9(9(9(9(9(FE9(xEEdE&9&DEE@ @ @ @ @ @ @ FE@ FEEdE&9&DEE] ] ] ] ] ] ] FE] @EEdE&9&DEEH H H H H H H FEH V)u@@@@@x@@@ccccccccttttt8tttH.$, .L!2(0 2,1S#s]1K\Z]_bZbMcersvew1w+xxxxx)0,L";;<***&#7#9GWYrGrAsttt!()K!LLLLL !$"% AAAAA A !$"% ]]]]] ] ! # ]]]]] ]!( $"3 llllll^W\ " " w~666       I8T`Ka    HZ$8"     *-        (        h        x        8   "*:, *B!C L,GH*TUZ1*=?\]g?hhi 24WYxx 3J ?A_`jAk kl      7777t ')  @#7C<(JJ[<<0;<<9#9#9#9#9#9#9#=<9#x#w|,NNN[<<0;<<#######=<###r2