Update app.py

app.py

@@ -6,24 +6,25 @@ from externalmod import gr_Interface_load
 import asyncio
 import os
 from threading import RLock
-import io
+from PIL import Image
 
 app = Flask(__name__)
 
 lock = RLock()
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
-# Load the models
+# Load models
 def load_fn(models):
     global models_load
     models_load = {}
+    
     for model in models:
         if model not in models_load.keys():
             try:
                 m = gr_Interface_load(f'models/{model}', hf_token=HF_TOKEN)
             except Exception as error:
                 print(error)
-                m = gr.Interface(lambda: None, ['text'], ['image'])  # Fallback
+                m = gr.Interface(lambda: None, ['text'], ['image'])
             models_load.update({model: m})
 
 load_fn(models)
@@ -33,7 +34,7 @@ MAX_SEED = 3999999999
 default_models = models[:num_models]
 inference_timeout = 600
 
-# Async inference function
+# Gradio inference function
 async def infer(model_str, prompt, seed=1, timeout=inference_timeout):
     kwargs = {"seed": seed}
     task = asyncio.create_task(asyncio.to_thread(models_load[model_str].fn, prompt=prompt, **kwargs, token=HF_TOKEN))
@@ -43,34 +44,32 @@ async def infer(model_str, prompt, seed=1, timeout=inference_timeout):
     except (Exception, asyncio.TimeoutError) as e:
         print(e)
         print(f"Task timed out: {model_str}")
-        if not task.done():
+        if not task.done(): 
             task.cancel()
         result = None
     if task.done() and result is not None:
         with lock:
-            png_path = "image.png"
-            result.save(png_path)
+            png_path = "generated_image.png"
+            result.save(png_path)  # Save the result as an image
         return png_path
     return None
 
-# Flask API endpoint
-@app.route('/async_infer', methods=['POST'])
-def async_infer():
+# API function to perform inference
+@app.route('/generate-image', methods=['POST'])
+def generate_image():
     data = request.get_json()
-    model_str = data.get('model_str')
-    prompt = data.get('prompt')
+    model_str = data['model_str']
+    prompt = data['prompt']
     seed = data.get('seed', 1)
 
-    # Run the inference
-    try:
-        image_path = asyncio.run(infer(model_str, prompt, seed))
-        if image_path:
-            return send_file(image_path, mimetype='image/png')
-        else:
-            return jsonify({"error": "Image generation failed."}), 500
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
+    # Run Gradio inference
+    result_path = asyncio.run(infer(model_str, prompt, seed))
+    
+    if result_path:
+        # Send back the generated image file
+        return send_file(result_path, mimetype='image/png')
+    else:
+        return jsonify({"error": "Failed to generate image."}), 500
 
-# Run the Flask app
 if __name__ == '__main__':
     app.run(debug=True)