from openai import OpenAI

client = OpenAI()  # Uses OPENAI_API_KEY env var

# Basic generation
response = client.images.generate(
    model="dall-e-3",
    prompt="A minimalist logo for 'Faion Network' featuring an abstract neural network pattern in deep blue and silver, white background, vector style",
    size="1024x1024",      # "1024x1024" | "1792x1024" | "1024x1792"
    quality="hd",          # "standard" | "hd"
    style="vivid",         # "vivid" | "natural"
    n=1                    # DALL-E 3 supports only n=1
)

image_url = response.data[0].url
revised_prompt = response.data[0].revised_prompt  # What DALL-E actually used

# URL response (default) - expires in 1 hour
response = client.images.generate(
    model="dall-e-3",
    prompt="...",
    response_format="url"
)
url = response.data[0].url

# Base64 response - for immediate use/storage
response = client.images.generate(
    model="dall-e-3",
    prompt="...",
    response_format="b64_json"
)
import base64
image_bytes = base64.b64decode(response.data[0].b64_json)
with open("image.png", "wb") as f:
    f.write(image_bytes)

# Inpainting - edit specific regions
response = client.images.edit(
    model="dall-e-2",
    image=open("original.png", "rb"),
    mask=open("mask.png", "rb"),  # Transparent areas will be regenerated
    prompt="Add a red sports car in the parking lot",
    size="1024x1024",
    n=1
)

# Variations - create similar images
response = client.images.create_variation(
    model="dall-e-2",
    image=open("source.png", "rb"),
    size="1024x1024",
    n=3
)

source ~/.secrets/openai

curl https://api.openai.com/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "dall-e-3",
    "prompt": "A futuristic AI network visualization, dark blue background with glowing neural connections",
    "n": 1,
    "size": "1024x1024",
    "quality": "hd",
    "style": "vivid"
  }'

import requests
import time

MIDJOURNEY_API_KEY = "your-api-key"
BASE_URL = "https://api.midjourney.com/v1"

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

# Submit generation request
response = requests.post(
    f"{BASE_URL}/imagine",
    headers=headers,
    json={
        "prompt": "portrait of a cyberpunk hacker, neon lights, cinematic --ar 16:9 --style raw --v 6.1",
        "webhook_url": "https://your-webhook.com/callback"  # Optional
    }
)

task_id = response.json()["task_id"]

# Poll for completion
while True:
    status = requests.get(
        f"{BASE_URL}/tasks/{task_id}",
        headers=headers
    ).json()

    if status["status"] == "completed":
        image_urls = status["images"]
        break
    elif status["status"] == "failed":
        raise Exception(f"Generation failed: {status['error']}")

    time.sleep(5)

# Upscale a specific image (U1, U2, U3, U4)
upscale_response = requests.post(
    f"{BASE_URL}/upscale",
    headers=headers,
    json={
        "task_id": task_id,
        "index": 1  # U1
    }
)

/imagine prompt: portrait of a scientist, dramatic lighting, oil painting style --ar 3:4 --v 6.1

Buttons:
U1-U4: Upscale individual images
V1-V4: Create variations
Re-roll: Generate new images

/imagine portrait of a woman with red hair, business attire --cref https://example.com/character.jpg --cw 100

--cw values:
0: Only face
50: Face + some style
100: Full character reference

/imagine mountain landscape at sunset --sref https://example.com/style.jpg --sw 500

--sw values:
0-100: Subtle influence
100-500: Moderate influence
500-1000: Strong influence

import replicate

# FLUX.1 Pro - best quality
output = replicate.run(
    "black-forest-labs/flux-1.1-pro",
    input={
        "prompt": "Professional headshot of a CEO, studio lighting, neutral background, sharp focus",
        "aspect_ratio": "1:1",
        "output_format": "webp",
        "output_quality": 90,
        "safety_tolerance": 2,
        "prompt_upsampling": True
    }
)

image_url = output
print(f"Generated: {image_url}")

# FLUX.1 Dev - open weights, good quality
output = replicate.run(
    "black-forest-labs/flux-dev",
    input={
        "prompt": "Serene Japanese garden with cherry blossoms, koi pond, photorealistic",
        "guidance": 3.5,
        "num_inference_steps": 50,
        "aspect_ratio": "16:9",
        "output_format": "png"
    }
)

# FLUX.1 Schnell - 4 steps, fastest
output = replicate.run(
    "black-forest-labs/flux-schnell",
    input={
        "prompt": "A golden retriever playing in autumn leaves",
        "num_inference_steps": 4,
        "aspect_ratio": "1:1"
    }
)

import fal_client

