feat: add Nano Banana Pro image API support and extract common image API utilities

banana_pro_image.py

@@ -0,0 +1,128 @@
+import os
+import argparse
+import requests
+from image_api_utils import (
+    IMAGE_API_BASE_URL,
+    API_KEY,
+    get_auth_headers,
+    upload_file_to_s3,
+    delete_file_from_s3,
+    poll_task_status,
+    download_image,
+    run_media_generation_pipeline
+)
+
+MODEL_NAME = "gemini-3-pro-image-preview"
+
+def generate_image(s3_urls=None, prompt="", aspect_ratio="1:1", image_size="2K", notify_url=None):
+    """
+    Triggers the image generation task using the Nano Banana Pro (gemini-3-pro-image-preview) model.
+    
+    :param s3_urls: List of reference image URLs (up to 14) for img2img, or None for txt2img.
+    :param prompt: Text prompt describing the desired image content.
+    :param aspect_ratio: Image aspect ratio. Allowed: "1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"
+    :param image_size: Image resolution/quality. Allowed: "1K", "2K", "4K"
+    :param notify_url: Optional webhook URL for async callback.
+    :return: task_id string/int
+    """
+    url = f"{IMAGE_API_BASE_URL}/v1/media/generate"
+    
+    params = {
+        "aspectRatio": aspect_ratio,
+        "imageSize": image_size
+    }
+    
+    if s3_urls:
+        if isinstance(s3_urls, str):
+            s3_urls = [s3_urls]
+        params["images"] = s3_urls
+
+    payload = {
+        "model": MODEL_NAME,
+        "params": params,
+        "prompt": prompt
+    }
+    
+    if notify_url:
+        payload["notify_url"] = notify_url
+    
+    headers = get_auth_headers(api_key=API_KEY)
+    print(f"[*] Sending Banana Pro ({MODEL_NAME}) generation request to: {url}")
+    response = requests.post(url, json=payload, headers=headers)
+    response.raise_for_status()
+    res_json = response.json()
+    
+    # Try parsing task_id from root or nested "data" dictionary
+    task_id = res_json.get("task_id")
+    if not task_id and "data" in res_json and isinstance(res_json["data"], dict):
+        task_id = res_json["data"].get("task_id")
+        
+    if not task_id:
+        raise ValueError(f"Failed to obtain task_id from response: {res_json}")
+    print(f"[+] Task created successfully. Task ID: {task_id}")
+    return task_id
+
+def generate_txt2img(prompt, output_path=None, aspect_ratio="1:1", image_size="2K", notify_url=None):
+    """
+    Text-to-image API for Nano Banana Pro (gemini-3-pro-image-preview).
+    """
+    def task_fn(_):
+        return generate_image(
+            s3_urls=None,
+            prompt=prompt,
+            aspect_ratio=aspect_ratio,
+            image_size=image_size,
+            notify_url=notify_url
+        )
+    return run_media_generation_pipeline(
+        generate_task_fn=task_fn,
+        local_image_paths=None,
+        output_path=output_path,
+        default_prefix="banana_pro_result"
+    )
+
+def generate_img2img(local_image_paths, prompt, output_path=None, aspect_ratio="1:1", image_size="2K", notify_url=None):
+    """
+    Image-to-image API for Nano Banana Pro (gemini-3-pro-image-preview).
+    """
+    def task_fn(s3_urls):
+        return generate_image(
+            s3_urls=s3_urls,
+            prompt=prompt,
+            aspect_ratio=aspect_ratio,
+            image_size=image_size,
+            notify_url=notify_url
+        )
+    return run_media_generation_pipeline(
+        generate_task_fn=task_fn,
+        local_image_paths=local_image_paths,
+        output_path=output_path,
+        default_prefix="banana_pro_result"
+    )
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="Generate image using Gemini 3 Pro (Nano Banana Pro) model.")
+    parser.add_argument("prompt", help="Text prompt for image generation.")
+    parser.add_argument("-i", "--images", nargs="+", help="Local reference image path(s) for img2img (up to 14).")
+    parser.add_argument("-o", "--output", help="Output path for the generated image.")
+    parser.add_argument("-a", "--aspect-ratio", 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 (default: 1:1).")
+    parser.add_argument("-s", "--image-size", default="2K", choices=["1K", "2K", "4K"], help="Resolution size (default: 2K).")
+    args = parser.parse_args()
+
+    if args.images:
+        generate_img2img(
+            local_image_paths=args.images,
+            prompt=args.prompt,
+            output_path=args.output,
+            aspect_ratio=args.aspect_ratio,
+            image_size=args.image_size
+        )
+    else:
+        generate_txt2img(
+            prompt=args.prompt,
+            output_path=args.output,
+            aspect_ratio=args.aspect_ratio,
+            image_size=args.image_size
+        )

gpt_image.py

@@ -1,57 +1,38 @@
 import os
-import sys
-import time
-import uuid
 import requests
-import boto3
-import mimetypes
-from dotenv import load_dotenv
+from image_api_utils import (
+    IMAGE_API_BASE_URL,
+    API_KEY,
+    AWS_BUCKET_NAME,
+    get_auth_headers,
+    upload_file_to_s3 as base_upload_file_to_s3,
+    delete_file_from_s3 as base_delete_file_from_s3,
+    poll_task_status,
+    download_image,
+    run_media_generation_pipeline
+)
 
-# Load .env file from the current directory
-env_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '.env')
-load_dotenv(env_path)
+# Kept for backward compatibility
+GPT_IMAGE_API_BASE_URL = os.getenv("IMAGE_API_BASE_URL") or os.getenv("GPT_IMAGE_API_BASE_URL") or IMAGE_API_BASE_URL
 
