快速开始

import time, openai

def call_with_retry(client, **kwargs):
    max_retries = 3
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(**kwargs)
        except openai.RateLimitError:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt   # 1s, 2s, 4s
            print(f"Rate limited, retrying in {wait}s...")
            time.sleep(wait)
        except openai.APIStatusError as e:
            if e.status_code in (500, 502, 503) and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise

FALLBACK_CHAIN = [
    "claude-4-sonnet",   # 主模型
    "gpt-4o",            # 备选1
    "gemini-2.5-pro",    # 备选2
    "deepseek-v3",       # 备选3（成本最低）
]

def call_with_fallback(client, messages):
    last_error = None
    for model in FALLBACK_CHAIN:
        try:
            return client.chat.completions.create(
                model=model,
                messages=messages,
                timeout=30,
            )
        except (openai.APIStatusError, openai.APIConnectionError) as e:
            print(f"Model {model} failed: {e}, trying next...")
            last_error = e
    raise last_error

import time
from collections import defaultdict

class CircuitBreaker:
    def __init__(self, failure_threshold=5, recovery_timeout=60):
        self.failures = defaultdict(int)
        self.last_failure_time = {}
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout  # seconds

    def is_open(self, model: str) -> bool:
        """True = 熔断中，不应发请求"""
        if self.failures[model] < self.failure_threshold:
            return False
        elapsed = time.time() - self.last_failure_time.get(model, 0)
        if elapsed > self.recovery_timeout:
            self.failures[model] = 0  # 半开状态，允许重试
            return False
        return True

    def record_failure(self, model: str):
        self.failures[model] += 1
        self.last_failure_time[model] = time.time()

    def record_success(self, model: str):
        self.failures[model] = 0

cb = CircuitBreaker()

def safe_call(client, model, messages):
    if cb.is_open(model):
        raise Exception(f"{model} is circuit-broken, skip")
    try:
        result = client.chat.completions.create(model=model, messages=messages)
        cb.record_success(model)
        return result
    except Exception as e:
        cb.record_failure(model)
        raise

import uuid

request_id = str(uuid.uuid4())

response = client.chat.completions.create(
    model="claude-4-sonnet",
    messages=[{"role": "user", "content": "hello"}],
    extra_headers={"X-Request-ID": request_id},
)

# 如果出问题，把 request_id 发给支持团队
print(f"Request ID: {request_id}")

import threading, time

class TokenBucket:
    def __init__(self, rate=10, burst=20):  # rate: 每秒补充, burst: 最大积攒
        self.tokens = burst
        self.rate = rate
        self.burst = burst
        self.last = time.monotonic()
        self.lock = threading.Lock()

    def acquire(self):
        with self.lock:
            now = time.monotonic()
            self.tokens = min(self.burst, self.tokens + (now - self.last) * self.rate)
            self.last = now
            if self.tokens >= 1:
                self.tokens -= 1
                return True
            return False  # 被限流，调用方应等待或排队

bucket = TokenBucket(rate=10, burst=20)  # 10 RPM 客户端限流