API参考文档

class GenerateUIRequest(BaseModel):
    prompt: str = Field(..., description="中文Prompt描述", min_length=1, max_length=500)
    model_path: Optional[str] = Field(None, description="模型路径")
    lora_path: Optional[str] = Field(None, description="LoRA权重路径")
    use_rules: bool = Field(False, description="是否强制使用规则生成")
    output_format: str = Field("json", description="输出格式", regex="^(json|png|vue)$")

class RenderRequest(BaseModel):
    dsl: Dict[str, Any] = Field(..., description="UI-DSL数据")
    output_format: str = Field("png", description="输出格式", regex="^(png|vue)$")

class GenerateUIResponse(BaseModel):
    success: bool
    message: str
    data: Optional[Dict[str, Any]] = None
    method: Optional[str] = None
    error: Optional[str] = None
    timestamp: Optional[str] = None

class RenderResponse(BaseModel):
    success: bool
    message: str
    data: Optional[str] = None  # Base64编码的图片或Vue代码
    error: Optional[str] = None
    timestamp: Optional[str] = None

class HealthResponse(BaseModel):
    status: str
    version: str
    model_loaded: bool
    timestamp: Optional[str] = None
    uptime: Optional[int] = None

class Page(BaseModel):
    name: str
    theme: str
    layout: Layout
    sections: List[Section]

class Layout(BaseModel):
    grid: int = 12
    gutter: int = 16
    padding: int = 16
    bg: str

class Section(BaseModel):
    type: str
    props: Dict[str, Any]

# Python客户端错误处理
import requests

def generate_ui(prompt: str, api_key: str):
    try:
        response = requests.post(
            "http://localhost:8000/generate-ui",
            headers={"Authorization": f"Bearer {api_key}"},
            json={"prompt": prompt, "output_format": "json"},
            timeout=30
        )
        response.raise_for_status()
        return response.json()
    
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 400:
            error_data = e.response.json()
            print(f"请求错误: {error_data['message']}")
        elif e.response.status_code == 429:
            print("请求频率过高，请稍后重试")
        elif e.response.status_code == 500:
            print("服务器内部错误，请稍后重试")
        else:
            print(f"HTTP错误: {e.response.status_code}")
    
    except requests.exceptions.Timeout:
        print("请求超时，请稍后重试")
    
    except requests.exceptions.RequestException as e:
        print(f"请求失败: {e}")

import requests
import json
import base64
from typing import Dict, Any, Optional

class AIUIClient:
    def __init__(self, base_url: str = "http://localhost:8000", api_key: str = None):
        self.base_url = base_url
        self.headers = {
            "Content-Type": "application/json"
        }
        if api_key:
            self.headers["Authorization"] = f"Bearer {api_key}"
    
    def generate_ui(self, prompt: str, output_format: str = "json", 
                   model_path: str = None, use_rules: bool = False) -> Dict[str, Any]:
        """生成UI设计"""
        data = {
            "prompt": prompt,
            "output_format": output_format,
            "use_rules": use_rules
        }
        
        if model_path:
            data["model_path"] = model_path
        
        response = requests.post(
            f"{self.base_url}/generate-ui",
            headers=self.headers,
            json=data,
            timeout=30
        )
        response.raise_for_status()
        return response.json()
    
    def render_ui(self, dsl: Dict[str, Any], output_format: str = "png") -> Dict[str, Any]:
        """渲染UI设计"""
        data = {
            "dsl": dsl,
            "output_format": output_format
        }
        
        response = requests.post(
            f"{self.base_url}/render",
            headers=self.headers,
            json=data,
            timeout=30
        )
        response.raise_for_status()
        return response.json()
    
    def get_templates(self) -> Dict[str, Any]:
        """获取模板列表"""
        response = requests.get(f"{self.base_url}/templates", headers=self.headers)
        response.raise_for_status()
        return response.json()
    
    def get_themes(self) -> Dict[str, Any]:
        """获取主题列表"""
        response = requests.get(f"{self.base_url}/themes", headers=self.headers)
        response.raise_for_status()
        return response.json()
    
    def health_check(self) -> Dict[str, Any]:
        """健康检查"""
        response = requests.get(f"{self.base_url}/health", headers=self.headers)
        response.raise_for_status()
        return response.json()
    
    def save_image(self, image_data: str, filename: str):
        """保存Base64图片"""
        image_bytes = base64.b64decode(image_data)
        with open(filename, 'wb') as f:
            f.write(image_bytes)
    
    def save_vue(self, vue_content: str, filename: str):
        """保存Vue代码"""
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(vue_content)

