Update app.py

app.py

@@ -15,48 +15,66 @@ logger = logging.getLogger(__name__)
 ACCESS_KEY_ID = "AFyHfnQATghFdCMyAG3gRPbNY4TNKFGB"
 ACCESS_KEY_SECRET = "TTepeLyBterLNM3brYPGmdndBnnyKJBA"
 API_BASE_URL = "https://api-singapore.klingai.com"
-CREATE_TASK_ENDPOINT = f"{API_BASE_URL}/v1/images/generations"
+CREATE_TASK_ENDPOINT = f"{API_BASE_URL}/v1/images/multi-image2image"
 
 # ===== AUTHENTICATION =====
 def generate_jwt_token():
     """Generate JWT token for API authentication"""
     payload = {
         "iss": ACCESS_KEY_ID,
-        "exp": int(time.time()) + 1800,
-        "nbf": int(time.time()) - 5
+        "exp": int(time.time()) + 1800,  # 30 minutes expiration
+        "nbf": int(time.time()) - 5      # Not before 5 seconds ago
     }
     return jwt.encode(payload, ACCESS_KEY_SECRET, algorithm="HS256")
 
-# ===== FACE VALIDATION =====
-def validate_face_image(image_path):
-    """Check if image contains exactly one face"""
+# ===== IMAGE PROCESSING =====
+def prepare_image_base64(image_path):
+    """Convert image to base64 without prefix"""
     try:
-        # In production, you'd use face detection here
-        # For demo, we'll just check basic image properties
+        with open(image_path, "rb") as img_file:
+            return base64.b64encode(img_file.read()).decode('utf-8')
+    except Exception as e:
+        logger.error(f"Image processing failed: {str(e)}")
+        return None
+
+def validate_image(image_path):
+    """Validate image meets API requirements"""
+    try:
+        # Check file size
         size_mb = os.path.getsize(image_path) / (1024 * 1024)
         if size_mb > 10:
             return False, "Image too large (max 10MB)"
+        
+        # Check dimensions (basic check - should use PIL for actual dimensions)
         return True, ""
     except Exception as e:
         return False, f"Image validation error: {str(e)}"
 
 # ===== API FUNCTIONS =====
-def create_face_transform_task(image_base64, prompt, strength=0.97):
-    """Create face transformation task with high reference strength"""
+def create_multi_image_task(subject_images, prompt):
+    """Create multi-image generation task"""
     headers = {
         "Authorization": f"Bearer {generate_jwt_token()}",
         "Content-Type": "application/json"
     }
     
+    # Prepare subject images list
+    subject_image_list = []
+    for img_path in subject_images:
+        if img_path:  # Skip empty/None images
+            base64_img = prepare_image_base64(img_path)
+            if base64_img:
+                subject_image_list.append({"subject_image": base64_img})
+    
+    if len(subject_image_list) < 2:
+        return None, "At least 2 subject images required"
+    
     payload = {
-        "model_name": "kling-v2-1",  # Best for face transformation
+        "model_name": "kling-v2",
         "prompt": prompt,
-        "image": image_base64,
-        "image_reference": "face",  # Critical for face transformation
-        "image_fidelity": strength,  # 0.97 = 97% reference strength
-        "resolution": "1k",
-        "aspect_ratio": "1:1",
-        "n": 1
+        "subject_image_list": subject_image_list,
+        "n": 1,
+        "aspect_ratio": "1:1"
     }
     
     try:
@@ -65,12 +83,14 @@ def create_face_transform_task(image_base64, prompt, strength=0.97):
         return response.json(), None
     except requests.exceptions.RequestException as e:
         logger.error(f"API request failed: {str(e)}")
+        if hasattr(e, 'response') and e.response:
+            logger.error(f"API response: {e.response.text}")
         return None, f"API Error: {str(e)}"
 
 def check_task_status(task_id):
     """Check task completion status"""
     headers = {"Authorization": f"Bearer {generate_jwt_token()}"}
-    status_url = f"{API_BASE_URL}/v1/images/generations/{task_id}"
+    status_url = f"{API_BASE_URL}/v1/images/multi-image2image/{task_id}"
     
     try:
         response = requests.get(status_url, headers=headers)
@@ -80,22 +100,17 @@ def check_task_status(task_id):
         return None, f"Status check failed: {str(e)}"
 
 # ===== MAIN PROCESSING =====
-def transform_face(image_path, prompt, strength=0.97):
-    """Handle face transformation workflow"""
-    # Validate image
-    is_valid, error_msg = validate_face_image(image_path)
-    if not is_valid:
-        return None, error_msg
+def generate_image(subject_images, prompt):
+    """Handle complete image generation workflow"""
+    # Validate images
+    for img in subject_images:
+        if img:  # Only validate non-empty images
+            is_valid, error_msg = validate_image(img)
+            if not is_valid:
+                return None, error_msg
     
-    # Read and encode image
-    try:
-        with open(image_path, "rb") as img_file:
-            image_base64 = base64.b64encode(img_file.read()).decode('utf-8')
-    except Exception as e:
-        return None, f"Failed to process image: {str(e)}"
-    
-    # Create task with face reference
-    task_response, error = create_face_transform_task(image_base64, prompt, strength)
+    # Create task
+    task_response, error = create_multi_image_task(subject_images, prompt)
     if error:
         return None, error
     
