Upload 3 files

all_models.py

@@ -901,4 +901,17 @@ models = [
     "CompVis/stable-diffusion-v1-3", #207
     "CompVis/stable-diffusion-v1-2", #208
     "CompVis/stable-diffusion-v1-1", #209
-]
+]
+
+
+from externalmod import find_model_list
+
+#models = find_model_list("Yntec", [], "", "last_modified", 20)
+
+# Examples:
+#models = ['yodayo-ai/kivotos-xl-2.0', 'yodayo-ai/holodayo-xl-2.1'] # specific models
+#models = find_model_list("Yntec", [], "", "last_modified", 20) # Yntec's latest 20 models
+#models = find_model_list("Yntec", ["anime"], "", "last_modified", 20) # Yntec's latest 20 models with 'anime' tag
+#models = find_model_list("Yntec", [], "anime", "last_modified", 20) # Yntec's latest 20 models without 'anime' tag
+#models = find_model_list("", [], "", "last_modified", 20) # latest 20 text-to-image models of huggingface
+#models = find_model_list("", [], "", "downloads", 20) # monthly most downloaded 20 text-to-image models of huggingface

app.py

@@ -1,40 +1,42 @@
 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
+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.
 
 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}')
+                m = gr_Interface_load(f'models/{model}', hf_token=HF_TOKEN)
             except Exception as error:
-                m = gr.Interface(lambda txt: None, ['text'], ['image'])
+                print(error)
+                m = gr.Interface(lambda: None, ['text'], ['image'])
             models_load.update({model: m})
 
-
 load_fn(models)
 
-
 num_models = 1
+max_imagesone = 1
+max_images = 6
 default_models = models[:num_models]
-
-
+inference_timeout = 300
+MAX_SEED = 2**32-1
 
 def extend_choices(choices):
     return choices + (num_models - len(choices)) * ['NA']
 
-
 def update_imgbox(choices):
     choices_plus = extend_choices(choices)
-    return [gr.Image(None, label = m, visible = (m != 'NA')) for m in choices_plus]
+    return [gr.Image(None, label=m, visible=(m != 'NA')) for m in choices_plus]
 
-    
-def gen_fn(model_str, prompt):
+def gen_fn_original(model_str, prompt):
     if model_str == 'NA':
         return None
     noise = str('') #str(randint(0, 99999999999))
@@ -45,7 +47,61 @@ def gen_fnsix(model_str, prompt):
         return None
     noisesix = str(randint(1941, 2023)) #str(randint(0, 99999999999))
     return models_load[model_str](f'{prompt} {noisesix}')
