U ={f_@s0UdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZddlmZddlmZddlmZmZmZd d lmZd d lmZmZmZm Z d d l!mZd d l"m#Z#ej$d krddlm%Z%n ddl m%Z%ej&Z'ej(fddie j)GdddZ*ej(fddie j)GdddZ+ej(fddie j)GdddZ,ej(fddie j)GdddZ-e rGddde%Z.Gddde%Z/Gddde%Z0ee/ej1e.ej2fZ3ee0ej4fZ5ee6e e e fe7e e fee fZ8de9d <ed!e3e8Z:ed"e5e8Z;ed#d#d$d%d%d&d'd(d)d*d+Zed6dd7Z?Gd8d9d9ej@e%e?ZAGd:d;d;e%e>ZBGdZCGd>d?d?e%ZDGd@dAdAe%ZEGdBdCdCe%ZFGdDdEdEe%ZGe e>ge>fZHe e>ejIge>fZJeeCe>eBe>fZKeeFeGeDeEfZLeeJe>eHe>fZMed-dFdGdHdIZNedJdKdGdLdIZNedMdNdGdOdIZNdPdQdGdRdIZNedSZOe reeOd#fZPnej(fe j)GdTdUdUZPe reeOd#fZQnej(fe j)GdVdWdWZQdS)XzBThis 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@s,eZdZUdZded<dddddd Zd S) AfterValidatora8Usage docs: https://docs.pydantic.dev/2.7/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.WithInfoValidatorFunctionfuncr_GetCoreSchemaHandlercore_schema.CoreSchema source_typehandlerreturncCsX||}t|jd}|r8ttj|j}tj|||jdSttj|j}tj||dSdS)Nafterschema field_namer&) _inspect_validatorrr r WithInfoValidatorFunctionZ"with_info_after_validator_functionr'NoInfoValidatorFunctionZ no_info_after_validator_functionselfr!r"r&info_argrr/]/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__Is z+AfterValidator.__get_pydantic_core_schema__N__name__ __module__ __qualname____doc____annotations__r1r/r/r/r0rs )rc@s,eZdZUdZded<dddddd Zd S) BeforeValidatoraUsage docs: https://docs.pydantic.dev/2.7/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 ``` rrrrrr cCsX||}t|jd}|r8ttj|j}tj|||jdSttj|j}tj||dSdS)Nbeforer%r() r)rr r r*Z#with_info_before_validator_functionr'r+Z!no_info_before_validator_functionr,r/r/r0r1us z,BeforeValidator.__get_pydantic_core_schema__Nr2r/r/r/r0r8Ts r8c@s,eZdZUdZded<dddddd Zd S) PlainValidatora;Usage docs: https://docs.pydantic.dev/2.7/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 ``` rrrrrr cCsddlm}z||}tjdd|d}Wn|k rBd}YnXt|jd}|rtttj|j}tj||j |dSttj |j}tj ||dSdS) NrPydanticSchemaGenerationErrorcSs||SNr/vhr/r/r0z=PlainValidator.__get_pydantic_core_schema__..functionr&plain)r' serialization)rF) pydanticr<r #wrap_serializer_function_ser_schemar)rr r*Z"with_info_plain_validator_functionr'r+Z no_info_plain_validator_function)r-r!r"r<r&rFr.rr/r/r0r1s    z+PlainValidator.__get_pydantic_core_schema__Nr2r/r/r/r0r:s r:c@s,eZdZUdZded<dddddd Zd S) WrapValidatoraUsage docs: https://docs.pydantic.dev/2.7/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.WithInfoWrapValidatorFunctionrrrrr cCsX||}t|jd}|r8ttj|j}tj|||jdSttj|j}tj||dSdS)Nwrapr%r() r)rr r WithInfoWrapValidatorFunctionZ!with_info_wrap_validator_functionr'ZNoInfoWrapValidatorFunctionZno_info_wrap_validator_functionr,r/r/r0r1s z*WrapValidator.__get_pydantic_core_schema__Nr2r/r/r/r0rIs $rIc@seZdZddddddZdS)_OnlyValueValidatorClsMethodrclsvaluer#cCsdSr=r/r-rNrOr/r/r0__call__sz%_OnlyValueValidatorClsMethod.__call__Nr3r4r5rQr/r/r/r0rLsrLc@s eZdZdddddddZdS)_V2ValidatorClsMethodr_core_schema.ValidationInforNrOinfor#cCsdSr=r/r-rNrOrVr/r/r0rQsz_V2ValidatorClsMethod.__call__NrRr/r/r/r0rSsrSc@s"eZdZddddddddZdS)_V2WrapValidatorClsMethodrz)_core_schema.ValidatorFunctionWrapHandlerrTrNrOr"rVr#cCsdSr=r/r-rNrOr"rVr/r/r0rQsz"_V2WrapValidatorClsMethod.__call__NrRr/r/r/r0rXsrXr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType_V2WrapValidatorType.)mode check_fieldsstrz%Literal[('before', 'after', 'plain')]z bool | NonezRCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType])fieldfieldsr^r_r#cGsdSr=r/rar^r_rbr/r/r0field_validatorsrd)r_zLiteral['wrap']z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cGsdSr=r/rcr/r/r0rds)r9r$rJrEFieldValidatorModesr$zCallable[[Any], Any]csZt|trtddd|ftddDs>tddddd d fd d }|S) a:Usage docs: https://docs.pydantic.dev/2.7/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|tVqdSr=) isinstancer`).0rar/r/r0 qsz"field_validator..z`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('', '', ...)`zvalidator-invalid-fieldszHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any](_decorators.PydanticDescriptorProxy[Any]fr#cs<t|rtdddt|}tjd}t||S)Nz8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodrf)rbr^r_)rZis_instance_method_from_sigr%ensure_classmethod_based_on_signatureZFieldValidatorDecoratorInfoPydanticDescriptorProxyrmZdec_infor_rbr^r/r0decxs  zfield_validator..dec)rhrrall)rar^r_rbrrr/rqr0rd+s?   _ModelType _ModelTypeCo) covariantc@s$eZdZdZd ddddddZdS) ModelWrapValidatorHandlerz[@model_validator decorated function handler argument type. This is used when `mode='wrap'`.Nrzstr | int | Noneru)rOouter_locationr#cCsdSr=r/)r-rOrxr/r/r0rQsz"ModelWrapValidatorHandler.__call__)Nr3r4r5r6rQr/r/r/r0rwsrwc@s$eZdZdZdddddddZd S) ModelWrapValidatorWithoutInfozA @model_validator decorated function signature. This is used when `mode='wrap'` and the function does not have info argument. type[_ModelType]r%ModelWrapValidatorHandler[_ModelType]rt)rNrOr"r#cCsdSr=r/)r-rNrOr"r/r/r0rQs z&ModelWrapValidatorWithoutInfo.__call__Nryr/r/r/r0rzsrzc@s&eZdZdZdddddddd Zd S) ModelWrapValidatorzQA @model_validator decorated function signature. This is used when `mode='wrap'`.r{rr|rTrtrYcCsdSr=r/rZr/r/r0rQs zModelWrapValidator.__call__Nryr/r/r/r0r}sr}c@s eZdZdZdddddZdS)#FreeModelBeforeValidatorWithoutInfoA @model_validator decorated function signature. This is used when `mode='before'` and the function does not have info argument. r)rOr#cCsdSr=r/)r-rOr/r/r0rQsz,FreeModelBeforeValidatorWithoutInfo.__call__Nryr/r/r/r0r~sr~c@s"eZdZdZddddddZdS)ModelBeforeValidatorWithoutInforrrMcCsdSr=r/rPr/r/r0rQs z(ModelBeforeValidatorWithoutInfo.__call__Nryr/r/r/r0rsrc@s"eZdZdZddddddZdS)FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.rrT)rOrVr#cCsdSr=r/)r-rOrVr/r/r0rQs z!FreeModelBeforeValidator.__call__Nryr/r/r/r0rsrc@s$eZdZdZdddddddZdS)ModelBeforeValidatorrrrTrUcCsdSr=r/rWr/r/r0rQs zModelBeforeValidator.__call__Nryr/r/r/r0rsrz|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])r^r#cCsdSr=r/r^r/r/r0model_validator srzLiteral['before']zqCallable[[_AnyModeBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCsdSr=r/rr/r/r0rszLiteral['after']z}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCsdSr=r/rr/r/r0rsz$Literal[('wrap', 'before', 'after')]rcsdddfdd }|S)a"Usage docs: https://docs.pydantic.dev/2.7/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. rrkrlcs"t|}tjd}t||S)Nr)rrnZModelValidatorDecoratorInfororprr/r0rrWs  zmodel_validator..decr/)r^rrr/rr0r's0AnyTypec@s@eZdZdZedddddZedddd d d ZejZd S) 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' │ } ] """ ``` ritemr#cCst||fSr=)r rNrr/r/r0__class_getitem__szInstanceOf.__class_getitem__rrrsourcer"r#cCsnddlm}tt|p|}z ||}Wn|k rD|YSXtjdd|d|d<tj||dSdS)Nrr;cSs||Sr=r/r>r/r/r0rArBz9InstanceOf.__get_pydantic_core_schema__..rCrF)Z python_schemaZ json_schema)rGr<r Zis_instance_schemar get_originrHZjson_or_python_schema)rNrr"r<Zinstance_of_schemaoriginal_schemar/r/r0r1s    z'InstanceOf.__get_pydantic_core_schema__N) r3r4r5r6 classmethodrr1object__hash__r/r/r/r0ris  rc@s<eZdZdZdddddZeddddd 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. rrcCst|tfSr=)r rrr/r/r0rsz SkipValidation.__class_getitem__rrrcs:||tjfddgd}tj|tjddddS)Ncs|Sr=r/)Z_cr@rr/r0rArBz=SkipValidation.__get_pydantic_core_schema__..)Zjs_annotation_functionscSs||Sr=r/r>r/r/r0rArBrC)metadatarF)rZbuild_metadata_dictr Z any_schemarH)rNrr"rr/rr0r1sz+SkipValidation.__get_pydantic_core_schema__N) r3r4r5r6rrr1rrr/r/r/r0rs   r)Rr6 __future__rZ _annotations dataclassessys functoolsrtypesrtypingrrrrr r r Z pydantic_corer Z _core_schemaZtyping_extensionsr rrrr _internalrrrrZannotated_handlerserrorsr version_inforZinspect_validatorr) dataclassZ slots_truerr8r:rIrLrSrXr*r+Z _V2ValidatorrKZ_V2WrapValidatorr staticmethodr[r7r\r]rdrertruZValidatorFunctionWrapHandlerrwrzr}r~rrrZModelAfterValidatorWithoutInfoZValidationInfoZModelAfterValidatorZ_AnyModelWrapValidatorZ_AnyModeBeforeValidatorZ_AnyModelAfterValidatorrrrrr/r/r/r0s   $       7+32 ,   ^     9 <