Update app.py

app.py

@@ -1,23 +1,18 @@
-from flask import Flask, request, jsonify, send_file
-from flask_cors import CORS
+import gradio as gr
+from random import randint
+from all_models import models
+from externalmod import gr_Interface_load
 import asyncio
-from threading import RLock
-from gradio_client import Client
-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
+from threading import RLock
 
 lock = RLock()
 HF_TOKEN = os.environ.get("HF_TOKEN")
-client = Client("Geek7/mdztxi2")
 
-# 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:
@@ -27,42 +22,39 @@ def load_fn(models):
                 m = gr.Interface(lambda: None, ['text'], ['image'])
             models_load.update({model: m})
 
-# Load the models
 load_fn(models)
 
 num_models = 6
 MAX_SEED = 3999999999
-inference_timeout = 600  # 10 minutes
+default_models = models[:num_models]
+inference_timeout = 600
 
-# Asynchronous inference function
-async def async_infer(model_str, prompt, seed=1, timeout=inference_timeout):
+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.to_thread(client.predict, model_str=model_str, prompt=prompt, seed=seed, api_name="/predict")
+        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 = "image.png"
-            result.save(png_path)  # Save the image to a file
+            result.save(png_path)
         return png_path
-    except Exception as e:
-        print(f"Error during inference: {e}")
-        return None
-
-# Define the endpoint for asynchronous inference
-@app.route('/async_infer', methods=['POST'])
-def async_infer_endpoint():
-    data = request.get_json()
-    model_str = data['model_str']
-    prompt = data['prompt']
-    seed = data.get('seed', 1)  # Default seed value is 1
-
-    # 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)
+    return None
+
+# Expose Gradio API
+def generate_api(model_str, prompt, seed=1):
+    result = asyncio.run(infer(model_str, prompt, seed))
+    if result:
+        return result  # Path to generated image
+    return None
+
+# Launch Gradio API without frontend
+iface = gr.Interface(fn=generate_api, inputs=["text", "text", "number"], outputs="file")
+iface.launch(show_api=True, share=True)