o Rhqp@s>UdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZddlmZmZddlmZdd lmZmZmZmZd d lmZmZmZmZd d l m!Z!d d l"m#Z#ej$dkrmddlm%Z%nddl m%Z%ej&Z'ej(dbddiej)GdddZ*ej(dbddiej)GdddZ+ej(dbddiej)GdddZ,ej(dbddiej)GdddZ-e rGddde%Z.Gddde%Z/Gddde%Z0Gd d!d!e%Z1ee/ej2e.ej3fZ4ee1ej5e0ej6fZ7ee8e e e fe9e e fee fZ:d"e;d#<ed$ee4e:fd%Zd"e;d(<ed)d)d*dcd6d7Z?ed)d)d*ddd:d7Z?ed)d)d;ded=d7Z?d>ded?dfdAd7Z?edBZ@edCddDZAGdEdFdFejBe%eAZCGdGdHdHe%e@ZDGdIdJdJe%e@ZEGdKdLdLe%ZFGdMdNdNe%ZGGdOdPdPe%ZHGdQdRdRe%ZIe e@ge@fZJ e e@ejKge@fZL eeEe@eDe@fZMeeHeIeFeGfZNeeLe@eJe@fZOedgdTdUZPedhdXdUZPedidZdUZPdjd\dUZPed]ZQe reeQd)fZRnej(dbiej)Gd^d_d_ZRe r eeQd)fZSdSej(dbiej)Gd`dadaZSdS)kzBThis 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@s2eZdZUdZded<dd d ZedddZdS)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.CoreSchemacCsT||}t|jd}|rttj|j}tj|||jdSttj|j}tj||dS)Nafter)schema field_name)r%) _inspect_validatorrr r WithInfoValidatorFunction"with_info_after_validator_functionr&NoInfoValidatorFunction no_info_after_validator_function)selfr r!r%info_argrr.`/home/air/sanwanet/backup_V2/venv/lib/python3.10/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__Hs z+AfterValidator.__get_pydantic_core_schema__ decorator>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]rcCs ||jdS)Nrr3clsr1r.r.r/_from_decoratorRs zAfterValidator._from_decoratorNr rr!rr"r#r1r2r"r)__name__ __module__ __qualname____doc____annotations__r0 classmethodr6r.r.r.r/rs )  rc@>eZdZUdZded<eZded<dd d ZedddZ 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 ``` rrrjson_schema_input_typer r!rr"r#cC~||}|jtur dn||j}tj|d}t|jd}|r0ttj |j}tj |||j |dSttj |j}tj |||dS)Njs_input_core_schemabeforer%r&metadatar%rG)rAr generate_schemarbuild_metadata_dictr'rr r r(#with_info_before_validator_functionr&r*!no_info_before_validator_functionr,r r!r% input_schemarGr-rr.r.r/r0{s"    z,BeforeValidator.__get_pydantic_core_schema__r1r2rcC||j|jjdSN)rrArinforAr4r.r.r/r6zBeforeValidator._from_decoratorNr7r8 r9r:r;r<r=r rAr0r>r6r.r.r.r/r@Ws   r@c@r?)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 ``` rrrrAr r!rr"r#c Csddlm}z||}|dtjdd|||d}Wn |y(d}Ynw||j}tj|d}t |j d}|rNt tj |j } tj | |j||d St tj|j } tj| ||d S) NrPydanticSchemaGenerationError serializationcS||SNr.vhr.r.r/z=PlainValidator.__get_pydantic_core_schema__..)functionr% return_schemarCplain)r&rXrG)rXrG)pydanticrWgetr #wrap_serializer_function_ser_schemarIrArrJr'rr r("with_info_plain_validator_functionr&r* no_info_plain_validator_function) r,r r!rWr%rXrNrGr-rr.r.r/r0s>     z+PlainValidator.__get_pydantic_core_schema__r1r2rcCrOrPrQr4r.r.r/r6rSzPlainValidator._from_decoratorNr7r8) r9r:r;r<r=rrAr0r>r6r.r.r.r/rUs   +rUc@r?) 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.WithInfoWrapValidatorFunctionrrrAr r!rr"r#cCrB)NrCwraprFrH)rAr rIrrJr'rr r WithInfoWrapValidatorFunction!with_info_wrap_validator_functionr&NoInfoWrapValidatorFunctionno_info_wrap_validator_functionrMr.r.r/r0s*    z*WrapValidator.__get_pydantic_core_schema__r1r2rcCrOrPrQr4r.r.r/r6/rSzWrapValidator._from_decoratorNr7r8rTr.r.r.r/rhs &  rhc@seZdZdddZdS) _OnlyValueValidatorClsMethodr5rvaluer"cCdSrZr.r,r5ror.r.r/__call__:z%_OnlyValueValidatorClsMethod.__call__Nr5rrorr"rr9r:r;rrr.r.r.r/rn9rnc@eZdZd ddZd S) _V2ValidatorClsMethodr5rrorR_core_schema.ValidationInfor"cCrprZr.r,r5rorRr.r.r/rr=rsz_V2ValidatorClsMethod.__call__Nr5rrorrRryr"rrur.r.r.r/rx<rvrxc@rw) _OnlyValueWrapValidatorClsMethodr5rror!)_core_schema.ValidatorFunctionWrapHandlerr"cCrprZr.r,r5ror!r.r.r/rr@rsz)_OnlyValueWrapValidatorClsMethod.__call__N)r5rrorr!r}r"rrur.r.r.r/r|?rvr|c@seZdZd d d Zd S) _V2WrapValidatorClsMethodr5rror!r}rRryr"cCrprZr.r,r5ror!rRr.r.r/rrCz"_V2WrapValidatorClsMethod.__call__N) r5rrorr!r}rRryr"rrur.r.r.r/rBrvrr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rEr$rirbFieldValidatorModes.) check_fieldsrAfieldstrfieldsmodeLiteral['wrap']r bool | NonerArr"6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cGrprZr.rrrrArr.r.r/field_validatorerLiteral['before', 'plain']RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cGrprZr.rr.r.r/rpr)rrLiteral['after']cGrprZr.)rrrrr.r.r/r{rr$)rrrACallable[[Any], Any]cst|tr tddddvrturtdddtur&dkr&t|gRtdd Ds;td d ddfdd }|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)rErbriz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typerbcss|]}t|tVqdSrZ) isinstancer).0rr.r.r/ sz"field_validator..z`@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]cs>t|r tdddt|}tjd}t||S)Nz8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodr)rrrrA)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxyrdec_inforrrArr.r/decs   zfield_validator..decN)rrr"r)rrrr rall)rrrrArrr.rr/rs( C  _ModelType _ModelTypeCo) covariantc@seZdZdZ d d d d ZdS) ModelWrapValidatorHandlerz]`@model_validator` decorated function handler argument type. This is used when `mode='wrap'`.Nrorouter_locationstr | int | Noner"rcCrprZr.)r,rorr.r.r/rrz"ModelWrapValidatorHandler.__call__rZ)rorrrr"rr9r:r;r<rrr.r.r.r/rsrc@seZdZdZd d d Zd S)ModelWrapValidatorWithoutInfozA `@model_validator` decorated function signature. This is used when `mode='wrap'` and the function does not have info argument. r5type[_ModelType]rorr!%ModelWrapValidatorHandler[_ModelType]r"rcCrprZr.r~r.r.r/rr z&ModelWrapValidatorWithoutInfo.__call__N)r5rrorr!rr"rrr.r.r.r/rrc@seZdZdZdd d ZdS)ModelWrapValidatorzSA `@model_validator` decorated function signature. This is used when `mode='wrap'`.r5rrorr!rrRryr"rcCrprZr.rr.r.r/rrs zModelWrapValidator.__call__N) r5rrorr!rrRryr"rrr.r.r.r/rrc@seZdZdZdddZdS) #FreeModelBeforeValidatorWithoutInfoA `@model_validator` decorated function signature. This is used when `mode='before'` and the function does not have info argument. rorr"cCrprZr.)r,ror.r.r/rr)rz,FreeModelBeforeValidatorWithoutInfo.__call__N)rorr"rrr.r.r.r/r$rrc@seZdZdZd ddZdS) ModelBeforeValidatorWithoutInforr5rror"cCrprZr.rqr.r.r/rr8rz(ModelBeforeValidatorWithoutInfo.__call__Nrtrr.r.r.r/r3rrc@seZdZdZd ddZd S) FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.rorrRryr"cCrprZr.)r,rorRr.r.r/rrFrz!FreeModelBeforeValidator.__call__N)rorrRryr"rrr.r.r.r/rCrrc@seZdZdZd dd Zd S) ModelBeforeValidatorrr5rrorRryr"cCrprZr.rzr.r.r/rrTrzModelBeforeValidator.__call__Nr{rr.r.r.r/rQrr|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrprZr.rr.r.r/model_validatororrLiteral['before']rCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrprZr.rr.r.r/rxr}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrprZr.rr.r.r/rr"Literal['wrap', 'before', 'after']csdfdd }|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"rcs"t|}tjd}t||S)Nr)rrModelValidatorDecoratorInforrrr.r/rs   zmodel_validator..decN)rrr"rr.)rrr.rr/rs0AnyTypec@s2eZdZdZedddZedd d ZejZdS) 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"cCst||fSrZ)rr5rr.r.r/__class_getitem__szInstanceOf.__class_getitem__sourcerr!rr#cCshddlm}tt|p|}z||}Wn |y!|YSwtjdd|d|d<tj||dS)NrrVcSrYrZr.r[r.r.r/r^r_z9InstanceOf.__get_pydantic_core_schema__..r`r%rX) python_schema json_schema)rcrWr is_instance_schemar get_originrejson_or_python_schema)r5rr!rWinstance_of_schemaoriginal_schemar.r.r/r0s    z'InstanceOf.__get_pydantic_core_schema__N)rrr"rrrr!rr"r#) r9r:r;r<r>rr0object__hash__r.r.r.r/rs   rc@s.eZdZdZdddZedd 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"cCst|tfSrZ)rrrr.r.r/rsz SkipValidation.__class_getitem__rr!rr#cs:||tjfddgd}tj|tjddddS)Ncs|SrZr.)_cr]rr.r/r^ r_z=SkipValidation.__get_pydantic_core_schema__..)js_annotation_functionscSrYrZr.r[r.r.r/r^$r_r)rGrX)rrJr any_schemare)r5rr!rGr.rr/r0sz+SkipValidation.__get_pydantic_core_schema__N)rrr"rr) r9r:r;r<rr>r0rrr.r.r.r/r s    rr.) rrrrrrrrrArr"r) rrrrrrrrrArr"r) rrrrrrrrr"r) rrrrrrrrrArr"r)rrr"r)rrr"r)rrr"r)rrr"r)Tr< __future__r _annotations dataclassessys functoolsrtypesrtypingrrrrr r r pydantic_corer r _core_schematyping_extensionsrrrr _internalrrrrannotated_handlersrerrorsr version_inforinspect_validatorr' dataclass slots_truerr@rUrhrnrxr|rr(r* _V2Validatorrjrl_V2WrapValidatorr> staticmethodrr=rrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrrrrr.r.r.r/s   $     ;APL ,    n       9<