# 使用示例
if __name__ == "__main__":
    client = AIUIClient(api_key="your-api-key")
    
    # 生成UI设计
    result = client.generate_ui(
        prompt="黑金风格的电商首页，顶部搜索，中间两列商品卡，底部导航",
        output_format="png"
    )
    
    if result["success"]:
        # 保存图片
        client.save_image(result["data"]["image"], "ui_design.png")
        print("UI设计已保存为 ui_design.png")
    else:
        print(f"生成失败: {result['message']}")

# 批量生成UI设计
def batch_generate_ui(client: AIUIClient, prompts: List[str], output_format: str = "json"):
    """批量生成UI设计"""
    results = []
    
    for i, prompt in enumerate(prompts):
        try:
            result = client.generate_ui(prompt, output_format)
            results.append({
                "index": i,
                "prompt": prompt,
                "result": result
            })
            print(f"完成 {i+1}/{len(prompts)}: {prompt[:50]}...")
        except Exception as e:
            results.append({
                "index": i,
                "prompt": prompt,
                "error": str(e)
            })
            print(f"失败 {i+1}/{len(prompts)}: {e}")
    
    return results

# 使用示例
prompts = [
    "黑金风格的电商首页",
    "简约风格的商品详情页",
    "白银风格的搜索页面"
]

client = AIUIClient(api_key="your-api-key")
results = batch_generate_ui(client, prompts, "png")

# 保存所有结果
for result in results:
    if "result" in result and result["result"]["success"]:
        filename = f"ui_design_{result['index']}.png"
        client.save_image(result["result"]["data"]["image"], filename)

import asyncio
import aiohttp

async def async_generate_ui(session: aiohttp.ClientSession, prompt: str, api_key: str):
    """异步生成UI设计"""
    data = {
        "prompt": prompt,
        "output_format": "json"
    }
    
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    
    async with session.post(
        "http://localhost:8000/generate-ui",
        json=data,
        headers=headers
    ) as response:
        return await response.json()

async def batch_async_generate(prompts: List[str], api_key: str):
    """批量异步生成"""
    async with aiohttp.ClientSession() as session:
        tasks = [
            async_generate_ui(session, prompt, api_key)
            for prompt in prompts
        ]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        return results

# 使用示例
prompts = [
    "黑金风格的电商首页",
    "简约风格的商品详情页",
    "白银风格的搜索页面"
]

results = asyncio.run(batch_async_generate(prompts, "your-api-key"))

import time
from functools import wraps

def retry(max_attempts: int = 3, delay: float = 1.0):
    """重试装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    if attempt < max_attempts - 1:
                        print(f"尝试 {attempt + 1} 失败，{delay}秒后重试...")
                        time.sleep(delay)
                    else:
                        print(f"所有尝试都失败了: {e}")
            
            raise last_exception
        return wrapper
    return decorator

class RobustAIUIClient(AIUIClient):
    @retry(max_attempts=3, delay=2.0)
    def generate_ui(self, prompt: str, output_format: str = "json", **kwargs):
        """带重试的UI生成"""
        return super().generate_ui(prompt, output_format, **kwargs)
    
    @retry(max_attempts=3, delay=1.0)
    def render_ui(self, dsl: Dict[str, Any], output_format: str = "png"):
        """带重试的UI渲染"""
        return super().render_ui(dsl, output_format)