update

banana_pro_image.py

@@ -1,24 +1,23 @@
-import os
 import argparse
+
 import requests
 from image_api_utils import (
     IMAGE_API_BASE_URL,
     API_KEY,
+    encode_json_request,
     get_auth_headers,
-    upload_file_to_s3,
-    delete_file_from_s3,
-    poll_task_status,
-    download_image,
-    run_media_generation_pipeline
+    poll_and_download_result,
+    prepare_reference_images,
 )
 
 MODEL_NAME = "gemini-3-pro-image-preview"
 
-def generate_image(s3_urls=None, prompt="", aspect_ratio="1:1", image_size="2K", notify_url=None):
+
+def generate_image(images=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 images: Up to 14 local image paths, HTTP(S) URLs, or base64 data URLs.
     :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"
@@ -32,10 +31,9 @@ def generate_image(s3_urls=None, prompt="", aspect_ratio="1:1", image_size="2K",
         "imageSize": image_size
     }
     
-    if s3_urls:
-        if isinstance(s3_urls, str):
-            s3_urls = [s3_urls]
-        params["images"] = s3_urls
+    reference_images = prepare_reference_images(images)
+    if reference_images:
+        params["images"] = reference_images
 
     payload = {
         "model": MODEL_NAME,
@@ -45,10 +43,12 @@ def generate_image(s3_urls=None, prompt="", aspect_ratio="1:1", image_size="2K",
     
     if notify_url:
         payload["notify_url"] = notify_url
+
+    payload_body = encode_json_request(payload)
     
     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 = requests.post(url, data=payload_body, headers=headers)
     response.raise_for_status()
     res_json = response.json()
     
@@ -62,48 +62,52 @@ def generate_image(s3_urls=None, prompt="", aspect_ratio="1:1", image_size="2K",
     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,
+    task_id = generate_image(
+        images=None,
+        prompt=prompt,
+        aspect_ratio=aspect_ratio,
+        image_size=image_size,
+        notify_url=notify_url,
+    )
+    return poll_and_download_result(
+        task_id=task_id,
         output_path=output_path,
-        default_prefix="banana_pro_result"
+        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).
+    Image-to-image API accepting local paths, HTTP(S) URLs, or base64 data URLs.
     """
-    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,
+    task_id = generate_image(
+        images=local_image_paths,
+        prompt=prompt,
+        aspect_ratio=aspect_ratio,
+        image_size=image_size,
+        notify_url=notify_url,
+    )
+    return poll_and_download_result(
+        task_id=task_id,
         output_path=output_path,
-        default_prefix="banana_pro_result"
+        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(
+        "-i",
+        "--images",
+        nargs="+",
+        help="Reference image path(s), HTTP(S) URL(s), or base64 data URL(s), 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"], 

gpt_image.py

@@ -1,78 +1,70 @@
 import os
+
 import requests
 from image_api_utils import (
     IMAGE_API_BASE_URL,
     API_KEY,
-    AWS_BUCKET_NAME,
+    encode_json_request,
     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
+    poll_and_download_result,
+    prepare_reference_images,
 )
 
-# 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
+GPT_IMAGE_API_BASE_URL = (
+    os.getenv("IMAGE_API_BASE_URL")
+    or os.getenv("GPT_IMAGE_API_BASE_URL")
+    or IMAGE_API_BASE_URL
+)
+MODEL_NAME = "gpt-image-2"
 
-def upload_file_to_s3(local_path, bucket=None, key=None):
-    """
-    Upload a local file to S3 (kept for backward compatibility).
-    """
-    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).
+def generate_image(images, prompt):
     """
-    base_delete_file_from_s3(bucket=bucket, key=key)
-
-def generate_image(s3_urls, prompt):
+    Trigger a gpt-image-2 task using local paths, URLs, or base64 data URLs.
     """
-    Triggers the image-to-image task using the gpt-image-2 model.
-    """
-    url = f"{IMAGE_API_BASE_URL}/v1/media/generate"
+    url = f"{GPT_IMAGE_API_BASE_URL}/v1/media/generate"
+    reference_images = prepare_reference_images(images)
     payload = {
-        "model": "gpt-image-2",
+        "model": MODEL_NAME,
         "params": {
             "aspect_ratio": "1:1",
-            "images": s3_urls,
+            "images": reference_images,
             "n": 1,
             "quality": "high",
             "resolution": "1K",
             "response_format": "url",
-            "size": "1024x1024"
+            "size": "1024x1024",
         },
-        "prompt": prompt
+        "prompt": prompt,
     }
-    
+
+    payload_body = encode_json_request(payload)
     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 = requests.post(url, data=payload_body, 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_img2img(local_image_paths, prompt, output_path=None):
     """
-    High-level API that handles S3 uploads, task submission, status polling, downloading, and cleanup.
+    Generate an image using up to 14 local paths, URLs, or base64 data URLs.
     """
-    def task_fn(s3_urls):
-        return generate_image(s3_urls, prompt)
-        
-    return run_media_generation_pipeline(
-        generate_task_fn=task_fn,
-        local_image_paths=local_image_paths,
+    task_id = generate_image(local_image_paths, prompt)
+    return poll_and_download_result(
+        task_id=task_id,
         output_path=output_path,
-        default_prefix="result"
+        default_prefix="result",
+        api_base_url=GPT_IMAGE_API_BASE_URL,
+        api_key=API_KEY,
     )

gpt_skin2real.py

@@ -13,11 +13,18 @@ from alice_to_steve import alice_to_steve
 from mc_voxel_texture_resolver import resolve_voxel_consistency
 
 def main():
-    parser = argparse.ArgumentParser(description="Render Minecraft skin to 3D views, upload to S3, and call img2img model.")
+    parser = argparse.ArgumentParser(
+        description="Render Minecraft skin to 3D views and call the img2img model with base64 references."
+    )
     parser.add_argument("skin", help="Path to local Minecraft skin image file.")
     parser.add_argument("-o", "--output", help="Output path for the generated image. Defaults to 'result_<timestamp>.png'.")
     parser.add_argument("-p", "--prompt", default="生成ta的全身真人照片，再生成ta的背面放在图片右边。请准确还原人物的特征细节，注意真人照片里面通常不包含像素风格的装饰。", help="Prompt for the img2img model.")
-    parser.add_argument("-r", "--render-only", action="store_true", help="Only render the 3D front and back views locally, without calling the S3/img2img pipeline.")
+    parser.add_argument(
+        "-r",
+        "--render-only",
+        action="store_true",
+        help="Only render the 3D front and back views locally, without calling img2img.",
+    )
     args = parser.parse_args()
 
     # 1. Validate skin path

image_api_utils.py

@@ -1,24 +1,26 @@
+import base64
+import binascii
+import json
+import mimetypes
 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")
 
+MAX_REFERENCE_IMAGES = 14
+MAX_IMAGE_BYTES = 10 * 1024 * 1024
+MAX_BASE64_TOTAL_BYTES = 30 * 1024 * 1024
+MAX_REQUEST_BODY_BYTES = 50 * 1024 * 1024
+
+
 def get_auth_headers(api_key=None, content_type="application/json"):
     """
     Construct HTTP headers including Bearer Authorization token.
@@ -31,61 +33,109 @@ def get_auth_headers(api_key=None, content_type="application/json"):
         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 _validate_data_url(data_url):
+    header, separator, encoded_data = data_url.partition(",")
+    header_lower = header.lower()
+    if (
+        not separator
+        or not header_lower.startswith("data:image/")
+        or ";base64" not in header_lower
+    ):
+        raise ValueError(
+            "Inline reference images must use the format "
+            "'data:image/...;base64,<data>'."
+        )
 
-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
+        decoded_size = len(base64.b64decode(encoded_data, validate=True))
+    except (binascii.Error, ValueError) as exc:
+        raise ValueError("Reference image contains invalid base64 data.") from exc
+
+    if decoded_size > MAX_IMAGE_BYTES:
+        raise ValueError(
+            f"Inline reference image is {decoded_size / 1024 / 1024:.2f}MB after decoding; "
+            f"the maximum is {MAX_IMAGE_BYTES / 1024 / 1024:.0f}MB."
+        )
+    return decoded_size
+
+
+def _local_image_to_data_url(image_path):
+    image_path = os.fspath(image_path)
+    if not os.path.isfile(image_path):
+        raise FileNotFoundError(f"Local reference image '{image_path}' does not exist.")
+
+    file_size = os.path.getsize(image_path)
+    if file_size > MAX_IMAGE_BYTES:
+        raise ValueError(
+            f"Reference image '{image_path}' is {file_size / 1024 / 1024:.2f}MB; "
+            f"the maximum is {MAX_IMAGE_BYTES / 1024 / 1024:.0f}MB."
+        )
+
+    mime_type, _ = mimetypes.guess_type(image_path)
+    if not mime_type or not mime_type.startswith("image/"):
+        raise ValueError(
+            f"Could not determine an image MIME type for '{image_path}'. "
+            "Use a standard image extension such as .png, .jpg, .webp, or .gif."
         )
-        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}")
+
+    print(f"[*] Encoding local reference image as base64: {image_path}")
+    with open(image_path, "rb") as image_file:
+        image_data = image_file.read()
+    encoded_data = base64.b64encode(image_data).decode("ascii")
+    return f"data:{mime_type};base64,{encoded_data}", file_size
+
+
+def prepare_reference_images(image_inputs):
+    """Convert local paths to data URLs and validate reference image limits."""
+    if not image_inputs:
+        return None
+    if isinstance(image_inputs, (str, os.PathLike)):
+        image_inputs = [image_inputs]
+    else:
+        image_inputs = list(image_inputs)
+
+    if len(image_inputs) > MAX_REFERENCE_IMAGES:
+        raise ValueError(
+            f"At most {MAX_REFERENCE_IMAGES} reference images are allowed; "
+            f"received {len(image_inputs)}."
+        )
+
+    images = []
+    base64_total_bytes = 0
+    for image_input in image_inputs:
+        value = os.fspath(image_input)
+        value_lower = value.lower()
+        if value_lower.startswith(("http://", "https://")):
+            images.append(value)
+            continue
+        if value_lower.startswith("data:"):
+            decoded_size = _validate_data_url(value)
+            images.append(value)
+        else:
+            data_url, decoded_size = _local_image_to_data_url(value)
+            images.append(data_url)
+
+        base64_total_bytes += decoded_size
+        if base64_total_bytes > MAX_BASE64_TOTAL_BYTES:
+            raise ValueError(
+                f"Base64 reference images total {base64_total_bytes / 1024 / 1024:.2f}MB "
+                f"after decoding; the maximum is "
+                f"{MAX_BASE64_TOTAL_BYTES / 1024 / 1024:.0f}MB."
+            )
+
+    return images
+
+
+def encode_json_request(payload):
+    """Serialize a JSON request and enforce the API's request-body size limit."""
+    payload_body = json.dumps(payload, ensure_ascii=False, allow_nan=False).encode("utf-8")
+    if len(payload_body) > MAX_REQUEST_BODY_BYTES:
+        raise ValueError(
+            f"Request body is {len(payload_body) / 1024 / 1024:.2f}MB; "
+            f"the maximum is {MAX_REQUEST_BODY_BYTES / 1024 / 1024:.0f}MB."
+        )
+    return payload_body
+
 
 def poll_task_status(task_id, api_base_url=None, api_key=None, timeout_seconds=320, poll_interval=10):
     """
@@ -135,6 +185,7 @@ def poll_task_status(task_id, api_base_url=None, api_key=None, timeout_seconds=3
             
         time.sleep(poll_interval)
 
+
 def download_image(url, output_path):
     """
     Downloads the final image from the given URL and saves it locally.
@@ -147,39 +198,21 @@ def download_image(url, output_path):
             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)
+
+def poll_and_download_result(
+    task_id,
+    output_path=None,
+    default_prefix="result",
+    api_base_url=None,
+    api_key=None,
+):
+    """Poll a media task and download its final image."""
+    result_url = poll_task_status(
+        task_id,
+        api_base_url=api_base_url,
+        api_key=api_key,
+    )
+    if not output_path:
+        output_path = f"{default_prefix}_{int(time.time())}.png"
+    download_image(result_url, output_path)
+    return output_path