Pydantic v2 is 5-50x faster — here's what changed and how to migrate

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

user = User(id=1, name="Alice", email="alice@example.com")

# v1 (still works in v2 but deprecated)
user.dict()

# v2 (use this)
user.model_dump()
user.model_dump(exclude={'email'})
user.model_dump(include={'id', 'name'})
user.model_dump(mode='json')  # Serializes non-JSON types like datetime

from pydantic import BaseModel, field_validator, model_validator

# v1 syntax (deprecated in v2)
class UserV1(BaseModel):
    email: str
    
    @validator('email')
    def email_must_be_lowercase(cls, v):
        return v.lower()

# v2 syntax
class UserV2(BaseModel):
    email: str
    password: str
    
    @field_validator('email')
    @classmethod
    def email_must_be_lowercase(cls, v: str) -> str:
        return v.lower()
    
    # Root validator equivalent
    @model_validator(mode='after')
    def check_password_strength(self) -> 'UserV2':
        if len(self.password) < 8:
            raise ValueError('Password must be at least 8 characters')
        return self

from pydantic import BaseModel, Field

class Product(BaseModel):
    name: str = Field(..., min_length=1, max_length=200)
    price_cents: int = Field(..., gt=0)
    
    # v1: Field(regex="...")
    # v2: Field(pattern="...")
    sku: str = Field(..., pattern=r'^[A-Z]{3}-d{6}$')
    
    # v1: Field(env="DATABASE_URL")  -- BaseSettings only
    # v2: still works in pydantic-settings
    
    # v1: const=True for literal fields
    # v2: use Literal type
    # type: Literal['product'] = 'product'  # Not const=True

from pydantic import BaseModel

# v1
class UserResponseV1(BaseModel):
    id: int
    name: str
    
    class Config:
        orm_mode = True

# v2
class UserResponse(BaseModel):
    id: int
    name: str
    
    model_config = ConfigDict(from_attributes=True)

# In FastAPI endpoints:
from pydantic import ConfigDict

class UserOut(BaseModel):
    id: int
    name: str
    model_config = ConfigDict(from_attributes=True)

@app.get("/users/{user_id}", response_model=UserOut)
async def get_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(UserModel).filter(UserModel.id == user_id).first()
    return UserOut.model_validate(user)  # v2 equivalent of from_orm()

from pydantic import BaseModel
from typing import Optional

# v1: Optional[str] meant "not required, defaults to None"
class UserV1(BaseModel):
    name: Optional[str]  # v1: defaults to None, not required

# v2: Optional[str] means "can be str or None, but REQUIRED"
class UserV2(BaseModel):
    name: Optional[str]           # v2: REQUIRED but can be None
    name_with_default: Optional[str] = None  # v2: not required, defaults to None

# Explicit required vs optional in v2
class UserV2Explicit(BaseModel):
    required_name: str                    # Required
    optional_name: str | None = None      # Not required (v2 style)
    nullable_required: str | None         # Required, but can be None

# Automated migration (handles most cases)
pip install bump-pydantic
bump-pydantic --path ./src

# Then manually fix:
# 1. Optional[T] fields without defaults (add = None or make explicit)
# 2. Complex validators that use pre=True (now mode='before')
# 3. Custom __get_validators__ (now __get_pydantic_core_schema__)
# 4. __fields__ access (now model_fields)