o $6dM@sUdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZddlmZddlmZddlmZmZmZd d lmZd d lmZmZmZmZm Z d d l!m"Z"ej#d kriddlm$Z$nddl m$Z$ej%Z&ej'dWddie j(GdddZ)ej'dWddie j(GdddZ*ej'dWddie j(GdddZ+ej'dWddie j(GdddZ,e r Gddde$Z-Gddde$Z.Gddde$Z/ee.ej0e-ej1fZ2ee/ej3ej4fZ5ee6e e e fe7e e fee fZ8de9d <ed!e2e8Z:ed"e5e8Z;ed#d#d$dXd.d/Zed:dd;Z?Gdd?d?e$e>ZBGd@dAdAe$e>ZCGdBdCdCe$ZDGdDdEdEe$ZEe e>ge>fZF e e>ejGge>fZH eeCe>eBe>fZIeeEeDfZJeeHe>eFe>fZKed[dGdHZLed\dKdHZLed]dNdHZLd^dQdHZLedRZMe reeMd#fZNnej'dWie j(GdSdTdTZNe reeMd#fZOdSej'dWie j(GdUdVdVZOdS)_zBThis module contains related classes and functions for validation.) annotationsN) partialmethod) FunctionType) TYPE_CHECKINGAnyCallableTypeVarUnionoverload) core_schema) AnnotatedLiteral TypeAlias)GetCoreSchemaHandler)_annotated_handlers_core_metadata _decorators _generics_internal_dataclass)PydanticUserError) )ProtocolfrozenTc@$eZdZUdZded<d d d Zd S)AfterValidatoraUsage docs: https://docs.pydantic.dev/2.2/usage/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 import Annotated from pydantic import BaseModel, AfterValidator, 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/0.38.0/v/int_parsing" } ] """ ``` Jcore_schema.NoInfoValidatorFunction | core_schema.GeneralValidatorFunctionfunc source_typerhandler_GetCoreSchemaHandlerreturncore_schema.CoreSchemacC8||}t|jd}|rtj|j|dStj|j|dS)Nafterschema)_inspect_validatorrr Z general_after_validator_functionZ no_info_after_validator_functionselfrr r'info_argr,uC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\pydantic/functional_validators.py__get_pydantic_core_schema__O  z+AfterValidator.__get_pydantic_core_schema__Nrrr r!r"r#__name__ __module__ __qualname____doc____annotations__r.r,r,r,r-r!s *rc@r)BeforeValidatoraUsage docs: https://docs.pydantic.dev/2.2/usage/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 ``` rrrrr r!r"r#cCr$)Nbeforer&)r(rr Z!general_before_validator_functionZ!no_info_before_validator_functionr)r,r,r-r.yr/z,BeforeValidator.__get_pydantic_core_schema__Nr0r1r,r,r,r-r7Xs r7c@r)PlainValidatora8Usage docs: https://docs.pydantic.dev/2.2/usage/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 ``` rrrrr r!r"r#cCs(t|jd}|rt|jSt|jS)Nplain)r(rr Z general_plain_validator_functionZ no_info_plain_validator_function)r*rr r+r,r,r-r.s   z+PlainValidator.__get_pydantic_core_schema__Nr0r1r,r,r,r-r9s r9c@r) WrapValidatoraUsage docs: https://docs.pydantic.dev/2.2/usage/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 ``` z{core_schema.NoInfoWrapValidatorFunction | core_schema.GeneralWrapValidatorFunction | core_schema.FieldWrapValidatorFunctionrrrr r!r"r#cCr$)Nwrapr&)r(rr Zgeneral_wrap_validator_functionZno_info_wrap_validator_functionr)r,r,r-r.r/z*WrapValidator.__get_pydantic_core_schema__Nr0r1r,r,r,r-r;s $r;c@seZdZdddZdS) _OnlyValueValidatorClsMethod!_OnlyValueValidatorClsMethod__clsr#_OnlyValueValidatorClsMethod__valuer"cCdSNr,)r*r>r?r,r,r-__call__z%_OnlyValueValidatorClsMethod.__call__N)r>rr?rr"rr2r3r4rBr,r,r,r-r=r=c@seZdZd ddZd S) _V2ValidatorClsMethod_V2ValidatorClsMethod__clsr"_V2ValidatorClsMethod__input_value_V2ValidatorClsMethod__info _core_schema.FieldValidationInfor"cCr@rAr,)r*rGrHrIr,r,r-rBrCz_V2ValidatorClsMethod.__call__N)rGrrHrrIrJr"rrDr,r,r,r-rFrErFc@seZdZd d d Zd S) _V2WrapValidatorClsMethod_V2WrapValidatorClsMethod__clsr&_V2WrapValidatorClsMethod__input_value$_V2WrapValidatorClsMethod__validator)_core_schema.ValidatorFunctionWrapHandler_V2WrapValidatorClsMethod__info_core_schema.ValidationInfor"cCr@rAr,)r*rLrMrNrPr,r,r-rBz"_V2WrapValidatorClsMethod.__call__N) rLrrMrrNrOrPrQr"rrDr,r,r,r-rKrErKr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType_V2WrapValidatorType.)mode check_fields__fieldstrfieldsrV#Literal['before', 'after', 'plain']rW bool | Noner"RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cGr@rAr,rXrVrWrZr,r,r-field_validatorrRr_)rWLiteral['wrap']6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cGr@rAr,r^r,r,r-r_rR)r8r%r<r:FieldValidatorModesr%Callable[[Any], Any]csVt|tr tddd|gRtddDs tddddfd d }|S)aUsage docs: https://docs.pydantic.dev/2.2/usage/validators/#field-validators Decorate methods on the class indicating that they should be used to validate fields. 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-fieldscodecss|]}t|tVqdSrA) isinstancerY).0fieldr,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-methodrd)rZrVrW)rZis_instance_method_from_sigr%ensure_classmethod_based_on_signatureZFieldValidatorDecoratorInfoPydanticDescriptorProxyrjZdec_inforWrZrVr,r-decDs   zfield_validator..decN)rjrkr"rl)rfrrall)rXrVrWrZrqr,rpr-r_s   _ModelType _ModelTypeCo) covariantc@seZdZdZ d d d d ZdS) ModelWrapValidatorHandlerz[@model_validator decorated function handler argument type. This is used when `mode='wrap'`.N input_valuerouter_locationstr | int | Noner"rtcCr@rAr,)r*rwrxr,r,r-rB\sz"ModelWrapValidatorHandler.__call__rA)rwrrxryr"rtr2r3r4r5rBr,r,r,r-rvYsrvc@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. clstype[_ModelType]%_ModelWrapValidatorWithoutInfo__valuer'_ModelWrapValidatorWithoutInfo__handler%ModelWrapValidatorHandler[_ModelType]r"rscCr@rAr,)r*r|r~rr,r,r-rBg z&ModelWrapValidatorWithoutInfo.__call__N)r|r}r~rrrr"rsrzr,r,r,r-r{br{c@seZdZdZdd d ZdS)ModelWrapValidatorzQA @model_validator decorated function signature. This is used when `mode='wrap'`.r|r}_ModelWrapValidator__valuer_ModelWrapValidator__handlerr_ModelWrapValidator__inforQr"rscCr@rAr,)r*r|rrrr,r,r-rBvs zModelWrapValidator.__call__N) r|r}rrrrrrQr"rsrzr,r,r,r-rsrc@seZdZdZd ddZdS) ModelBeforeValidatorWithoutInfozA @model_validator decorated function signature. This is used when `mode='before'` and the function does not have info argument. r|r'_ModelBeforeValidatorWithoutInfo__valuer"cCr@rAr,)r*r|rr,r,r-rBsz(ModelBeforeValidatorWithoutInfo.__call__N)r|rrrr"rrzr,r,r,r-rrrc@seZdZdZd dd Zd S) ModelBeforeValidatorzUA `@model_validator` decorated function signature. This is used when `mode='before'`.r|r_ModelBeforeValidator__value_ModelBeforeValidator__inforQr"cCr@rAr,)r*r|rrr,r,r-rBrzModelBeforeValidator.__call__N)r|rrrrrQr"rrzr,r,r,r-rrrpCallable[[_AnyModelWrapValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCr@rAr,rVr,r,r-model_validatorrLiteral['before']qCallable[[_AnyModeBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCr@rAr,rr,r,r-rrLiteral['after']}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCr@rAr,rr,r,r-rrR"Literal['wrap', 'before', 'after']rcsdfdd }|S) a@Decorate model methods for validation purposes. 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. rjrr"rlcs"t|}tjd}t||S)Nr)rrmZModelValidatorDecoratorInfornrorr,r-rqs   zmodel_validator..decN)rjrr"rlr,)rVrqr,rr-rsAnyTypec@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||fSrA)r r|rr,r,r-__class_getitem__ szInstanceOf.__class_getitem__sourcerr (_annotated_handlers.GetCoreSchemaHandlerr#cCshddlm}tt|p|}z||}Wn |y!|YSwtjdd|d|d<tj||dS)Nr)PydanticSchemaGenerationErrorcSs||SrAr,)vhr,r,r-!z9InstanceOf.__get_pydantic_core_schema__..)functionr' serialization)Z python_schemaZ json_schema)Zpydanticrr Zis_instance_schemar get_originZ#wrap_serializer_function_ser_schemaZjson_or_python_schema)r|rr rZinstance_of_schemaoriginal_schemar,r,r-r.s    z'InstanceOf.__get_pydantic_core_schema__N)rrr"rrrr rr"r#) r2r3r4r5 classmethodrr.object__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|tfSrA)r rrr,r,r-r9sz SkipValidation.__class_getitem__rr rr#cs,||tjfddgd}tj|dS)Ncs|SrAr,)Z_crrr,r-rArz=SkipValidation.__get_pydantic_core_schema__..)Zjs_annotation_functions)metadatar)rZbuild_metadata_dictr Z any_schema)r|rr rr,rr-r.<sz+SkipValidation.__get_pydantic_core_schema__N)rrr"rr) r2r3r4r5rrr.rrr,r,r,r-r,s    rr,) rXrYrZrYrVr[rWr\r"r]) rXrYrZrYrVr`rWr\r"ra) rXrYrZrYrVrbrWr\r"rc)rVr`r"r)rVrr"r)rVrr"r)rVrr"r)Pr5 __future__rZ _annotations dataclassessys functoolsrtypesrtypingrrrrr r Z pydantic_corer Z _core_schemaZtyping_extensionsr r rrr! _internalrrrrrerrorsr version_inforZinspect_validatorr( dataclassZ slots_truerr7r9r;r=rFrKZFieldValidatorFunctionZNoInfoValidatorFunctionZ _V2ValidatorZGeneralWrapValidatorFunctionZFieldWrapValidatorFunctionZ_V2WrapValidatorr staticmethodrSr6rTrUr_rbrsrtZValidatorFunctionWrapHandlerrvr{rrrZModelAfterValidatorWithoutInfoZValidationInfoZModelAfterValidatorZ_AnyModelWrapValidatorZ_AnyModeBeforeValidatorZ_AnyModelAfterValidatorrrrrr,r,r,r-s          6)"4 ,   9       >