app.py

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)