Update app.py

app.py

@@ -1,123 +1,99 @@
 import gradio as gr
-import requests
-import io
-import random
+from random import randint
+from all_models import models
+
+from externalmod import gr_Interface_load, randomize_seed
+
+import asyncio
 import os
-import time
-from PIL import Image
-import json
 from threading import RLock
+lock = RLock()
+HF_TOKEN = os.environ.get("HF_TOKEN") if os.environ.get("HF_TOKEN") else None # If private or gated models aren't used, ENV setting is unnecessary.
 
-# Project by Nymbo
 
-# Base API URL for Hugging Face inference
-API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
-# Retrieve the API token from environment variables
-API_TOKEN = os.getenv("HF_READ_TOKEN")
-headers = {"Authorization": f"Bearer {API_TOKEN}"}
-# Timeout for requests
-timeout = 100
+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})
 
-lock = RLock()
 
-# Function to query the Hugging Face API for image generation
-def query(prompt, model, negative_prompt, steps, cfg_scale, sampler, seed, strength, width, height):
-    # Debug log to indicate function start
-    print("Starting query function...")
-    # Print the parameters for debugging purposes
-    print(f"Prompt: {prompt}")
-    print(f"Model: {model}")
-    print(f"Parameters - Steps: {steps}, CFG Scale: {cfg_scale}, Seed: {seed}, Strength: {strength}, Width: {width}, Height: {height}")
-
-    # Check if the prompt is empty or None
-    if prompt == "" or prompt is None:
-        print("Prompt is empty or None. Exiting query function.")  # Debug log
-        return None
+load_fn(models)
 
-    # Randomly select an API token from available options to distribute the load
-    API_TOKEN = random.choice([os.getenv("HF_READ_TOKEN"), os.getenv("HF_READ_TOKEN_2"), os.getenv("HF_READ_TOKEN_3"), os.getenv("HF_READ_TOKEN_4"), os.getenv("HF_READ_TOKEN_5")])
-    headers = {"Authorization": f"Bearer {API_TOKEN}"}
-    print(f"Selected API token: {API_TOKEN}")  # Debug log
-
-    # Enhance the prompt with additional details for better quality
-    prompt = f"{prompt} | ultra detail, ultra elaboration, ultra quality, perfect."
-    print(f'Generation: {prompt}')  # Debug log
-
-    # Set the API URL based on the selected model
-    if model == 'Stable Diffusion XL':
-        API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
-    # Add more model options as needed
-    print(f"API URL set to: {API_URL}")  # Debug log
-
-    # Define the payload for the request
-    payload = {
-        "inputs": prompt,
-        "negative_prompt": negative_prompt,
-        "steps": steps,  # Number of sampling steps
-        "cfg_scale": cfg_scale,  # Scale for controlling adherence to prompt
-        "seed": seed if seed != -1 else random.randint(1, 1000000000),  # Random seed for reproducibility
-        "strength": strength,  # How strongly the model should transform the image
-        "parameters": {
-            "width": width,  # Width of the generated image
-            "height": height  # Height of the generated image
-        }
-    }
-    print(f"Payload: {json.dumps(payload, indent=2)}")  # Debug log
-
-    # Make a request to the API to generate the image
-    try:
-        response = requests.post(API_URL, headers=headers, json=payload, timeout=timeout)
-        print(f"Response status code: {response.status_code}")  # Debug log
-    except requests.exceptions.RequestException as e:
-        # Log any request exceptions and raise an error for the user
-        print(f"Request failed: {e}")  # Debug log
-        raise gr.Error(f"Request failed: {e}")
-
-    # Check if the response status is not successful
-    if response.status_code != 200:
-        print(f"Error: Failed to retrieve image. Response status: {response.status_code}")  # Debug log
-        print(f"Response content: {response.text}")  # Debug log
-        if response.status_code == 400:
-            raise gr.Error(f"{response.status_code}: Bad Request - There might be an issue with the input parameters.")
-        elif response.status_code == 401:
-            raise gr.Error(f"{response.status_code}: Unauthorized - Please check your API token.")
-        elif response.status_code == 403:
-            raise gr.Error(f"{response.status_code}: Forbidden - You do not have permission to access this model.")
-        elif response.status_code == 404:
-            raise gr.Error(f"{response.status_code}: Not Found - The requested model could not be found.")
-        elif response.status_code == 503:
-            raise gr.Error(f"{response.status_code}: The model is being loaded. Please try again later.")
-        else:
-            raise gr.Error(f"{response.status_code}: An unexpected error occurred.")
-    
+
+num_models = 6
+
+default_models = models[:num_models]
+inference_timeout = 600
+MAX_SEED=3999999999
+starting_seed = randint(1941, 2024)
+
+def extend_choices(choices):
+    return choices[:num_models] + (num_models - len(choices[:num_models])) * ['NA']
+
+
+def update_imgbox(choices):
+    choices_plus = extend_choices(choices[:num_models])
+    return [gr.Image(None, label=m, visible=(m!='NA')) for m in choices_plus]
+
+async def infer(model_str, prompt, seed=1, timeout=inference_timeout):
+    from pathlib import Path
+    kwargs = {}
+    noise = ""
+    kwargs["seed"] = seed
+    task = asyncio.create_task(asyncio.to_thread(models_load[model_str].fn,
+                               prompt=f'{prompt} {noise}', **kwargs, token=HF_TOKEN))
+    await asyncio.sleep(0)
     try:
