Nano Banana Pro

{
  "ownerId": "kn70pywhg0fyz996kpa8xj89s57yhv26",
  "slug": "nano-banana-pro",
  "version": "1.0.1",
  "publishedAt": 1767651987917
}

{
  "version": 1,
  "registry": "https://clawhub.ai",
  "slug": "nano-banana-pro",
  "installedVersion": "1.0.1",
  "installedAt": 1772790606347
}

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "requests>=2.28.0",
# ]
# ///
"""
Generate images using Boluobao API (菠萝包 image generation).
Fallback provider for nano-banana-pro when xingjiabiapi is unavailable.

API: POST https://apipark.boluobao.ai/v1/images/generations
Models: gemini-3-pro-image-preview (and others)

Usage:
    uv run generate_image_boluobao.py --prompt "description" --filename "out.jpg" [--resolution 1k|2k|4k] [--aspect-ratio 16:9] [--input-image URL]
"""

import argparse
import os
import sys
import subprocess
from pathlib import Path


def get_api_key(provided_key: str | None) -> str | None:
    if provided_key:
        return provided_key
    key = os.environ.get("BOLUOBAO_API_KEY")
    if key:
        return key
    # Try pass
    try:
        result = subprocess.run(["pass", "show", "api/boluobao"], capture_output=True, text=True, timeout=5)
        if result.returncode == 0:
            return result.stdout.strip()
    except Exception:
        pass
    return None


def main():
    parser = argparse.ArgumentParser(description="Generate images via Boluobao API")
    parser.add_argument("--prompt", "-p", required=True, help="Image prompt")
    parser.add_argument("--filename", "-f", required=True, help="Output filename")
    parser.add_argument("--model", "-m", default="gemini-3-pro-image-preview", help="Model name")
    parser.add_argument("--resolution", "-r", choices=["1k", "2k", "4k"], default="1k", help="Image size")
    parser.add_argument("--aspect-ratio", "-a", default="1:1",
                        choices=["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"],
                        help="Aspect ratio")
    parser.add_argument("--input-image", "-i", nargs="*", default=[], help="Input image URLs (up to 14)")
    parser.add_argument("--api-key", "-k", help="API key (overrides env/pass)")

    args = parser.parse_args()

    api_key = get_api_key(args.api_key)
    if not api_key:
        print("Error: No API key. Set BOLUOBAO_API_KEY, pass --api-key, or store in `pass api/boluobao`", file=sys.stderr)
        sys.exit(1)

    import requests

    url = "https://apipark.boluobao.ai/v1/images/generations"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    }
    payload = {
        "model": args.model,
        "prompt": args.prompt,
        "aspect_ratio": args.aspect_ratio,
        "image": args.input_image,
        "image_size": args.resolution,
    }

    print(f"Generating image: model={args.model}, resolution={args.resolution}, aspect={args.aspect_ratio}")

    try:
        resp = requests.post(url, json=payload, headers=headers, timeout=120)
        data = resp.json()
    except Exception as e:
        print(f"Error calling API: {e}", file=sys.stderr)
        sys.exit(1)

    if data.get("status") != 200 and "data" not in data:
        print(f"API error: {data}", file=sys.stderr)
        sys.exit(1)

    results = data.get("data", [])
    if not results:
        print("Error: No image in response", file=sys.stderr)
        sys.exit(1)

    image_url = results[0].get("url", "")
    revised_prompt = results[0].get("revised_prompt", "")
    if revised_prompt:
        print(f"Revised prompt: {revised_prompt}")

    if not image_url:
        print("Error: No image URL in response", file=sys.stderr)
        sys.exit(1)

    print(f"Image URL: {image_url}")

    # Download image
    output_path = Path(args.filename)
    output_path.parent.mkdir(parents=True, exist_ok=True)

    try:
        img_resp = requests.get(image_url, timeout=60)
        img_resp.raise_for_status()
        output_path.write_bytes(img_resp.content)
        print(f"\nImage saved: {output_path.resolve()} ({len(img_resp.content) / 1024:.0f} KB)")
    except Exception as e:
        print(f"Error downloading image: {e}", file=sys.stderr)
        print(f"Image URL (manual download): {image_url}")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "google-genai>=1.0.0",
#     "pillow>=10.0.0",
# ]
# ///
"""
Generate images using Google's Nano Banana Pro (Gemini 3 Pro Image) API.

Usage:
    uv run generate_image.py --prompt "your image description" --filename "output.png" [--resolution 1K|2K|4K] [--api-key KEY]
"""

import argparse
import os
import sys
from pathlib import Path


def get_api_key(provided_key: str | None) -> str | None:
    """Get API key from argument first, then environment."""
    if provided_key:
        return provided_key
    return os.environ.get("GEMINI_API_KEY")


