api mode

app.py

@@ -1,5 +1,6 @@
 import base64
 import io
+import json
 import os
 import sys
 from typing import Union, Any, Optional
@@ -45,6 +46,7 @@ os.environ["GRADIO_TEMP_DIR"] = temp_dir
 
 ADAPTER_NAME = "subject"
 MODEL_PATH = model_path
+ZEN_BG_ENDPOINT = "https://zen-inpaint-1066271267292.europe-west1.run.app/"
 
 def get_gpu_memory_gb() -> float:
     return torch.cuda.get_device_properties(0).total_memory / 1024**3
@@ -296,12 +298,12 @@ def generate_background_local(styled_image: Image.Image, prompt: str, steps: int
     return result_img
 
 def image_to_base64(image: Image.Image) -> str:
-    """Convert PIL Image to base64 string"""
-    if image.mode != "RGB":
-        image = image.convert("RGB")
+    """Convert PIL Image to base64 string (PNG to preserve transparency)"""
+    if image.mode != "RGBA":
+        image = image.convert("RGBA")
     
     buffer = io.BytesIO()
-    image.save(buffer, format="JPEG", quality=95)
+    image.save(buffer, format="PNG")
     img_bytes = buffer.getvalue()
     return base64.b64encode(img_bytes).decode("utf-8")
 
@@ -311,7 +313,7 @@ def generate_background_api(
     steps: int = 4,
     api_key: str = "",
     email: str = "",
-    mode: str = "subject",
+    zen_mode: str = "bg_generation",
 ) -> Image.Image:
     """Generate background using API"""
     if styled_image is None:
@@ -321,44 +323,79 @@ def generate_background_api(
         return Image.new("RGB", styled_image.size, (255, 200, 200))  # Red tint to indicate error
     
     try:
-        base64_image = image_to_base64(styled_image)
         width, height = styled_image.size
-        position_x = width // 2
-        position_y = height // 2
+        base64_image = image_to_base64(styled_image)
+        # Ensure padding so the API always receives valid Base64 chunks
+        subject_base64 = base64_image + "=" * (-len(base64_image) % 4)
+
+        # Map legacy UI modes to documented gen_mode values
+        gen_mode = {
+            "subject": "bg_generation",
+            "canny": "bg_generation",
+            "bg_generation": "bg_generation",
+        }.get(zen_mode, "bg_generation")
+
+        max_dim = max(width, height)
+        if max_dim <= 1024:
+            upscale = "1k"
+        elif max_dim <= 1536:
+            upscale = "1.5k"
+        else:
+            upscale = "2k"
 
         payload = {
-            "feat": "API",
-            "mode": mode,
-            "base64_image": base64_image,
+            "gen_mode": gen_mode,
             "prompt": prompt.strip() if prompt else "professional product photography background",
-            "steps": steps,
-            "rmbg": True,
-            "scale": 1,
-            "position_x": position_x,
-            "position_y": position_y,
+            "subject": subject_base64,
+            "subject_format": "base64",
+            "background": "",
+            "negative_prompt": "",
+            "steps": int(steps),
+            "seed": 42,
+            "randomize_seed": True,
+            "bg_upscale_choice": upscale,
+            "max_bg_side_px": int(max_dim),
+            "output_image_format": "base64",
+            "use_bg_size_for_output": True,
         }
 
         headers = {
             "x-api-key": api_key,
             "x-email": email,
+            "Content-Type": "application/json",
         }
 
         response = requests.post(
-            "https://api.fotographer.ai/Image-gen/Image-gen",
+            ZEN_BG_ENDPOINT,
             headers=headers,
             json=payload,
-            timeout=60,
+            timeout=90,
         )
 
         if response.status_code == 200:
-            result_data = response.json()
-            if "image" in result_data:
-                img_data = base64.b64decode(result_data["image"])
-                return Image.open(io.BytesIO(img_data))
-            if "data" in result_data and "image" in result_data["data"]:
-                img_data = base64.b64decode(result_data["data"]["image"])
-                return Image.open(io.BytesIO(img_data))
-
+            try:
+                result_data = response.json()
+            except Exception:
+                print(f"[API] Unable to parse response JSON: {response.text[:200]}")
+                result_data = {}
+            image_field = result_data.get("image")
+            if image_field:
+                if image_field.startswith("http"):
+                    try:
+                        img_resp = requests.get(image_field, timeout=60)
+                        img_resp.raise_for_status()
+                        return Image.open(io.BytesIO(img_resp.content))
+                    except Exception as download_err:
+                        print(f"[API] Failed to download image URL: {download_err}")
+                else:
+                    try:
+                        img_data = base64.b64decode(image_field)
+                        return Image.open(io.BytesIO(img_data))
+                    except Exception as decode_err:
+                        print(f"[API] Failed to decode base64 response: {decode_err}")
+            print(f"[API] 200 response without image: {result_data}")
+        else:
+            print(f"[API] Non-200 response ({response.status_code}): {response.text[:500]}")
         return Image.new("RGB", styled_image.size, (255, 200, 200))
     except Exception as e:
         print(f"API Error: {e}")
@@ -377,7 +414,9 @@ def generate_background(
 ) -> Image.Image:
     """Generate background using either API or local model"""
     if use_api:
-        return generate_background_api(styled_image, prompt, steps, api_key, email, mode)
+        return generate_background_api(
+            styled_image, prompt, steps, api_key, email, zen_mode=mode
+        )
     return generate_background_local(styled_image, prompt, steps, width, height)
 
 @spaces.GPU
@@ -499,9 +538,10 @@ def create_simple_app():
                         placeholder="Enter your registered email"
                     )
                     mode = gr.Radio(
-                        choices=["subject", "canny"],
-                        value="subject",
-                        label="API Mode"
+                        choices=["bg_generation"],
+                        value="bg_generation",
+                        label="API gen_mode",
+                        interactive=False
                     )
                 
                 # Generation steps