-# Retrieve configuration details
-AWS_ACCESS_KEY_ID = os.getenv("AWS_S3_ACCESS_KEY_ID")
-AWS_SECRET_ACCESS_KEY = os.getenv("AWS_S3_SECRET_ACCESS_KEY")
-AWS_REGION = os.getenv("AWS_REGION")
-AWS_BUCKET_NAME = os.getenv("AWS_BUCKET_NAME")
-GPT_IMAGE_API_BASE_URL = os.getenv("GPT_IMAGE_API_BASE_URL")
-API_KEY = os.getenv("API_KEY")
-
-def upload_file_to_s3(local_path, bucket, key):
+def upload_file_to_s3(local_path, bucket=None, key=None):
     """
-    Upload a local file to S3 with ACL='public-read' so the external API can access it.
+    Upload a local file to S3 (kept for backward compatibility).
     """
-    print(f"[*] Uploading '{local_path}' to S3 bucket '{bucket}' with key '{key}'...")
-    s3_client = boto3.client(
-        's3',
-        aws_access_key_id=AWS_ACCESS_KEY_ID,
-        aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
-        region_name=AWS_REGION
-    )
-    
-    # Guess mime type or default to image/png
-    content_type, _ = mimetypes.guess_type(local_path)
-    if not content_type:
-        content_type = 'image/png'
-
-    s3_client.upload_file(
-        local_path,
-        bucket,
-        key,
-        ExtraArgs={'ACL': 'public-read', 'ContentType': content_type}
-    )
-    
-    s3_url = f"https://{bucket}.s3.{AWS_REGION}.amazonaws.com/{key}"
-    print(f"[+] Uploaded successfully. S3 public URL: {s3_url}")
+    s3_url, _ = base_upload_file_to_s3(local_path, bucket=bucket, key=key)
     return s3_url
 
+def delete_file_from_s3(bucket=None, key=None):
+    """
+    Cleans up temporary file from S3 (kept for backward compatibility).
+    """
+    base_delete_file_from_s3(bucket=bucket, key=key)
+
 def generate_image(s3_urls, prompt):
     """
     Triggers the image-to-image task using the gpt-image-2 model.
     """
