Flux Image Edit API

from openai import OpenAI

# Initialize client
client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

def edit_local_image(image_path, prompt, aspect_ratio="1:1", mask_path=None,
                    seed=None, safety_tolerance=1, output_format="png"):
    """Edit local image"""
    try:
        # Prepare base parameters
        edit_params = {
            "model": "flux-kontext-max",
            "image": open(image_path, "rb"),
            "prompt": prompt,
            "extra_body": {
                "aspect_ratio": aspect_ratio,
                "safety_tolerance": safety_tolerance,
                "output_format": output_format
            }
        }

        # Optional parameters
        if seed is not None:
            edit_params["extra_body"]["seed"] = seed

        # If mask exists, add to parameters
        if mask_path:
            edit_params["mask"] = open(mask_path, "rb")

        # Call edit API
        response = client.images.edit(**edit_params)

        # Return edited image URL (note: URL valid for 10 minutes)
        return response.data[0].url

    except Exception as e:
        print(f"Edit failed: {e}")
        return None

    finally:
        # Ensure file handles are closed
        if 'edit_params' in locals():
            if 'image' in edit_params:
                edit_params['image'].close()
            if 'mask' in edit_params:
                edit_params['mask'].close()

# Usage example
edited_url = edit_local_image(
    image_path="portrait.jpg",
    prompt="Change the background to a beautiful sunset sky",
    aspect_ratio="2:3",
    seed=42,  # Reproducible results
    safety_tolerance=1,  # Safety level (0-2)
    output_format="jpeg"  # Or "png"
)

if edited_url:
    print(f"Edit complete: {edited_url}")
    print("Note: URL will expire after 10 minutes, download promptly!")

import requests
import tempfile
import os
from urllib.parse import urlparse

def download_image_from_url(url):
    """Download image from URL to temporary file"""
    try:
        response = requests.get(url, timeout=30)
        response.raise_for_status()

        # Get file extension
        parsed_url = urlparse(url)
        extension = parsed_url.path.split('.')[-1] if '.' in parsed_url.path else 'jpg'

        # Create temporary file
        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=f'.{extension}')
        temp_file.write(response.content)
        temp_file.close()

        return temp_file.name

    except Exception as e:
        print(f"Image download failed: {e}")
        return None

def edit_online_image(image_url, prompt, aspect_ratio="1:1", mask_url=None):
    """Edit online image"""
    image_path = None
    mask_path = None

    try:
        # Download original image
        image_path = download_image_from_url(image_url)
        if not image_path:
            return None

        # Download mask (if exists)
        if mask_url:
            mask_path = download_image_from_url(mask_url)

        # Edit image
        result = edit_local_image(image_path, prompt, aspect_ratio, mask_path)

        return result

    finally:
        # Clean up temporary files
        for path in [image_path, mask_path]:
            if path and os.path.exists(path):
                os.unlink(path)

# Usage example
edited_url = edit_online_image(
    image_url="https://example.com/photo.jpg",
    prompt="Remove the person in the background, keep the foreground intact",
    aspect_ratio="16:9"
)

def batch_edit_images(edit_tasks):
    """Batch edit images"""
    results = []

    for task in edit_tasks:
        try:
            print(f"Editing: {task['image_path']}")
            print(f"Edit instruction: {task['prompt']}")

            edited_url = edit_local_image(
                image_path=task['image_path'],
                prompt=task['prompt'],
                aspect_ratio=task.get('aspect_ratio', '1:1'),
                mask_path=task.get('mask_path')
            )

            if edited_url:
                # Download edited image
                filename = save_edited_image(edited_url, task['image_path'])

                results.append({
                    'original': task['image_path'],
                    'prompt': task['prompt'],
                    'edited_url': edited_url,
                    'saved_file': filename,
                    'success': True
                })
            else:
                results.append({
                    'original': task['image_path'],
                    'prompt': task['prompt'],
                    'success': False,
                    'error': 'API call failed'
                })

        except Exception as e:
            results.append({
                'original': task['image_path'],
                'prompt': task['prompt'],
                'success': False,
                'error': str(e)
            })

    return results

def save_edited_image(url, original_path):
    """Save edited image"""
    import time

    response = requests.get(url)
    if response.status_code == 200:
        # Generate new filename
        base_name = os.path.splitext(os.path.basename(original_path))[0]
        timestamp = int(time.time())
        filename = f"{base_name}_edited_{timestamp}.png"

        with open(filename, 'wb') as f:
            f.write(response.content)

        print(f"Saved: {filename}")
        return filename

    return None