-        # Attempt to read the image from the response content
-        image_bytes = response.content
-        image = Image.open(io.BytesIO(image_bytes))
-        print(f'Generation completed! ({prompt})')  # Debug log
+        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)
+            image = str(Path(png_path).resolve())
         return image
-    except Exception as e:
-        # Handle any errors that occur when opening the image
-        print(f"Error while trying to open image: {e}")  # Debug log
-        return None
-
-# Custom CSS to hide the footer in the interface
-css = """
-* {}
-footer {visibility: hidden !important;}
-"""
+    return None
 
-print("Initializing Gradio interface...")  # Debug log
 
-# Define the Gradio interface
-with gr.Blocks(theme='Nymbo/Nymbo_Theme') as demo:
-    # Tab for basic settings
-    with gr.Tab('Basic Settings'):
+def gen_fnseed(model_str, prompt, seed=1):
+    if model_str == 'NA':
+        return None
+    try:
+        loop = asyncio.new_event_loop()
+        result = loop.run_until_complete(infer(model_str, prompt, seed, inference_timeout))
+    except (Exception, asyncio.CancelledError) as e:
+        print(e)
+        print(f"Task aborted: {model_str}")
+        result = None
+    finally:
+        loop.close()
+    return result
+
+with gr.Blocks(theme="Nymbo/Nymbo_Theme") as demo:
+    gr.HTML("<h1>My Gradio Interface</h1>")  # Add this line to include the HTML title
+    with gr.Tab('Compare-6'): 
         txt_input = gr.Textbox(label='Your prompt:', lines=4)
-        model = gr.Radio(label="Select a model", value="Stable Diffusion XL", choices=["Stable Diffusion XL", "Stable Diffusion 3", "FLUX.1 [Schnell]", "RealVisXL v4.0", "Duchaiten Real3D NSFW XL", "Tempest v0.1"], interactive=True)
-        gen_button = gr.Button('Generate Image')
+        gen_button = gr.Button('Generate up to 6 images in up to 3 minutes total')
+        with gr.Row():
+            seed = gr.Slider(label="Use a seed to replicate the same image later (maximum 3999999999)", minimum=0, maximum=MAX_SEED, step=1, value=starting_seed, scale=3)
+            seed_rand = gr.Button("Randomize Seed 🎲", size="sm", variant="secondary", scale=1)    
+        seed_rand.click(randomize_seed, None, [seed], queue=False)
+        #stop_button = gr.Button('Stop', variant = 'secondary', interactive = False)
+               
+        gen_button.click(lambda s: gr.update(interactive = True), None)
         
-    # Tab for advanced settings
     with gr.Tab("Advanced Settings"):
         with gr.Row():
             # Textbox for specifying elements to exclude from the image
@@ -143,9 +119,34 @@ with gr.Blocks(theme='Nymbo/Nymbo_Theme') as demo:
             # Radio buttons for selecting the sampling method
             method = gr.Radio(label="Sampling method", value="DPM++ 2M Karras", choices=["DPM++ 2M Karras", "DPM++ SDE Karras", "Euler", "Euler a", "Heun", "DDIM"])
 
-    # Set up button click event to call the query function
-    gen_button.click(query, inputs=[txt_input, model, negative_prompt, steps, cfg, method, seed, strength, width, height], outputs=gr.Image(type="pil", label="Generated Image"))
+        gr.HTML(
+        """
+            <div style="text-align: center; max-width: 1200px; margin: 0 auto;">
+              <div>
+                <body>
+                <div class="center"><p style="margin-bottom: 10px; color: #000000;">Scroll down to see more images and select models.</p>
+                </div>
+                </body>
+              </div>
+            </div>
+        """
+               )
+        with gr.Row():
+            output = [gr.Image(label = m, min_width=480) for m in default_models]
+            current_models = [gr.Textbox(m, visible = False) for m in default_models]
+                        
+            for m, o in zip(current_models, output):
+                gen_event = gr.on(triggers=[gen_button.click, txt_input.submit], fn=gen_fnseed,
+                            inputs=[m, txt_input, seed], outputs=[o], concurrency_limit=None, queue=False)
+                #stop_button.click(lambda s: gr.update(interactive = False), None, stop_button, cancels = [gen_event])
+        with gr.Accordion('Model selection'):
+            model_choice = gr.CheckboxGroup(models, label = f'Choose up to {int(num_models)} different models from the {len(models)} available!', value=default_models, interactive=True)
+            #model_choice = gr.CheckboxGroup(models, label = f'Choose up to {num_models} different models from the 2 available! Untick them to only use one!', value = default_models, multiselect = True, max_choices = num_models, interactive = True, filterable = False)
+            model_choice.change(update_imgbox, model_choice, output)
+            model_choice.change(extend_choices, model_choice, current_models)
+        with gr.Row():
+            gr.HTML(
+)
 
-print("Launching Gradio interface...")  # Debug log
-# Launch the Gradio interface without showing the API or sharing externally
+demo.queue(default_concurrency_limit=200, max_size=200)
 demo.launch(show_api=False, max_threads=400)