Google Gemini 2.5 Flash Image (Nano Banana) API 深度解析与实战指南

import google.generativeai as genai
import os
from PIL import Image
import io
import base64

# 配置API密钥
genai.configure(api_key=os.environ.get('GEMINI_API_KEY'))

# 初始化模型
model = genai.GenerativeModel('gemini-2.5-flash-image-preview')

def generate_image(prompt, style="photorealistic"):
    """
    生成图像的核心函数
    
    Args:
        prompt: 图像描述文本
        style: 风格参数 (photorealistic, artistic, cartoon等)
    
    Returns:
        PIL.Image对象
    """
    try:
        # 构建增强提示词
        enhanced_prompt = f"{prompt}, {style} style, high quality, 4k resolution"
        
        # 调用API生成图像
        response = model.generate_content(
            enhanced_prompt,
            generation_config={
                "temperature": 0.7,
                "max_output_tokens": 1290, # 标准图像token消耗
                "response_mime_type": "image/png"
            }
        )
        
        # 处理响应并返回图像
        if response.parts:
            image_data = response.parts[0].inline_data.data
            image = Image.open(io.BytesIO(base64.b64decode(image_data)))
            return image
        else:
            raise Exception("No image generated")
            
    except Exception as e:
        print(f"Error generating image: {e}")
        return None

# 使用示例
if __name__ == "__main__":
    # 生成一张未来城市的图像
    image = generate_image(
        "A futuristic nano-tech powered city with floating buildings and holographic displays",
        style="cyberpunk"
    )
    if image:
        image.save("nano_city.png")
        print("Image saved successfully!")

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");
const sharp = require("sharp");

class NanoBananaClient {
    constructor(apiKey) {
        this.genAI = new GoogleGenerativeAI(apiKey);
        this.model = this.genAI.getGenerativeModel({ model: "gemini-2.5-flash-image-preview" });
    }

    async generateImage(prompt, options = {}) {
        const defaultOptions = {
            width: 1024,
            height: 1024,
            style: "photorealistic",
            quality: "high"
        };
        const config = { ...defaultOptions, ...options };

        try {
            const detailedPrompt = this.buildPrompt(prompt, config);
            const result = await this.model.generateContent({
                contents: [{ parts: [{ text: detailedPrompt }] }],
                generationConfig: {
                    temperature: 0.7,
                    candidateCount: 1,
                    maxOutputTokens: 1290
                }
            });

            const response = await result.response;
            const imageData = response.candidates[0].content.parts[0].inlineData;
            const buffer = Buffer.from(imageData.data, 'base64');
            return buffer;

        } catch (error) {
            console.error('Generation failed:', error);
            throw new Error(`Failed to generate image: ${error.message}`);
        }
    }

    buildPrompt(basePrompt, config) {
        return `${basePrompt}, ${config.style} style, ${config.quality} quality, ${config.width}x${config.height} resolution`;
    }
}

// 使用示例
async function main() {
    const client = new NanoBananaClient(process.env.GEMINI_API_KEY);
    try {
        const imageBuffer = await client.generateImage(
            "A serene Japanese garden with cherry blossoms and a traditional tea house",
            { style: "watercolor", quality: "ultra" }
        );

        // 使用sharp进行后处理（可选）
        await sharp(imageBuffer)
            .resize(2048, 2048, { fit: 'contain' })
            .jpeg({ quality: 95 })
            .toFile('japanese_garden.jpg');
            
        console.log('Image generated and saved!');
    } catch (error) {
        console.error('Error:', error);
    }
}

main();

import time
import random
from typing import Optional
from dataclasses import dataclass
from enum import Enum

class ErrorType(Enum):
    RATE_LIMIT = "rate_limit"
    QUOTA_EXCEEDED = "quota_exceeded"
    INVALID_REQUEST = "invalid_request"
    SERVER_ERROR = "server_error"
    NETWORK_ERROR = "network_error"

@dataclass
class RetryConfig:
    max_retries: int = 3
    base_delay: float = 1.0
    max_delay: float = 60.0
    exponential_base: float = 2.0
    jitter: bool = True

class NanoBananaAPIWrapper:
    def __init__(self, api_key: str, retry_config: Optional[RetryConfig] = None):
        self.api_key = api_key
        self.retry_config = retry_config or RetryConfig()
        genai.configure(api_key=api_key)
        self.model = genai.GenerativeModel('gemini-2.5-flash-image-preview')

    def generate_with_retry(self, prompt: str, **kwargs) -> Optional[Image.Image]:
        last_error = None
        for attempt in range(self.retry_config.max_retries):
            try:
                return self._generate_image(prompt, **kwargs)
            except Exception as e:
                last_error = e
                error_type = self._classify_error(e)
                if error_type == ErrorType.INVALID_REQUEST:
                    raise e # 无效请求不重试
                
                if attempt < self.retry_config.max_retries - 1:
                    delay = self._calculate_delay(attempt, error_type)
                    print(f"Attempt {attempt + 1} failed: {e}. Retrying in {delay:.2f}s...")
                    time.sleep(delay)
                else:
                    print(f"All retries exhausted. Last error: {e}")
                    raise last_error

    def _generate_image(self, prompt: str, **kwargs) -> Image.Image:
        response = self.model.generate_content(
            prompt,
            generation_config=kwargs.get('generation_config', {"temperature": 0.7, "max_output_tokens": 1290})
        )
        if not response.parts:
            raise ValueError("No image generated in response")
        
        image_data = response.parts[0].inline_data.data
        return Image.open(io.BytesIO(base64.b64decode(image_data)))

    def _classify_error(self, error: Exception) -> ErrorType:
        error_msg = str(error).lower()
        if "rate limit" in error_msg or "429" in error_msg:
            return ErrorType.RATE_LIMIT
        elif "quota" in error_msg or "403" in error_msg:
            return ErrorType.QUOTA_EXCEEDED
        elif "invalid" in error_msg or "400" in error_msg:
            return ErrorType.INVALID_REQUEST
        elif "500" in error_msg or "503" in error_msg:
            return ErrorType.SERVER_ERROR
        else:
            return ErrorType.NETWORK_ERROR

    def _calculate_delay(self, attempt: int, error_type: ErrorType) -> float:
        base_delay = self.retry_config.base_delay * 2 if error_type == ErrorType.RATE_LIMIT else self.retry_config.base_delay
        delay = min(base_delay * (self.retry_config.exponential_base ** attempt), self.retry_config.max_delay)
        if self.retry_config.jitter:
            delay *= (0.5 + random.random())
        return delay

# 使用示例
api_wrapper = NanoBananaAPIWrapper(
    api_key=os.environ.get('GEMINI_API_KEY'),
    retry_config=RetryConfig(max_retries=5, base_delay=2.0)
)
try:
    image = api_wrapper.generate_with_retry(
        "A stunning photograph of the Northern Lights over a frozen lake"
    )
    image.save("northern_lights.png")
    print("Image generated successfully with retry protection!")
except Exception as e:
    print(f"Failed to generate image: {e}")