# Batch editing example
edit_tasks = [
    {
        'image_path': 'photo1.jpg',
        'prompt': 'Change the sky to a dramatic stormy sky',
        'aspect_ratio': '3:2'
    },
    {
        'image_path': 'photo2.jpg',
        'prompt': 'Remove all people from the image',
        'aspect_ratio': '16:9',
        'mask_path': 'mask2.png'
    },
    {
        'image_path': 'photo3.jpg',
        'prompt': 'Make the image look like a vintage photograph',
        'aspect_ratio': '1:1'
    }
]

results = batch_edit_images(edit_tasks)

# Output results
for result in results:
    if result['success']:
        print(f"✅ {result['original']} -> {result['saved_file']}")
    else:
        print(f"❌ {result['original']} -> {result['error']}")

# Add text to image
add_text = edit_local_image(
    image_path="poster.jpg",
    prompt='Add the text "SALE 50% OFF" in bold red letters at the top center',
    aspect_ratio="3:2"
)

# Modify existing text
modify_text = edit_local_image(
    image_path="sign.jpg",
    prompt='Change the text from "Open" to "Closed"',
    aspect_ratio="1:1"
)

# Use quotes for text accuracy
precise_text = edit_local_image(
    image_path="banner.jpg",
    prompt='Replace the existing text with exactly "Welcome to Our Store"',
    aspect_ratio="7:3"
)

# Maintain lighting consistency
lighting_edit = edit_local_image(
    image_path="interior.jpg",
    prompt="Add a lamp in the corner, matching the existing warm lighting",
    aspect_ratio="16:9"
)

# Maintain perspective and proportions
perspective_edit = edit_local_image(
    image_path="street.jpg",
    prompt="Add a bicycle parked next to the building, matching the street perspective",
    aspect_ratio="3:2"
)

# Maintain character features
character_edit = edit_local_image(
    image_path="person.jpg",
    prompt="Change the person's shirt to blue while keeping all facial features identical",
    aspect_ratio="2:3",
    seed=42  # Use fixed seed for consistency
)

# Change background
background_edit = edit_local_image(
    image_path="portrait.jpg",
    prompt="Replace the background with a modern office environment",
    aspect_ratio="2:3"
)

# Remove background
remove_bg = edit_local_image(
    image_path="product.jpg",
    prompt="Remove the background, make it transparent",
    aspect_ratio="1:1"
)

# Add elements
add_element = edit_local_image(
    image_path="room.jpg",
    prompt="Add a beautiful plant in the corner of the room",
    aspect_ratio="16:9"
)

# Remove objects
remove_object = edit_local_image(
    image_path="street.jpg",
    prompt="Remove the car from the street, replace with empty road",
    aspect_ratio="3:2"
)

# Replace objects
replace_object = edit_local_image(
    image_path="table.jpg",
    prompt="Replace the apple on the table with an orange",
    aspect_ratio="1:1"
)

# Artistic style
artistic_style = edit_local_image(
    image_path="landscape.jpg",
    prompt="Transform into an impressionist painting style",
    aspect_ratio="3:2"
)

# Season change
season_change = edit_local_image(
    image_path="park.jpg",
    prompt="Change from summer to autumn, add colorful fall leaves",
    aspect_ratio="16:9"
)

# Use mask for precise area editing
masked_edit = edit_local_image(
    image_path="group_photo.jpg",
    prompt="Blur the faces of the people in the masked area",
    aspect_ratio="3:2",
    mask_path="face_mask.png"  # White areas will be edited
)

from PIL import Image, ImageDraw

def create_circular_mask(image_path, center, radius):
    """Create circular mask"""
    # Open original to get dimensions
    with Image.open(image_path) as img:
        width, height = img.size

    # Create black background mask
    mask = Image.new('L', (width, height), 0)
    draw = ImageDraw.Draw(mask)

    # Draw white circle (edit region)
    left = center[0] - radius
    top = center[1] - radius
    right = center[0] + radius
    bottom = center[1] + radius

    draw.ellipse([left, top, right, bottom], fill=255)

    # Save mask
    mask_path = f"circular_mask_{int(time.time())}.png"
    mask.save(mask_path)
    return mask_path

