o N!hxs@s:UdZddlmZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZmZmZddlmZmZddlmZdd lmZmZd d lmZmZmZd d lm Z d d l!m"Z"ej#dkrkddlm$Z$nddl m$Z$ej%Z&ej'dbddiej(GdddZ)ej'dbddiej(GdddZ*ej'dbddiej(GdddZ+ej'dbddiej(GdddZ,e rGddde$Z-Gddde$Z.Gddde$Z/Gd d!d!e$Z0ee.ej1e-ej2fZ3ee0ej4e/ej5fZ6ee7e e e fe8e e fee fZ9d"e:d#<ed$ee3e9fd%Z;ed&ee6e9fd%Zed)d)d*ddd:d7Z>ed)d)d;ded=d7Z>d>ded?dfdAd7Z>edBZ?edCddDZ@GdEdFdFejAe$e@ZBGdGdHdHe$e?ZCGdIdJdJe$e?ZDGdKdLdLe$ZEGdMdNdNe$ZFGdOdPdPe$ZGGdQdRdRe$ZHee?ge?fZI ee?ejJge?fZK eeDe?eCe?fZLeeGeHeEeFfZMeeKe?eIe?fZNedgdTdUZOedhdXdUZOedidZdUZOdjd\dUZOed]ZPe re ePd)fZQnej'dbiej(Gd^d_d_ZQe r e ePd)fZRdSej'dbiej(Gd`dadaZRdS)kzBThis module contains related classes and functions for validation.) annotationsN) partialmethod) FunctionType) TYPE_CHECKING AnnotatedAnyCallableLiteralTypeVarUnioncastoverload)PydanticUndefined core_schema)r)Self TypeAlias) _decorators _generics_internal_dataclass)GetCoreSchemaHandler)PydanticUserError) )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|jd}|rttj|j}tj|||jdSttj|j}tj||dS)Nafter)schema field_name)r$) _inspect_validatorrr rWithInfoValidatorFunction"with_info_after_validator_functionr%NoInfoValidatorFunction no_info_after_validator_function)selfrr r$info_argrr-/var/www/html/contec/backend/tec.wsc/Coding/backend/Contec_Project_backend/env/lib/python3.10/site-packages/pydantic/functional_validators.py__get_pydantic_core_schema__Is z+AfterValidator.__get_pydantic_core_schema__ decorator>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]rcCs ||jdS)Nrr2clsr0r-r-r._from_decoratorSs zAfterValidator._from_decoratorNrrr rr!r"r0r1r!r)__name__ __module__ __qualname____doc____annotations__r/ classmethodr5r-r-r-r.rs *  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 of the function. This is only used to generate the appropriate JSON Schema (in validation mode). 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 ``` rrrjson_schema_input_typerr rr!r"cCr||}|jtur dn||j}t|jd}|r*ttj|j}tj|||j |dSttj |j}tj |||dS)Nbeforer$r%json_schema_input_schemar$rD) r@rgenerate_schemar&rr rr'#with_info_before_validator_functionr%r)!no_info_before_validator_functionr+rr r$ input_schemar,rr-r-r.r/}s$   z,BeforeValidator.__get_pydantic_core_schema__r0r1rcC||j|jjdSN)rr@rinfor@r3r-r-r.r5zBeforeValidator._from_decoratorNr6r7 r8r9r:r;r<rr@r/r=r5r-r-r-r.r?Xs   r?c@r>)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 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 Annotated, Union 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`. rrrr@rr rr!r"c Csddlm}z||}|dtjdd|||d}Wn |y(d}Ynw||j}t|jd}|rHt tj |j}tj ||j ||dSt tj |j}tj|||d S) NrPydanticSchemaGenerationError serializationcS||SNr-vhr-r-r.z=PlainValidator.__get_pydantic_core_schema__..)functionr$ return_schemaplain)r%rTrD)rTrD)pydanticrSgetr#wrap_serializer_function_ser_schemarFr@r&rr r'"with_info_plain_validator_functionr%r) no_info_plain_validator_function) r+rr rSr$rTrJr,rr-r-r.r/s<    z+PlainValidator.__get_pydantic_core_schema__r0r1rcCrKrLrMr3r-r-r.r5rOzPlainValidator._from_decoratorNr6r7) r8r9r:r;r<rr@r/r=r5r-r-r-r.rQs *  *rQc@r>) 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 of the function. This is only used to generate the appropriate JSON Schema (in validation mode). ```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.WithInfoWrapValidatorFunctionrrr@rr rr!r"cCrA)NwraprCrE) r@rrFr&rr rWithInfoWrapValidatorFunction!with_info_wrap_validator_functionr%NoInfoWrapValidatorFunctionno_info_wrap_validator_functionrIr-r-r.r/(s(   z*WrapValidator.__get_pydantic_core_schema__r0r1rcCrKrLrMr3r-r-r.r5ArOzWrapValidator._from_decoratorNr6r7rPr-r-r-r.rds &  rdc@seZdZdddZdS) _OnlyValueValidatorClsMethodr4rvaluer!cCdSrVr-r+r4rkr-r-r.__call__Lz%_OnlyValueValidatorClsMethod.__call__Nr4rrkrr!rr8r9r:rnr-r-r-r.rjKrjc@eZdZd ddZd S) _V2ValidatorClsMethodr4rrkrN_core_schema.ValidationInfor!cCrlrVr-r+r4rkrNr-r-r.rnOroz_V2ValidatorClsMethod.__call__Nr4rrkrrNrur!rrqr-r-r-r.rtNrrrtc@rs) _OnlyValueWrapValidatorClsMethodr4rrkr )_core_schema.ValidatorFunctionWrapHandlerr!cCrlrVr-r+r4rkr r-r-r.rnRroz)_OnlyValueWrapValidatorClsMethod.__call__N)r4rrkrr ryr!rrqr-r-r-r.rxQrrrxc@seZdZd d d Zd S) _V2WrapValidatorClsMethodr4rrkr ryrNrur!cCrlrVr-r+r4rkr rNr-r-r.rnUz"_V2WrapValidatorClsMethod.__call__N) r4rrkrr ryrNrur!rrqr-r-r-r.r{Trrr{r_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorType)rBr#rer^FieldValidatorModes.) check_fieldsr@fieldstrfieldsmodeLiteral['wrap']r bool | Noner@rr!6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]cGrlrVr-rrrr@rr-r-r.field_validatorwrLiteral['before', 'plain']RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]cGrlrVr-rr-r-r.rr)rrLiteral['after']cGrlrVr-)rrrrr-r-r.rr}r#)rrr@Callable[[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)rBr^rez;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typer^css|]}t|tVqdSrV) isinstancer).0rr-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-methodr)rrrr@)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxyrdec_inforrr@rr-r.decs   zfield_validator..decN)rrr!r)rrrrrall)rrrr@rrr-rr.rs( D  _ModelType _ModelTypeCo) covariantc@seZdZdZ d d d d ZdS) ModelWrapValidatorHandlerz]`@model_validator` decorated function handler argument type. This is used when `mode='wrap'`.Nrkrouter_locationstr | int | Noner!rcCrlrVr-)r+rkrr-r-r.rn z"ModelWrapValidatorHandler.__call__rV)rkrrrr!rr8r9r:r;rnr-r-r-r.r 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. r4type[_ModelType]rkrr %ModelWrapValidatorHandler[_ModelType]r!rcCrlrVr-rzr-r-r.rn z&ModelWrapValidatorWithoutInfo.__call__N)r4rrkrr rr!rrr-r-r-r.rrc@seZdZdZdd d ZdS)ModelWrapValidatorzSA `@model_validator` decorated function signature. This is used when `mode='wrap'`.r4rrkrr rrNrur!rcCrlrVr-r|r-r-r.rn*s zModelWrapValidator.__call__N) r4rrkrr rrNrur!rrr-r-r-r.r'rc@seZdZdZdddZdS) #FreeModelBeforeValidatorWithoutInfoA `@model_validator` decorated function signature. This is used when `mode='before'` and the function does not have info argument. rkrr!cCrlrVr-)r+rkr-r-r.rn<r}z,FreeModelBeforeValidatorWithoutInfo.__call__N)rkrr!rrr-r-r-r.r7rrc@seZdZdZd ddZdS) ModelBeforeValidatorWithoutInforr4rrkr!cCrlrVr-rmr-r-r.rnKrz(ModelBeforeValidatorWithoutInfo.__call__Nrprr-r-r-r.rFrrc@seZdZdZd ddZd S) FreeModelBeforeValidatorUA `@model_validator` decorated function signature. This is used when `mode='before'`.rkrrNrur!cCrlrVr-)r+rkrNr-r-r.rnYrz!FreeModelBeforeValidator.__call__N)rkrrNrur!rrr-r-r-r.rVrrc@seZdZdZd dd Zd S) ModelBeforeValidatorrr4rrkrNrur!cCrlrVr-rvr-r-r.rngrzModelBeforeValidator.__call__Nrwrr-r-r-r.rdrr|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrlrVr-rr-r-r.model_validatorrrLiteral['before']rCallable[[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrlrVr-rr-r-r.rr}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]cCrlrVr-rr-r-r.rr"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!rcs"t|}tjd}t||S)Nr)rrModelValidatorDecoratorInforrrr-r.rs   zmodel_validator..decN)rrr!rr-)rrr-rr.rs1AnyTypec@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||fSrV)rr4rr-r-r.__class_getitem__szInstanceOf.__class_getitem__sourcerr rr"cCshddlm}tt|p|}z||}Wn |y!|YSwtjdd|d|d<tj||dS)NrrRcSrUrVr-rWr-r-r.rZr[z9InstanceOf.__get_pydantic_core_schema__..r\r$rT) python_schema json_schema)r_rSris_instance_schemar get_originrajson_or_python_schema)r4rr rSinstance_of_schemaoriginal_schemar-r-r.r/s    z'InstanceOf.__get_pydantic_core_schema__N)rrr!rrrr rr!r") r8r9r:r;r=rr/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|tfSrV)rrrr-r-r.r.sz SkipValidation.__class_getitem__rr rr"cs6||dfddgi}tj|tjddddS)N pydantic_js_annotation_functionscs|SrVr-)_crYrr-r.rZ4r[z=SkipValidation.__get_pydantic_core_schema__..cSrUrVr-rWr-r-r.rZ8r[r)metadatarT)r any_schemara)r4rr rr-rr.r/1sz+SkipValidation.__get_pydantic_core_schema__N)rrr!rr) r8r9r:r;rr=r/rrr-r-r-r.r!s    rr-) rrrrrrrrr@rr!r) rrrrrrrrr@rr!r) rrrrrrrrr!r) rrrrrrrrr@rr!r)rrr!r)rrr!r)rrr!r)rrr!r)Sr; __future__r _annotations dataclassessys functoolsrtypesrtypingrrrrr r r r r pydantic_corerr _core_schematyping_extensionsrr _internalrrrannotated_handlersrerrorsr version_inforinspect_validatorr& dataclass slots_truerr?rQrdrjrtrxr{r'r) _V2Validatorrfrh_V2WrapValidatorr= staticmethodr~r<rrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrrrrr-r-r-r.s   ,     <C`K ,    o       :<