Update myapp.py

myapp.py

@@ -1,63 +1,35 @@
 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 PIL import Image  # Import Pillow
 from io import BytesIO  # For converting image to bytes
+from PIL import Image  # Import Pillow for image processing
 
+# Initialize the Flask app
 myapp = Flask(__name__)
 CORS(myapp)  # Enable CORS for all routes
 
-lock = RLock()
-HF_TOKEN = os.environ.get("HF_TOKEN")  # Hugging Face token
-
-inference_timeout = 600  # Set timeout for inference
+# Initialize the InferenceClient with your Hugging Face token
+HF_TOKEN = os.environ.get("HF_TOKEN")  # Ensure to set your Hugging Face token in the environment
+client = InferenceClient(token=HF_TOKEN)
 
 @myapp.route('/')
 def home():
     return "Welcome to the Image Background Remover!"
 
-# 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)
+# Function to generate an image from a prompt
+def generate_image(prompt, seed=1, model="prompthero/openjourney-v4"):
     try:
-        result = await asyncio.wait_for(task, timeout=timeout)
-    except (Exception, asyncio.TimeoutError) as e:
-        print(e)
-        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:
-            # Convert image result to bytes using Pillow
-            image_bytes = BytesIO()
-            # Assuming result is an image object from huggingface_hub
-            result.save(image_bytes, format='PNG')  # Save the image to a BytesIO object
-            image_bytes.seek(0)  # Go to the start of the byte stream
-            
-            # Save the result image as a temporary file
-            temp_image = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
-            with open(temp_image.name, "wb") as f:
-                f.write(image_bytes.read())  # Write the bytes to the temp file
-
-        return temp_image.name  # Return the path to the saved image
-    return None
+        # Generate the image using Hugging Face's inference API with the given model
+        result_image = client.text_to_image(prompt=prompt, seed=seed, model=model)
+        return result_image
+    except Exception as e:
+        print(f"Error generating image: {str(e)}")
+        return None
 
 # Flask route for the API endpoint
 @myapp.route('/generate_image', methods=['POST'])
-def generate_image():
+def generate_api():
     data = request.get_json()
     
     # Extract required fields from the request
@@ -68,23 +40,22 @@ def generate_image():
     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)
+        # Call the generate_image function with the custom model name
+        image = generate_image(prompt, seed, model_name)
+        
+        if image:
+            # Save the image to a BytesIO object to send as response
+            image_bytes = BytesIO()
+            image.save(image_bytes, format='PNG')
+            image_bytes.seek(0)  # Go to the start of the byte stream
 
-        # 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
+            # Send the generated image as a response with a download option
+            return send_file(image_bytes, mimetype='image/png', as_attachment=True, download_name='generated_image.png')
         else:
             return jsonify({"error": "Failed to generate image"}), 500
     except Exception as e:
-        print(f"Error in generate_image: {str(e)}")  # Log the error
+        print(f"Error in generate_api: {str(e)}")  # Log the error
         return jsonify({"error": str(e)}), 500
 
 # Add this block to make sure your app runs when called