FastAPI 개발을 위한 Python 타입 힌트 알아보기

from fastapi import FastAPI
 
app = FastAPI()
 
def get_response(param: str):
    return {"message": f"Hello {param}"}
 
@app.get("/")
def example_route(example_param: str):
    return get_response(example_param)
 

from pydantic import BaseModel, EmailStr, model_validator, field_validator
 
 
class RegisterUserRequest(BaseModel):
    email: EmailStr | None = None
    password: str | None = None
    password_confirmation: str = None
 
    @field_validator("password")
    @classmethod
    def validate(cls, value):
        if len(value) < 8:
            raise ValueError("비밀번호는 8자 이상이어야 합니다.")
        if not any(char.isdigit() for char in value):
            raise ValueError("비밀번호는 숫자를 포함해야 합니다.")
        if not any(char.isalpha() for char in value):
            raise ValueError("비밀번호는 문자를 포함해야 합니다.")
        if not any(char.isupper() for char in value):
            raise ValueError("비밀번호는 대문자를 포함해야 합니다.")
 
        return value
 
    @model_validator(mode="before")
    @classmethod
    def validate_password(cls, data):
        password = data.get("password")
        password_confirmation = data.get("password_confirmation")
 
        if password != password_confirmation:
            raise ValueError("비밀번호 확인이 일치하지 않습니다.")
        return data
 
# 다음과 같은 방식으로 Pydantic 모델을 사용할 수 있음
async def check_email_exists(data: Annotated[RegisterUserRequest, Form()], db: DB) -> RegisterUserRequest:
    user = await user_orm.get_by_filters(db, columns=["email"], email=data.email)
    if user:
        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="이미 존재하는 이메일입니다.", code="EMAIL_EXISTS")
    return data
 
async def register_user_by_email(vaild_data: Annotated[RegisterUserRequest, Depends(check_email_exists)], db: DB) -> dict:
    data = vaild_data.model_dump()
    password = PasswordService.get_password_hash(data.get("password"))
    data = {
        "email": data.get("email"),
        "password": password,
    }
 
    user = await user_orm.create(db, **data)
    result = {
        "id": user.id,
        "email": user.email,
    }
    return result

def add(param_1: str, param_2: str) -> str:
    return param_1 + param_2

def add2(param_1: str | int, param_2: str | int) -> str | int:
    return param_1 + param_2

def example_function(
    param_1: list[str],           # 문자열 리스트
    param_2: tuple[int, float],   # 정수와 실수로 이루어진 튜플
    param_3: dict[str, int]       # 문자열 키와 정수 값을 가진 딕셔너리
):
    ...

from typing import Callable, Iterable
 
# 숫자 리스트에서 필터 조건을 만족하는 숫자만 추출
def filter_numbers(numbers: Iterable[int], condition: Callable[[int], bool]) -> Iterable[int]:
    """
    숫자 Iterable과 필터 조건을 받아 조건을 만족하는 숫자만 반환합니다.
 
    :param numbers: 숫자가 포함된 Iterable
    :param condition: 숫자를 입력으로 받아 True/False를 반환하는 함수
    :return: 조건을 만족하는 숫자 Iterable
    """
    return (num for num in numbers if condition(num))
 
# 문자열을 받아 각 문자열의 길이를 반환
def get_string_lengths(strings: Iterable[str]) -> Iterable[int]:
    """
    문자열 Iterable을 받아 각 문자열의 길이를 계산합니다.
 
    :param strings: 문자열이 포함된 Iterable
    :return: 각 문자열 길이의 Iterable
    """
    return (len(s) for s in strings)

from typing import TypeVar, Callable
 
T = TypeVar('T')  # 입력 타입
R = TypeVar('R')  # 출력 타입
 
def transform(items: list[T], transformer: Callable[[T], R]) -> list[R]:
    """
    리스트의 각 아이템을 주어진 변환 함수를 이용해 변환합니다.
 
    :param items: 변환할 원본 리스트
    :param transformer: 변환 함수 (입력 타입 T -> 출력 타입 R)
    :return: 변환된 리스트
    """
    return [transformer(item) for item in items]

from math import sqrt
 
class Point:
    """
    2차원 좌표를 나타내는 클래스
    """
    def __init__(self, x: float, y: float) -> None:
        self.x = x
        self.y = y
 
def distance(point1: Point, point2: Point) -> float:
    """
    두 점 사이의 거리를 계산합니다.
 
    :param point1: 첫 번째 점
    :param point2: 두 번째 점
    :return: 두 점 사이의 거리
    """
    return sqrt((point2.x - point1.x) ** 2 + (point2.y - point1.y) ** 2)

from typing import Annotated
 
# Annotated[기본 타입, 메타데이터]
# 처음 예시 코드
data: Annotated[RegisterUserRequest, Form()]
 
# 변수에 할당해서 재활용 가능
DB = Annotated[AsyncSession, Depends(get_db)]
 
# FastAPI에서 이런 방식으로 의존성 주입 가능
db: DB