def create_rectangular_mask(image_path, bbox):
    """Create rectangular mask"""
    with Image.open(image_path) as img:
        width, height = img.size

    mask = Image.new('L', (width, height), 0)
    draw = ImageDraw.Draw(mask)

    # Draw white rectangle (edit region)
    draw.rectangle(bbox, fill=255)

    mask_path = f"rect_mask_{int(time.time())}.png"
    mask.save(mask_path)
    return mask_path

# Usage example
mask_path = create_circular_mask("photo.jpg", center=(500, 300), radius=100)
edited = edit_local_image("photo.jpg", "Add sunglasses", mask_path=mask_path)

# ❌ Vague description
prompt = "make it better"

# ✅ Specific and detailed instructions
prompt = """
Remove the person standing in the background on the left side,
fill the area with matching landscape elements,
maintain the original lighting and perspective
"""

# ✅ Text editing with quotes
text_prompt = 'Change the store sign text to "OPEN 24/7" in red letters'

# ✅ Consistency instructions
consistency_prompt = """
Add a red sports car parked in the driveway,
matching the existing lighting conditions and perspective,
ensure it fits naturally with the house architecture
"""

# ✅ Precise local editing
precise_prompt = """
Change only the woman's dress color from blue to emerald green,
keep all other elements including lighting, background, and pose unchanged
"""

def create_professional_prompt(action, target, context_preservation):
    """Create professional-grade editing prompt"""
    return f"""
    {action} {target}.
    Maintain the original {context_preservation}.
    Ensure the edit looks natural and seamlessly integrated.
    """

# Example usage
prompt = create_professional_prompt(
    action="Replace",
    target="the cloudy sky with a clear sunset sky",
    context_preservation="lighting, shadows, and overall atmosphere"
)

def recommend_aspect_ratio(edit_type, original_ratio=None):
    """Recommend aspect ratio based on edit type"""
    recommendations = {
        "portrait_edit": "2:3",
        "landscape_edit": "3:2",
        "social_media": "1:1",
        "banner_creation": "7:3",
        "mobile_content": "9:16",
        "desktop_wallpaper": "16:9"
    }

    # If original ratio exists, prioritize maintaining it
    if original_ratio:
        return original_ratio

    return recommendations.get(edit_type, "1:1")

import time

def edit_with_retry(image_path, prompt, max_retries=3, **kwargs):
    """Image editing with retry mechanism"""
    for attempt in range(max_retries):
        try:
            result = edit_local_image(image_path, prompt, **kwargs)
            if result:
                return result
        except Exception as e:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Edit failed, retrying in {wait_time}s... (attempt {attempt + 1}/{max_retries})")
                time.sleep(wait_time)
            else:
                print(f"Edit ultimately failed: {e}")
                raise e

    return None

import time
import requests
from concurrent.futures import ThreadPoolExecutor

def download_with_urgency(url, filename, max_attempts=3):
    """Urgent download considering 10-minute expiry"""
    start_time = time.time()

    for attempt in range(max_attempts):
        try:
            response = requests.get(url, timeout=30)
            response.raise_for_status()

            with open(filename, 'wb') as f:
                f.write(response.content)

            elapsed = time.time() - start_time
            print(f"✅ Download successful: {filename} (took {elapsed:.1f}s)")
            return True

        except Exception as e:
            elapsed = time.time() - start_time
            if elapsed > 540:  # Over 9 minutes, 1 minute buffer
                print(f"⚠️ Warning: Approaching URL expiry time!")

            if attempt < max_attempts - 1:
                print(f"Download failed, retrying... (attempt {attempt + 1}/{max_attempts})")
                time.sleep(1)
            else:
                print(f"❌ Download ultimately failed: {e}")
                return False

    return False

def batch_edit_with_immediate_download(tasks):
    """Batch edit with immediate download"""
    def edit_and_download(task):
        # Edit
        edited_url = edit_local_image(**task['edit_params'])
        if not edited_url:
            return {'success': False, 'error': 'Edit failed'}

        # Download immediately
        filename = f"{task['name']}_edited_{int(time.time())}.png"
        success = download_with_urgency(edited_url, filename)

        return {
            'success': success,
            'filename': filename if success else None,
            'url': edited_url,
            'task_name': task['name']
        }

    # Parallel processing to save time
    with ThreadPoolExecutor(max_workers=3) as executor:
        results = list(executor.map(edit_and_download, tasks))

    return results