-    url = f"{GPT_IMAGE_API_BASE_URL}/v1/media/generate"
+    url = f"{IMAGE_API_BASE_URL}/v1/media/generate"
     payload = {
         "model": "gpt-image-2",
         "params": {
@@ -66,10 +47,7 @@ def generate_image(s3_urls, prompt):
         "prompt": prompt
     }
     
-    headers = {"Content-Type": "application/json"}
-    if API_KEY:
-        headers["Authorization"] = f"Bearer {API_KEY}"
-        
+    headers = get_auth_headers(api_key=API_KEY)
     print(f"[*] Sending image generation request to: {url}")
     response = requests.post(url, json=payload, headers=headers)
     response.raise_for_status()
@@ -85,124 +63,16 @@ def generate_image(s3_urls, prompt):
     print(f"[+] Task created successfully. Task ID: {task_id}")
     return task_id
 
-def poll_task_status(task_id, timeout_seconds=320, poll_interval=10):
-    """
-    Polls the task status with a timeout.
-    """
-    status_url = f"{GPT_IMAGE_API_BASE_URL}/v1/media/status"
-    start_time = time.time()
-    print(f"[*] Polling task status (timeout={timeout_seconds}s, interval={poll_interval}s)...")
-    
-    while True:
-        elapsed = time.time() - start_time
-        if elapsed > timeout_seconds:
-            raise TimeoutError(f"Task {task_id} timed out after {timeout_seconds} seconds.")
-            
-        try:
-            headers = {}
-            if API_KEY:
-                headers["Authorization"] = f"Bearer {API_KEY}"
-            response = requests.get(status_url, params={"task_id": task_id}, headers=headers)
-            response.raise_for_status()
-            res_json = response.json()
-            
-            # Support both flat and nested responses for task status
-            data = res_json
-            if "data" in res_json and isinstance(res_json["data"], dict):
-                if any(k in res_json["data"] for k in ["state", "is_final", "result_url"]):
-                    data = res_json["data"]
-            
-            state = data.get("state")
-            is_final = data.get("is_final", False)
-            progress = data.get("progress", "0%")
-            print(f"[*] [Elapsed: {int(elapsed)}s] State: {state}, Progress: {progress}")
-            
-            if is_final:
-                if state == "success":
-                    result_url = data.get("result_url")
-                    if not result_url:
-                        raise ValueError("Task finished with success state, but result_url is empty.")
-                    return result_url
-                else:
-                    error_msg = data.get("error", "Unknown error")
-                    raise RuntimeError(f"Task failed with state '{state}': {error_msg}")
-                    
-        except Exception as e:
-            # Print error and retry during polling
-            print(f"[!] Error querying task status: {e}")
-            
-        time.sleep(poll_interval)
-
-def download_image(url, output_path):
-    """
-    Downloads the final image from the given URL and saves it locally.
-    """
-    print(f"[*] Downloading result image from: {url}")
-    response = requests.get(url, stream=True)
-    response.raise_for_status()
-    with open(output_path, "wb") as f:
-        for chunk in response.iter_content(chunk_size=8192):
-            f.write(chunk)
-    print(f"[+] Image saved successfully to: {output_path}")
-
-def delete_file_from_s3(bucket, key):
-    """
-    Cleans up the uploaded file from S3.
-    """
-    print(f"[*] Cleaning up temporary file from S3: {key}")
-    try:
-        s3_client = boto3.client(
-            's3',
-            aws_access_key_id=AWS_ACCESS_KEY_ID,
-            aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
-            region_name=AWS_REGION
-        )
-        s3_client.delete_object(Bucket=bucket, Key=key)
-        print("[+] Temporary file deleted from S3 successfully.")
-    except Exception as e:
-        print(f"[!] Failed to delete temporary S3 object: {e}")
-
 def generate_img2img(local_image_paths, prompt, output_path=None):
     """
-    High-level API that does:
-    1. S3 uploads
-    2. Model task trigger
-    3. Status polling
-    4. Saving result locally
-    5. Clean up S3 temporary files
+    High-level API that handles S3 uploads, task submission, status polling, downloading, and cleanup.
     """
-    if not AWS_ACCESS_KEY_ID or not AWS_SECRET_ACCESS_KEY:
-        raise ValueError("AWS_S3_ACCESS_KEY_ID or AWS_S3_SECRET_ACCESS_KEY is not configured in .env.")
-
-    # Validate that all input files exist
-    for img_path in local_image_paths:
-        if not os.path.exists(img_path):
-            raise FileNotFoundError(f"Local file '{img_path}' does not exist.")
-
-    s3_uploaded_keys = []
-    s3_urls = []
-    try:
-        # 1. Upload the local images to S3
-        for img_path in local_image_paths:
-            file_ext = os.path.splitext(img_path)[1] or ".png"
-            s3_temp_key = f"temp/{uuid.uuid4()}{file_ext}"
-            s3_url = upload_file_to_s3(img_path, AWS_BUCKET_NAME, s3_temp_key)
-            s3_uploaded_keys.append(s3_temp_key)
-            s3_urls.append(s3_url)
-        
-        # 2. Invoke the image-to-image model
-        task_id = generate_image(s3_urls, prompt)
+    def task_fn(s3_urls):
+        return generate_image(s3_urls, prompt)
         
-        # 3. Poll for the task status with a 2-minute timeout
-        result_url = poll_task_status(task_id)
-        
-        # 4. Save the result to the output path
-        if not output_path:
-            output_path = f"result_{int(time.time())}.png"
-        download_image(result_url, output_path)
-        return output_path
-        
-    finally:
-        # 5. Clean up S3 temporary files
-        for key in s3_uploaded_keys:
-            delete_file_from_s3(AWS_BUCKET_NAME, key)
+    return run_media_generation_pipeline(
+        generate_task_fn=task_fn,
+        local_image_paths=local_image_paths,
+        output_path=output_path,
+        default_prefix="result"
+    )

image_api_utils.py

@@ -0,0 +1,185 @@
+import os
+import sys
+import time
+import uuid
+import requests
+import boto3
+import mimetypes
+from dotenv import load_dotenv
+
+# Load .env file from the directory of this module
+env_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '.env')
+load_dotenv(env_path)
+
+AWS_ACCESS_KEY_ID = os.getenv("AWS_S3_ACCESS_KEY_ID")
+AWS_SECRET_ACCESS_KEY = os.getenv("AWS_S3_SECRET_ACCESS_KEY")
+AWS_REGION = os.getenv("AWS_REGION")
+AWS_BUCKET_NAME = os.getenv("AWS_BUCKET_NAME")
+
+IMAGE_API_BASE_URL = os.getenv("IMAGE_API_BASE_URL")
+API_KEY = os.getenv("API_KEY")
+
+def get_auth_headers(api_key=None, content_type="application/json"):
+    """
+    Construct HTTP headers including Bearer Authorization token.
+    """
+    key = api_key or API_KEY
+    headers = {}
+    if content_type:
+        headers["Content-Type"] = content_type
+    if key:
+        headers["Authorization"] = f"Bearer {key}"
+    return headers
+
+def upload_file_to_s3(local_path, bucket=None, key=None):
+    """
+    Upload a local file to S3 with ACL='public-read' so the external API can access it.
+    Returns (s3_url, key).
+    """
+    bucket = bucket or AWS_BUCKET_NAME
+    if not AWS_ACCESS_KEY_ID or not AWS_SECRET_ACCESS_KEY:
+        raise ValueError("AWS_S3_ACCESS_KEY_ID or AWS_S3_SECRET_ACCESS_KEY is not configured in .env.")
+        
+    if not key:
+        file_ext = os.path.splitext(local_path)[1] or ".png"
+        key = f"temp/{uuid.uuid4()}{file_ext}"
+
+    print(f"[*] Uploading '{local_path}' to S3 bucket '{bucket}' with key '{key}'...")
+    s3_client = boto3.client(
+        's3',
+        aws_access_key_id=AWS_ACCESS_KEY_ID,
+        aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
+        region_name=AWS_REGION
+    )
+    
+    content_type, _ = mimetypes.guess_type(local_path)
+    if not content_type:
+        content_type = 'image/png'
+
+    s3_client.upload_file(
+        local_path,
+        bucket,
+        key,
+        ExtraArgs={'ACL': 'public-read', 'ContentType': content_type}
+    )
+    
+    s3_url = f"https://{bucket}.s3.{AWS_REGION}.amazonaws.com/{key}"
+    print(f"[+] Uploaded successfully. S3 public URL: {s3_url}")
+    return s3_url, key
+
+def delete_file_from_s3(bucket=None, key=None):
+    """
+    Cleans up the uploaded file from S3.
+    """
+    bucket = bucket or AWS_BUCKET_NAME
+    if not key:
+        return
+    print(f"[*] Cleaning up temporary file from S3: {key}")
+    try:
+        s3_client = boto3.client(
+            's3',
+            aws_access_key_id=AWS_ACCESS_KEY_ID,
+            aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
+            region_name=AWS_REGION
+        )
+        s3_client.delete_object(Bucket=bucket, Key=key)
+        print("[+] Temporary file deleted from S3 successfully.")
+    except Exception as e:
+        print(f"[!] Failed to delete temporary S3 object: {e}")
+
+def poll_task_status(task_id, api_base_url=None, api_key=None, timeout_seconds=320, poll_interval=10):
+    """
+    Polls the task status with a timeout.
+    """
+    base_url = api_base_url or IMAGE_API_BASE_URL
+    status_url = f"{base_url}/v1/media/status"
+    start_time = time.time()
+    print(f"[*] Polling task status (timeout={timeout_seconds}s, interval={poll_interval}s)...")
+    
+    headers = get_auth_headers(api_key=api_key, content_type=None)
+    
+    while True:
+        elapsed = time.time() - start_time
+        if elapsed > timeout_seconds:
+            raise TimeoutError(f"Task {task_id} timed out after {timeout_seconds} seconds.")
+            
+        try:
+            response = requests.get(status_url, params={"task_id": task_id}, headers=headers)
+            response.raise_for_status()
+            res_json = response.json()
+            
+            # Support both flat and nested responses for task status
+            data = res_json
+            if "data" in res_json and isinstance(res_json["data"], dict):
+                if any(k in res_json["data"] for k in ["state", "is_final", "result_url"]):
+                    data = res_json["data"]
+            
+            state = data.get("state")
+            is_final = data.get("is_final", False)
+            progress = data.get("progress", "0%")
+            status_text = data.get("status", "")
+            print(f"[*] [Elapsed: {int(elapsed)}s] State: {state} ({status_text}), Progress: {progress}")
+            
+            if is_final:
+                if state == "success":
+                    result_url = data.get("result_url")
+                    if not result_url:
+                        raise ValueError("Task finished with success state, but result_url is empty.")
+                    return result_url
+                else:
+                    error_msg = data.get("error", "Unknown error")
+                    raise RuntimeError(f"Task failed with state '{state}': {error_msg}")
+                    
+        except Exception as e:
+            print(f"[!] Error querying task status: {e}")
+            
+        time.sleep(poll_interval)
+
+def download_image(url, output_path):
+    """
+    Downloads the final image from the given URL and saves it locally.
+    """
+    print(f"[*] Downloading result image from: {url}")
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+    with open(output_path, "wb") as f:
+        for chunk in response.iter_content(chunk_size=8192):
+            f.write(chunk)
+    print(f"[+] Image saved successfully to: {output_path}")
+
+def run_media_generation_pipeline(generate_task_fn, local_image_paths=None, output_path=None, default_prefix="result"):
+    """
+    Generic execution pipeline for media generation tasks:
+    1. Upload local images to S3 (if any)
+    2. Invoke generation task function -> returns task_id
+    3. Poll task status -> returns result_url
+    4. Download final image to output_path
+    5. Clean up temporary S3 objects
+    """
+    s3_uploaded_keys = []
+    s3_urls = []
+    
+    if local_image_paths:
+        if isinstance(local_image_paths, str):
+            local_image_paths = [local_image_paths]
+            
+        for img_path in local_image_paths:
+            if not os.path.exists(img_path):
+                raise FileNotFoundError(f"Local file '{img_path}' does not exist.")
+            s3_url, s3_key = upload_file_to_s3(img_path)
+            s3_uploaded_keys.append(s3_key)
+            s3_urls.append(s3_url)
+            
+    try:
+        task_id = generate_task_fn(s3_urls if s3_urls else None)
+        result_url = poll_task_status(task_id)
+        
+        if not output_path:
+            output_path = f"{default_prefix}_{int(time.time())}.png"
+            
+        download_image(result_url, output_path)
+        return output_path
+        
+    finally:
+        for key in s3_uploaded_keys:
+            delete_file_from_s3(key=key)