o Fh W@sUdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZddlmZddlmZddlmZmZmZd d lmZd d lmZmZmZm Z d d l!mZd d l"m#Z#ej$d kroddlm%Z%nddl m%Z%ej&Z'ej(dWddie j)GdddZ*ej(dWddie j)GdddZ+ej(dWddie j)GdddZ,ej(dWddie j)GdddZ-e rGddde%Z.Gddde%Z/Gddde%Z0ee/ej1e.ej2fZ3ee0ej4fZ5ee6e e e fe7e e fee fZ8de9d <ed!e3e8Z: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_CHECKINGAnyCallableTypeVarUnioncastoverload) core_schema) AnnotatedLiteral TypeAlias)GetCoreSchemaHandler)_core_metadata _decorators _generics_internal_dataclass)PydanticUserError) )ProtocolfrozenTc@$eZdZUdZded<d d d Zd S)AfterValidatora8Usage docs: https://docs.pydantic.dev/2.5/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.CoreSchemacCT||}t|jd}|rttj|j}tj|||jdSttj|j}tj||dS)Nafterschema field_namer') _inspect_validatorrr r WithInfoValidatorFunction"with_info_after_validator_functionr(NoInfoValidatorFunction no_info_after_validator_functionselfrr r'info_argrr2k/var/www/html/HyperOracle/crypto_trader/venv/lib/python3.10/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__I z+AfterValidator.__get_pydantic_core_schema__Nrrr r!r"r#__name__ __module__ __qualname____doc____annotations__r4r2r2r2r3rs )rc@r)BeforeValidatoraUsage docs: https://docs.pydantic.dev/2.5/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 ``` rrrrr r!r"r#cCr$)Nbeforer&r)) r*rr r r+#with_info_before_validator_functionr(r-!no_info_before_validator_functionr/r2r2r3r4ur5z,BeforeValidator.__get_pydantic_core_schema__Nr6r7r2r2r2r3r=Ts r=c@r)PlainValidatora;Usage docs: https://docs.pydantic.dev/2.5/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 ``` rrrrr r!r"r#cCsFt|jd}|rttj|j}tj||jdSttj|j}t|S)Nplain)r() r*rr r r+"with_info_plain_validator_functionr(r- no_info_plain_validator_function)r0rr r1rr2r2r3r4s  z+PlainValidator.__get_pydantic_core_schema__Nr6r7r2r2r2r3rAs rAc@r) WrapValidatoraUsage docs: https://docs.pydantic.dev/2.5/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.WithInfoWrapValidatorFunctionrrrr r!r"r#cCr$)Nwrapr&r)) r*rr r WithInfoWrapValidatorFunction!with_info_wrap_validator_functionr(NoInfoWrapValidatorFunctionno_info_wrap_validator_functionr/r2r2r3r4r5z*WrapValidator.__get_pydantic_core_schema__Nr6r7r2r2r2r3rEs $rEc@seZdZdddZdS) _OnlyValueValidatorClsMethod!_OnlyValueValidatorClsMethod__clsr#_OnlyValueValidatorClsMethod__valuer"cCdSNr2)r0rLrMr2r2r3__call__z%_OnlyValueValidatorClsMethod.__call__N)rLrrMrr"rr8r9r:rPr2r2r2r3rKrKc@seZdZd ddZd S) _V2ValidatorClsMethod_V2ValidatorClsMethod__clsr"_V2ValidatorClsMethod__input_value_V2ValidatorClsMethod__info_core_schema.ValidationInfor"cCrNrOr2)r0rUrVrWr2r2r3rPrQz_V2ValidatorClsMethod.__call__N)rUrrVrrWrXr"rrRr2r2r2r3rTrSrTc@seZdZd d d Zd S) _V2WrapValidatorClsMethod_V2WrapValidatorClsMethod__clsr&_V2WrapValidatorClsMethod__input_value$_V2WrapValidatorClsMethod__validator)_core_schema.ValidatorFunctionWrapHandler_V2WrapValidatorClsMethod__inforXr"cCrNrOr2)r0rZr[r\r^r2r2r3rPz"_V2WrapValidatorClsMethod.__call__N) rZrr[rr\r]r^rXr"rrRr2r2r2r3rYrSrYr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType_V2WrapValidatorType.)mode check_fields__fieldstrfieldsrc#Literal['before', 'after', 'plain']rd bool | Noner"RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cGrNrOr2rercrdrgr2r2r3field_validatorr_rl)rdLiteral['wrap']6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cGrNrOr2rkr2r2r3rl r_)r>r%rFrBFieldValidatorModesr%Callable[[Any], Any]csVt|tr tddd|gRtddDs tddddfd d }|S)a<Usage docs: https://docs.pydantic.dev/2.5/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-fieldscodecss|]}t|tVqdSrO) isinstancerf).0fieldr2r2r3 ^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-methodrq)rgrcrd)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxyrwdec_infordrgrcr2r3deces   zfield_validator..decN)rwrxr"ry)rsrrall)rercrdrgrr2rr3rls >  _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"rcCrNrOr2)r0rrr2r2r3rP}sz"ModelWrapValidatorHandler.__call__rO)rrrrr"rr8r9r:r;rPr2r2r2r3rzsrc@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"rcCrNrOr2)r0rrrr2r2r3rP z&ModelWrapValidatorWithoutInfo.__call__N)rrrrrrr"rrr2r2r2r3rrc@seZdZdZdd d ZdS)ModelWrapValidatorzQA @model_validator decorated function signature. This is used when `mode='wrap'`.rr_ModelWrapValidator__valuer_ModelWrapValidator__handlerr_ModelWrapValidator__inforXr"rcCrNrOr2)r0rrrrr2r2r3rPs zModelWrapValidator.__call__N) rrrrrrrrXr"rrr2r2r2r3rrc@seZdZdZd ddZdS) ModelBeforeValidatorWithoutInfozA @model_validator decorated function signature. This is used when `mode='before'` and the function does not have info argument. rr'_ModelBeforeValidatorWithoutInfo__valuer"cCrNrOr2)r0rrr2r2r3rPsz(ModelBeforeValidatorWithoutInfo.__call__N)rrrrr"rrr2r2r2r3rrrc@seZdZdZd dd Zd S) ModelBeforeValidatorzUA `@model_validator` decorated function signature. This is used when `mode='before'`.rr_ModelBeforeValidator__value_ModelBeforeValidator__inforXr"cCrNrOr2)r0rrrr2r2r3rPrzModelBeforeValidator.__call__N)rrrrrrXr"rrr2r2r2r3rrr|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrNrOr2rcr2r2r3model_validatorr_rLiteral['before']qCallable[[_AnyModeBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrNrOr2rr2r2r3rsLiteral['after']}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrNrOr2rr2r2r3rr_"Literal['wrap', 'before', 'after']rcsdfdd }|S) aUsage docs: https://docs.pydantic.dev/2.5/concepts/validators/#model-validators Decorate model methods for validation purposes. Example usage: ```py from typing import Optional from pydantic import BaseModel, ValidationError, model_validator class Square(BaseModel): width: float height: float @model_validator(mode='after') def verify_square(self) -> 'Rectangle': 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 __root__ width and height do not match (type=value_error) ''' ``` 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. rwrr"rycs"t|}tjd}t||S)Nr)rr{ModelValidatorDecoratorInfor}r~rr2r3rs   zmodel_validator..decN)rwrr"ryr2)rcrr2rr3rs1AnyTypec@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||fSrO)r rrr2r2r3__class_getitem__QszInstanceOf.__class_getitem__sourcerr rr#cCshddlm}tt|p|}z||}Wn |y!|YSwtjdd|d|d<tj||dS)Nr)PydanticSchemaGenerationErrorcS||SrOr2vhr2r2r3ez9InstanceOf.__get_pydantic_core_schema__..functionr' serialization) python_schema json_schema)pydanticrr is_instance_schemar get_origin#wrap_serializer_function_ser_schemajson_or_python_schema)rrr rinstance_of_schemaoriginal_schemar2r2r3r4Us    z'InstanceOf.__get_pydantic_core_schema__N)rrr"rrrr rr"r#) r8r9r:r; classmethodrr4object__hash__r2r2r2r3r/s   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|tfSrO)r rrr2r2r3r}sz SkipValidation.__class_getitem__rr rr#cs:||tjfddgd}tj|tjddddS)Ncs|SrOr2)_crrr2r3rrz=SkipValidation.__get_pydantic_core_schema__..)js_annotation_functionscSrrOr2rr2r2r3rrr)metadatar)rbuild_metadata_dictr any_schemar)rrr rr2rr3r4sz+SkipValidation.__get_pydantic_core_schema__N)rrr"rr) r8r9r:r;rrr4rrr2r2r2r3rps    rr2) rerfrgrfrcrhrdrir"rj) rerfrgrfrcrmrdrir"rn) rerfrgrfrcrordrir"rp)rcrmr"r)rcrr"r)rcrr"r)rcrr"r)Pr; __future__r _annotations dataclassessys functoolsrtypesrtypingrrrrr r r pydantic_corer _core_schematyping_extensionsr rrrr! _internalrrrrannotated_handlerserrorsr version_inforinspect_validatorr* dataclass slots_truerr=rArErKrTrYr+r- _V2ValidatorrG_V2WrapValidatorr staticmethodr`r<rarbrlrorrValidatorFunctionWrapHandlerrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModeBeforeValidator_AnyModelAfterValidatorrrrrr2r2r2r3s   $       7+$2 ,   ]       :<