-with gr.Blocks() as demo:
+
+# https://huggingface.co/docs/api-inference/detailed_parameters
+# https://huggingface.co/docs/huggingface_hub/package_reference/inference_client
+async def infer(model_str, prompt, nprompt="", height=None, width=None, steps=None, cfg=None, seed=-1, timeout=inference_timeout):
+    from pathlib import Path
+    kwargs = {}
+    if height is not None and height >= 256: kwargs["height"] = height
+    if width is not None and width >= 256: kwargs["width"] = width
+    if steps is not None and steps >= 1: kwargs["num_inference_steps"] = steps
+    if cfg is not None and cfg > 0: cfg = kwargs["guidance_scale"] = cfg
+    noise = ""
+    if seed >= 0: kwargs["seed"] = seed
+    else:
+        rand = randint(1, 500)
+        for i in range(rand):
+            noise += " "
+    task = asyncio.create_task(asyncio.to_thread(models_load[model_str].fn,
+                               prompt=f'{prompt} {noise}', negative_prompt=nprompt, **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)
+            image = str(Path(png_path).resolve())
+        return image
+    return None
+
+def gen_fn(model_str, prompt, nprompt="", height=None, width=None, steps=None, cfg=None, seed=-1):
+    if model_str == 'NA':
+        return None
+    try:
+        loop = asyncio.new_event_loop()
+        result = loop.run_until_complete(infer(model_str, prompt, nprompt,
+                                         height, width, steps, cfg, seed, inference_timeout))
+    except (Exception, asyncio.CancelledError) as e:
+        print(e)
+        print(f"Task aborted: {model_str}")
+        result = None
+    finally:
+        loop.close()
+    return result
+
+css="""
+.gradio-container {max-width: 1200px; margin: 0 auto; !important;}
+.output { width=128px; height=128px; !important; }
+.outputone { width=512px; height=512px; !important; }
+"""
+with gr.Blocks(theme='Nymbo/Nymbo_Theme', fill_width=True, css=css) as demo:
     gr.HTML(
     """
         <div>
@@ -54,24 +110,38 @@ with gr.Blocks() as demo:
     """
 )    
     with gr.Tab('One Image'):
-        model_choice = gr.Dropdown(models, label = 'Choose a model from the 872 available! Try clearing the box and typing on it to filter them!', value = models[0], filterable = True)
-        txt_input = gr.Textbox(label = 'Your prompt:')
+        model_choice = gr.Dropdown(models, label=f'Choose a model from the {int(len(models))} available! Try clearing the box and typing on it to filter them!', value=models[0], filterable=True)
+        with gr.Group():
+            txt_input = gr.Textbox(label='Your prompt:', lines=1)
+            with gr.Accordion("Advanced", open=False, visible=True):
+                neg_input = gr.Textbox(label='Negative prompt:', lines=1)
+                with gr.Row():
+                    width = gr.Slider(label="Width", info="If 0, the default value is used.", maximum=1216, step=32, value=0)
+                    height = gr.Slider(label="Height", info="If 0, the default value is used.", maximum=1216, step=32, value=0)
+                with gr.Row():
+                    steps = gr.Slider(label="Number of inference steps", info="If 0, the default value is used.", maximum=100, step=1, value=0)
+                    cfg = gr.Slider(label="Guidance scale", info="If 0, the default value is used.", maximum=30.0, step=0.1, value=0)
+                    seed = gr.Slider(label="Seed", info="Randomize Seed if -1.", minimum=-1, maximum=MAX_SEED, step=1, value=-1)
+        num_imagesone = gr.Slider(1, max_imagesone, value=max_imagesone, step=1, label='Nobody gets to see this label so I can put here whatever I want!', visible=False)
         
-        max_imagesone = 1
-        num_imagesone = gr.Slider(1, max_imagesone, value = max_imagesone, step = 1, label = 'Nobody gets to see this label so I can put here whatever I want!', visible = False)
-        
-        gen_button = gr.Button('Generate')
-        stop_button = gr.Button('Stop', variant = 'secondary', interactive = False)
-        gen_button.click(lambda s: gr.update(interactive = True), None, stop_button)
+        with gr.Row():
+            gen_button = gr.Button('Generate', scale=3)
+            stop_button = gr.Button('Stop', variant='secondary', interactive=False, scale=1)
+        gen_button.click(lambda: gr.update(interactive=True), None, stop_button)
         
         with gr.Row():
-            output = [gr.Image(label = '') for _ in range(max_imagesone)]
+            output = [gr.Image(label='', show_download_button=True, elem_classes="outputone",
+                               interactive=False, min_width=80, show_share_button=False, format="png",
+                               visible=True) for _ in range(max_imagesone)]
 
         for i, o in enumerate(output):
             img_in = gr.Number(i, visible = False)
             num_imagesone.change(lambda i, n: gr.update(visible = (i < n)), [img_in, num_imagesone], o, show_progress = False)
-            gen_event = gen_button.click(lambda i, n, m, t: gen_fn(m, t) if (i < n) else None, [img_in, num_imagesone, model_choice, txt_input], o)
-            stop_button.click(lambda s: gr.update(interactive = False), None, stop_button, cancels = [gen_event])
+            gen_event = gr.on(triggers=[gen_button.click, txt_input.submit],
+                               fn=lambda i, n, m, t1, t2, n1, n2, n3, n4, n5: gen_fn(m, t1, t2, n1, n2, n3, n4, n5) if (i < n) else None,
+                               inputs=[img_in, num_imagesone, model_choice, txt_input, neg_input,
+                                       height, width, steps, cfg, seed], outputs=[o])
+            stop_button.click(lambda: gr.update(interactive = False), None, stop_button, cancels=[gen_event])
         with gr.Row():
             gr.HTML(
     """
@@ -81,35 +151,52 @@ with gr.Blocks() as demo:
     """
 )
     with gr.Tab('Up To Six'):
-        model_choice2 = gr.Dropdown(models, label = 'Choose a model from the 872 available! Try clearing the box and typing on it to filter them!', value = models[0], filterable = True)
-        txt_input2 = gr.Textbox(label = 'Your prompt:')
+        model_choice2 = gr.Dropdown(models, label=f'Choose a model from the {int(len(models))} available! Try clearing the box and typing on it to filter them!',
+                                    value=models[0], filterable=True)
+        with gr.Group():
+            txt_input2 = gr.Textbox(label='Your prompt:', lines=1)
+            with gr.Accordion("Advanced", open=False, visible=True):
+                neg_input2 = gr.Textbox(label='Negative prompt:', lines=1)
+                with gr.Row():
+                    width2 = gr.Slider(label="Width", info="If 0, the default value is used.", maximum=1216, step=32, value=0)
+                    height2 = gr.Slider(label="Height", info="If 0, the default value is used.", maximum=1216, step=32, value=0)
+                with gr.Row():
+                    steps2 = gr.Slider(label="Number of inference steps", info="If 0, the default value is used.", maximum=100, step=1, value=0)
+                    cfg2 = gr.Slider(label="Guidance scale", info="If 0, the default value is used.", maximum=30.0, step=0.1, value=0)
+                    seed2 = gr.Slider(label="Seed", info="Randomize Seed if -1.", minimum=-1, maximum=MAX_SEED, step=1, value=-1)
+
+        num_images = gr.Slider(1, max_images, value=max_images, step=1, 
+         label=f'Number of images (if you want less than {int(max_images)} decrease them slowly until they match the boxes below)')
         
-        max_images = 6
-        num_images = gr.Slider(1, max_images, value = max_images, step = 1, label = 'Number of images (if you want less than 6 decrease them slowly until they match the boxes below)')
-        
-        gen_button2 = gr.Button('Generate up to 6 images in up to 3 minutes total')
-        stop_button2 = gr.Button('Stop', variant = 'secondary', interactive = False)
-        gen_button2.click(lambda s: gr.update(interactive = True), None, stop_button2)
+        with gr.Row():
+            gen_button2 = gr.Button(f'Generate up to {int(max_images)} images in up to 3 minutes total', scale=3)
+            stop_button2 = gr.Button('Stop', variant='secondary', interactive=False, scale=1)
+        gen_button2.click(lambda: gr.update(interactive=True), None, stop_button2)
         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 (they generate in a random order).</p>
+                <div class="center"><p style="margin-bottom: 10px;">Scroll down to see more images (they generate in a random order).</p>
                 </div>
                 </body>
               </div>
             </div>
         """
                )
-        with gr.Column():
-            output2 = [gr.Image(label = '') for _ in range(max_images)]
+        with gr.Row():
+            output2 = [gr.Image(label = '', show_download_button=True, elem_classes="output",
+                                interactive=False, min_width=80, visible=True, format="png",
+                                show_share_button=False, show_label=False) for _ in range(max_images)]
 
         for i, o in enumerate(output2):
-            img_i = gr.Number(i, visible = False)
-            num_images.change(lambda i, n: gr.update(visible = (i < n)), [img_i, num_images], o, show_progress = False)
-            gen_event2 = gen_button2.click(lambda i, n, m, t: gen_fnsix(m, t) if (i < n) else None, [img_i, num_images, model_choice2, txt_input2], o)
-            stop_button2.click(lambda s: gr.update(interactive = False), None, stop_button2, cancels = [gen_event2])
+            img_i = gr.Number(i, visible=False)
+            num_images.change(lambda i, n: gr.update(visible=(i < n)), [img_i, num_images], o, show_progress=False)
+            gen_event2 = gr.on(triggers=[gen_button2.click, txt_input2.submit],
+                               fn=lambda i, n, m, t1, t2, n1, n2, n3, n4, n5: gen_fn(m, t1, t2, n1, n2, n3, n4, n5) if (i < n) else None,
+                               inputs=[img_i, num_images, model_choice2, txt_input2, neg_input2,
+                                       height2, width2, steps2, cfg2, seed2], outputs=[o])
+            stop_button2.click(lambda: gr.update(interactive=False), None, stop_button2, cancels=[gen_event2])
         with gr.Row():
             gr.HTML(
     """
@@ -119,5 +206,5 @@ with gr.Blocks() as demo:
     """
 )
 
-demo.queue()                        
-demo.launch()
+demo.queue(default_concurrency_limit=200, max_size=200)                        
+demo.launch(show_api=False, max_threads=400)

externalmod.py

@@ -33,6 +33,9 @@ if TYPE_CHECKING:
     from gradio.interface import Interface
 
 
+server_timeout = 600
+
+
 @document()
 def load(
     name: str,
@@ -115,7 +118,7 @@ def from_model(model_name: str, hf_token: str | None, alias: str | None, **kwarg
 
     headers["X-Wait-For-Model"] = "true"
     client = huggingface_hub.InferenceClient(
-        model=model_name, headers=headers, token=hf_token
+        model=model_name, headers=headers, token=hf_token, timeout=server_timeout,
     )
 
     # For tasks that are not yet supported by the InferenceClient
@@ -365,10 +368,10 @@ def from_model(model_name: str, hf_token: str | None, alias: str | None, **kwarg
     else:
         raise ValueError(f"Unsupported pipeline type: {p}")
 
-    def query_huggingface_inference_endpoints(*data):
+    def query_huggingface_inference_endpoints(*data, **kwargs):
         if preprocess is not None:
             data = preprocess(*data)
-        data = fn(*data)  # type: ignore
+        data = fn(*data, **kwargs)  # type: ignore
         if postprocess is not None:
             data = postprocess(data)  # type: ignore
         return data
@@ -528,4 +531,54 @@ def gr_Interface_load(
     alias: str | None = None,
     **kwargs,
 ) -> Blocks:
-    return load_blocks_from_repo(name, src, hf_token, alias)
+    try:
+        return load_blocks_from_repo(name, src, hf_token, alias)
+    except Exception as e:
+        print(e)
+        return gradio.Interface(lambda: None, ['text'], ['image'])
+
+
+def list_uniq(l):
+    return sorted(set(l), key=l.index)
+
+
+def get_status(model_name: str):
+    from huggingface_hub import InferenceClient
+    client = InferenceClient(timeout=10)
+    return client.get_model_status(model_name)
+
+
+def is_loadable(model_name: str, force_gpu: bool = False):
+    try:
+        status = get_status(model_name)
+    except Exception as e:
+        print(e)
+        print(f"Couldn't load {model_name}.")
+        return False
+    gpu_state = isinstance(status.compute_type, dict) and "gpu" in status.compute_type.keys()
+    if status is None or status.state not in ["Loadable", "Loaded"] or (force_gpu and not gpu_state):
+        print(f"Couldn't load {model_name}. Model state:'{status.state}', GPU:{gpu_state}")
+    return status is not None and status.state in ["Loadable", "Loaded"] and (not force_gpu or gpu_state)
+
+
+def find_model_list(author: str="", tags: list[str]=[], not_tag="", sort: str="last_modified", limit: int=30, force_gpu=False, check_status=False):
+    from huggingface_hub import HfApi
+    api = HfApi()
+    default_tags = ["diffusers"]
+    if not sort: sort = "last_modified"
+    limit = limit * 20 if check_status and force_gpu else limit * 5
+    models = []
+    try:
+        model_infos = api.list_models(author=author, task="text-to-image",
+                                       tags=list_uniq(default_tags + tags), cardData=True, sort=sort, limit=limit)
+    except Exception as e:
+        print(f"Error: Failed to list models.")
+        print(e)
+        return models
+    for model in model_infos:
+        if not model.private and not model.gated:
+           loadable = is_loadable(model.id, force_gpu) if check_status else True
+           if not_tag and not_tag in model.tags or not loadable: continue
+           models.append(model.id)
+           if len(models) == limit: break
+    return models