# Text-to-Image
result = fal_client.subscribe(
    "fal-ai/flux-pro/v1.1",
    arguments={
        "prompt": "Minimalist product shot of wireless earbuds on marble surface",
        "image_size": "landscape_16_9",
        "num_images": 1,
        "enable_safety_checker": True
    }
)

image_url = result["images"][0]["url"]

# Image-to-Image with FLUX
result = fal_client.subscribe(
    "fal-ai/flux-pro/v1.1/redux",
    arguments={
        "image_url": "https://example.com/source.jpg",
        "prompt": "Same scene but at sunset with warm golden lighting",
        "strength": 0.7
    }
)

# FLUX with Canny edge control
result = fal_client.subscribe(
    "fal-ai/flux-pro/v1.1/canny",
    arguments={
        "image_url": "https://example.com/pose_reference.jpg",
        "prompt": "Fashion model in designer outfit, studio photography",
        "control_strength": 0.8
    }
)

# FLUX with Depth control
result = fal_client.subscribe(
    "fal-ai/flux-pro/v1.1/depth",
    arguments={
        "image_url": "https://example.com/scene.jpg",
        "prompt": "Same composition but in watercolor painting style",
        "control_strength": 0.7
    }
)

# Using ComfyUI (recommended)
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt

# Download SD 3.5 Large model
# Place in ComfyUI/models/checkpoints/
# Get from huggingface.co/stabilityai/stable-diffusion-3.5-large

# Run ComfyUI
python main.py

from diffusers import StableDiffusion3Pipeline
import torch

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Basic generation
image = pipe(
    prompt="A majestic lion in the savanna at golden hour, photorealistic, 8K",
    negative_prompt="blurry, low quality, distorted",
    num_inference_steps=28,
    guidance_scale=4.5,
    height=1024,
    width=1024
).images[0]

image.save("lion.png")

from diffusers import StableDiffusion3ControlNetPipeline, SD3ControlNetModel
from diffusers.utils import load_image
import torch

# Load ControlNet model
controlnet = SD3ControlNetModel.from_pretrained(
    "stabilityai/stable-diffusion-3.5-controlnet-canny",
    torch_dtype=torch.float16
)

pipe = StableDiffusion3ControlNetPipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    controlnet=controlnet,
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Load control image
control_image = load_image("https://example.com/canny_edges.png")

# Generate with control
image = pipe(
    prompt="Modern architecture building, glass and steel, sunny day",
    control_image=control_image,
    controlnet_conditioning_scale=0.8,
    num_inference_steps=28
).images[0]

# Load base model with LoRA
from diffusers import StableDiffusion3Pipeline
import torch

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    torch_dtype=torch.float16
)

# Load custom LoRA
pipe.load_lora_weights("path/to/custom_style.safetensors")
pipe.to("cuda")

# Generate with LoRA style
image = pipe(
    prompt="portrait of a person in custom_style",
    num_inference_steps=28
).images[0]

{
  "workflow": {
    "nodes": [
      {
        "id": 1,
        "type": "CheckpointLoaderSimple",
        "inputs": {"ckpt_name": "sd3.5_large.safetensors"}
      },
      {
        "id": 2,
        "type": "CLIPTextEncode",
        "inputs": {"text": "beautiful landscape, mountains, sunset"}
      },
      {
        "id": 3,
        "type": "KSampler",
        "inputs": {
          "seed": 42,
          "steps": 28,
          "cfg": 4.5,
          "sampler_name": "euler",
          "scheduler": "normal"
        }
      },
      {
        "id": 4,
        "type": "VAEDecode",
        "inputs": {}
      },
      {
        "id": 5,
        "type": "SaveImage",
        "inputs": {"filename_prefix": "output"}
      }
    ]
  }
}

import requests

IDEOGRAM_API_KEY = "your-api-key"

response = requests.post(
    "https://api.ideogram.ai/generate",
    headers={
        "Api-Key": IDEOGRAM_API_KEY,
        "Content-Type": "application/json"
    },
    json={
        "image_request": {
            "prompt": "A modern tech startup logo with the text 'FAION' in bold geometric font, blue and silver gradient, white background, vector style",
            "aspect_ratio": "ASPECT_1_1",
            "model": "V_2",
            "magic_prompt_option": "AUTO",
            "style_type": "DESIGN"
        }
    }
)

result = response.json()
image_url = result["data"][0]["url"]

[Subject] + [Setting/Environment] + [Style] + [Lighting] + [Composition] + [Technical]

A professional businesswoman | in a modern glass office | corporate photography style |
soft natural window light | medium shot, shallow depth of field | 8K, sharp focus

High quality: 8K, UHD, high resolution, sharp focus, detailed
Camera: shot on Sony A7R IV, Canon EOS R5, Hasselblad
Lens: 85mm f/1.4, 35mm wide angle, macro lens
Post-processing: color graded, professionally retouched

