Update myapp.py

myapp.py

@@ -1,60 +1,77 @@
-import gradio as gr
-from random import randint
-from all_models import models
-from externalmod import gr_Interface_load
+from flask import Flask, request, jsonify, send_file
+from flask_cors import CORS
 import asyncio
+import tempfile
 import os
 from threading import RLock
+from huggingface_hub import InferenceClient
+from all_models import models  # Importing models from all_models
+
+myapp = Flask(__name__)
+CORS(myapp)  # Enable CORS for all routes
 
 lock = RLock()
-HF_TOKEN = os.environ.get("HF_TOKEN")
+HF_TOKEN = os.environ.get("HF_TOKEN")  # Hugging Face token
 
-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})
-
-load_fn(models)
-
-num_models = 6
-MAX_SEED = 3999999999
-default_models = models[:num_models]
-inference_timeout = 600
-
-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))
+inference_timeout = 600  # Set timeout for inference
+
+# Function to dynamically load models from the "models" list
+def get_model_from_name(model_name):
+    return model_name if model_name in models else None
+
+# Asynchronous function to perform inference
+async def infer(client, prompt, seed=1, timeout=inference_timeout, model="prompthero/openjourney-v4"):
+    task = asyncio.create_task(
+        asyncio.to_thread(client.text_to_image, prompt=prompt, seed=seed, model=model)
+    )
     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(): 
+        print(f"Task timed out for model: {model}")
+        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)
-        return png_path
+            temp_image = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+            with open(temp_image.name, "wb") as f:
+                f.write(result)  # Save the result image as a temporary file
+        return temp_image.name  # Return the path to the saved image
     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
+# Flask route for the API endpoint
+@myapp.route('/generate_api', methods=['POST'])
+def generate_api():
+    data = request.get_json()
+
+    # Extract required fields from the request
+    prompt = data.get('prompt', '')
+    seed = data.get('seed', 1)
+    model_name = data.get('model', 'prompthero/openjourney-v4')  # Default to "prompthero/openjourney-v4" if not provided
+
+    if not prompt:
+        return jsonify({"error": "Prompt is required"}), 400
+
+    # Get the model from all_models
+    model = get_model_from_name(model_name)
+    if not model:
+        return jsonify({"error": f"Model '{model_name}' not found in available models"}), 400
+
+    try:
+        # Create a generic InferenceClient for the model
+        client = InferenceClient(token=HF_TOKEN)  # Pass Hugging Face token if needed
+
+        # Call the async inference function
+        result_path = asyncio.run(infer(client, prompt, seed, model=model))
+        if result_path:
+            return send_file(result_path, mimetype='image/png')  # Send back the generated image file
+        else:
+            return jsonify({"error": "Failed to generate image"}), 500
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
 
-# Launch Gradio API without frontend
-iface = gr.Interface(fn=generate_api, inputs=["text", "text", "number"], outputs="file")
-iface.launch(show_api=True, share=True)
+if __name__ == "__main__":
+    myapp.run(host='0.0.0.0', port=7860)  # Run directly if needed for testing