@@ -103,10 +118,10 @@ def transform_face(image_path, prompt, strength=0.97):
         return None, f"API error: {task_response.get('message', 'Unknown error')}"
     
     task_id = task_response["data"]["task_id"]
-    logger.info(f"Face transformation task created: {task_id}")
+    logger.info(f"Task created: {task_id}")
     
-    # Poll for results
-    for _ in range(30):  # Max 5 minutes (10s intervals)
+    # Poll for results (max 10 minutes)
+    for _ in range(60):
         task_data, error = check_task_status(task_id)
         if error:
             return None, error
@@ -118,12 +133,12 @@ def transform_face(image_path, prompt, strength=0.97):
             try:
                 response = requests.get(image_url)
                 response.raise_for_status()
-                output_path = Path(f"/tmp/kling_face_{task_id}.png")
+                output_path = Path(f"/tmp/kling_output_{task_id}.png")
                 with open(output_path, "wb") as f:
                     f.write(response.content)
                 return str(output_path), None
             except Exception as e:
-                return None, f"Failed to save result: {str(e)}"
+                return None, f"Failed to download result: {str(e)}"
                 
         elif status in ("failed", "canceled"):
             error_msg = task_data["data"].get("task_status_msg", "Unknown error")
@@ -131,73 +146,66 @@ def transform_face(image_path, prompt, strength=0.97):
             
         time.sleep(10)
     
-    return None, "Task timed out after 5 minutes"
+    return None, "Task timed out after 10 minutes"
 
 # ===== GRADIO INTERFACE =====
-def process_interface(image, prompt, strength):
-    if not image:
-        return None, None, "Please upload an image with a clear face"
+def process_interface(subject_images, prompt):
+    # Filter out None values from subject_images
+    valid_images = [img for img in subject_images if img is not None]
+    
+    if len(valid_images) < 2:
+        return None, None, "Please upload at least 2 subject images"
     
-    output_path, error = transform_face(image, prompt, strength/100)
+    output_path, error = generate_image(valid_images, prompt)
     if error:
         return None, None, error
     
-    return output_path, output_path, "Face transformation successful!"
+    return output_path, output_path, "Generation successful!"
 
-with gr.Blocks(title="Kling AI Face Transformer") as app:
-    gr.Markdown("## 👤 Kling AI Face Transformation")
-    gr.Markdown("Transform faces with high precision (97% reference strength)")
+with gr.Blocks(title="Kling AI Multi-Image Generator") as app:
+    gr.Markdown("## 🖼️ Kling AI Multi-Image to Image")
+    gr.Markdown("Combine features from multiple images into one result")
     
     with gr.Row():
         with gr.Column():
             gr.Markdown("### Input Settings")
-            image_input = gr.Image(
-                type="filepath",
-                label="Upload Face Image",
-                sources=["upload"],
-                height=300
-            )
+            with gr.Row():
+                subject_image1 = gr.Image(type="filepath", label="Subject Image 1")
+                subject_image2 = gr.Image(type="filepath", label="Subject Image 2")
+            with gr.Row():
+                subject_image3 = gr.Image(type="filepath", label="Subject Image 3 (Optional)")
+                subject_image4 = gr.Image(type="filepath", label="Subject Image 4 (Optional)")
+            
             prompt_input = gr.Textbox(
-                label="Transformation Style",
-                placeholder="Describe the new style (e.g. 'anime character', 'oil painting portrait')"
-            )
-            strength_slider = gr.Slider(
-                minimum=80,
-                maximum=100,
-                value=97,
-                step=1,
-                label="Reference Strength (%)",
-                info="Higher values preserve more facial features"
+                label="Transformation Prompt",
+                placeholder="Describe how to combine these images (e.g. 'merge facial features from all images')"
             )
-            generate_btn = gr.Button("Transform Face", variant="primary")
+            
+            generate_btn = gr.Button("Generate", variant="primary")
             
             gr.Markdown("### Requirements")
             gr.Markdown("""
-            - **Must contain exactly one clear face**
-            - Max size: 10MB
+            - **Minimum 2 subject images required**
+            - Max 4 images total
+            - Max size per image: 10MB
             - Formats: JPG, PNG
-            - Min resolution: 300x300px
+            - Min dimensions: 300x300px
             """)
             
         with gr.Column():
             gr.Markdown("### Output")
-            output_image = gr.Image(
-                label="Transformed Face", 
-                interactive=False,
-                height=400
-            )
-            output_file = gr.File(
-                label="Download Result",
-                file_types=["image/png"]
-            )
-            status_output = gr.Textbox(
-                label="Status",
-                interactive=False
-            )
+            output_image = gr.Image(label="Generated Image", interactive=False, height=400)
+            output_file = gr.File(label="Download Result", file_types=["image/png"])
+            status_output = gr.Textbox(label="Status", interactive=False)
     
     generate_btn.click(
         fn=process_interface,
-        inputs=[image_input, prompt_input, strength_slider],
+        inputs=[gr.components.List([
+            subject_image1, 
+            subject_image2, 
+            subject_image3, 
+            subject_image4
+        ]), prompt_input],
         outputs=[output_image, output_file, status_output]
     )