blurry, low quality, distorted, deformed, ugly, duplicate,
watermark, text, signature, cropped, out of frame,
extra limbs, bad anatomy, bad proportions, gross proportions,
mutation, disfigured, poorly drawn, jpeg artifacts

# FLUX Redux for style transfer
import fal_client

result = fal_client.subscribe(
    "fal-ai/flux-pro/v1.1/redux",
    arguments={
        "image_url": "https://example.com/photo.jpg",
        "prompt": "Same scene in impressionist painting style, vibrant colors",
        "strength": 0.6  # 0.3-0.8 typical range
    }
)

# Stable Diffusion img2img
from diffusers import StableDiffusion3Img2ImgPipeline
from diffusers.utils import load_image

pipe = StableDiffusion3Img2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    torch_dtype=torch.float16
)
pipe.to("cuda")

init_image = load_image("photo.png").resize((1024, 1024))

image = pipe(
    prompt="oil painting style, impressionist brush strokes",
    image=init_image,
    strength=0.7,  # How much to change (0-1)
    num_inference_steps=28
).images[0]

# Using Real-ESRGAN via Replicate
import replicate

output = replicate.run(
    "nightmareai/real-esrgan:350d32041630ffbe63c8352783a26d94126809164e54085352f8571e3d4edd3b",
    input={
        "image": open("low_res.png", "rb"),
        "scale": 4,  # 2x or 4x
        "face_enhance": True
    }
)

# Using FLUX for creative upscaling
output = replicate.run(
    "black-forest-labs/flux-1.1-pro-ultra",
    input={
        "image": open("source.png", "rb"),
        "prompt": "enhance details, sharp focus, 4K resolution",
        "aspect_ratio": "1:1",
        "output_quality": 100
    }
)

# Using remove.bg API
import requests

response = requests.post(
    "https://api.remove.bg/v1.0/removebg",
    files={"image_file": open("photo.png", "rb")},
    data={"size": "auto"},
    headers={"X-Api-Key": "YOUR_API_KEY"}
)

with open("no_bg.png", "wb") as f:
    f.write(response.content)

# Using Replicate
output = replicate.run(
    "lucataco/remove-bg:95fcc2a26d3899cd6c2691c900465aaeff466285a65c14638cc5f36f34befaf1",
    input={"image": open("photo.png", "rb")}
)

# DALL-E 2 Inpainting
from openai import OpenAI
client = OpenAI()

response = client.images.edit(
    model="dall-e-2",
    image=open("scene.png", "rb"),
    mask=open("mask.png", "rb"),  # White = keep, Transparent = edit
    prompt="A golden retriever sitting on the grass",
    size="1024x1024"
)

# Stable Diffusion Inpainting
from diffusers import StableDiffusionInpaintPipeline
from diffusers.utils import load_image

pipe = StableDiffusionInpaintPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-inpainting",
    torch_dtype=torch.float16
)
pipe.to("cuda")

init_image = load_image("scene.png").resize((512, 512))
mask_image = load_image("mask.png").resize((512, 512))

image = pipe(
    prompt="a beautiful flower garden",
    image=init_image,
    mask_image=mask_image,
    num_inference_steps=50
).images[0]

# Automatic mask with Segment Anything
from segment_anything import SamPredictor, sam_model_registry
import numpy as np
from PIL import Image

sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h.pth")
predictor = SamPredictor(sam)

image = np.array(Image.open("photo.png"))
predictor.set_image(image)

# Point-based segmentation
masks, scores, _ = predictor.predict(
    point_coords=np.array([[500, 300]]),  # Click point
    point_labels=np.array([1]),  # 1 = foreground
    multimask_output=True
)

# Save best mask
best_mask = masks[np.argmax(scores)]
mask_image = Image.fromarray((best_mask * 255).astype(np.uint8))
mask_image.save("mask.png")

# DALL-E 2 Outpainting
from PIL import Image
import numpy as np

# Create expanded canvas with transparent edges
original = Image.open("original.png")
expanded = Image.new("RGBA", (1024, 1024), (0, 0, 0, 0))

# Center original in expanded canvas
x_offset = (1024 - original.width) // 2
y_offset = (1024 - original.height) // 2
expanded.paste(original, (x_offset, y_offset))

# Create mask (white = keep, transparent = generate)
mask = Image.new("RGBA", (1024, 1024), (0, 0, 0, 0))
mask.paste(Image.new("RGB", original.size, (255, 255, 255)), (x_offset, y_offset))

# Save for API
expanded.save("expanded.png")
mask.save("outpaint_mask.png")

