Flux 图像生成 API

from openai import OpenAI

# 初始化客户端
client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.laozhang.ai/v1"
)

# 生成图像（完整参数版）
def generate_flux_image(prompt, aspect_ratio="1:1", model="flux-kontext-pro",
                       seed=None, safety_tolerance=2, output_format="jpeg",
                       prompt_upsampling=False):
    """
    生成 Flux 图像
    
    参数：
    - prompt: 图像描述文本
    - aspect_ratio: 宽高比 (3:7 到 7:3)
    - model: 模型选择
    - seed: 随机种子，用于结果重现
    - safety_tolerance: 内容安全级别 (0-6)
    - output_format: 输出格式 "jpeg" 或 "png"
    - prompt_upsampling: 是否增强提示词
    """
    try:
        # 构建 extra_body 参数
        extra_params = {
            "aspect_ratio": aspect_ratio,
            "safety_tolerance": safety_tolerance,
            "output_format": output_format,
            "prompt_upsampling": prompt_upsampling
        }
        
        # 可选参数
        if seed is not None:
            extra_params["seed"] = seed
        
        response = client.images.generate(
            model=model,
            prompt=prompt,
            extra_body=extra_params
        )
        
        # 获取图像 URL（注意：10分钟后失效）
        image_url = response.data[0].url
        return image_url
    
    except Exception as e:
        print(f"生成失败: {e}")
        return None

# 使用示例
image_url = generate_flux_image(
    prompt="A futuristic city with flying cars and neon lights",
    aspect_ratio="16:9",
    model="flux-kontext-pro",
    seed=42,  # 固定种子，确保可重现
    safety_tolerance=2,  # 默认安全级别
    output_format="png",  # 高质量 PNG 格式
    prompt_upsampling=True  # 增强提示词效果
)

if image_url:
    print(f"生成的图像: {image_url}")
    print("⚠️ 注意：URL 将在 10 分钟后失效，请及时下载！")

import requests
import time
from PIL import Image
from io import BytesIO

def batch_generate_flux(prompts_with_ratios, model="flux-kontext-pro"):
    """批量生成不同比例的图像"""
    results = []
    
    for prompt, ratio in prompts_with_ratios:
        try:
            print(f"正在生成 {ratio} 比例的图像...")
            
            response = client.images.generate(
                model=model,
                prompt=prompt,
                extra_body={"aspect_ratio": ratio}
            )
            
            image_url = response.data[0].url
            
            # 下载并保存图像
            filename = save_image_from_url(image_url, prompt, ratio)
            
            results.append({
                "prompt": prompt,
                "ratio": ratio,
                "url": image_url,
                "filename": filename,
                "success": True
            })
            
        except Exception as e:
            results.append({
                "prompt": prompt,
                "ratio": ratio,
                "error": str(e),
                "success": False
            })
    
    return results

def save_image_from_url(url, prompt, ratio):
    """从 URL 下载并保存图像（考虑 10 分钟失效）"""
    try:
        # 立即下载，避免 URL 失效
        response = requests.get(url, timeout=30)
        response.raise_for_status()
        
        # 生成文件名
        timestamp = int(time.time())
        safe_prompt = prompt[:30].replace(" ", "_").replace("/", "_")
        filename = f"flux_{safe_prompt}_{ratio.replace(':', 'x')}_{timestamp}.png"
        
        with open(filename, 'wb') as f:
            f.write(response.content)
        
        print(f"✅ 已保存: {filename}")
        return filename
        
    except requests.exceptions.RequestException as e:
        print(f"❌ 下载失败: {e}")
        print("提示：Flux URL 仅 10 分钟有效，请确保及时下载！")
        return None

# 批量生成示例
prompts_and_ratios = [
    ("A beautiful sunset over mountains", "3:2"),
    ("Portrait of a wise old wizard", "2:3"),
    ("Cyberpunk street scene", "16:9"),
    ("Minimalist app icon design", "1:1")
]

