from typing import Optional, Union

# Optional[X] = X | None (Python 3.10+)
def find_user(user_id: int) -> Optional[str]:
    """사용자를 찾으면 이름을, 못 찾으면 None을 반환합니다."""
    users = {1: "Alice", 2: "Bob"}
    return users.get(user_id)

# Python 3.10+ 문법: X | None
def find_user_new(user_id: int) -> str | None:
    users = {1: "Alice", 2: "Bob"}
    return users.get(user_id)

# Union - 여러 타입 중 하나
def process_input(data: Union[str, list[str]]) -> list[str]:
    """문자열 또는 문자열 리스트를 받아 리스트로 통일합니다."""
    if isinstance(data, str):
        return [data]
    return data

# Python 3.10+ 문법
def process_input_new(data: str | list[str]) -> list[str]:
    if isinstance(data, str):
        return [data]
    return data

from typing import Literal, TypedDict

# Literal - 허용되는 값을 제한
def set_device(device: Literal["cpu", "cuda", "mps"]) -> None:
    print(f"장치 설정: {device}")

set_device("cuda")   # OK
# set_device("tpu")  # mypy 에러: "tpu"는 허용되지 않음

# Literal로 모드 제한
def split_data(
    mode: Literal["train", "val", "test"],
    ratio: float = 0.8,
) -> None:
    print(f"모드: {mode}, 비율: {ratio}")

# TypedDict - 딕셔너리의 키별 타입 지정
class ModelConfig(TypedDict):
    name: str
    hidden_size: int
    num_layers: int
    dropout: float

config: ModelConfig = {
    "name": "bert-base",
    "hidden_size": 768,
    "num_layers": 12,
    "dropout": 0.1,
}

# total=False로 선택적 키 허용
class TrainingConfig(TypedDict, total=False):
    epochs: int
    learning_rate: float
    warmup_steps: int  # 선택적

partial_config: TrainingConfig = {"epochs": 10}  # OK

from typing import TypeVar, Generic

# TypeVar - 타입 변수 정의
T = TypeVar("T")

def first_element(items: list[T]) -> T:
    """리스트의 첫 번째 요소를 반환합니다."""
    return items[0]

# 타입이 자동으로 추론됨
name = first_element(["Alice", "Bob"])     # str로 추론
score = first_element([0.9, 0.8, 0.7])    # float로 추론

# 타입 범위 제한
Number = TypeVar("Number", int, float)

def add(a: Number, b: Number) -> Number:
    return a + b

# Generic 클래스 - 타입 매개변수를 가진 클래스
class DataLoader(Generic[T]):
    """범용 데이터 로더"""

    def __init__(self, data: list[T], batch_size: int = 32) -> None:
        self.data = data
        self.batch_size = batch_size

    def get_batch(self, index: int) -> list[T]:
        start = index * self.batch_size
        end = start + self.batch_size
        return self.data[start:end]

    def __len__(self) -> int:
        return (len(self.data) + self.batch_size - 1) // self.batch_size

# 사용
str_loader = DataLoader[str](["a", "b", "c"], batch_size=2)
int_loader = DataLoader[int]([1, 2, 3, 4, 5], batch_size=2)

from __future__ import annotations  # 모든 어노테이션을 문자열로 지연 평가
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    # 타입 검사 시에만 import (런타임에는 실행되지 않음)
    from torch import Tensor
    from model import MyModel

class Trainer:
    def __init__(self, model: "MyModel", lr: float = 0.001) -> None:
        self.model = model
        self.lr = lr

    def train_step(self, batch: "Tensor") -> float:
        """한 스텝 학습을 수행합니다."""
        loss = 0.0  # 실제 학습 로직
        return loss

from typing import TypeGuard

# isinstance로 타입 좁히기
def process(value: int | str) -> str:
    if isinstance(value, int):
        # 여기서 value는 int로 좁혀짐
        return str(value * 2)
    # 여기서 value는 str로 좁혀짐
    return value.upper()

# TypeGuard - 커스텀 타입 가드 (Python 3.10+)
def is_string_list(val: list[object]) -> TypeGuard[list[str]]:
    """리스트의 모든 요소가 문자열인지 확인합니다."""
    return all(isinstance(x, str) for x in val)

def process_items(items: list[object]) -> None:
    if is_string_list(items):
        # 여기서 items는 list[str]로 좁혀짐
        for item in items:
            print(item.upper())  # str 메서드 사용 가능

from __future__ import annotations
from typing import TypeVar, Generic, Literal, TypedDict
from collections.abc import Callable, Sequence

# 학습 설정 타입 정의
class HyperParams(TypedDict):
    learning_rate: float
    batch_size: int
    epochs: int
    optimizer: Literal["adam", "sgd", "adamw"]

# 메트릭 콜백 타입
MetricFn = Callable[[list[float], list[float]], float]

def evaluate(
    y_true: Sequence[float],
    y_pred: Sequence[float],
    metrics: dict[str, MetricFn],
) -> dict[str, float]:
    """여러 메트릭으로 모델을 평가합니다."""
    results: dict[str, float] = {}
    for name, metric_fn in metrics.items():
        results[name] = metric_fn(list(y_true), list(y_pred))
    return results

# 제네릭 결과 컨테이너
T = TypeVar("T")

class Result(Generic[T]):
    """성공/실패를 표현하는 결과 타입"""

    def __init__(self, value: T | None = None, error: str | None = None) -> None:
        self._value = value
        self._error = error

    @property
    def is_ok(self) -> bool:
        return self._error is None

    def unwrap(self) -> T:
        if self._error is not None:
            raise ValueError(self._error)
        assert self._value is not None
        return self._value

# 사용
def load_model(path: str) -> Result[dict[str, float]]:
    """모델 가중치를 로딩합니다."""
    try:
        weights = {"layer1": 0.5, "layer2": 0.3}
        return Result(value=weights)
    except FileNotFoundError:
        return Result(error=f"파일을 찾을 수 없습니다: {path}")

result = load_model("model.pt")
if result.is_ok:
    weights = result.unwrap()
    print(f"로딩 성공: {len(weights)}개 레이어")

# mypy 설치
pip install mypy

# 타입 검사 실행
mypy my_script.py

# 엄격 모드 (모든 함수에 타입 필수)
mypy --strict my_script.py

# pyproject.toml에 mypy 설정
# [tool.mypy]
# python_version = "3.12"
# warn_return_any = true
# warn_unused_configs = true
# disallow_untyped_defs = true