# install_sdk.py
# 安装Anthropic Python SDK
# pip install anthropic

import anthropic

client = anthropic.Anthropic(
    api_key="your-api-key-here"  # 建议使用环境变量: os.environ.get("ANTHROPIC_API_KEY")
)

def ask_claude(prompt, system="你是一位资深软件工程师。"):
    """基础API调用封装"""
    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        system=system,
        messages=[
            {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

# 测试调用
response = ask_claude("用Python写一个快速排序算法")
print(response)

# main.py - 任务管理API核心实现
from datetime import datetime
from typing import Optional
from fastapi import FastAPI, Depends, HTTPException, Query
from fastapi.middleware.gin import GZipMiddleware
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker, DeclarativeBase, Mapped, mapped_column
from sqlalchemy import String, Boolean, DateTime, func, or_
from pydantic import BaseModel, Field, ConfigDict
from contextlib import asynccontextmanager
import asyncio

# ============ 数据库配置 ============
DATABASE_URL = "postgresql+asyncpg://user:pass@localhost/taskdb"
engine = create_async_engine(DATABASE_URL, echo=False)
async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)


class Base(DeclarativeBase):
    pass


# ============ 数据模型 ============
class Task(Base):
    __tablename__ = "tasks"

    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
    title: Mapped[str] = mapped_column(String(200), nullable=False, index=True)
    description: Mapped[Optional[str]] = mapped_column(String(2000))
    is_completed: Mapped[bool] = mapped_column(Boolean, default=False, index=True)
    priority: Mapped[int] = mapped_column(default=0)  # 0=低, 1=中, 2=高
    is_deleted: Mapped[bool] = mapped_column(Boolean, default=False, index=True)
    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now())
    updated_at: Mapped[datetime] = mapped_column(
        DateTime, server_default=func.now(), onupdate=func.now()
    )


# ============ Pydantic Schema ============
class TaskCreate(BaseModel):
    model_config = ConfigDict(strict=True)

    title: str = Field(..., min_length=1, max_length=200)
    description: Optional[str] = Field(None, max_length=2000)
    priority: int = Field(default=0, ge=0, le=2)


class TaskUpdate(BaseModel):
    model_config = ConfigDict(strict=True)

    title: Optional[str] = Field(None, min_length=1, max_length=200)
    description: Optional[str] = Field(None, max_length=2000)
    is_completed: Optional[bool] = None
    priority: Optional[int] = Field(None, ge=0, le=2)


