&V.j wUdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZddlmZmZddlmZdd lmZmZmZmZd d lmZmZmZd d lm Z d d l!m"Z"ejFdkrddlm$Z$nddl m$Z$ejJZ&ejNdLddiejPGddZ)ejNdLddiejPGddZ*ejNdLddiejPGddZ+ejNdLddiejPGddZ,e rGdde$Z-Gdde$Z.Gdde$Z/Gd d!e$Z0ee.ejbe-ejdfZ3ee0ejhe/ejjfZ6ee7e e e fe8e e fee fZ9d"e:d#<ed$ee3e9f%Z;ed&ee6e9f%Zed)d)d* dNd,Z>ed)d)d- dOd.Z>d/ded0 dPd1Z>ed2Z?ed3d4Z@Gd5d6eje$e@ZBGd7d8e$e?ZCGd9d:e$e?ZDGd;de$ZFGd?d@e$ZGGdAdBe$ZHe e?ge?fZI e e?ejge?fZK eeDe?eCe?fZLeeGeHeEeFfZMeeKe?eIe?fZNe dQdCZOe dRdDZOe dSdEZO dTdFZOedGZPe reePd)fZQn)ejNdLiejPGdHdIZQe reePd)fZRyejNdLiejPGdJdKZRy)UzBThis module contains related classes and functions for validation.) annotationsN) partialmethod) FunctionType) TYPE_CHECKINGAnyCallableTypeVarUnioncastoverload)PydanticUndefined core_schema)r) AnnotatedLiteralSelf TypeAlias) _decorators _generics_internal_dataclass)GetCoreSchemaHandler)PydanticUserError) )ProtocolfrozenTc6eZdZUdZded<ddZeddZy) AfterValidatora=Usage docs: https://docs.pydantic.dev/2.10/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: ```python 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.WithInfoValidatorFunctionfunccD||}t|jd}|rFttj|j}tj |||j Sttj|j}tj||S)Nafter)schema field_name)r#) _inspect_validatorr r rWithInfoValidatorFunction"with_info_after_validator_functionr$NoInfoValidatorFunction no_info_after_validator_function)self source_typehandlerr#info_argr s `C:\xampp\htdocs\tradingbinance\backend\.venv\Lib\site-packages\pydantic/functional_validators.py__get_pydantic_core_schema__z+AfterValidator.__get_pydantic_core_schema__Hsz%%dii9  ==tyyIDAA$vbibtbtu u ;;TYYGD??VT Tc(||jS)Nr r2cls decorators r._from_decoratorzAfterValidator._from_decoratorRs ''r0Nr+rr,rreturncore_schema.CoreSchemar5z>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]r8r)__name__ __module__ __qualname____doc____annotations__r/ classmethodr6r0r.rrs+'R VUU((r0rcDeZdZUdZded<eZded<d dZed dZ y) BeforeValidatoraiUsage docs: https://docs.pydantic.dev/2.10/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: ```python 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 ``` rr rjson_schema_input_typec||}|jturdn|j|j}| |j|}|d|ini}t |j d}|rGttj|j }tj|||j|Sttj|j }tj|||S#t$rYwxYw)Npydantic_js_input_core_schemabeforer#r$metadatar#rI)rDr generate_schemaresolve_ref_schema LookupErrorr%r r rr&#with_info_before_validator_functionr$r(!no_info_before_validator_functionr*r+r,r# input_schemarIr-r s r.r/z,BeforeValidator.__get_pydantic_core_schema__{s%**.?? (()D)DE   # &99,G GSF^3\Bdf%dii:  ==tyyIDBB"--!   ;;TYYGD@@f_gh h  C// C;:C;cR||j|jjSN)r rDr inforDr3s r.r6zBeforeValidator._from_decorator##,>>#H#H  r0Nr7r: r;r<r=r>r?r rDr/r@r6rAr0r.rCrCWs5> VU"3C3i:  r0rCcDeZdZUdZded<eZded<d dZed dZ y) PlainValidatoraUsage docs: https://docs.pydantic.dev/2.10/concepts/validators/#annotated-validators 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 of the function. This is only used to generate the appropriate JSON Schema (in validation mode). If not provided, will default to `Any`. Example: ```python from typing import Union from typing_extensions import Annotated from pydantic import BaseModel, PlainValidator MyInt = Annotated[ int, PlainValidator( lambda v: int(v) + 1, 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`. rr rrDc hddlm} ||}|jdtjd||j |}|j |j } |j|}|d|ini}t|jd}|rGttj|j} tj| |j||Sttj|j} tj | || S#|$rd}YwxYw#t$rYwxYw) NrPydanticSchemaGenerationError serializationc||SNrAvhs r.z=PlainValidator.__get_pydantic_core_schema__..!A$r0)functionr# return_schemarFplain)r$r^rI)r^rI)pydanticr]getr#wrap_serializer_function_ser_schemarKrDrLrMr%r r r&"with_info_plain_validator_functionr$r( no_info_plain_validator_function) r*r+r,r]r#r^rQrIr-r s r.r/z+PlainValidator.__get_pydantic_core_schema__s: ; ![)F#JJ??.!")"9"9+"FM..t/J/JK  "55lCLGSF^3\Bdf%dii9  ==tyyIDAA"--+!   ;;TYYGD??+! /- ! M !   s$AD$D%D"!D"% D10D1cR||j|jjSrTrUr3s r.r6zPlainValidator._from_decoratorrWr0Nr7r:) r;r<r=r>r?rrDr/r@r6rAr0r.rZrZs6)V VU"%C%/b  r0rZcDeZdZUdZded<eZded<d dZed dZ y) WrapValidatoraUsage docs: https://docs.pydantic.dev/2.10/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). ```python 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.WithInfoWrapValidatorFunctionr rrDc||}|jturdn|j|j}| |j|}|d|ini}t |j d}|rGttj|j }tj|||j|Sttj|j }tj|||S#t$rYwxYw)NrFwraprHrJ)rDr rKrLrMr%r r rWithInfoWrapValidatorFunction!with_info_wrap_validator_functionr$NoInfoWrapValidatorFunctionno_info_wrap_validator_functionrPs r.r/z*WrapValidator.__get_pydantic_core_schema__4s%**.?? (()D)DE   # &99,G GSF^3\Bdf%dii8  AA499MD@@"--!   ??KD>>!   rRcR||j|jjSrTrUr3s r.r6zWrapValidator._from_decoratorUrWr0Nr7r:rXrAr0r.rprp s6$L ^]"3C3B  r0rpceZdZddZy)_OnlyValueValidatorClsMethodcyr`rAr*r4values r.__call__z%_OnlyValueValidatorClsMethod.__call__`sCr0Nr4rr|rr8rr;r<r=r}rAr0r.ryry_s?r0ryceZdZddZy)_V2ValidatorClsMethodcyr`rAr*r4r|rVs r.r}z_V2ValidatorClsMethod.__call__cs_br0Nr4rr|rrV_core_schema.ValidationInfor8rrrAr0r.rrbsbr0rceZdZddZy) _OnlyValueWrapValidatorClsMethodcyr`rAr*r4r|r,s r.r}z)_OnlyValueWrapValidatorClsMethod.__call__fspsr0N)r4rr|rr,)_core_schema.ValidatorFunctionWrapHandlerr8rrrAr0r.rressr0rc(eZdZ ddZy)_V2WrapValidatorClsMethodcyr`rAr*r4r|r,rVs r.r}z"_V2WrapValidatorClsMethod.__call__isr0N) r4rr|rr,rrVrr8rrrAr0r.rrhs7   ?   .   r0rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rGr"rrrhFieldValidatorModes.) check_fieldsrDcyr`rAfieldmoderrDfieldss r.field_validatorrs>Ar0cyr`rArs r.rrs Z]r0)rrcyr`rA)rrrrs r.rrs Z]r0r")rrrDc t|tr tdddvrturtddtur dk(rt|gt dDs td d  d fd }|S) a6Usage docs: https://docs.pydantic.dev/2.10/concepts/validators/#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)rGrhrrz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typerhc3<K|]}t|tywr`) isinstancestr).0rs r. z"field_validator..s:6%z%%6sz`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('', '', ...)`zvalidator-invalid-fieldsctj|r tddtj|}tj}tj ||S)Nz8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodr)rrrrD)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)fdec_inforrrDrs r.deczfield_validator..decsg  2 21 5#JQl   = =a @::r}rAr0r.rrs+g ,0  )   r0rc(eZdZdZ ddZy)ModelWrapValidatorWithoutInfozA `@model_validator` decorated function signature. This is used when `mode='wrap'` and the function does not have info argument. cyr`rArs r.r}z&ModelWrapValidatorWithoutInfo.__call__.sr0N)r4type[_ModelType]r|rr,%ModelWrapValidatorHandler[_ModelType]r8rrrAr0r.rr)s2     7   r0rc,eZdZdZ ddZy)ModelWrapValidatorzSA `@model_validator` decorated function signature. This is used when `mode='wrap'`.cyr`rArs r.r}zModelWrapValidator.__call__=sr0N) r4rr|rr,rrVrr8rrrAr0r.rr:s:]     7 *   r0rc eZdZdZ ddZy)#FreeModelBeforeValidatorWithoutInfoA `@model_validator` decorated function signature. This is used when `mode='before'` and the function does not have info argument. cyr`rA)r*r|s r.r}z,FreeModelBeforeValidatorWithoutInfo.__call__Osr0N)r|rr8rrrAr0r.rrJs    r0rc$eZdZdZ ddZy)ModelBeforeValidatorWithoutInforcyr`rAr{s r.r}z(ModelBeforeValidatorWithoutInfo.__call__^r0Nr~rrAr0r.rrYs(    r0rc$eZdZdZ ddZy)FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.cyr`rA)r*r|rVs r.r}z!FreeModelBeforeValidator.__call__lrr0N)r|rrVrr8rrrAr0r.rris(_   *  r0rc(eZdZdZ ddZy)ModelBeforeValidatorrcyr`rArs r.r}zModelBeforeValidator.__call__zsr0NrrrAr0r.rrws0_     *   r0rcyr`rArs r.model_validatorr r0cyr`rArs r.rrrr0cyr`rArs r.rrrr0cdfd }|S)a'Usage docs: https://docs.pydantic.dev/2.10/concepts/validators/#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. ctj|}tj}tj||S)Nr)rrModelValidatorDecoratorInfor)rrrs r.rzmodel_validator..decs6  = =a @::E221h??r0)rrr8rrA)rrs` r.rrs`@ Jr0AnyTypecLeZdZdZeddZeddZejZy) 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' │ } ] """ ``` c"t||fSr`)rr4items r.__class_getitem__zInstanceOf.__class_getitem__sT35[) )r0cddlm}tjt j |xs|} ||}tj d||d<tj||S#|$r|cYSwxYw)Nrr\c||Sr`rAras r.rdz9InstanceOf.__get_pydantic_core_schema__..(rer0rfr#r^) python_schema json_schema)rir]ris_instance_schemar get_originrkjson_or_python_schema)r4sourcer,r]instance_of_schemaoriginal_schemas r.r/z'InstanceOf.__get_pydantic_core_schema__s >"-!?!? @T@TU[@\@f`f!g  x")&/ 7B6e6e.7"?3#88GYgvww1 *)) *sA..A87A8N)rrr8rrrr,rr8r9) r;r<r=r>r@rr/object__hash__rAr0r.rrs= @  *  *  x  x&??r0rcBeZdZdZddZeddZejZy)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. c(t|tfSr`)rrrs r.rz SkipValidation.__class_getitem__@sT>#334 4r0c~||dfdgi}tj|tjdS)N pydantic_js_annotation_functionsc|Sr`rA)_crcrs r.rdz=SkipValidation.__get_pydantic_core_schema__..Fs 1_K]r0c||Sr`rAras r.rdz=SkipValidation.__get_pydantic_core_schema__..Jrer0r)rIr^)r any_schemark)r4rr,rIrs @r.r/z+SkipValidation.__get_pydantic_core_schema__CsC%foO:=]<^_H))!)MM. r0N)rrr8rr) r;r<r=r>rr@r/rrrAr0r.rr3s+  5    ??r0rrA) rrrrrLiteral['wrap']r bool | NonerDrr8z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]) rrrrrzLiteral['before', 'plain']rrrDrr8RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]) rrrrrLiteral['after']rrr8r) rrrrrrrrrDrr8zCallable[[Any], Any])rrr8z|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rzLiteral['before']r8zrCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rrr8z}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])rz"Literal['wrap', 'before', 'after']r8r)Sr> __future__r _annotations dataclassessys functoolsrtypesrtypingrrrr r r r pydantic_corer r _core_schematyping_extensionsrrrr _internalrrrannotated_handlersrerrorsr version_inforinspect_validatorr% dataclass slots_truerrCrZrpryrrrr&r( _V2Validatorrsru_V2WrapValidatorr@ staticmethodrr?rrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrrrrrAr0r.rsH2 #OOO85AABB4%g* 22EdE&9&D&DE8(8(F8(vEdE&9&D&DEE E FE PEdE&9&D&DEe e Fe PEdE&9&D&DEP P FP f@x@cct8tH..$,, .L!22(00 2,1S#s]1K\Z]_bZbMcersvew1w+xyx)0,L";;<*&##9GWYrGrAst!()K!LYL !$"% A AA  A  A  A<A A !$"% ] ]] % ]  ]  ]X] ] ! # ] ]]  ]  ] X ] ]!( $"3 k kk  k  k  kk\\ " ~6   I I8T`Ka  HZ$8" *-  (  h  x  8 "*:, *B!C L,G,GH*TUZ1*=?\]g?hhi 24WYxx 3J ?A_`jAk kl         6 ,6 6r ) 7C<(J[<0;;<9#9#=9#xw|,N[<0;;<##=#r0