# Use with DALL-E 2 edit endpoint
response = client.images.edit(
    model="dall-e-2",
    image=open("expanded.png", "rb"),
    mask=open("outpaint_mask.png", "rb"),
    prompt="continuation of the landscape scene, same style",
    size="1024x1024"
)

import os
import json
import hashlib
from datetime import datetime

class ImageGenerationPipeline:
    def __init__(self, output_dir: str = "generated_assets"):
        self.output_dir = output_dir
        os.makedirs(output_dir, exist_ok=True)
        self.manifest = []

    def generate_dall_e(self, prompt: str, **kwargs) -> dict:
        from openai import OpenAI
        client = OpenAI()

        response = client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size=kwargs.get("size", "1024x1024"),
            quality=kwargs.get("quality", "hd"),
            style=kwargs.get("style", "vivid"),
            response_format="b64_json"
        )

        # Save image
        import base64
        image_data = base64.b64decode(response.data[0].b64_json)
        prompt_hash = hashlib.md5(prompt.encode()).hexdigest()[:8]
        filename = f"dalle3_{prompt_hash}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
        filepath = os.path.join(self.output_dir, filename)

        with open(filepath, "wb") as f:
            f.write(image_data)

        # Record metadata
        metadata = {
            "model": "dall-e-3",
            "prompt": prompt,
            "revised_prompt": response.data[0].revised_prompt,
            "filepath": filepath,
            "timestamp": datetime.now().isoformat(),
            "params": kwargs
        }
        self.manifest.append(metadata)

        return metadata

    def generate_flux(self, prompt: str, **kwargs) -> dict:
        import replicate

        model = kwargs.get("model", "black-forest-labs/flux-1.1-pro")
        output = replicate.run(
            model,
            input={
                "prompt": prompt,
                "aspect_ratio": kwargs.get("aspect_ratio", "1:1"),
                "output_format": kwargs.get("format", "png")
            }
        )

        # Download image
        import requests
        response = requests.get(output)
        prompt_hash = hashlib.md5(prompt.encode()).hexdigest()[:8]
        filename = f"flux_{prompt_hash}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
        filepath = os.path.join(self.output_dir, filename)

        with open(filepath, "wb") as f:
            f.write(response.content)

        metadata = {
            "model": model,
            "prompt": prompt,
            "filepath": filepath,
            "timestamp": datetime.now().isoformat(),
            "params": kwargs
        }
        self.manifest.append(metadata)

        return metadata

    def save_manifest(self):
        manifest_path = os.path.join(self.output_dir, "manifest.json")
        with open(manifest_path, "w") as f:
            json.dump(self.manifest, f, indent=2)

# Usage
pipeline = ImageGenerationPipeline("project_assets")

# Generate hero images
for style in ["professional", "creative", "minimalist"]:
    pipeline.generate_dall_e(
        f"Hero image for tech startup, {style} style, abstract neural network pattern",
        quality="hd",
        size="1792x1024"
    )

pipeline.save_manifest()

import asyncio
from typing import List, Dict

async def batch_generate(prompts: List[str], model: str = "flux") -> List[Dict]:
    """Generate multiple images concurrently."""
    import aiohttp
    import replicate

    async def generate_one(prompt: str) -> Dict:
        output = await asyncio.to_thread(
            replicate.run,
            "black-forest-labs/flux-1.1-pro",
            input={"prompt": prompt, "aspect_ratio": "1:1"}
        )
        return {"prompt": prompt, "url": output}

    tasks = [generate_one(p) for p in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)

    return [r for r in results if not isinstance(r, Exception)]

# Usage
prompts = [
    "Product shot of wireless earbuds on marble",
    "Product shot of smartwatch on wooden desk",
    "Product shot of laptop in modern office",
]

results = asyncio.run(batch_generate(prompts))

def generate_variants(base_prompt: str, variations: List[str], model: str = "dall-e-3") -> List[Dict]:
    """Generate prompt variations for A/B testing."""
    from openai import OpenAI
    client = OpenAI()

    results = []
    for variation in variations:
        full_prompt = f"{base_prompt}, {variation}"
        response = client.images.generate(
            model="dall-e-3",
            prompt=full_prompt,
            size="1024x1024",
            quality="standard"
        )
        results.append({
            "variation": variation,
            "prompt": full_prompt,
            "revised_prompt": response.data[0].revised_prompt,
            "url": response.data[0].url
        })

    return results

# Test different styles
variants = generate_variants(
    base_prompt="Landing page hero image for AI productivity app",
    variations=[
        "minimalist design, blue gradient",
        "vibrant colors, abstract shapes",
        "dark theme, neon accents",
        "natural lighting, workspace setting"
    ]
)