Pydantic V2, FastAPI에서 제대로 쓰는 법

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int
    email: str | None = None

user = User(name="강돈혁", age="25")
print(user.age)        # 25 (int)
print(user.email)      # None
print(user.model_dump())
# {'name': '강돈혁', 'age': 25, 'email': None}

from pydantic import BaseModel, Field

class Product(BaseModel):
    name: str = Field(min_length=1, max_length=100)
    price: int = Field(gt=0, description="상품 가격 (원)")
    tags: list[str] = Field(default_factory=list, max_length=10)

from pydantic import BaseModel, ConfigDict

class StrictUser(BaseModel):
    model_config = ConfigDict(
        str_strip_whitespace=True,
        strict=True,
        frozen=True,
    )

    name: str
    age: int

from pydantic import BaseModel, Field
from typing import Annotated

class Order(BaseModel):
    user_id: Annotated[int, Field(strict=True)]  # 이 필드만 strict
    quantity: int  # "3" → 3 변환 허용

from pydantic import BaseModel, field_validator

class UserCreate(BaseModel):
    username: str
    password: str

    @field_validator("username")
    @classmethod
    def username_must_be_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("대문자를 1개 이상 포함해야 합니다")
        return v

# pydantic/functional_validators.py
if _decorators.is_instance_method_from_sig(f):
    raise PydanticUserError(
        'The `@field_validator` decorator cannot be applied to instance methods',
        code='validator-instance-method',
    )

# auto apply the @classmethod decorator
f = _decorators.ensure_classmethod_based_on_signature(f)

class UserProfile(BaseModel):
    name: str
    email: str

    @field_validator("email", mode="before")
    @classmethod
    def normalize_email(cls, v: str) -> str:
        """타입 변환 전에 실행되는 before 모드"""
        if isinstance(v, str):
            return v.lower().strip()
        return v

from datetime import date
from pydantic import BaseModel, model_validator

class DateRange(BaseModel):
    start_date: date
    end_date: date

    @model_validator(mode="after")
    def check_date_order(self) -> "DateRange":
        if self.start_date >= self.end_date:
            raise ValueError("end_date는 start_date보다 이후여야 합니다")
        return self

class APIRequest(BaseModel):
    auth_type: str
    api_key: str | None = None
    username: str | None = None
    password: str | None = None

    @model_validator(mode="before")
    @classmethod
    def check_auth_fields(cls, data: dict) -> dict:
        auth_type = data.get("auth_type")
        if auth_type == "api_key" and not data.get("api_key"):
            raise ValueError("api_key 인증에는 api_key가 필수입니다")
        if auth_type == "basic":
            if not data.get("username") or not data.get("password"):
                raise ValueError("basic 인증에는 username, password가 필수입니다")
        return data

class UserResponse(BaseModel):
    id: int
    name: str
    email: str | None = None
    internal_score: float = Field(exclude=True)

user = UserResponse(id=1, name="강돈혁", email=None, internal_score=0.95)

# 기본 변환
user.model_dump()
# {'id': 1, 'name': '강돈혁', 'email': None}
# → internal_score는 exclude=True이므로 제외됨

# None 값 제외
user.model_dump(exclude_none=True)
# {'id': 1, 'name': '강돈혁'}

# 특정 필드만 포함
user.model_dump(include={"id", "name"})
# {'id': 1, 'name': '강돈혁'}

user.model_dump_json()
# '{"id":1,"name":"강돈혁","email":null}'

from datetime import datetime
from pydantic import BaseModel, field_serializer

class Event(BaseModel):
    name: str
    created_at: datetime

    @field_serializer("created_at")
    def serialize_dt(self, dt: datetime, _info) -> str:
        return dt.strftime("%Y-%m-%d %H:%M")

event = Event(name="배포", created_at=datetime(2026, 4, 8, 14, 30))
event.model_dump()
# {'name': '배포', 'created_at': '2026-04-08 14:30'}

from pydantic import BaseModel, computed_field

class UserProfile(BaseModel):
    first_name: str
    last_name: str
    birth_year: int

    @computed_field
    @property
    def full_name(self) -> str:
        return f"{self.last_name}{self.first_name}"

    @computed_field
    @property
    def age(self) -> int:
        from datetime import datetime
        return datetime.now().year - self.birth_year

profile = UserProfile(first_name="돈혁", last_name="강", birth_year=1995)
profile.model_dump()
# {'first_name': '돈혁', 'last_name': '강', 'birth_year': 1995,
#  'full_name': '강돈혁', 'age': 31}  # age는 현재 연도 기준 계산

