Update app.py

app.py

@@ -1,55 +1,95 @@
+import gradio as gr
+from random import randint
 from all_models import models
-from flask import Flask, request, jsonify, send_file
-from flask_cors import CORS
-from gradio_client import Client
 from externalmod import gr_Interface_load
+import asyncio
 import os
+from threading import RLock
+from flask import Flask, request, jsonify, send_file
+from flask_cors import CORS
+
+lock = RLock()
+HF_TOKEN = os.environ.get("HF_TOKEN")
 
+# Initialize Flask app
 app = Flask(__name__)
 CORS(app)  # Enable CORS for all routes
 
-HF_TOKEN = os.environ.get("HF_TOKEN")  # Load the Hugging Face token if needed
+# Load models using gr_Interface_load
+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'])
+            models_load.update({model: m})
 
-# Function to load the model using gr_Interface_load
-def load_model(model_name):
-    try:
-        model_interface = gr_Interface_load(f'models/{model_name}', hf_token=HF_TOKEN)
-        return model_interface
-    except Exception as error:
-        print(f"Error loading model: {error}")
-        return None
+load_fn(models)
+
+num_models = 6
+MAX_SEED = 3999999999
+default_models = models[:num_models]
+inference_timeout = 600
 
+# Inference function to generate image
+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:
+        result = await asyncio.wait_for(task, timeout=timeout)
+    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)
+        return png_path
+    return None
 
+# Generate API function that calls the async infer function
+def generate_api(model_str, prompt, seed=1):
+    result = asyncio.run(infer(model_str, prompt, seed))
+    if result:
+        return result  # Path to the generated image
+    return None
 
+# Flask route to handle predictions
 @app.route('/predict', methods=['POST'])
 def predict():
-    # Get the JSON data from the request
     data = request.get_json()
 
     # Validate required fields
-    if not data or 'prompt' not in data:
+    if not data or 'prompt' not in data or 'model_str' not in data:
         return jsonify({"error": "Missing required fields"}), 400
 
+    model_str = data['model_str']
     prompt = data['prompt']
     seed = data.get('seed', 1)
 
-    # Make a prediction request using the loaded model
+    # Generate the image using the model
     try:
-        if model_interface:
-            # Send the request to the model interface and retrieve the result
-            result = model_interface.fn(prompt=prompt, seed=seed, token=HF_TOKEN)  # Assuming the function returns the result
-            
-            # Save the result to a file (if the model returns an image)
-            result_path = "generated_image.png"
-            result.save(result_path)  # Assuming result has a save method
-            
-            # Send back the generated image file
-            return send_file(result_path, mimetype='image/png')
+        image_path = generate_api(model_str, prompt, seed)
+        if image_path:
+            return send_file(image_path, mimetype='image/png')
         else:
-            return jsonify({"error": "Model interface not loaded."}), 500
-
+            return jsonify({"error": "Failed to generate image"}), 500
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 
 if __name__ == '__main__':
-    app.run(debug=True)
+    # Run Flask app
+    app.run(debug=True)
+
+# You can optionally launch the Gradio interface in parallel
+iface = gr.Interface(fn=generate_api, inputs=["text", "text", "number"], outputs="file")
+iface.launch(show_api=True, share=True)