Pydantic Cheatsheet 03 — Validators

from pydantic import BaseModel, field_validator

class M(BaseModel):
    email: str
    age: int

    @field_validator("email", mode="before")
    @classmethod
    def lower_email(cls, v):
        return v.lower().strip() if isinstance(v, str) else v

    @field_validator("age")             # default mode="after"
    @classmethod
    def positive_age(cls, v: int) -> int:
        if v < 0:
            raise ValueError("age must be non-negative")
        return v

@field_validator("email", "alt_email")
@classmethod
def lower(cls, v: str) -> str:
    return v.lower()

from pydantic import ValidationInfo

@field_validator("password_confirm")
@classmethod
def passwords_match(cls, v, info: ValidationInfo):
    if v != info.data.get("password"):
        raise ValueError("passwords don't match")
    return v

from pydantic import model_validator

class Order(BaseModel):
    quantity: int
    price: float

    @model_validator(mode="after")
    def total_under_limit(self):
        if self.quantity * self.price > 1_000_000:
            raise ValueError("order too large")
        return self

@model_validator(mode="before")
@classmethod
def normalize(cls, data):
    if isinstance(data, dict):
        if "name" in data and isinstance(data["name"], str):
            data["name"] = data["name"].strip()
    return data

from typing import Annotated
from pydantic import BeforeValidator, AfterValidator

def lowercase(v: str) -> str:
    return v.lower()

def positive(v: int) -> int:
    if v <= 0: raise ValueError("must be positive")
    return v

LowercaseEmail = Annotated[str, AfterValidator(lowercase)]
PositiveInt = Annotated[int, AfterValidator(positive)]

class User(BaseModel):
    email: LowercaseEmail
    age: PositiveInt

from pydantic import WrapValidator
from pydantic import ValidatorFunctionWrapHandler
from typing import Any

def trim_then_validate(v: Any, handler: ValidatorFunctionWrapHandler) -> str:
    if isinstance(v, str): v = v.strip()
    return handler(v)              # delegate to original

TrimmedStr = Annotated[str, WrapValidator(trim_then_validate)]

from pydantic import PlainValidator

def my_validate(v):
    return str(v).strip()

class M(BaseModel):
    name: Annotated[str, PlainValidator(my_validate)]

@field_validator("email")
@classmethod
def check(cls, v, info: ValidationInfo):
    if info.context and info.context.get("check_db"):
        if email_exists(v):
            raise ValueError("email taken")
    return v

User.model_validate({"email": "..."}, context={"check_db": True})

@field_validator("age")
@classmethod
def positive(cls, v):
    if v < 0:
        raise ValueError("age must be non-negative")   # converted to ValidationError with loc
    return v

@field_validator("phone", mode="before")
@classmethod
def normalize(cls, v):
    if isinstance(v, str):
        return re.sub(r"\D", "", v)
    return v

@model_validator(mode="after")
def end_after_start(self):
    if self.end_date <= self.start_date:
        raise ValueError("end must be after start")
    return self

@model_validator(mode="after")
def kind_specific(self):
    if self.type == "alpha" and not self.alpha_field:
        raise ValueError("alpha_field required when type=alpha")
    return self