from typing import Annotated
from pydantic import Field

# 재사용 가능한 타입 정의
UserId = Annotated[int, Field(gt=0, description="사용자 ID")]
Username = Annotated[str, Field(min_length=3, max_length=20, pattern=r"^[a-zA-Z0-9_]+$")]
Email = Annotated[str, Field(max_length=255, pattern=r"^[\w\.-]+@[\w\.-]+\.\w+$")]

from pydantic import BaseModel

class UserCreate(BaseModel):
    username: Username
    email: Email

class UserUpdate(BaseModel):
    username: Username | None = None
    email: Email | None = None

class AdminCreate(BaseModel):
    user_id: UserId
    username: Username
    email: Email
    role: str

from typing import Annotated
from fastapi import FastAPI, Query

app = FastAPI()

PageSize = Annotated[int, Query(ge=1, le=100, description="페이지당 항목 수")]
PageNumber = Annotated[int, Query(ge=1, description="페이지 번호")]

@app.get("/users")
def list_users(page: PageNumber = 1, size: PageSize = 20):
    return {"page": page, "size": size}

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

class EmailNotification(BaseModel):
    channel: Literal["email"]
    to: str
    subject: str

class SlackNotification(BaseModel):
    channel: Literal["slack"]
    webhook_url: str

class SMSNotification(BaseModel):
    channel: Literal["sms"]
    phone: str

Notification = Annotated[
    Union[EmailNotification, SlackNotification, SMSNotification],
    Field(discriminator="channel")
]

from fastapi import FastAPI

app = FastAPI()

@app.post("/notifications")
def send_notification(notification: Notification):
    match notification:
        case EmailNotification():
            return {"type": "email", "to": notification.to}
        case SlackNotification():
            return {"type": "slack", "url": notification.webhook_url}
        case SMSNotification():
            return {"type": "sms", "phone": notification.phone}

pip install pydantic-settings

from pydantic_settings import BaseSettings, SettingsConfigDict

class Settings(BaseSettings):
    model_config = SettingsConfigDict(
        env_file=".env",
        env_file_encoding="utf-8",
        case_sensitive=False,
    )

    app_name: str = "MyApp"
    debug: bool = False
    database_url: str
    redis_url: str = "redis://localhost:6379"
    allowed_origins: list[str] = ["http://localhost:3000"]

# .env
DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
DEBUG=true
ALLOWED_ORIGINS=["http://localhost:3000","https://example.com"]

settings = Settings()
print(settings.debug)            # True (str → bool 자동 변환)
print(settings.allowed_origins)  # ['http://localhost:3000', 'https://example.com']

from functools import lru_cache
from fastapi import FastAPI, Depends

app = FastAPI()

@lru_cache
def get_settings() -> Settings:
    return Settings()

@app.get("/info")
def app_info(settings: Settings = Depends(get_settings)):
    return {
        "app_name": settings.app_name,
        "debug": settings.debug,
    }

from pydantic import BaseModel
from pydantic_settings import BaseSettings, SettingsConfigDict

class DatabaseConfig(BaseModel):
    host: str = "localhost"
    port: int = 5432
    name: str = "mydb"

class Settings(BaseSettings):
    model_config = SettingsConfigDict(
        env_file=".env",
        env_nested_delimiter="__",
    )

    database: DatabaseConfig = DatabaseConfig()

# .env
DATABASE__HOST=prod-db.example.com
DATABASE__PORT=5432
DATABASE__NAME=production

from pydantic import TypeAdapter

# 정수 리스트 검증
int_list_adapter = TypeAdapter(list[int])

result = int_list_adapter.validate_python(["1", "2", "3"])
print(result)  # [1, 2, 3]

# 유효하지 않은 입력
try:
    int_list_adapter.validate_python(["a", "b"])
except Exception as e:
    print(e)  # validation error

from pydantic import BaseModel, TypeAdapter

class UserSummary(BaseModel):
    id: int
    name: str

# 외부 API에서 받은 JSON 리스트를 검증
users_adapter = TypeAdapter(list[UserSummary])

raw_data = [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Bob"},
]

users = users_adapter.validate_python(raw_data)
# [UserSummary(id=1, name='Alice'), UserSummary(id=2, name='Bob')]

# JSON 문자열에서 직접 파싱
json_str = '[{"id": 1, "name": "Alice"}]'
users = users_adapter.validate_json(json_str)

class UserResponse(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    name: str
    email: str

# SQLAlchemy 모델 인스턴스에서 바로 변환
user_response = UserResponse.model_validate(db_user)