results = batch_generate_flux(prompts_and_ratios, "flux-kontext-max")

# 打印结果
for result in results:
    if result["success"]:
        print(f"✅ {result['prompt']} ({result['ratio']}) -> {result['filename']}")
    else:
        print(f"❌ {result['prompt']} ({result['ratio']}) -> {result['error']}")

const OpenAI = require('openai');
const fs = require('fs');
const https = require('https');

// 初始化客户端
const openai = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.laozhang.ai/v1'
});

// 生成 Flux 图像
async function generateFluxImage(prompt, aspectRatio = '1:1', model = 'flux-kontext-pro') {
  try {
    const response = await openai.images.generate({
      model: model,
      prompt: prompt,
      extra_body: {
        aspect_ratio: aspectRatio
      }
    });
    
    return response.data[0].url;
  } catch (error) {
    console.error('生成失败:', error);
    return null;
  }
}

// 下载图像
function downloadImage(url, filename) {
  return new Promise((resolve, reject) => {
    const file = fs.createWriteStream(filename);
    https.get(url, (response) => {
      response.pipe(file);
      file.on('finish', () => {
        file.close();
        resolve(filename);
      });
    }).on('error', (err) => {
      fs.unlink(filename, () => {}); // 删除失败的文件
      reject(err);
    });
  });
}

// 使用示例
async function main() {
  const scenarios = [
    {
      prompt: "A serene Japanese garden with cherry blossoms",
      ratio: "3:2",
      model: "flux-kontext-pro"
    },
    {
      prompt: "Abstract geometric pattern in vibrant colors",
      ratio: "1:1", 
      model: "flux-kontext-max"
    }
  ];
  
  for (const scenario of scenarios) {
    console.log(`生成图像: ${scenario.prompt}`);
    
    const imageUrl = await generateFluxImage(
      scenario.prompt,
      scenario.ratio,
      scenario.model
    );
    
    if (imageUrl) {
      const filename = `flux_${Date.now()}.png`;
      await downloadImage(imageUrl, filename);
      console.log(`已保存: ${filename}`);
    }
  }
}

main().catch(console.error);

# 网站横幅
banner = generate_flux_image(
    "Modern website banner with clean design and tech elements",
    aspect_ratio="7:3",
    model="flux-kontext-max"
)

# 产品展示图
product = generate_flux_image(
    "Elegant product photography of a smartphone on white background",
    aspect_ratio="1:1",
    model="flux-kontext-pro"
)

# Instagram 帖子
instagram_post = generate_flux_image(
    "Inspirational quote design with aesthetic background",
    aspect_ratio="1:1",
    model="flux-kontext-pro"
)

# 手机壁纸
mobile_wallpaper = generate_flux_image(
    "Abstract cosmic art with stars and nebula",
    aspect_ratio="9:16",
    model="flux-kontext-max"
)

# 海报设计
poster = generate_flux_image(
    "Concert poster design with bold typography and music elements",
    aspect_ratio="2:3",
    model="flux-kontext-max"
)

# 网站背景
background = generate_flux_image(
    "Subtle geometric pattern for website background",
    aspect_ratio="16:9",
    model="flux-kontext-pro"
)

import time
from concurrent.futures import ThreadPoolExecutor
import requests

class FluxImageManager:
    """Flux 图像生成和下载管理器"""
    
    def __init__(self, api_key, base_url="https://api.laozhang.ai/v1"):
        self.client = OpenAI(api_key=api_key, base_url=base_url)
        
    def generate_and_save(self, prompt, **kwargs):
        """生成图像并立即保存"""
        start_time = time.time()
        
        # 生成图像
        image_url = generate_flux_image(prompt, **kwargs)
        if not image_url:
            return None
            
        # 立即下载（避免超时）
        elapsed = time.time() - start_time
        if elapsed > 540:  # 超过 9 分钟
            print("⚠️ 警告：接近 URL 失效时间！")
        
        # 下载并保存
        filename = f"flux_{int(time.time())}.png"
        try:
            response = requests.get(image_url, timeout=30)
            response.raise_for_status()
            
            with open(filename, 'wb') as f:
                f.write(response.content)
                
            print(f"✅ 已保存: {filename} (耗时: {elapsed:.1f}s)")
            return filename
            
        except Exception as e:
            print(f"❌ 下载失败: {e}")
            return None

