o i_|@sjUdZddlmZddlZddlZddlZddlmZddl 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'dkrwddlm(Z(nddl m(Z(ej)Z*ej+dfddiej,GdddZ-ej+dfddiej,GdddZ.ej+dfddiej,GdddZ/ej+dfddiej,GdddZ0e r)Gddde(Z1Gddde(Z2Gdd d e(Z3Gd!d"d"e(Z4ee2ej5e1ej6fZ7ee4ej8e3ej9fZ:ee;eeefed$<ed%ee7e=fd&Z?ed'ee:e=fd&Z@ed(ZAd#e>d)<ed*d*d+dgd7d8ZBed*d*d+dhd;d8ZBed*d*d<did>d8ZBd?ded@djdBd8ZBedCZCedDddEZDGdFdGdGejEe(eDZFGdHdIdIe(eCZGGdJdKdKe(eCZHGdLdMdMe(ZIGdNdOdOe(ZJGdPdQdQe(ZKGdRdSdSe(ZLeeCgeCfZM eeCejNegeCfZO eeHeCeGeCfZPeeKeLeIeJfZQeeOeCeMeCfZRedkdUdVZSedldYdVZSedmd[dVZSdnd]dVZSed^ZTe re eTd*fZUnej+dfiej,Gd_d`d`ZUe re eTd*fZVnej+dfiej,GdadbdbZVedcZWGdddedeZXdS)ozBThis 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@s2eZdZUdZded<dd d ZedddZdS)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.CoreSchemacCsT||}t|jddd}|rttj|j}tj||dSttj|j}tj||dS)Nafterfieldmodetypeschema)_inspect_validatorr!r rWithInfoValidatorFunctionZ"with_info_after_validator_functionNoInfoValidatorFunction no_info_after_validator_function)selfr"r#r,info_argr!r3X/home/kim/smarthome/.venv/lib/python3.10/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__Ksz+AfterValidator.__get_pydantic_core_schema__ decorator>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]rcCs ||jdS)Nr!r8clsr6r3r3r4_from_decoratorUs zAfterValidator._from_decoratorNr"rr#rr$r%r6r7r$r)__name__ __module__ __qualname____doc____annotations__r5 classmethodr;r3r3r3r4rs *  rc@>eZdZUdZded<eZded<dd d ZedddZ 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%cCr||}|jtur dn||j}t|jddd}|r*ttj|j}tj|||dSttj |j}tj |||dS)Nbeforer'r(r,json_schema_input_schema) rFrgenerate_schemar-r!r rr.Z#with_info_before_validator_functionr/Z!no_info_before_validator_functionr1r"r#r, input_schemar2r!r3r3r4r5s"  z,BeforeValidator.__get_pydantic_core_schema__r6r7rcC||j|jjdSN)r!rFr!inforFr9r3r3r4r;zBeforeValidator._from_decoratorNr<r= r>r?r@rArBrrFr5rCr;r3r3r3r4rEZs   rEc@rD)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!rrFr"r#rr$r%c Csddlm}z||}|dtjdd|||d}Wn |y(d}Ynw||j}t|jddd }|rHt tj |j}tj |||d St tj |j}tj |||d S) NrPydanticSchemaGenerationError serializationcS||SNr3vhr3r3r4z=PlainValidator.__get_pydantic_core_schema__..)functionr,Z return_schemaplainr'r()rWrJ)pydanticrVgetr#wrap_serializer_function_ser_schemarKrFr-r!r r.Z"with_info_plain_validator_functionr/Z no_info_plain_validator_function) r1r"r#rVr,rWrMr2r!r3r3r4r5s:   z+PlainValidator.__get_pydantic_core_schema__r6r7rcCrNrOrPr9r3r3r4r;rRzPlainValidator._from_decoratorNr<r=) r>r?r@rArBrrFr5rCr;r3r3r3r4rTs .  )rTc@rD) 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!rrFr"r#rr$r%cCrG)Nwrapr'r(rI) rFrrKr-r!r rWithInfoWrapValidatorFunctionZ!with_info_wrap_validator_functionNoInfoWrapValidatorFunctionZno_info_wrap_validator_functionrLr3r3r4r5,s&  z*WrapValidator.__get_pydantic_core_schema__r6r7rcCrNrOrPr9r3r3r4r;DrRzWrapValidator._from_decoratorNr<r=rSr3r3r3r4rds &  rdc@seZdZdddZdS) _OnlyValueValidatorClsMethodr:rvaluer$cCdSrYr3r1r:rir3r3r4__call__Oz%_OnlyValueValidatorClsMethod.__call__Nr:rrirr$rr>r?r@rlr3r3r3r4rhNrhc@eZdZd ddZd S) _V2ValidatorClsMethodr:rrirQcore_schema.ValidationInfo[Any]r$cCrjrYr3r1r:rirQr3r3r4rlRrmz_V2ValidatorClsMethod.__call__Nr:rrirrQrsr$rror3r3r3r4rrQrprrc@rq) _OnlyValueWrapValidatorClsMethodr:rrir#(core_schema.ValidatorFunctionWrapHandlerr$cCrjrYr3r1r:rir#r3r3r4rlUrmz)_OnlyValueWrapValidatorClsMethod.__call__N)r:rrirr#rwr$rror3r3r3r4rvTrprvc@seZdZd d d Zd S) _V2WrapValidatorClsMethodr:rrir#rwrQrsr$cCrjrYr3r1r:rir#rQr3r3r4rlXz"_V2WrapValidatorClsMethod.__call__N) r:rrirr#rwrQrsr$rror3r3r3r4ryWrpryr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rHr&rer`FieldValidatorModes.) check_fieldsrFr'strfieldsr)Literal['wrap']r bool | NonerFrr$6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cGrjrYr3r'r)rrFrr3r3r4field_validatorzrLiteral['before', 'plain']RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cGrjrYr3rr3r3r4rr)r)rLiteral['after']cGrjrYr3)r'r)rrr3r3r4rr{r&)r)rrFCallable[[Any], Any]cst|tr tddddvrturtdddtur&dkr&t|gRtdd Ds;td d ddfdd }|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)rHr`rez;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typer`css|]}t|tVqdSrY) isinstancer).0r'r3r3r4 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)rr)rrF)rZis_instance_method_from_sigr%ensure_classmethod_based_on_signatureZFieldValidatorDecoratorInfoPydanticDescriptorProxyrZdec_inforrrFr)r3r4decs   zfield_validator..decN)rrr$r)rrrrrall)r'r)rrFrrr3rr4rs( D  _ModelType _ModelTypeCo) covariantc@seZdZdZ d d d d ZdS) ModelWrapValidatorHandlerz]`@model_validator` decorated function handler argument type. This is used when `mode='wrap'`.Nrirouter_locationstr | int | Noner$rcCrjrYr3)r1rirr3r3r4rlz"ModelWrapValidatorHandler.__call__rY)rirrrr$rr>r?r@rArlr3r3r3r4r src@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. r:type[_ModelType]rirr#%ModelWrapValidatorHandler[_ModelType]r$rcCrjrYr3rxr3r3r4rl z&ModelWrapValidatorWithoutInfo.__call__N)r:rrirr#rr$rrr3r3r3r4rrc@seZdZdZdd d ZdS)ModelWrapValidatorzSA `@model_validator` decorated function signature. This is used when `mode='wrap'`.r:rrirr#rrQcore_schema.ValidationInfor$rcCrjrYr3rzr3r3r4rl-s zModelWrapValidator.__call__N) r:rrirr#rrQrr$rrr3r3r3r4r*rc@seZdZdZdddZdS) #FreeModelBeforeValidatorWithoutInfoA `@model_validator` decorated function signature. This is used when `mode='before'` and the function does not have info argument. rirr$cCrjrYr3)r1rir3r3r4rl?r{z,FreeModelBeforeValidatorWithoutInfo.__call__N)rirr$rrr3r3r3r4r:rrc@seZdZdZd ddZdS) ModelBeforeValidatorWithoutInforr:rrir$cCrjrYr3rkr3r3r4rlNrz(ModelBeforeValidatorWithoutInfo.__call__Nrnrr3r3r3r4rIrrc@seZdZdZd ddZd S) FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.rirrQrsr$cCrjrYr3)r1rirQr3r3r4rl\rz!FreeModelBeforeValidator.__call__N)rirrQrsr$rrr3r3r3r4rYrrc@seZdZdZd dd Zd S) ModelBeforeValidatorrr:rrirQrsr$cCrjrYr3rtr3r3r4rljrzModelBeforeValidator.__call__Nrurr3r3r3r4rgrr|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrjrYr3r)r3r3r4model_validatorrrLiteral['before']rCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrjrYr3rr3r3r4rr}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrjrYr3rr3r3r4rr"Literal['wrap', 'before', 'after']csdfdd }|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$rcsNt|}dkrt|trtjtdtdddtjd}t ||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) rrrrCwarningswarnrrZModelValidatorDecoratorInforrrr3r4rs  zmodel_validator..decN)rrr$rr3)r)rr3rr4rs1AnyTypec@s2eZdZdZedddZedd d ZejZdS) 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$cCst||fSrY)rr:rr3r3r4__class_getitem__szInstanceOf.__class_getitem__sourcerr#rr%cCshddlm}tt|p|}z||}Wn |y!|YSwtjdd|d|d<tj||dS)NrrUcSrXrYr3rZr3r3r4r]#r^z9InstanceOf.__get_pydantic_core_schema__..r_r,rW)Z python_schemaZ json_schema)rarVrZis_instance_schemar get_originrcZjson_or_python_schema)r:rr#rVZinstance_of_schemaoriginal_schemar3r3r4r5s    z'InstanceOf.__get_pydantic_core_schema__N)rrr$rrrr#rr$r%) r>r?r@rArCrr5object__hash__r3r3r3r4rs   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|tfSrY)rrrr3r3r4r;sz SkipValidation.__class_getitem__rr#rr%csjttdt||Wdn1swYdfddgi}tj|tjddddS)NignoreZ pydantic_js_annotation_functionscs|SrYr3)Z_cr\rr3r4r]Cr^z=SkipValidation.__get_pydantic_core_schema__..cSrXrYr3rZr3r3r4r]Gr^r)metadatarW)rcatch_warnings simplefilterrrZ any_schemarc)r:rr#rr3rr4r5>s   z+SkipValidation.__get_pydantic_core_schema__N)rrr$rr) r>r?r@rArrCr5rrr3r3r3r4r.s    r _FromTypeTc@s$eZdZdZddd ZdddZdS) 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$NonecCs||_||_dSrY)rr)r1rrr3r3r4__init__ts zValidateAs.__init__rrr#rr%cCs||j}tj|j|dS)Nr+)rrr0r)r1rr#r,r3r3r4r5xs z'ValidateAs.__get_pydantic_core_schema__N)rrrrr$rr)r>r?r@rArr5r3r3r3r4rQs "rr3) r'rrrr)rrrrFrr$r) r'rrrr)rrrrFrr$r) r'rrrr)rrrr$r) r'rrrr)rrrrFrr$r)r)rr$r)r)rr$r)r)rr$r)r)rr$r)YrA __future__rZ _annotations dataclassessysr functoolsrtypesrtypingrrrrr r r r r Z pydantic_corerrZtyping_extensionsrr _internalrrrZannotated_handlersrerrorsrversionrrr version_inforZinspect_validatorr- dataclassZ slots_truerrErTrdrhrrrvryr.r/Z _V2ValidatorrfrgZ_V2WrapValidatorrC staticmethodr|rBr}rrrrrZValidatorFunctionWrapHandlerrrrrrrrZModelAfterValidatorWithoutInfoZValidationInfoZModelAfterValidatorZ_AnyModelWrapValidatorZ_AnyModelBeforeValidatorZ_AnyModelAfterValidatorrrrrrrr3r3r3r4s   ,     <BcJ ,    o       D<