Sora Image Generation API

import requests
import re

# API Configuration
API_KEY = "YOUR_API_KEY"
API_URL = "https://api.apiyi.com/v1/chat/completions"

def generate_image(prompt, ratio="2:3"):
    """
    Generate image using Sora Image

    Args:
        prompt: Image description text
        ratio: Image ratio, supports "2:3", "3:2", "1:1"
    """
    # Add ratio tag at end of prompt
    if ratio and ratio in ["2:3", "3:2", "1:1"]:
        prompt = f"{prompt}【{ratio}】"

    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    payload = {
        "model": "sora_image",
        "messages": [
            {
                "role": "user",
                "content": prompt
            }
        ]
    }

    response = requests.post(API_URL, headers=headers, json=payload)
    result = response.json()

    # Extract image URL
    content = result['choices'][0]['message']['content']
    image_urls = re.findall(r'!\[.*?\]\((https?://[^)]+)\)', content)

    return image_urls

# Usage example
urls = generate_image("A cute cat playing in the garden", "2:3")
print(f"Generated image: {urls[0]}")

def batch_generate_images(prompts, ratio="2:3"):
    """Batch generate images"""
    results = []

    for prompt in prompts:
        try:
            urls = generate_image(prompt, ratio)
            results.append({
                "prompt": prompt,
                "url": urls[0] if urls else None,
                "success": bool(urls)
            })
            print(f"✅ Successfully generated: {prompt}")
        except Exception as e:
            results.append({
                "prompt": prompt,
                "url": None,
                "success": False,
                "error": str(e)
            })
            print(f"❌ Generation failed: {prompt} - {e}")

    return results

# Batch generation example
prompts = [
    "Beach at sunset",
    "Futuristic tech city",
    "Fairy in a fantasy forest"
]

results = batch_generate_images(prompts, "3:2")

# Portrait
portrait = generate_image("Elegant lady portrait, professional photography style【2:3】")

# Landscape
landscape = generate_image("Mountain valley at sunrise, soft lighting【3:2】")

# Square icon
icon = generate_image("Minimalist modern app icon design【1:1】")

# ❌ Not recommended: Too simple
prompt = "cat"

# ✅ Recommended: Detailed description
prompt = """
A fluffy orange cat,
sitting on a sunny windowsill,
with blurred cityscape background,
photography style, high-definition details
【2:3】
"""

import time

def generate_with_retry(prompt, max_retries=3):
    """Image generation with retry mechanism"""
    for attempt in range(max_retries):
        try:
            urls = generate_image(prompt)
            if urls:
                return urls[0]
        except Exception as e:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Retry {attempt + 1}/{max_retries}, waiting {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise e

    return None

import requests
from datetime import datetime

def save_generated_image(url, prompt):
    """Save generated image locally"""
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"sora_{timestamp}.png"

    response = requests.get(url)
    with open(filename, 'wb') as f:
        f.write(response.content)

    # Save prompt information
    with open(f"sora_{timestamp}_prompt.txt", 'w', encoding='utf-8') as f:
        f.write(f"Prompt: {prompt}\n")
        f.write(f"URL: {url}\n")
        f.write(f"Time: {datetime.now()}\n")

    return filename

# Artistic style templates
art_styles = {
    "oil_painting": "oil painting style, thick brush strokes, rich color layers",
    "watercolor": "watercolor style, transparency, flowing colors",
    "sketch": "pencil sketch style, black and white, delicate lines",
    "anime": "Japanese anime style, big eyes, vibrant colors",
    "photorealistic": "ultra-realistic photography, high-definition details, professional photography"
}

def generate_with_style(subject, style_name):
    """Generate image with preset style"""
    style = art_styles.get(style_name, "")
    prompt = f"{subject}, {style}【2:3】"
    return generate_image(prompt)

# Usage example
url = generate_with_style("Beautiful rose flower", "watercolor")

# Scene generation template
def generate_scene(subject, time="sunset", weather="clear", mood="serene"):
    """Generate scene image based on parameters"""
    prompt = f"""
    {subject}
    Time: {time}
    Weather: {weather}
    Mood: {mood}
    Photography style, professional composition
    【3:2】
    """
    return generate_image(prompt.strip())

# Generate different scenes
sunset_beach = generate_scene("Beach", "sunset", "breeze", "romantic")
morning_forest = generate_scene("Forest path", "morning", "mist", "mysterious")

def generate_variations(base_prompt, variations, ratio="2:3"):
    """Generate multiple variations of same theme"""
    results = []

    for variation in variations:
        full_prompt = f"{base_prompt}, {variation}【{ratio}】"
        try:
            url = generate_image(full_prompt)[0]
            results.append({
                "variation": variation,
                "url": url,
                "prompt": full_prompt
            })
        except Exception as e:
            print(f"Variation generation failed: {variation}")

    return results

# Generate different cat variations
base = "A cute cat"
variations = [
    "orange tabby",
    "black and white cow pattern",
    "pure white long hair",
    "gray short hair"
]

cat_variations = generate_variations(base, variations)

def calculate_cost(num_images):
    """Calculate image generation cost"""
    cost_per_image = 0.01  # $0.01 per image
    total_cost = num_images * cost_per_image

    # Compare with GPT-Image-1
    # GPT-Image-1 uses token billing, assume ~1000 tokens per image average
    avg_tokens_per_image = 1000
    gpt_image_1_cost = num_images * (avg_tokens_per_image / 1_000_000) * 40  # Output token cost

    print(f"Sora Image Cost Calculation:")
    print(f"- Number of images: {num_images}")
    print(f"- Unit price: ${cost_per_image} (fixed price)")
    print(f"- Total cost: ${total_cost:.2f}")
    print(f"\nCompare with GPT-Image-1:")
    print(f"- GPT-Image-1 billing: Token-based ($10 input/$40 output per M)")
    print(f"- Estimated cost: ${gpt_image_1_cost:.2f} (assuming ~1000 tokens per image)")
    print(f"- Sora advantage: Fixed price, controllable cost")

# Calculation example
calculate_cost(100)  # Generate 100 images