Update app.py

app.py

@@ -1,78 +1,68 @@
 from flask import Flask, request, jsonify, send_file
-from flask_cors import CORS  # For enabling CORS
-import gradio as gr
+from flask_cors import CORS
 import asyncio
-import os
 from threading import RLock
 from gradio_client import Client
-from all_models import models  # Your model import
-from externalmod import gr_Interface_load  # Your custom model loader
+from all_models import models  # Import your models
+from externalmod import gr_Interface_load  # Import the model loading function
+import os
 
 app = Flask(__name__)
 CORS(app)  # Enable CORS for all routes
 
-# Gradio Client Initialization
-client = Client("Geek7/mdztxi2")
-
 lock = RLock()
 HF_TOKEN = os.environ.get("HF_TOKEN")
+client = Client("Geek7/mdztxi2")
 
-# Model Loading Function
+# 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'])  # Fallback
+                m = gr.Interface(lambda: None, ['text'], ['image'])
             models_load.update({model: m})
 
+# Load the models
 load_fn(models)
 
-# Async inference function to call Gradio model prediction
-async def infer(model_str, prompt, seed=1, timeout=600):
-    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)
+num_models = 6
+MAX_SEED = 3999999999
+inference_timeout = 600  # 10 minutes
+
+# Asynchronous inference function
+async def async_infer(model_str, prompt, seed=1, timeout=inference_timeout):
     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:
+        result = await asyncio.to_thread(client.predict, model_str=model_str, prompt=prompt, seed=seed, api_name="/predict")
         with lock:
             png_path = "image.png"
-            result.save(png_path)
+            result.save(png_path)  # Save the image to a file
         return png_path
-    return None
+    except Exception as e:
+        print(f"Error during inference: {e}")
+        return None
 
-# API endpoint for generating an image and sending it as a file
-@app.route('/generate-image', methods=['POST'])
-def generate_image():
+# Define the endpoint for asynchronous inference
+@app.route('/async_infer', methods=['POST'])
+def async_infer_endpoint():
     data = request.get_json()
-    model_str = data.get('model_str')
-    prompt = data.get('prompt')
-    seed = data.get('seed', 1)
-
-    # Validate input
-    if not model_str or not prompt:
-        return jsonify({"error": "Model string and prompt are required."}), 400
+    model_str = data['model_str']
+    prompt = data['prompt']
+    seed = data.get('seed', 1)  # Default seed value is 1
 
-    # Generate image using the async inference function
-    result_path = asyncio.run(infer(model_str, prompt, seed))
-
-    if result_path:
-        # Return the image file using send_file
-        return send_file(result_path, mimetype='image/png')
-    else:
-        return jsonify({"error": "Image generation failed."}), 500
+    # Make a prediction request
+    try:
+        result_path = asyncio.run(async_infer(model_str, prompt, seed))
+        if result_path:
+            return send_file(result_path, mimetype='image/png')  # Send the generated image file
+        else:
+            return jsonify({"error": "Image generation failed."}), 500
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
 
 if __name__ == '__main__':
     app.run(debug=True)