Update myapp.py

myapp.py

@@ -1,21 +1,19 @@
 from flask import Flask, request, jsonify, send_file
-from flask_cors import CORS
-import os
+import gradio as gr
+from random import randint
 from all_models import models
 from externalmod import gr_Interface_load
 import asyncio
+import os
 from threading import RLock
+from PIL import Image
 
-# Initialize Flask app and enable CORS
 app = Flask(__name__)
-CORS(app)
 
 lock = RLock()
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
-# Load models into a global dictionary
-models_load = {}
-
+# Load models
 def load_fn(models):
     global models_load
     models_load = {}
@@ -24,50 +22,56 @@ def load_fn(models):
         if model not in models_load.keys():
             try:
                 m = gr_Interface_load(f'models/{model}', hf_token=HF_TOKEN)
-                models_load[model] = m
             except Exception as error:
-                print(f"Error loading model {model}: {error}")
-                models_load[model] = None  # Handle model loading failures
+                print(error)
+                m = gr.Interface(lambda: None, ['text'], ['image'])
+            models_load.update({model: m})
 
 load_fn(models)
 
+num_models = 6
+MAX_SEED = 3999999999
+default_models = models[:num_models]
 inference_timeout = 600
 
+# 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))
+    await asyncio.sleep(0)
     try:
-        task = asyncio.create_task(asyncio.to_thread(models_load[model_str].fn, prompt=prompt, **kwargs, token=HF_TOKEN))
-        await asyncio.sleep(0)
-
         result = await asyncio.wait_for(task, timeout=timeout)
-        if task.done() and result is not None:
-            with lock:
-                png_path = "image.png"
-                result.save(png_path)
-                return png_path  # Return the path of the saved image
-    except Exception as e:
-        print(f"Inference error for model {model_str}: {e}")  # Log the error message
-        return None
+    except (Exception, asyncio.TimeoutError) as e:
+        print(e)
+        print(f"Task timed out: {model_str}")
+        if not task.done(): 
+            task.cancel()
+        result = None
+    if task.done() and result is not None:
+        with lock:
+            png_path = "generated_image.png"
+            result.save(png_path)  # Save the result as an image
+        return png_path
+    return None
 
-@app.route('/generate', methods=['POST'])
-def generate():
-    data = request.json
-    model_str = data.get('model')
-    prompt = data.get('prompt')
+# API function to perform inference
+@app.route('/generate-image', methods=['POST'])
+def generate_image():
+    data = request.get_json()
+    model_str = data['model_str']
+    prompt = data['prompt']
     seed = data.get('seed', 1)
 
-    print(f"Received request for model: '{model_str}', prompt: '{prompt}', seed: {seed}")
-
-    if model_str not in models_load or models_load[model_str] is None:
-        print(f"Model not found in models_load: {model_str}. Available models: {models_load.keys()}")
-        return jsonify({"error": "Model not found or not loaded"}), 404
-
-    image_path = asyncio.run(infer(model_str, prompt, seed, inference_timeout))
-    if image_path is not None:
-        return send_file(image_path, mimetype='image/png')
+    # Run Gradio inference
+    result_path = asyncio.run(infer(model_str, prompt, seed))
     
-    print("Image generation failed for:", model_str)  # Log failure reason
-    return jsonify({"error": "Image generation failed"}), 500
+    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
+
 
-if __name__ == '__main__':
-    app.run(debug=True)
+# Add this block to make sure your app runs when called
+if __name__ == "__main__":
+    app.run(host='0.0.0.0', port=7860)  # Run directly