Update app.py: Add HF Inference API integration with n8n support

app.py

@@ -1,47 +1,83 @@
 import gradio as gr
-import torch
-from transformers import AutoModelForCausalLM
+import requests
 import os
-import spaces
+import base64
+from io import BytesIO
+from PIL import Image
+import json
 
-# Load the model
-model_id = "tencent/HunyuanImage-3.0"
+# Hugging Face API configuration
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+API_URL = "https://api-inference.huggingface.co/models/tencent/HunyuanImage-3.0"
 
-print("Loading HunyuanImage-3.0 model...")
-print("Note: This is a very large model (80B params) and requires significant GPU memory.")
-print("For production use, consider using the FAL API or other inference providers.")
+headers = {"Authorization": f"Bearer {HF_TOKEN}"}
 
-# For demo purposes, we'll use inference API
-@spaces.GPU
-def generate_image(prompt, seed=42, diff_infer_steps=50, image_size="auto"):
+def generate_image_api(prompt, seed=42, num_inference_steps=50):
     """
-    Generate image using HunyuanImage-3.0
-    Note: Direct model loading requires 3x80GB GPU memory.
-    For Spaces, consider using Inference API or providers like FAL.
+    Generate image using Hugging Face Inference API
+    Uses paid API from your HF account balance
     """
     try:
-        # This is a placeholder - actual implementation would require
-        # either very large GPU or using Inference API
-        from PIL import Image
-        import numpy as np
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "seed": int(seed),
+                "num_inference_steps": int(num_inference_steps)
+            }
+        }
         
-        # Create a placeholder image with text
-        img = Image.new('RGB', (1024, 1024), color=(240, 240, 245))
+        response = requests.post(API_URL, headers=headers, json=payload, timeout=60)
         
-        return img, seed
+        if response.status_code == 200:
+            image = Image.open(BytesIO(response.content))
+            return image, seed, "Success!"
+        else:
+            error_msg = f"API Error: {response.status_code} - {response.text}"
+            print(error_msg)
+            placeholder = Image.new('RGB', (1024, 1024), color=(240, 240, 245))
+            return placeholder, seed, error_msg
+            
     except Exception as e:
-        print(f"Error: {e}")
-        return None, seed
+        error_msg = f"Error: {str(e)}"
+        print(error_msg)
+        placeholder = Image.new('RGB', (1024, 1024), color=(240, 240, 245))
+        return placeholder, seed, error_msg
 
 def infer(prompt, seed, randomize_seed, diff_infer_steps, image_size):
     import random
     if randomize_seed:
         seed = random.randint(0, 2**32 - 1)
     
-    image, used_seed = generate_image(prompt, seed, diff_infer_steps, image_size)
-    return image, used_seed
+    image, used_seed, status = generate_image_api(prompt, seed, diff_infer_steps)
+    return image, used_seed, status
+
+def api_generate(prompt: str, seed: int = 42, num_inference_steps: int = 50):
+    """
+    API endpoint for external integrations like n8n
+    Returns base64 encoded image
+    """
+    try:
+        image, used_seed, status = generate_image_api(prompt, seed, num_inference_steps)
+        
+        buffered = BytesIO()
+        image.save(buffered, format="PNG")
+        img_str = base64.b64encode(buffered.getvalue()).decode()
+        
+        return {
+            "success": True,
+            "image_base64": img_str,
+            "seed": used_seed,
+            "status": status,
+            "prompt": prompt
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "seed": seed,
+            "prompt": prompt
+        }
 
-# Gradio Interface
 examples = [
     "A brown and white dog is running on the grass",
     "A futuristic city at sunset with flying cars",
@@ -63,17 +99,16 @@ css = """
 
 with gr.Blocks(css=css) as demo:
     with gr.Column(elem_id="col-container"):
-        gr.Markdown("# 🎨 HunyuanImage-3.0 Text-to-Image")
+        gr.Markdown("# 🎨 HunyuanImage-3.0 Text-to-Image with Inference API")
         gr.Markdown(
-            """### Tencent HunyuanImage-3.0 - A Powerful Native Multimodal Model
+            """### Tencent HunyuanImage-3.0 - Using Paid Hugging Face Inference API
             
-            **⚠️ Important Note:** This model requires 3×80GB GPU memory for direct inference.
-            For production use, please:
-            1. Use the Inference API endpoint
-            2. Use inference providers like FAL AI
-            3. Deploy on appropriate hardware
+            ✅ This Space now uses the Hugging Face Inference API (paid from your account balance)
+            - Real image generation with HunyuanImage-3.0
+            - API endpoint available for n8n integration
+            - Set your HF_TOKEN in Space secrets
             
-            This demo shows the interface structure. For actual inference, configure with appropriate resources.
+            🔗 For n8n integration: Use the API endpoint at /gradio_api/ with the api_generate function
             """,
             elem_classes="note"
         )
@@ -84,11 +119,13 @@ with gr.Blocks(css=css) as demo:
                 show_label=True,
                 max_lines=3,
                 placeholder="Enter your prompt for image generation...",
+                value="A serene mountain landscape with a crystal clear lake"
             )
         
         run_button = gr.Button("🎨 Generate Image", variant="primary")
         
         result = gr.Image(label="Generated Image", show_label=True)
+        status_text = gr.Textbox(label="Status", interactive=False)
         
         with gr.Accordion("Advanced Settings", open=False):
             seed = gr.Slider(
@@ -120,8 +157,26 @@ with gr.Blocks(css=css) as demo:
         run_button.click(
             fn=infer,
             inputs=[prompt, seed, randomize_seed, diff_infer_steps, image_size],
-            outputs=[result, seed],
+            outputs=[result, seed, status_text],
         )
 
+api_demo = gr.Interface(
+    fn=api_generate,
+    inputs=[
+        gr.Text(label="Prompt"),
+        gr.Number(label="Seed", value=42),
+        gr.Number(label="Inference Steps", value=50)
+    ],
+    outputs=gr.JSON(label="Response"),
+    title="HunyuanImage-3.0 API Endpoint",
+    description="API endpoint for n8n and other integrations. Returns base64 encoded image."
+)
+
+app = gr.TabbedInterface(
+    [demo, api_demo],
+    ["Interface", "API Endpoint"],
+    title="HunyuanImage-3.0 Generator"
+)
+
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()