import time
from openai import OpenAI, RateLimitError, APIError

client = OpenAI(api_key="your-api-key")

def call_llm_with_retry(messages, max_retries=3):
    """带重试机制的 LLM 调用"""
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=messages,
                temperature=0.7,
                timeout=30  # 超时设置
            )
            return response.choices[0].message.content

        except RateLimitError:
            # Rate Limit 错误：等待后重试
            wait_time = (attempt + 1) * 2
            print(f"Rate limit, waiting {wait_time}s...")
            time.sleep(wait_time)

        except APIError as e:
            # API 错误：检查是否可恢复
            if "server_error" in str(e):
                print(f"Server error, retry {attempt + 1}/{max_retries}")
                time.sleep(2)
            else:
                raise  # 其他错误直接抛出

        except Exception as e:
            print(f"Unknown error: {e}")
            raise

    raise Exception("Max retries exceeded")

from openai import OpenAI

client = OpenAI(api_key="your-api-key")

# 启用流式输出
stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "写一首关于春天的诗"}],
    stream=True  # 开启流式
)

# 逐块解析响应
full_content = ""
chunk_count = 0

for chunk in stream:
    if chunk.choices[0].delta.content:
        content_chunk = chunk.choices[0].delta.content
        full_content += content_chunk
        chunk_count += 1
        print(f"[Chunk {chunk_count}] {content_chunk}", end="", flush=True)

print(f"\n\n总块数: {chunk_count}")
print(f"完整内容长度: {len(full_content)} 字符")

# 流式响应结构
# {
#     "id": "chatcmpl-...",
#     "object": "chat.completion.chunk",
#     "created": 1690000000,
#     "model": "gpt-4o",
#     "choices": [{
#         "index": 0,
#         "delta": {"content": "春", "role": "assistant"},
#         "finish_reason": null
#     }]
# }

from openai import OpenAI, RateLimitError, APIError, AuthenticationError

client = OpenAI(api_key="your-api-key")

def parse_error_response(error):
    """解析错误响应并提供处理建议"""
    
    if isinstance(error, AuthenticationError):
        # 认证错误
        print(f"❌ 认证失败: {error}")
        print("💡 解决：检查 API Key 是否正确、是否有效")
        return {"type": "auth", "action": "check_api_key"}
    
    elif isinstance(error, RateLimitError):
        # 速率限制
        print(f"🚫 速率限制: {error}")
        if "rate limit" in str(error).lower():
            print("💡 解决：等待后重试，或申请提高限额")
        return {"type": "rate_limit", "action": "retry_after"}
    
    elif isinstance(error, APIError):
        # API 服务器错误
        print(f"⚠️ API 错误: {error.status_code} - {error.message}")
        if 500 <= error.status_code < 600:
            print("💡 解决：服务器错误，等待后重试")
            return {"type": "server_error", "action": "retry"}
        else:
            print("💡 解决：检查请求参数是否正确")
            return {"type": "client_error", "action": "fix_request"}
    
    else:
        print(f"❓ 未知错误: {error}")
        return {"type": "unknown", "action": "investigate"}

# 使用示例
try:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello"}]
    )
except Exception as e:
    error_info = parse_error_response(e)
    print(f"错误类型: {error_info['type']}, 建议操作: {error_info['action']}")

from dataclasses import dataclass
from typing import List, Dict
from datetime import datetime

@dataclass
class APIResponseStats:
    """API 响应统计"""
    request_id: str
    model: str
    prompt_tokens: int
    completion_tokens: int
    total_tokens: int
    response_time: float  # 秒
    timestamp: datetime

class ResponseAnalyzer:
    """响应分析器 - 统计和监控 API 使用情况"""
    
    def __init__(self):
        self.history: List[APIResponseStats] = []
    
    def record_response(self, response, response_time: float):
        """记录一次响应"""
        stats = APIResponseStats(
            request_id=response.id,
            model=response.model,
            prompt_tokens=response.usage.prompt_tokens,
            completion_tokens=response.usage.completion_tokens,
            total_tokens=response.usage.total_tokens,
            response_time=response_time,
            timestamp=datetime.now()
        )
        self.history.append(stats)
    
    def get_statistics(self) -> Dict:
        """获取统计信息"""
        if not self.history:
            return {}
        
        total_requests = len(self.history)
        total_tokens = sum(s.total_tokens for s in self.history)
        total_prompt = sum(s.prompt_tokens for s in self.history)
        total_completion = sum(s.completion_tokens for s in self.history)
        avg_response_time = sum(s.response_time for s in self.history) / total_requests
        
        return {
            "总请求数": total_requests,
            "总Token消耗": total_tokens,
            "输入Token": total_prompt,
            "输出Token": total_completion,
            "平均响应时间": f"{avg_response_time:.2f}s",
            "平均每请求Token": total_tokens // total_requests
        }
    
    def get_model_usage(self, model_name: str) -> Dict:
        """获取特定模型的使用统计"""
        model_stats = [s for s in self.history if s.model == model_name]
        if not model_stats:
            return {}
        
        return {
            "模型": model_name,
            "请求次数": len(model_stats),
            "总Token": sum(s.total_tokens for s in model_stats)
        }

# 使用示例
analyzer = ResponseAnalyzer()

# 记录 API 调用
import time

start = time.time()
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "你好"}]
)
elapsed = time.time() - start

analyzer.record_response(response, elapsed)

# 查看统计
stats = analyzer.get_statistics()
for key, value in stats.items():
    print(f"{key}: {value}")