Add image generation endpoints using Hugging Face API

Integrates new image generation endpoints into `app_local.py` using the Hugging Face Inference API, including synchronous, asynchronous, and base64 options. Updates health check status and version number.

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: a662ebb5-fd71-4dd7-ad81-6f1890051700
Replit-Commit-Checkpoint-Type: full_checkpoint
Replit-Commit-Event-Id: b03946f7-415b-473e-96d1-92cc1cee45b5
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/d9f57912-08a1-48b9-ad13-f36ce06579fd/a662ebb5-fd71-4dd7-ad81-6f1890051700/fWRWvD9

app_local.py

@@ -4,12 +4,100 @@ This version uses simple image processing instead of AI models.
 For full AI processing, deploy to Hugging Face Spaces.
 """
 import io
+import os
 import uuid
+import threading
+import base64
 from pathlib import Path
 from http.server import HTTPServer, SimpleHTTPRequestHandler
 import json
 import urllib.parse
 
+try:
+    import httpx
+    HAS_HTTPX = True
+except ImportError:
+    import urllib.request
+    HAS_HTTPX = False
+
+HF_API_URL = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell"
+
+jobs = {}
+
+def get_hf_token():
+    """Get Hugging Face API token from environment."""
+    token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_TOKEN")
+    if not token:
+        return None
+    return token
+
+def generate_image_from_hf(prompt: str, width: int = 1024, height: int = 1024) -> bytes:
+    """Generate image using Hugging Face Inference API with FLUX.1-schnell model."""
+    token = get_hf_token()
+    if not token:
+        raise Exception("Hugging Face API token not configured. Please set HF_TOKEN secret.")
+    
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "width": width,
+            "height": height,
+            "num_inference_steps": 4
+        }
+    }
+    
+    if HAS_HTTPX:
+        with httpx.Client(timeout=120.0) as client:
+            response = client.post(HF_API_URL, headers=headers, json=payload)
+            
+            if response.status_code == 503:
+                error_data = response.json()
+                if "estimated_time" in error_data:
+                    raise Exception(f"Model is loading. Estimated time: {error_data['estimated_time']:.0f}s. Please retry shortly.")
+            
+            if response.status_code != 200:
+                try:
+                    error_detail = response.json()
+                except:
+                    error_detail = response.text
+                raise Exception(f"Hugging Face API error: {error_detail}")
+            
+            return response.content
+    else:
+        req = urllib.request.Request(HF_API_URL, data=json.dumps(payload).encode(), headers=headers, method='POST')
+        try:
+            with urllib.request.urlopen(req, timeout=120) as response:
+                return response.read()
+        except urllib.error.HTTPError as e:
+            raise Exception(f"Hugging Face API error: {e.read().decode()}")
+
+def process_generate_image_job(job_id: str, prompt: str, width: int, height: int, output_path: Path):
+    """Background task for image generation."""
+    try:
+        jobs[job_id] = {"status": "processing", "progress": 20.0, "message": "Sending prompt to FLUX.1-schnell..."}
+        
+        image_bytes = generate_image_from_hf(prompt, width, height)
+        
+        jobs[job_id] = {"status": "processing", "progress": 80.0, "message": "Saving image..."}
+        
+        from PIL import Image
+        generated_image = Image.open(io.BytesIO(image_bytes))
+        generated_image.save(output_path, "PNG")
+        
+        jobs[job_id] = {
+            "status": "completed", 
+            "progress": 100.0, 
+            "message": f"Image generated: {generated_image.width}x{generated_image.height}",
+            "result": str(output_path)
+        }
+        
+    except Exception as e:
+        jobs[job_id] = {"status": "failed", "progress": 0, "error": str(e)}
+
 UPLOAD_DIR = Path("uploads")
 OUTPUT_DIR = Path("outputs")
 UPLOAD_DIR.mkdir(exist_ok=True)
@@ -27,8 +115,8 @@ class APIHandler(SimpleHTTPRequestHandler):
         elif path == "/health":
             self.send_json({
                 "status": "healthy",
-                "version": "2.0.0 (preview)",
-                "features": ["enhance", "remove-background", "denoise"]
+                "version": "2.2.0 (preview)",
+                "features": ["enhance", "remove-background", "denoise", "generate-image"]
             })
         elif path == "/model-info":
             self.send_json({
@@ -46,6 +134,13 @@ class APIHandler(SimpleHTTPRequestHandler):
                     "noise_reduction": {
                         "name": "Non-Local Means Denoising",
                         "description": "Advanced noise reduction algorithm"
+                    },
+                    "image_generation": {
+                        "name": "FLUX.1-schnell",
+                        "description": "Fast, high-quality text-to-image generation by Black Forest Labs",
+                        "max_resolution": "1440x1440",
+                        "default_resolution": "1024x1024",
+                        "source": "https://huggingface.co/black-forest-labs/FLUX.1-schnell"
                     }
                 },
                 "supported_formats": ["png", "jpg", "jpeg", "webp", "bmp"]
@@ -54,6 +149,32 @@ class APIHandler(SimpleHTTPRequestHandler):
             self.serve_openapi()
         elif path.startswith("/outputs/"):
             self.serve_file(path)
+        elif path.startswith("/progress/"):
+            job_id = path.split("/progress/")[1]
+            if job_id in jobs:
+                self.send_json(jobs[job_id])
+            else:
+                self.send_error(404, "Job not found")
+        elif path.startswith("/result/"):
+            job_id = path.split("/result/")[1]
+            if job_id in jobs:
+                job = jobs[job_id]
+                if job.get("status") == "completed" and job.get("result"):
+                    result_path = Path(job["result"])
+                    if result_path.exists():
+                        self.send_response(200)
+                        self.send_header('Content-Type', 'image/png')
+                        self.send_header('Content-Disposition', f'attachment; filename="{result_path.name}"')
+                        self.end_headers()
+                        self.wfile.write(result_path.read_bytes())
+                    else:
+                        self.send_error(404, "Result file not found")
+                elif job.get("status") == "failed":
+                    self.send_error(500, job.get("error", "Job failed"))
+                else:
+                    self.send_json({"status": job.get("status"), "progress": job.get("progress"), "message": "Job still processing"})
+            else:
+                self.send_error(404, "Job not found")
         else:
             super().do_GET()
     
@@ -68,6 +189,10 @@ class APIHandler(SimpleHTTPRequestHandler):
             self.handle_remove_background(path, query)
         elif path == "/denoise" or path == "/denoise/base64":
             self.handle_denoise(path, query)
+        elif path == "/generate-image" or path == "/generate-image/base64":
+            self.handle_generate_image(path, query)
+        elif path == "/generate-image/async":
+            self.handle_generate_image_async(query)
         else:
             self.send_error(404, "Not Found")