class TaskResponse(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    title: str
    description: Optional[str]
    is_completed: bool
    priority: int
    created_at: datetime
    updated_at: datetime


class PaginatedResponse(BaseModel):
    items: list[TaskResponse]
    total: int
    page: int
    page_size: int


# ============ 依赖注入 ============
async def get_db():
    async with async_session() as session:
        try:
            yield session
        finally:
            await session.close()


# ============ 路由 ============
@asynccontextmanager
async def lifespan(app: FastAPI):
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    yield
    await engine.dispose()


app = FastAPI(
    title="任务管理API",
    version="1.0.0",
    lifespan=lifespan,
)
app.add_middleware(GZipMiddleware, minimum_size=1000)


@app.post("/api/tasks", response_model=TaskResponse, status_code=201)
async def create_task(data: TaskCreate, db: AsyncSession = Depends(get_db)):
    """创建新任务"""
    task = Task(**data.model_dump())
    db.add(task)
    await db.commit()
    await db.refresh(task)
    return task


@app.get("/api/tasks", response_model=PaginatedResponse)
async def list_tasks(
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    search: Optional[str] = Query(None),
    priority: Optional[int] = Query(None, ge=0, le=2),
    is_completed: Optional[bool] = None,
    db: AsyncSession = Depends(get_db),
):
    """获取任务列表，支持分页、搜索和过滤"""
    query = (
        db.query(Task)
        .filter(Task.is_deleted == False)
        .order_by(Task.created_at.desc())
    )

    if search:
        pattern = f"%{search}%"
        query = query.filter(
            or_(Task.title.ilike(pattern), Task.description.ilike(pattern))
        )

    if priority is not None:
        query = query.filter(Task.priority == priority)

    if is_completed is not None:
        query = query.filter(Task.is_completed == is_completed)

    total = await db.scalar(query.with_entities(func.count()).select())
    items = await db.scalars(
        query.offset((page - 1) * page_size).limit(page_size)
    )

    return PaginatedResponse(
        items=items.all(),
        total=total,
        page=page,
        page_size=page_size,
    )


@app.delete("/api/tasks/{task_id}", status_code=204)
async def soft_delete_task(task_id: int, db: AsyncSession = Depends(get_db)):
    """软删除任务"""
    task = await db.get(Task, task_id)
    if not task or task.is_deleted:
        raise HTTPException(status_code=404, detail="任务不存在")
    task.is_deleted = True
    await db.commit()

# 安全的配置方式
import os
from anthropic import Anthropic

# 从环境变量读取，而非硬编码
client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

# 如果需要传递配置给Claude，使用脱敏后的示例
prompt = """
数据库配置如下（已脱敏）：
- host: db.example.com
- port: 5432
- database: myapp_production
请基于以上信息生成SQLAlchemy连接字符串模板。
"""

# cached_claude.py - 带缓存的Claude调用封装
import hashlib
import json
import functools
from anthropic import Anthropic

client = Anthropic()

def claude_cache(ttl_seconds=3600):
    """Claude响应缓存装饰器"""
    def decorator(func):
        cache = {}

        @functools.wraps(func)
        def wrapper(prompt, **kwargs):
            # 生成缓存键
            cache_key = hashlib.md5(
                json.dumps({"prompt": prompt, "kwargs": kwargs}, sort_keys=True).encode()
            ).hexdigest()

            # 检查缓存
            if cache_key in cache:
                result, timestamp = cache[cache_key]
                import time
                if time.time() - timestamp < ttl_seconds:
                    print(f"[缓存命中] {cache_key[:8]}...")
                    return result

            # 调用API
            result = func(prompt, **kwargs)
            cache[cache_key] = (result, time.time())
            return result

        return wrapper
    return decorator


@claude_cache(ttl_seconds=1800)
def generate_code(prompt: str, language: str = "python") -> str:
    """带缓存的代码生成"""
    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        system=f"你是一位资深{language}工程师。",
        messages=[{"role": "user", "content": prompt}],
    )
    return message.content[0].text

# model_router.py - 根据任务复杂度路由到不同模型
def route_to_model(task_complexity: str) -> str:
    """
    根据任务复杂度选择模型：
    - simple: claude-3-5-haiku（快速、便宜，适合简单任务）
    - medium: claude-sonnet-4（平衡性能和成本）
    - complex: claude-opus-4（最强能力，适合复杂架构设计）
    """
    model_map = {
        "simple": "claude-3-5-haiku-20241022",
        "medium": "claude-sonnet-4-20250514",
        "complex": "claude-opus-4-20250514",
    }
    return model_map.get(task_complexity, "claude-sonnet-4-20250514")


# 使用示例
def generate_with_routing(prompt: str):
    # 简单任务：单文件代码片段、格式转换、简单Bug修复
    if len(prompt) < 200 and any(kw in prompt for kw in ["格式化", "转换", "简单"]):
        model = route_to_model("simple")
    # 复杂任务：架构设计、多文件重构、性能优化
    elif any(kw in prompt for kw in ["架构", "重构", "优化", "设计"]):
        model = route_to_model("complex")
    else:
        model = route_to_model("medium")

    return ask_claude(prompt, model=model)

# context_compressor.py - 上下文压缩工具
def compress_code_context(files: dict[str, str]) -> str:
    """
    智能压缩代码上下文：
    1. 去除空行和纯注释行
    2. 保留函数签名和类定义
    3. 压缩重复的import语句
    """
    compressed = {}
    for filepath, content in files.items():
        lines = content.split('\n')
        essential_lines = []
        for line in lines:
            stripped = line.strip()
            # 保留有意义的代码行
            if (stripped and
                not stripped.startswith('#') and
                not stripped.startswith('//') and
                stripped != ''):
                essential_lines.append(line)

        compressed[filepath] = '\n'.join(essential_lines)

    return '\n\n'.join(
        f"// {path}\n{code}" for path, code in compressed.items()
    )