File size: 3,561 Bytes
ba47c7a c297a11 dcc382f c680ed4 ba47c7a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 |
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 gradio_client import Client
from flask import Flask, request, jsonify, send_file
from flask_cors import CORS
app = Flask(__name__)
CORS(app) # Enable CORS for all routes
lock = RLock()
HF_TOKEN = os.environ.get("HF_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))
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 = "image.png"
result.save(png_path)
return png_path
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
@app.route('/predict', methods=['POST'])
def predict():
try:
# Log the request body for debugging
data = request.get_json()
print("Received request:", data)
if not data or 'data' not in data:
return jsonify({"error": "Missing 'data' in request body"}), 400
data_fields = data['data']
# Extract the relevant fields
model_str = data_fields.get('model_str')
prompt = data_fields.get('prompt')
seed = data_fields.get('seed', 1)
if not model_str or not prompt:
return jsonify({"error": "Missing required fields: 'model_str' or 'prompt'"}), 400
# Log the extracted fields for debugging
print(f"model_str: {model_str}, prompt: {prompt}, seed: {seed}")
# Call the Gradio client to run inference
client = Client("Geek7/mdztxi2")
result_path = client.predict(
model_str=model_str,
prompt=prompt,
seed=seed,
api_name="/predict"
)
if result_path and os.path.exists(result_path):
try:
return send_file(result_path, mimetype='image/png')
except Exception as e:
print(f"Error sending file: {str(e)}")
return jsonify({"error": "Failed to send image."}), 500
else:
return jsonify({"error": "Failed to generate image."}), 500
except Exception as e:
print(f"Error in /predict: {str(e)}")
return jsonify({"error": "An error occurred during processing."}), 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) |