# ❌ 过于简单
prompt = "cat"

# ✅ 详细描述
prompt = """
A majestic orange tabby cat sitting by a window,
golden hour lighting, soft focus background,
professional pet photography style,
warm and cozy atmosphere
"""

# ✅ 利用 prompt_upsampling 增强简单提示词
enhanced_result = generate_flux_image(
    prompt="cat by window",
    prompt_upsampling=True  # AI 会自动扩展和优化提示词
)

# ✅ 艺术风格提示词
artistic_prompt = """
A surreal landscape painting in the style of Salvador Dali,
melting clocks draped over twisted trees,
vibrant sunset colors bleeding into a starry night sky,
hyper-detailed, dreamlike atmosphere
"""

def choose_aspect_ratio(use_case):
    """根据用途选择最佳宽高比"""
    ratios = {
        "social_media_post": "1:1",
        "mobile_wallpaper": "9:16", 
        "desktop_wallpaper": "16:9",
        "portrait_photo": "2:3",
        "landscape_photo": "3:2",
        "website_banner": "7:3",
        "bookmark_design": "3:7"
    }
    return ratios.get(use_case, "1:1")

# 使用示例
ratio = choose_aspect_ratio("mobile_wallpaper")
wallpaper = generate_flux_image("Peaceful forest scene", ratio)

import asyncio
import aiohttp

async def generate_async(session, prompt, ratio, model):
    """异步生成图像"""
    payload = {
        "model": model,
        "prompt": prompt,
        "extra_body": {"aspect_ratio": ratio}
    }
    
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    async with session.post(
        "https://api.laozhang.ai/v1/images/generations",
        json=payload,
        headers=headers
    ) as response:
        result = await response.json()
        return result["data"][0]["url"]

async def batch_generate_async(tasks):
    """异步批量生成"""
    async with aiohttp.ClientSession() as session:
        results = await asyncio.gather(*[
            generate_async(session, prompt, ratio, model)
            for prompt, ratio, model in tasks
        ])
    return results

def calculate_flux_costs(num_images, model_type="pro"):
    """计算 Flux 生成成本"""
    prices = {
        "pro": {"laozhang": 0.035, "official": 0.040},
        "max": {"laozhang": 0.07, "official": 0.08}
    }
    
    laozhang_cost = num_images * prices[model_type]["laozhang"]
    official_cost = num_images * prices[model_type]["official"]
    savings = official_cost - laozhang_cost
    
    print(f"Flux Kontext {model_type.upper()} 成本分析:")
    print(f"生成数量: {num_images} 张")
    print(f"老张API价格: ${laozhang_cost:.2f}")
    print(f"官方价格: ${official_cost:.2f}")
    print(f"节省金额: ${savings:.2f}")
    print(f"节省比例: {(savings/official_cost*100):.1f}%")

# 成本计算示例
calculate_flux_costs(100, "pro")   # 100张 Pro 版本
calculate_flux_costs(50, "max")    # 50张 Max 版本

# 提示词配置
BATCH_PROMPT="Look at the left image and right image. Transfer the pattern/design from the left image to the clothes of the model in the right image, with the size being 2/3 of the width of the chest, located in the middle. Make it look natural and well-integrated."

# 图片对数组
IMAGE_PAIRS=(
    "https://example.com/pattern1.jpg|https://example.com/model1.jpg"
    "https://example.com/design2.jpg|https://example.com/shirt2.jpg"
)