# 좋은 설계 - 리소스 중심
GET    /api/v1/models                  # 모델 목록
POST   /api/v1/models                  # 모델 등록
GET    /api/v1/models/{model_id}       # 특정 모델 조회
PUT    /api/v1/models/{model_id}       # 모델 전체 수정
PATCH  /api/v1/models/{model_id}       # 모델 부분 수정
DELETE /api/v1/models/{model_id}       # 모델 삭제

# 중첩 리소스
GET    /api/v1/models/{model_id}/versions
POST   /api/v1/models/{model_id}/versions
GET    /api/v1/models/{model_id}/versions/{version_id}

# 액션이 필요한 경우 (리소스로 표현하기 어려울 때)
POST   /api/v1/models/{model_id}/deploy
POST   /api/v1/chat/completions

# openapi.yaml 예시 (간략)
openapi: "3.1.0"
info:
  title: "ML Model API"
  version: "1.0.0"
paths:
  /models:
    get:
      summary: "모델 목록 조회"
      responses:
        "200":
          description: "성공"
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: "#/components/schemas/Model"
  /models/{model_id}/predict:
    post:
      summary: "모델 추론"
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/PredictRequest"

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI(title="ML Model API", version="1.0.0")

class PredictRequest(BaseModel):
    text: str
    max_tokens: int = 100

class PredictResponse(BaseModel):
    prediction: str
    confidence: float

@app.post("/models/{model_id}/predict", response_model=PredictResponse)
async def predict(model_id: str, request: PredictRequest):
    # 모델 추론 로직
    return PredictResponse(prediction="긍정", confidence=0.95)

# /docs → Swagger UI 자동 생성
# /openapi.json → OpenAPI 스펙 자동 생성

from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import JSONResponse
import time

# 간단한 인메모리 Rate Limiter (프로덕션에서는 Redis 사용)
rate_limits: dict[str, list[float]] = {}

@app.middleware("http")
async def rate_limit_middleware(request: Request, call_next):
    client_ip = request.client.host
    now = time.time()
    window = 60  # 1분
    max_requests = 60  # 분당 60회

    # 이전 기록 정리 및 현재 요청 추가
    rate_limits.setdefault(client_ip, [])
    rate_limits[client_ip] = [t for t in rate_limits[client_ip] if now - t < window]

    if len(rate_limits[client_ip]) >= max_requests:
        return JSONResponse(
            status_code=429,
            content={"error": "rate_limit_exceeded", "retry_after": window},
            headers={
                "X-RateLimit-Limit": str(max_requests),
                "X-RateLimit-Remaining": "0",
                "Retry-After": str(window),
            },
        )

    rate_limits[client_ip].append(now)
    response = await call_next(request)
    response.headers["X-RateLimit-Limit"] = str(max_requests)
    response.headers["X-RateLimit-Remaining"] = str(max_requests - len(rate_limits[client_ip]))
    return response

from openai import OpenAI

client = OpenAI()

# 스트리밍 응답
stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Python의 장점 3가지"}],
    stream=True,  # SSE 스트리밍 활성화
    max_tokens=500,
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI()

async def process_single(prompt: str) -> str:
    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=200,
    )
    return response.choices[0].message.content

async def process_batch(prompts: list[str], concurrency: int = 5) -> list[str]:
    semaphore = asyncio.Semaphore(concurrency)  # 동시 요청 제한

    async def limited_process(prompt):
        async with semaphore:
            return await process_single(prompt)

    tasks = [limited_process(p) for p in prompts]
    return await asyncio.gather(*tasks)

# 사용
prompts = ["질문1", "질문2", "질문3", "질문4", "질문5"]
results = asyncio.run(process_batch(prompts, concurrency=3))

# SDK 방식 - 간결하고 안전
from openai import OpenAI, RateLimitError

client = OpenAI()
try:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello"}],
    )
    print(response.choices[0].message.content)
except RateLimitError as e:
    print(f"Rate limited: {e}")

# HTTP 직접 호출 - 유연하지만 수동 관리 필요
import requests

response = requests.post(
    "https://api.openai.com/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    },
    json={
        "model": "gpt-4o",
        "messages": [{"role": "user", "content": "Hello"}],
    },
    timeout=(5, 120),
)
if response.status_code == 429:
    retry_after = response.headers.get("Retry-After", 60)
    # 재시도 로직 직접 구현 필요

{
  "type": "https://api.example.com/errors/rate-limit-exceeded",
  "title": "Rate Limit Exceeded",
  "status": 429,
  "detail": "분당 60회 요청 제한을 초과했습니다. 43초 후 재시도하세요.",
  "instance": "/v1/chat/completions",
  "retry_after": 43
}

from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import JSONResponse

@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
    return JSONResponse(
        status_code=exc.status_code,
        content={
            "type": f"https://api.example.com/errors/{exc.status_code}",
            "title": exc.detail if isinstance(exc.detail, str) else "Error",
            "status": exc.status_code,
            "detail": str(exc.detail),
            "instance": str(request.url.path),
        },
    )