Python Dataclasses and Pydantic: Modern Data Validation for Production APIs

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class User:
 id: int
 name: str
 email: str
 created_at: datetime = field(default_factory=datetime.now)
 tags: list[str] = field(default_factory=list)

 def __post_init__(self):
 # Validation after auto-generated __init__
 if not self.email or '@' not in self.email:
 raise ValueError(f'Invalid email: {self.email}')

# Auto-generated: __init__, __repr__, __eq__
user = User(id=1, name='Alice', email='alice@example.com')
print(user) # User(id=1, name='Alice', email='alice@example.com', ...)

# Immutable dataclass:
@dataclass(frozen=True) # __hash__ generated, fields immutable
class Point:
 x: float
 y: float

from pydantic import BaseModel, Field, field_validator, model_validator
from typing import Optional
from datetime import datetime

class CreateUserRequest(BaseModel):
 name: str = Field(min_length=1, max_length=100)
 email: str = Field(pattern=r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$')
 age: int = Field(ge=18, le=120)
 role: str = Field(default='user')

 @field_validator('email')
 @classmethod
 def lowercase_email(cls, v: str) -> str:
 return v.lower().strip()

 @field_validator('role')
 @classmethod
 def valid_role(cls, v: str) -> str:
 if v not in ('user', 'admin', 'moderator'):
 raise ValueError(f'Invalid role: {v}')
 return v

# Parse and validate:
try:
 user = CreateUserRequest(name='Alice', email='ALICE@Example.COM', age=25)
 print(user.email) # 'alice@example.com' (auto-lowercased)
except ValidationError as e:
 print(e.errors()) # Structured error list with field details

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class UserCreate(BaseModel):
 name: str
 email: str
 age: int

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

@app.post('/users', response_model=UserResponse, status_code=201)
async def create_user(body: UserCreate): # Auto-validated from request JSON
 # body is already validated UserCreate instance
 user = await db.create_user(body.model_dump())
 return UserResponse(**user) # Only returns fields in response_model
# FastAPI generates OpenAPI docs automatically from Pydantic models

from abc import ABC, abstractmethod
from dataclasses import dataclass, field
import math


@dataclass
class Account:
    owner: str
    balance: float = 0.0
    tags: list[str] = field(default_factory=list)   # never a shared mutable default

    def __post_init__(self):
        if self.balance < 0:
            raise ValueError(f"balance cannot be negative: {self.balance}")


@dataclass(frozen=True)
class Money:
    amount: int
    currency: str

    def __add__(self, other: "Money") -> "Money":
        if other.currency != self.currency:
            raise ValueError("currency mismatch")
        return Money(self.amount + other.amount, self.currency)


print(Account("ana"))                       # generated __repr__
print(Account("ana") == Account("ana"))     # generated __eq__: True
print(Account.__hash__)                     # None: eq=True without frozen makes it unhashable
print({Money(5, "USD") + Money(7, "USD")})  # frozen + eq: hashable, usable in sets


class Shape(ABC):
    @abstractmethod
    def area(self) -> float: ...

    def describe(self) -> str:
        return f"{type(self).__name__}: area={self.area():.2f}"


@dataclass
class Circle(Shape):
    r: float

    def area(self) -> float:
        return math.pi * self.r ** 2


print(Circle(5).describe())                 # Circle: area=78.54


class A:
    def method(self): return "A"
class B(A):
    def method(self): return "B" + super().method()
class C(A):
    def method(self): return "C" + super().method()
class D(B, C):
    pass


print(D().method(), [k.__name__ for k in D.__mro__])   # BCA ['D', 'B', 'C', 'A', 'object']
try:
    Shape()
except TypeError as e:
    print("TypeError:", e)