from openai import OpenAI
import base64

client = OpenAI()

response = client.images.generate(
    model="dall-e-3",
    prompt="A technical diagram showing a microservices architecture with 5 services "
           "connected by message queues. Clean, minimal style, white background. "
           "Label each service: API Gateway, Auth Service, User Service, Order Service, Notification Service.",
    size="1792x1024",
    quality="standard",
    n=1,
    response_format="b64_json",
)

image_data = base64.b64decode(response.data[0].b64_json)
with open("architecture_diagram.png", "wb") as f:
    f.write(image_data)

print(f"Revised prompt: {response.data[0].revised_prompt}")

import requests
import os

def generate_image_stability(prompt: str, output_path: str, negative_prompt: str = ""):
    response = requests.post(
        "https://api.stability.ai/v2beta/stable-image/generate/core",
        headers={
            "Authorization": f"Bearer {os.getenv('STABILITY_API_KEY')}",
            "Accept": "image/*",
        },
        files={"none": ""},
        data={
            "prompt": prompt,
            "negative_prompt": negative_prompt,
            "output_format": "png",
            "aspect_ratio": "16:9",
            "seed": 42,
        },
    )

    if response.status_code == 200:
        with open(output_path, "wb") as f:
            f.write(response.content)
        return output_path
    else:
        raise Exception(f"Error {response.status_code}: {response.json()}")

generate_image_stability(
    prompt="Product photo of a wireless headphone, studio lighting, white background",
    negative_prompt="text, watermarks, blurry, distorted",
    output_path="headphone.png",
)

import replicate

output = replicate.run(
    "black-forest-labs/flux-schnell",
    input={
        "prompt": "A cozy coffee shop interior, warm lighting, wooden furniture, patrons working on laptops",
        "num_outputs": 4,
        "num_inference_steps": 4,
        "width": 1024,
        "height": 1024,
    },
)

for i, url in enumerate(output):
    print(f"Image {i}: {url}")

import fal_client

result = fal_client.subscribe(
    "fal-ai/flux/dev",
    arguments={
        "prompt": "Minimalist logo design for a tech startup, geometric shapes, deep blue and white",
        "image_size": "square_hd",
        "num_inference_steps": 28,
        "guidance_scale": 3.5,
        "num_images": 1,
        "enable_safety_checker": True,
    },
)

print(result["images"][0]["url"])
print(f"Generation time: {result['timings']['inference']:.2f}s")

import replicate
import json

# Submit 100 jobs, get webhook notifications when done
batch_prompts = [
    "Coffee shop interior, warm lighting, professional photo",
    "Mountain landscape at sunset, dramatic sky",
    # ... 98 more
]

results = []
for prompt in batch_prompts:
    result = replicate.create_prediction(
        version="black-forest-labs/flux-schnell",
        input={"prompt": prompt, "num_outputs": 1},
        webhook=f"https://myapp.com/webhook/image/{prompt[:20]}",
        webhook_events_filter=["completed"],
    )
    results.append(result)

# Cost: ~$0.0023 per image
# Time: 3-8 seconds per image (async)
# Total for 100: $0.23, 10-15 minutes

import asyncio
import fal_client

async def generate_batch(prompts):
    tasks = []
    for prompt in prompts:
        task = fal_client.submit_async(
            "fal-ai/flux/dev",
            arguments={"prompt": prompt, "image_size": "landscape_4_3"},
        )
        tasks.append(task)

    # All requests fire in parallel
    results = await asyncio.gather(*tasks)
    return results

# Cost: ~$0.025 per image
# Time: 5-8 seconds for entire batch (parallel)
# Total for 100: $2.50, 10 seconds

import os
import replicate
from pathlib import Path

def upscale_product_images(input_dir: str, output_dir: str):
    """Generate 4x upscales + detail enhancement for all product photos."""

    Path(output_dir).mkdir(exist_ok=True)

    for image_path in Path(input_dir).glob("*.jpg"):
        with open(image_path, "rb") as f:
            image_data = f.read()

        # Run upscaler (4x resolution, 2-3 seconds)
        output = replicate.run(
            "nightmareai/real-esrgan",
            input={"image": image_data, "scale": 4},
        )

        upscaled_path = Path(output_dir) / f"{image_path.stem}_4x.png"
        with open(upscaled_path, "wb") as f:
            f.write(output)

        # Cost: $0.0023 per image, batch of 50 = $0.115
        print(f"Upscaled: {upscaled_path}")

# Usage
upscale_product_images("./product_photos", "./product_photos_4x")