]f^UdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZddlmZddlmZddlmZmZmZd d lmZd d lmZmZmZm Z d d l!mZd d l"m#Z#ej$d krddlm%Z%nddl m%Z%ej&Z'ej(dYddie j)GddZ*ej(dYddie j)GddZ+ej(dYddie j)GddZ,ej(dYddie j)GddZ-e rGdde%Z.Gdde%Z/Gdde%Z0ee/ej1e.ej2fZ3ee0ej4fZ5ee6e e e fe7e e fee fZ8de9d <ed!e3e8Z:ed"e5e8Z;ed#d#d$dZd.Zed9d:Z?Gd;de%e>ZBGd?d@e%e>ZCGdAdBe%ZDGdCdDe%ZEGdEdFe%ZFGdGdHe%ZGe e>ge>fZH e e>ejIge>fZJ eeCe>eBe>fZKeeFeGeDeEfZLeeJe>eHe>fZMed]dJZNed^dMZNed_dPZNd`dSZNedTZOe r eeOd#fZPn%ej(dYie j)GdUdVZPe r eeOd#fZQdSej(dYie j)GdWdXZQdS)azBThis module contains related classes and functions for validation.) annotationsN) partialmethod) FunctionType) TYPE_CHECKINGAnyCallableTypeVarUnioncastoverload) core_schema) AnnotatedLiteral TypeAlias)GetCoreSchemaHandler)_core_metadata _decorators _generics_internal_dataclass)PydanticUserError) )ProtocolfrozenTc&eZdZUdZded<d d Zd S) AfterValidatora8Usage docs: https://docs.pydantic.dev/2.8/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_typerhandler_GetCoreSchemaHandlerreturncore_schema.CoreSchemac&||}t|jd}|r;ttj|j}tj|||jSttj|j}tj||S)Nafterschema field_namer() _inspect_validatorrr r WithInfoValidatorFunction"with_info_after_validator_functionr)NoInfoValidatorFunction no_info_after_validator_functionselfr r!r(info_argrs P/var/www/html/env/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 TNr rr!r"r#r$__name__ __module__ __qualname____doc____annotations__r4r5r3rrsJ''RVUUUUUUUUUr5rc&eZdZUdZded<d d Zd S) BeforeValidatoraUsage docs: https://docs.pydantic.dev/2.8/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. 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 ``` rrr rr!r"r#r$c&||}t|jd}|r;ttj|j}tj|||jSttj|j}tj||S)Nbeforer'r*) r+rr r r,#with_info_before_validator_functionr)r.!no_info_before_validator_functionr0s r3r4z,BeforeValidator.__get_pydantic_core_schema__us%%%di::  V =tyIIDB4PVcjcuvvv v ;TYGGD@fUUU Ur5Nr6r7r=r5r3r?r?TsI:VUUUVVVVVVr5r?c&eZdZUdZded<d d Zd S) PlainValidatora;Usage docs: https://docs.pydantic.dev/2.8/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. 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 ``` rrr rr!r"r#r$c~ddlm} ||}tjd|}n #|$rd}YnwxYwt |jd}|r;t tj|j}tj||j |St tj |j}tj ||S)NrPydanticSchemaGenerationErrorc||SNr=vhs r3z=PlainValidator.__get_pydantic_core_schema__..sbcbcdebfbfr5functionr(plain)r) serialization)rR) pydanticrHr #wrap_serializer_function_ser_schemar+rr r,"with_info_plain_validator_functionr)r. no_info_plain_validator_function)r1r r!rHr(rRr2rs r3r4z+PlainValidator.__get_pydantic_core_schema__s ;::::: !W[))F'KUfUfouvvvMM, ! ! ! MMM !&di99  c =tyIIDA!3=  ;TYGGD?Tabbb bs "+55Nr6r7r=r5r3rErEsI.VUUUccccccr5rEc&eZdZUdZded<d d Zd S) WrapValidatoraUsage docs: https://docs.pydantic.dev/2.8/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. ```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.WithInfoWrapValidatorFunctionrr rr!r"r#r$c&||}t|jd}|r;ttj|j}tj|||jSttj|j}tj||S)Nwrapr'r*) r+rr r WithInfoWrapValidatorFunction!with_info_wrap_validator_functionr)NoInfoWrapValidatorFunctionno_info_wrap_validator_functionr0s r3r4z*WrapValidator.__get_pydantic_core_schema__s%%%di88  T A49MMD@fahasttt t ?KKD>tFSSS Sr5Nr6r7r=r5r3rXrXsJ""H^]]]TTTTTTr5rXceZdZddZdS)_OnlyValueValidatorClsMethodclsrvaluer#cdSrJr=r1rarbs r3__call__z%_OnlyValueValidatorClsMethod.__call__r5Nrarrbrr#rr8r9r:rer=r5r3r`r`s??????r5r`ceZdZd dZdS) _V2ValidatorClsMethodrarrbinfo_core_schema.ValidationInfor#cdSrJr=r1rarbrks r3rez_V2ValidatorClsMethod.__call__rfr5Nrarrbrrkrlr#rrhr=r5r3rjrjsbbbbbbr5rjceZdZd d Zd S) _V2WrapValidatorClsMethodrarrbr!)_core_schema.ValidatorFunctionWrapHandlerrkrlr#cdSrJr=r1rarbr!rks r3rez"_V2WrapValidatorClsMethod.__call__s #r5N) rarrbrr!rrrkrlr#rrhr=r5r3rqrqs(      r5rqr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType_V2WrapValidatorType.)mode check_fieldsfieldstrfieldsrx#Literal['before', 'after', 'plain']ry bool | Noner#RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cdSrJr=rzrxryr|s r3field_validatorrs Z]Y\r5)ryLiteral['wrap']6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cdSrJr=rs r3rrs >ASr5)rAr&rZrQFieldValidatorModesr&Callable[[Any], Any]ct|trtdd|gRtdDstddd fd }|S) a:Usage docs: https://docs.pydantic.dev/2.8/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. 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-fieldscodec3@K|]}t|tVdSrJ) isinstancer{).0rzs r3 z"field_validator..ls,::%z%%%::::::r5z`@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)r|rxry)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)rdec_inforyr|rxs r3deczfield_validator..decssr  21 5 5 #JQl   =a @ @:&tbnooo21h???r5)rrr#r)rrrall)rzrxryr|rs ``` r3rr&s~%&&  E&    ^V^^F ::6::: : :  Y+    @ @ @ @ @ @ @ @ Jr5 _ModelType _ModelTypeCo) covariantceZdZdZ d d d ZdS) ModelWrapValidatorHandlerz[@model_validator decorated function handler argument type. This is used when `mode='wrap'`.Nrbrouter_locationstr | int | Noner#rcdSrJr=)r1rbrs r3rez"ModelWrapValidatorHandler.__call__s r5rJ)rbrrrr#rr8r9r:r;rer=r5r3rrs8ee ,0       r5rceZdZdZd d Zd S) ModelWrapValidatorWithoutInfozA @model_validator decorated function signature. This is used when `mode='wrap'` and the function does not have info argument. ratype[_ModelType]rbrr!%ModelWrapValidatorHandler[_ModelType]r#rcdSrJr=)r1rarbr!s r3rez&ModelWrapValidatorWithoutInfo.__call__s Sr5N)rarrbrr!rr#rrr=r5r3rrs2      r5rceZdZdZdd Zd S)ModelWrapValidatorzQA @model_validator decorated function signature. This is used when `mode='wrap'`.rarrbrr!rrkrlr#rcdSrJr=rts r3rezModelWrapValidator.__call__s Sr5N) rarrbrr!rrkrlr#rrr=r5r3rrs.[[      r5rceZdZdZddZdS)#FreeModelBeforeValidatorWithoutInfoA @model_validator decorated function signature. This is used when `mode='before'` and the function does not have info argument. rbrr#cdSrJr=)r1rbs r3rez,FreeModelBeforeValidatorWithoutInfo.__call__s cr5N)rbrr#rrr=r5r3rrs2r5rceZdZdZddZdS) ModelBeforeValidatorWithoutInforrarrbr#cdSrJr=rds r3rez(ModelBeforeValidatorWithoutInfo.__call__ cr5Nrgrr=r5r3rrs2r5rceZdZdZd dZdS) FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.rbrrkrlr#cdSrJr=)r1rbrks r3rez!FreeModelBeforeValidator.__call__rr5N)rbrrkrlr#rrr=r5r3rrs.__r5rceZdZdZd dZd S) ModelBeforeValidatorrrarrbrkrlr#cdSrJr=rns r3rezModelBeforeValidator.__call__s cr5Nrorr=r5r3rrs.__      r5r|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSrJr=rxs r3model_validatorr 3r5Literal['before']qCallable[[_AnyModeBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSrJr=rs r3rr rr5Literal['after']}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cdSrJr=rs r3rrrr5"Literal['wrap', 'before', 'after']rcdfd }|S)a"Usage docs: https://docs.pydantic.dev/2.8/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)rrrxs r3rzmodel_validator..decKs9  =a @ @:EEE21h???r5)rrr#rr=)rxrs` r3rrs/`@@@@@@ Jr5AnyTypecPeZdZdZed 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||fSrJ)rrars r3__class_getitem__zInstanceOf.__class_getitem__sT3355[) )r5sourcerr!rr$cddlm}tjt j|p|} ||}tjd||d<tj||S#|$r|cYSwxYw)NrrGc||SrJr=rKs r3rNz9InstanceOf.__get_pydantic_core_schema__..!!A$$r5rOrR) python_schema json_schema)rSrHr is_instance_schemar get_originrTjson_or_python_schema)rarr!rHinstance_of_schemaoriginal_schemas r3r4z'InstanceOf.__get_pydantic_core_schema__s > > > > > >"-!? @TU[@\@\@f`f!g!g  x")'&// 7B6e..777"?3#8GYgvwwww1 * * *)))) *s A++A54A5N)rrr#rrrr!rr#r$) r8r9r:r; classmethodrr4object__hash__r=r5r3rr]sf  @  * * *  *  x x x  x&?r5rc@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|tfSrJ)rrrs r3rz SkipValidation.__class_getitem__sT>#3#334 4r5rr!rr$c||tjfdg}tj|tjdS)Nc|SrJr=)_crMrs r3rNz=SkipValidation.__get_pydantic_core_schema__..sababcrasasr5)js_annotation_functionsc||SrJr=rKs r3rNz=SkipValidation.__get_pydantic_core_schema__..rr5rO)metadatarR)rbuild_metadata_dictr any_schemarT)rarr!rrs @r3r4z+SkipValidation.__get_pydantic_core_schema__sj%gfooO%9SsSsSsSsRtuuuH)!)M.. r5N)rrr#rr) r8r9r:r;rrr4rrr=r5r3rrsU  5 5 5 5      ?r5rr=) rzr{r|r{rxr}ryr~r#r) rzr{r|r{rxrryr~r#r) rzr{r|r{rxrryr~r#r)rxrr#r)rxrr#r)rxrr#r)rxrr#r)Rr; __future__r _annotations dataclassessys functoolsrtypesrtypingrrrr r r r pydantic_corer _core_schematyping_extensionsrrrrr" _internalrrrrannotated_handlerserrorsr version_inforinspect_validatorr+ dataclass slots_truerr?rErXr`rjrqr,r. _V2Validatorr[_V2WrapValidatorr staticmethodrur<rvrwrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModeBeforeValidator_AnyModelAfterValidatorrrrrr=r5r3rsHHH222222 ######OOOOOOOOOOOOOOOOOO%%%%%%555555;;;;;;;;;;;;;;;;RRRRRRRRRRRR444444%%%%%%g******* 2EEdE&9&DEE4U4U4U4U4U4U4UFE4UnEEdE&9&DEE(V(V(V(V(V(V(VFE(VVEEdE&9&DEE0c0c0c0c0c0c0cFE0cfEEdE&9&DEE/T/T/T/T/T/T/TFE/Td%h@@@@@x@@@ccccccccH.$, .L!2 4 ,1S#s]1K\Z]_bZbMcersvew1w+xxxxx)0,!**& #7#9;KMfgg 14 # ]]]]] ] !$ AAAAA A"))K!LLLLL!( $ [[[[[[|W\ " " w~666       I8T`Ka    HZ$8"     *-        (        h        x        8   "*:, *B!C L,GH*TUZ1*=?\]g?hhi24WYxx 3J ?A_`jAk kl      6666r ')  @#7C<(JJ[<<0;<<9#9#9#9#9#9#9#=<9#x#w|,NNN[<<0;<<#######=<###r5