Functional Validators
This module contains related classes and functions for validation.
Bases: PydanticErrorMixin, TypeError
An error raised due to incorrect use of Pydantic.
Usage 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.
Type: core_schema.NoInfoValidatorFunction | core_schema.GeneralValidatorFunction
Usage 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.
Type: core_schema.NoInfoValidatorFunction | core_schema.GeneralValidatorFunction
Usage 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.
Type: core_schema.NoInfoValidatorFunction | core_schema.GeneralValidatorFunction
Usage 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.
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
Type: core_schema.NoInfoWrapValidatorFunction | core_schema.GeneralWrapValidatorFunction | core_schema.FieldWrapValidatorFunction
Bases: ValidatorFunctionWrapHandler, Protocol[_ModelTypeCo]
@model_validator decorated function handler argument type. This is used when mode='wrap'.
Bases: Protocol[_ModelType]
A @model_validator decorated function signature.
This is used when mode='wrap' and the function does not have info argument.
Bases: Protocol[_ModelType]
A @model_validator decorated function signature. This is used when mode='wrap'.
Bases: Protocol
A @model_validator decorated function signature.
This is used when mode='before' and the function does not have info argument.
Bases: Protocol
A @model_validator decorated function signature. This is used when mode='before'.
Generic type for annotating a type that is an instance of a given class.
If 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.
def field_validator(
__field: str,
fields: str = (),
mode: Literal['before', 'after', 'plain'] = ...,
check_fields: bool | None = ...,
) -> Callable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]
def field_validator(
__field: str,
fields: str = (),
mode: Literal['wrap'],
check_fields: bool | None = ...,
) -> Callable[[_V2WrapValidatorType], _V2WrapValidatorType]
Usage 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.
Callable[[Any], Any] — A decorator that can be used to decorate a function to be used as a field_validator.
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.
Additional field(s) the field_validator should be called on.
Specifies whether to validate the fields before or after validation.
Whether to check that the fields actually exist on the model.
PydanticUserError—- If
@field_validatoris used bare (with no fields). - If the args passed to
@field_validatoras fields are not strings. - If
@field_validatorapplied to instance methods.
def model_validator(
mode: Literal['wrap'],
) -> Callable[[_AnyModelWrapValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]
def model_validator(
mode: Literal['before'],
) -> Callable[[_AnyModeBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]
def model_validator(
mode: Literal['after'],
) -> Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]
Decorate model methods for validation purposes.
Any — A decorator that can be used to decorate a function to be used as a model validator.
A required string literal that specifies the validation mode. It can be one of the following: ‘wrap’, ‘before’, or ‘after’.
Type: TypeAlias Default: Literal['before', 'after', 'wrap', 'plain']
A @model_validator decorated function signature. This is used when mode='after' and the function does not
have info argument.
Default: Callable[[_ModelType], _ModelType]
A @model_validator decorated function signature. This is used when mode='after'.
Default: Callable[[_ModelType, _core_schema.ValidationInfo], _ModelType]
Default: TypeVar('AnyType')