def main():
    parser = argparse.ArgumentParser(
        description="Generate images using Nano Banana Pro (Gemini 3 Pro Image)"
    )
    parser.add_argument(
        "--prompt", "-p",
        required=True,
        help="Image description/prompt"
    )
    parser.add_argument(
        "--filename", "-f",
        required=True,
        help="Output filename (e.g., sunset-mountains.png)"
    )
    parser.add_argument(
        "--input-image", "-i",
        help="Optional input image path for editing/modification"
    )
    parser.add_argument(
        "--resolution", "-r",
        choices=["1K", "2K", "4K"],
        default="1K",
        help="Output resolution: 1K (default), 2K, or 4K"
    )
    parser.add_argument(
        "--api-key", "-k",
        help="Gemini API key (overrides GEMINI_API_KEY env var)"
    )

    args = parser.parse_args()

    # Get API key
    api_key = get_api_key(args.api_key)
    if not api_key:
        print("Error: No API key provided.", file=sys.stderr)
        print("Please either:", file=sys.stderr)
        print("  1. Provide --api-key argument", file=sys.stderr)
        print("  2. Set GEMINI_API_KEY environment variable", file=sys.stderr)
        sys.exit(1)

    # Import here after checking API key to avoid slow import on error
    from google import genai
    from google.genai import types
    from PIL import Image as PILImage

    # Initialise client
    client = genai.Client(api_key=api_key)

    # Set up output path
    output_path = Path(args.filename)
    output_path.parent.mkdir(parents=True, exist_ok=True)

    # Load input image if provided
    input_image = None
    output_resolution = args.resolution
    if args.input_image:
        try:
            input_image = PILImage.open(args.input_image)
            print(f"Loaded input image: {args.input_image}")

            # Auto-detect resolution if not explicitly set by user
            if args.resolution == "1K":  # Default value
                # Map input image size to resolution
                width, height = input_image.size
                max_dim = max(width, height)
                if max_dim >= 3000:
                    output_resolution = "4K"
                elif max_dim >= 1500:
                    output_resolution = "2K"
                else:
                    output_resolution = "1K"
                print(f"Auto-detected resolution: {output_resolution} (from input {width}x{height})")
        except Exception as e:
            print(f"Error loading input image: {e}", file=sys.stderr)
            sys.exit(1)

    # Build contents (image first if editing, prompt only if generating)
    if input_image:
        contents = [input_image, args.prompt]
        print(f"Editing image with resolution {output_resolution}...")
    else:
        contents = args.prompt
        print(f"Generating image with resolution {output_resolution}...")

    try:
        response = client.models.generate_content(
            model="gemini-3-pro-image-preview",
            contents=contents,
            config=types.GenerateContentConfig(
                response_modalities=["TEXT", "IMAGE"],
                image_config=types.ImageConfig(
                    image_size=output_resolution
                )
            )
        )

        # Process response and convert to PNG
        image_saved = False
        for part in response.parts:
            if part.text is not None:
                print(f"Model response: {part.text}")
            elif part.inline_data is not None:
                # Convert inline data to PIL Image and save as PNG
                from io import BytesIO

                # inline_data.data is already bytes, not base64
                image_data = part.inline_data.data
                if isinstance(image_data, str):
                    # If it's a string, it might be base64
                    import base64
                    image_data = base64.b64decode(image_data)

                image = PILImage.open(BytesIO(image_data))

                # Ensure RGB mode for PNG (convert RGBA to RGB with white background if needed)
                if image.mode == 'RGBA':
                    rgb_image = PILImage.new('RGB', image.size, (255, 255, 255))
                    rgb_image.paste(image, mask=image.split()[3])
                    rgb_image.save(str(output_path), 'PNG')
                elif image.mode == 'RGB':
                    image.save(str(output_path), 'PNG')
                else:
                    image.convert('RGB').save(str(output_path), 'PNG')
                image_saved = True

        if image_saved:
            full_path = output_path.resolve()
            print(f"\nImage saved: {full_path}")
        else:
            print("Error: No image was generated in the response.", file=sys.stderr)
            sys.exit(1)

    except Exception as e:
        print(f"Error generating image: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "requests>=2.28.0",
# ]
# ///
"""
Prompt Optimizer for Image Generation.
Takes a simple user prompt and enhances it into a professional image generation prompt.

Uses a fast/cheap LLM (boluobao or xingjiabiapi) to optimize.

Usage:
    uv run optimize_prompt.py --prompt "一只猫" [--style photo|illustration|anime|oil-painting|3d|pixel]
    uv run optimize_prompt.py --prompt "sunset" --style "oil-painting" --lang en
"""

import argparse
import json
import os
import subprocess
import sys

import requests

SYSTEM_PROMPT = """你是一个专业的 AI 图像生成提示词优化师。

用户会给你一个简短的图像描述，你需要将其扩展为一个详细、高质量的图像生成提示词。

## 优化规则：

1. **保留用户的核心意图** — 不要改变主题，只是丰富细节
2. **添加以下维度**（如果用户没有指定）：
   - 主体细节（姿态、表情、材质、纹理）
   - 构图（视角、景深、画面布局）
   - 光线（方向、色温、氛围）
   - 色彩（主色调、对比度、饱和度）
   - 风格（写实/插画/油画/3D等）
   - 背景（环境、氛围、层次）
   - 品质关键词（8K, masterpiece, ultra detailed 等）

3. **输出纯英文** — 图像生成模型对英文效果最好
4. **长度控制** — 80-200 词之间，不要太短也不要太长
5. **不要用 markdown 格式** — 只输出纯文本提示词
6. **不要写"Prompt:"前缀** — 直接输出优化后的文本

## 风格映射：
- photo → photorealistic, DSLR quality, natural lighting
- illustration → digital illustration, clean lines, vibrant
- anime → anime style, cel-shading, Japanese animation aesthetic
- oil-painting → oil painting style, visible brush strokes, rich texture
- 3d → 3D render, octane render, volumetric lighting
- pixel → pixel art, retro gaming aesthetic, 8-bit/16-bit
- cinematic → cinematic composition, dramatic lighting, movie still
- watercolor → watercolor painting, soft edges, translucent layers"""


def get_api_key(provider: str) -> str | None:
    """Get API key for the specified provider."""
    env_map = {
        "boluobao": "BOLUOBAO_API_KEY",
        "xingjiabiapi": "XINGJIABIAPI_API_KEY",
    }
    pass_map = {
        "boluobao": "api/boluobao",
        "xingjiabiapi": "api/xingjiabiapi",
    }

    # Try env first
    key = os.environ.get(env_map.get(provider, ""))
    if key:
        return key

    # Try pass
    try:
        result = subprocess.run(
            ["pass", "show", pass_map.get(provider, "")],
            capture_output=True, text=True, timeout=5
        )
        if result.returncode == 0:
            return result.stdout.strip()
    except Exception:
        pass
    return None


def optimize_with_boluobao(prompt: str, style: str, api_key: str) -> str:
    """Use Boluobao API to optimize prompt."""
    user_msg = f"请优化这个图像生成提示词：「{prompt}」"
    if style:
        user_msg += f"\n风格要求：{style}"

    resp = requests.post(
        "https://apipark.boluobao.ai/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        },
        json={
            "model": "gemini-3-pro-preview",
            "messages": [
                {"role": "system", "content": SYSTEM_PROMPT},
                {"role": "user", "content": user_msg},
            ],
            "max_tokens": 500,
            "temperature": 0.7,
        },
        timeout=30,
    )
    data = resp.json()
    return data["choices"][0]["message"]["content"].strip()


def optimize_with_xingjiabiapi(prompt: str, style: str, api_key: str) -> str:
    """Use xingjiabiapi API to optimize prompt."""
    user_msg = f"请优化这个图像生成提示词：「{prompt}」"
    if style:
        user_msg += f"\n风格要求：{style}"

    resp = requests.post(
        "https://api.xingjiabiapi.com/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        },
        json={
            "model": "gemini-2.5-flash-preview-05-20",
            "messages": [
                {"role": "system", "content": SYSTEM_PROMPT},
                {"role": "user", "content": user_msg},
            ],
            "max_tokens": 500,
            "temperature": 0.7,
        },
        timeout=30,
    )
    data = resp.json()
    return data["choices"][0]["message"]["content"].strip()


def main():
    parser = argparse.ArgumentParser(description="Optimize image generation prompts")
    parser.add_argument("--prompt", "-p", required=True, help="User's original prompt")
    parser.add_argument("--style", "-s", default="",
                        choices=["", "photo", "illustration", "anime", "oil-painting",
                                 "3d", "pixel", "cinematic", "watercolor"],
                        help="Desired style")
    parser.add_argument("--provider", default="auto",
                        choices=["auto", "boluobao", "xingjiabiapi"],
                        help="LLM provider for optimization")

    args = parser.parse_args()

    # Try providers in order
    providers = (
        ["boluobao", "xingjiabiapi"] if args.provider == "auto"
        else [args.provider]
    )

    optimized = None
    for provider in providers:
        api_key = get_api_key(provider)
        if not api_key:
            continue
        try:
            if provider == "boluobao":
                optimized = optimize_with_boluobao(args.prompt, args.style, api_key)
            else:
                optimized = optimize_with_xingjiabiapi(args.prompt, args.style, api_key)
            if optimized:
                break
        except Exception as e:
            print(f"Warning: {provider} failed: {e}", file=sys.stderr)
            continue

    if not optimized:
        print("Error: All providers failed. Using original prompt.", file=sys.stderr)
        optimized = args.prompt

    # Output the optimized prompt
    print(optimized)


if __name__ == "__main__":
    main()