FastAPI와 Pydantic v2: 타입 안전성과 성능을 극대화하는 검증 패턴 5가지

from pydantic import BaseModel, field_validator, ValidationError
from typing import List

class UserRegistration(BaseModel):
    username: str
    email: str
    password: str
    tags: List[str]

    @field_validator('username')
    @classmethod
    def username_alphanumeric(cls, v: str) -> str:
        if not v.isalnum():
            raise ValueError('사용자명은 영문자와 숫자만 가능합니다')
        return v

    @field_validator('password')
    @classmethod
    def password_strength(cls, v: str) -> str:
        if len(v) < 8:
            raise ValueError('비밀번호는 최소 8자 이상이어야 합니다')
        if not any(c.isupper() for c in v):
            raise ValueError('비밀번호에 대문자가 포함되어야 합니다')
        return v

    @field_validator('tags')
    @classmethod
    def validate_tags(cls, v: List[str]) -> List[str]:
        if len(v) > 5:
            raise ValueError('태그는 최대 5개까지 가능합니다')
        return [tag.lower().strip() for tag in v]

# 사용 예시
try:
    user = UserRegistration(
        username="user123",
        email="user@example.com",
        password="SecurePass123",
        tags=["Python", "FastAPI", "Backend"]
    )
    print(user.model_dump())
except ValidationError as e:
    print(e.errors())

from pydantic import BaseModel, model_validator
from datetime import datetime

class EventSchedule(BaseModel):
    event_name: str
    start_date: datetime
    end_date: datetime
    max_participants: int
    min_participants: int

    @model_validator(mode='after')
    def validate_dates_and_participants(self) -> 'EventSchedule':
        # 날짜 검증
        if self.end_date <= self.start_date:
            raise ValueError('종료일은 시작일보다 이후여야 합니다')

        # 참가자 수 검증
        if self.min_participants > self.max_participants:
            raise ValueError('최소 참가자 수는 최대 참가자 수보다 클 수 없습니다')

        # 이벤트 기간 검증
        duration = (self.end_date - self.start_date).days
        if duration > 30:
            raise ValueError('이벤트는 최대 30일까지만 가능합니다')

        return self

# 사용 예시
event = EventSchedule(
    event_name="Python Conference 2026",
    start_date=datetime(2026, 3, 1),
    end_date=datetime(2026, 3, 3),
    max_participants=100,
    min_participants=20
)

from pydantic import BaseModel, computed_field
from typing import Optional

class Product(BaseModel):
    name: str
    price: float
    tax_rate: float = 0.1
    discount_rate: float = 0.0

    @computed_field
    @property
    def final_price(self) -> float:
        """세금과 할인이 적용된 최종 가격"""
        price_with_tax = self.price * (1 + self.tax_rate)
        return price_with_tax * (1 - self.discount_rate)

    @computed_field
    @property
    def discount_amount(self) -> float:
        """할인 금액"""
        return self.price * self.discount_rate

    @computed_field
    @property
    def price_category(self) -> str:
        """가격 카테고리"""
        if self.final_price < 10000:
            return "저가"
        elif self.final_price < 50000:
            return "중가"
        else:
            return "고가"

product = Product(name="노트북", price=100000, discount_rate=0.15)
print(f"최종 가격: {product.final_price:,.0f}원")
print(f"할인액: {product.discount_amount:,.0f}원")
print(f"카테고리: {product.price_category}")
# 출력:
# 최종 가격: 93,500원
# 할인액: 15,000원
# 카테고리: 고가

from pydantic import BaseModel, Field
from typing import Literal, Union

class ImageMessage(BaseModel):
    type: Literal["image"] = "image"
    url: str
    width: int
    height: int

class TextMessage(BaseModel):
    type: Literal["text"] = "text"
    content: str
    format: Literal["plain", "markdown"] = "plain"

class VideoMessage(BaseModel):
    type: Literal["video"] = "video"
    url: str
    duration: int  # 초 단위
    thumbnail: str

class ChatRequest(BaseModel):
    user_id: int
    message: Union[
        ImageMessage,
        TextMessage,
        VideoMessage
    ] = Field(discriminator='type')

# 사용 예시
requests = [
    ChatRequest(user_id=1, message={"type": "text", "content": "안녕하세요"}),
    ChatRequest(user_id=2, message={"type": "image", "url": "https://...", "width": 800, "height": 600}),
    ChatRequest(user_id=3, message={"type": "video", "url": "https://...", "duration": 120, "thumbnail": "https://..."})
]

for req in requests:
    if req.message.type == "text":
        print(f"텍스트 메시지: {req.message.content}")
    elif req.message.type == "image":
        print(f"이미지 ({req.message.width}x{req.message.height})")
    elif req.message.type == "video":
        print(f"동영상 ({req.message.duration}초)")

from pydantic import BaseModel, ConfigDict, Field
from datetime import datetime

class APIResponse(BaseModel):
    model_config = ConfigDict(
        # 추가 필드 금지 (보안 강화)
        extra='forbid',
        # 불변 객체로 만들기
        frozen=True,
        # 필드명을 snake_case로 자동 변환
        alias_generator=lambda field_name: field_name,
        # JSON 스키마에 예제 포함
        json_schema_extra={
            "examples": [
                {
                    "status": "success",
                    "data": {"user_id": 123},
                    "timestamp": "2026-01-30T10:00:00Z"
                }
            ]
        },
        # 문자열 앞뒤 공백 자동 제거
        str_strip_whitespace=True,
        # 유효성 검증 엄격 모드
        strict=False
    )

    status: str = Field(pattern='^(success|error)$')
    data: dict
    timestamp: datetime = Field(default_factory=datetime.now)

# 사용 예시
response = APIResponse(
    status="success",
    data={"user_id": 123, "name": "홍길동"}
)

# frozen=True이므로 수정 불가
try:
    response.status = "error"  # 에러 발생!
except Exception as e:
    print(f"수정 불가: {e}")