Upload 4 files

app.py

@@ -22,6 +22,7 @@ from stablepy import (
     SD15_TASKS,
     SDXL_TASKS,
 )
+import time
 #import urllib.parse
 
 PREPROCESSOR_CONTROLNET = {
@@ -393,6 +394,7 @@ class GuiSD:
             retain_task_model_in_cache=False,
             device="cpu",
         )
+        self.model.device = torch.device("cpu") #
 
     def load_new_model(self, model_name, vae_model, task, progress=gr.Progress(track_tqdm=True)):
 
@@ -404,7 +406,7 @@ class GuiSD:
         if vae_model:
             vae_type = "SDXL" if "sdxl" in vae_model.lower() else "SD 1.5"
             if model_type != vae_type:
-                gr.Info(msg_inc_vae)
+                gr.Warning(msg_inc_vae)
 
         self.model.device = torch.device("cpu")
         dtype_model = torch.bfloat16 if model_type == "FLUX" else torch.float16
@@ -418,7 +420,7 @@ class GuiSD:
         )
         yield f"Model loaded: {model_name}"
 
-    @spaces.GPU
+    #@spaces.GPU
     @torch.inference_mode()
     def generate_pipeline(
         self,
@@ -531,7 +533,7 @@ class GuiSD:
         vae_model = vae_model if vae_model != "None" else None
         loras_list = [lora1, lora2, lora3, lora4, lora5]
         vae_msg = f"VAE: {vae_model}" if vae_model else ""
-        msg_lora = []
+        msg_lora = ""
 
         print("Config model:", model_name, vae_model, loras_list)
 
@@ -539,7 +541,7 @@ class GuiSD:
         global lora_model_list
         lora_model_list = get_lora_model_list()
         lora1, lora_scale1, lora2, lora_scale2, lora3, lora_scale3, lora4, lora_scale4, lora5, lora_scale5 = \
-                set_prompt_loras(prompt, syntax_weights, lora1, lora_scale1, lora2, lora_scale2, lora3,
+                set_prompt_loras(prompt, syntax_weights, model_name, lora1, lora_scale1, lora2, lora_scale2, lora3,
                                   lora_scale3, lora4, lora_scale4, lora5, lora_scale5)
         prompt, neg_prompt = insert_model_recom_prompt(prompt, neg_prompt, model_name)
 ## END MOD
@@ -703,17 +705,24 @@ class GuiSD:
 
         #progress(0, desc="Preparation completed. Starting inference...")
 
-        info_state = f"PROCESSING "
+        info_state = "PROCESSING "
         for img, seed, image_path, metadata in self.model(**pipe_params):
             info_state += ">"
             if image_path:
-                info_state = f"COMPLETED. Seeds: {str(seed)}"
+                info_state = f"COMPLETE. Seeds: {str(seed)}"
                 if vae_msg:
                     info_state = info_state + "<br>" + vae_msg
+
+                for status, lora in zip(self.model.lora_status, self.model.lora_memory):
+                    if status:
+                        msg_lora += f"<br>Loaded: {lora}"
+                    elif status is not None:
+                        msg_lora += f"<br>Error with: {lora}"
+
                 if msg_lora:
-                    info_state = info_state + "<br>" + "<br>".join(msg_lora)
+                    info_state += msg_lora
 
-                info_state = info_state + "<br>" + "GENERATION DATA:<br>" + "<br>-------<br>".join(metadata).replace("\n", "<br>")
+                info_state = info_state + "<br>" + "GENERATION DATA:<br>" + "<br>-------<br>".join(metadata).replace("\n", "<br>") 
 
                 download_links = "<br>".join(
                     [
@@ -721,7 +730,8 @@ class GuiSD:
                         for i, path in enumerate(image_path)
                     ]
                 )
-                if save_generated_images: info_state += f"<br>{download_links}"
+                if save_generated_images:
+                    info_state += f"<br>{download_links}"
                 
                 img = save_images(img, metadata)
                 
@@ -735,32 +745,90 @@ def update_task_options(model_name, task_name):
 
     return gr.update(value=task_name, choices=new_choices)
 
-# def sd_gen_generate_pipeline(*args):
+def dynamic_gpu_duration(func, duration, *args):
+
+    @spaces.GPU(duration=duration)
+    def wrapped_func():
+        yield from func(*args)
+
+    return wrapped_func()
+
+
+@spaces.GPU
+def dummy_gpu():
+    return None
+
+
+def sd_gen_generate_pipeline(*args):
+
+    gpu_duration_arg = int(args[-1]) if args[-1] else 59
+    verbose_arg = int(args[-2])
+    load_lora_cpu = args[-3]
+    generation_args = args[:-3]
+    lora_list = [
+        None if item == "None" or item == "" else item
+        for item in [args[7], args[9], args[11], args[13], args[15]]
+    ]
+    lora_status = [None] * 5
+
+    msg_load_lora = "Updating LoRAs in GPU..."
+    if load_lora_cpu:
+        msg_load_lora = "Updating LoRAs in CPU (Slow but saves GPU usage)..."
+
+    if lora_list != sd_gen.model.lora_memory and lora_list != [None] * 5:
+        yield None, msg_load_lora
 
-#     # Load lora in CPU
-#     status_lora = sd_gen.model.lora_merge(
-#         lora_A=args[7] if args[7] != "None" else None, lora_scale_A=args[8],
-#         lora_B=args[9] if args[9] != "None" else None, lora_scale_B=args[10],
-#         lora_C=args[11] if args[11] != "None" else None, lora_scale_C=args[12],
-#         lora_D=args[13] if args[13] != "None" else None, lora_scale_D=args[14],
-#         lora_E=args[15] if args[15] != "None" else None, lora_scale_E=args[16],
-#     )
+    # Load lora in CPU
+    if load_lora_cpu:
+        lora_status = sd_gen.model.lora_merge(
+            lora_A=lora_list[0], lora_scale_A=args[8],
+            lora_B=lora_list[1], lora_scale_B=args[10],
+            lora_C=lora_list[2], lora_scale_C=args[12],
+            lora_D=lora_list[3], lora_scale_D=args[14],
+            lora_E=lora_list[4], lora_scale_E=args[16],
+        )
+        print(lora_status)
+
+    if verbose_arg:
+        for status, lora in zip(lora_status, lora_list):
+            if status:
+                gr.Info(f"LoRA loaded in CPU: {lora}")
+            elif status is not None:
+                gr.Warning(f"Failed to load LoRA: {lora}")
+
+        if lora_status == [None] * 5 and sd_gen.model.lora_memory != [None] * 5 and load_lora_cpu:
+            lora_cache_msg = ", ".join(
+                str(x) for x in sd_gen.model.lora_memory if x is not None
+            )
+            gr.Info(f"LoRAs in cache: {lora_cache_msg}")
 
-#     lora_list = [args[7], args[9], args[11], args[13], args[15]]
-#     print(status_lora)
-#     for status, lora in zip(status_lora, lora_list):
-#         if status:
-#             gr.Info(f"LoRA loaded: {lora}")
-#         elif status is not None:
-#             gr.Warning(f"Failed to load LoRA: {lora}")
+        msg_request = f"Requesting {gpu_duration_arg}s. of GPU time"
+        gr.Info(msg_request)
+        print(msg_request)
 
-#     # if status_lora == [None] * 5 and self.model.lora_memory != [None] * 5:
-#     #     gr.Info(f"LoRAs in cache: {", ".join(str(x) for x in self.model.lora_memory if x is not None)}")
+    # yield from sd_gen.generate_pipeline(*generation_args)
 
-#     yield from sd_gen.generate_pipeline(*args)
+    start_time = time.time()
 
+    yield from dynamic_gpu_duration(
+        sd_gen.generate_pipeline,
+        gpu_duration_arg,
+        *generation_args,
+    )
+
+    end_time = time.time()
 
-# sd_gen_generate_pipeline.zerogpu = True
+    if verbose_arg:
+        execution_time = end_time - start_time
+        msg_task_complete = (
+            f"GPU task complete in: {round(execution_time, 0) + 1} seconds"
+        )
+        gr.Info(msg_task_complete)
+        print(msg_task_complete)
+
+
+dynamic_gpu_duration.zerogpu = True
+sd_gen_generate_pipeline.zerogpu = True
 sd_gen = GuiSD()
 
 ## BEGIN MOD
@@ -869,6 +937,12 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', elem_id="main", fill_width=True, cs
 
                     actual_task_info = gr.HTML()
 
+                    with gr.Row(equal_height=False, variant="default"):
+                        gpu_duration_gui = gr.Number(minimum=5, maximum=240, value=59, show_label=False, container=False, info="GPU time duration (seconds)")
+                        with gr.Column():
+                            verbose_info_gui = gr.Checkbox(value=False, container=False, label="Status info")
+                            load_lora_cpu_gui = gr.Checkbox(value=False, container=False, label="Load LoRAs on CPU (Save GPU time)")
+
                 with gr.Column(scale=1):
                     with gr.Accordion("Generation settings", open=False, visible=True) as menu_gen:
                         with gr.Row():
@@ -1015,9 +1089,13 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', elem_id="main", fill_width=True, cs
                                         lora5_copy_gui = gr.Button(value="Copy example to prompt", visible=False)
                                     lora5_desc_gui = gr.Markdown(value="", visible=False)
                         with gr.Accordion("From URL", open=True, visible=True):
+                            with gr.Row():
+                                search_civitai_basemodel_lora = gr.CheckboxGroup(label="Search LoRA for", choices=["Pony", "SD 1.5", "SDXL 1.0", "Flux.1 D", "Flux.1 S"], value=["Pony", "SDXL 1.0"])
+                                search_civitai_sort_lora = gr.Radio(label="Sort", choices=["Highest Rated", "Most Downloaded", "Newest"], value="Highest Rated")
+                                search_civitai_period_lora = gr.Radio(label="Period", choices=["AllTime", "Year", "Month", "Week", "Day"], value="AllTime")
                             with gr.Row():
                                 search_civitai_query_lora = gr.Textbox(label="Query", placeholder="oomuro sakurako...", lines=1)
-                                search_civitai_basemodel_lora = gr.CheckboxGroup(label="Search LoRA for", choices=["Pony", "SD 1.5", "SDXL 1.0"], value=["Pony", "SDXL 1.0"])
+                                search_civitai_tag_lora = gr.Textbox(label="Tag", lines=1)
                                 search_civitai_button_lora = gr.Button("Search on Civitai")
                             search_civitai_desc_lora = gr.Markdown(value="", visible=False)
                             search_civitai_result_lora = gr.Dropdown(label="Search Results", choices=[("", "")], value="", allow_custom_value=True, visible=False)
@@ -1269,7 +1347,7 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', elem_id="main", fill_width=True, cs
                             "Euler a",
                             1024,
                             1024,
-                            "votepurchase/animagine-xl-3.1",
+                            "cagliostrolab/animagine-xl-3.1",
                         ],
                     ],
                     fn=sd_gen.generate_pipeline,
@@ -1407,9 +1485,9 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', elem_id="main", fill_width=True, cs
         lora4_copy_gui.click(apply_lora_prompt, [prompt_gui, lora4_info_gui], [prompt_gui], queue=False)
         lora5_copy_gui.click(apply_lora_prompt, [prompt_gui, lora5_info_gui], [prompt_gui], queue=False)
         gr.on(
-            triggers=[search_civitai_button_lora.click, search_civitai_query_lora.submit],
+            triggers=[search_civitai_button_lora.click, search_civitai_query_lora.submit, search_civitai_tag_lora.submit],
             fn=search_civitai_lora,
-            inputs=[search_civitai_query_lora, search_civitai_basemodel_lora],
+            inputs=[search_civitai_query_lora, search_civitai_basemodel_lora, search_civitai_sort_lora, search_civitai_period_lora, search_civitai_tag_lora],
             outputs=[search_civitai_result_lora, search_civitai_desc_lora, search_civitai_button_lora, search_civitai_query_lora],
             queue=True,
             scroll_to_output=True,
@@ -1463,7 +1541,7 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', elem_id="main", fill_width=True, cs
             queue=True,
             show_progress="minimal",
         ).success(
-            fn=sd_gen.generate_pipeline,
+            fn=sd_gen_generate_pipeline,
             inputs=[
                 prompt_gui,
                 neg_prompt_gui,
@@ -1567,6 +1645,9 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', elem_id="main", fill_width=True, cs
                 mode_ip2,
                 scale_ip2,
                 pag_scale_gui,
+                load_lora_cpu_gui,
+                verbose_info_gui,
+                gpu_duration_gui,
             ],
             outputs=[result_images, actual_task_info], 
             queue=True,

env.py

@@ -72,6 +72,11 @@ load_diffusers_format_model = [
     "Raelina/Raemu-Flux",
 ]
 
+DIFFUSERS_FORMAT_LORAS = [
+    "nerijs/animation2k-flux",
+    "XLabs-AI/flux-RealismLora",
+]
+
 # List all Models for specified user
 HF_MODEL_USER_LIKES = ["votepurchase"] # sorted by number of likes
 HF_MODEL_USER_EX = ["John6666"] # sorted by a special rule

modutils.py

@@ -4,13 +4,21 @@ import gradio as gr
 from huggingface_hub import HfApi
 import os
 from pathlib import Path
+from PIL import Image
 
 
 from env import (HF_LORA_PRIVATE_REPOS1, HF_LORA_PRIVATE_REPOS2,
-    HF_MODEL_USER_EX, HF_MODEL_USER_LIKES,
+    HF_MODEL_USER_EX, HF_MODEL_USER_LIKES, DIFFUSERS_FORMAT_LORAS,
     directory_loras, hf_read_token, HF_TOKEN, CIVITAI_API_KEY)
 
 
+MODEL_TYPE_DICT = {
+    "diffusers:StableDiffusionPipeline": "SD 1.5",
+    "diffusers:StableDiffusionXLPipeline": "SDXL",
+    "diffusers:FluxPipeline": "FLUX",
+}
+
+
 def get_user_agent():
     return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:127.0) Gecko/20100101 Firefox/127.0'
 
@@ -27,6 +35,11 @@ def list_sub(a, b):
     return [e for e in a if e not in b]
 
 
+def is_repo_name(s):
+    import re
+    return re.fullmatch(r'^[^/]+?/[^/]+?$', s)
+
+
 from translatepy import Translator
 translator = Translator()
 def translate_to_en(input: str):
@@ -64,7 +77,7 @@ def download_things(directory, url, hf_token="", civitai_api_key=""):
         if hf_token:
             os.system(f"aria2c --console-log-level=error --summary-interval=10 --header={user_header} -c -x 16 -k 1M -s 16 {url} -d {directory}  -o {url.split('/')[-1]}")
         else:
-            os.system (f"aria2c --optimize-concurrent-downloads --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 {url} -d {directory}  -o {url.split('/')[-1]}")
+            os.system(f"aria2c --optimize-concurrent-downloads --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 {url} -d {directory}  -o {url.split('/')[-1]}")
     elif "civitai.com" in url:
         if "?" in url:
             url = url.split("?")[0]
@@ -100,7 +113,6 @@ def safe_float(input):
     return output
 
 
-from PIL import Image
 def save_images(images: list[Image.Image], metadatas: list[str]):
     from PIL import PngImagePlugin
     import uuid
@@ -245,10 +257,10 @@ model_id_list = get_model_id_list()
 
 
 def get_t2i_model_info(repo_id: str):
-    api = HfApi()
+    api = HfApi(token=HF_TOKEN)
     try:
-        if " " in repo_id or not api.repo_exists(repo_id): return ""
-        model = api.model_info(repo_id=repo_id)
+        if not is_repo_name(repo_id): return ""
+        model = api.model_info(repo_id=repo_id, timeout=5.0)
     except Exception as e:
         print(f"Error: Failed to get {repo_id}'s info.")
         print(e)
@@ -258,9 +270,8 @@ def get_t2i_model_info(repo_id: str):
     info = []
     url = f"https://huggingface.co/{repo_id}/"
     if not 'diffusers' in tags: return ""
-    if 'diffusers:FluxPipeline' in tags: info.append("FLUX.1")
-    elif 'diffusers:StableDiffusionXLPipeline' in tags: info.append("SDXL")
-    elif 'diffusers:StableDiffusionPipeline' in tags: info.append("SD1.5")
+    for k, v in MODEL_TYPE_DICT.items():
+        if k in tags: info.append(v)
     if model.card_data and model.card_data.tags:
         info.extend(list_sub(model.card_data.tags, ['text-to-image', 'stable-diffusion', 'stable-diffusion-api', 'safetensors', 'stable-diffusion-xl']))
     info.append(f"DLs: {model.downloads}")
@@ -285,12 +296,8 @@ def get_tupled_model_list(model_list):
         tags = model.tags
         info = []
         if not 'diffusers' in tags: continue
-        if 'diffusers:FluxPipeline' in tags:
-            info.append("FLUX.1")
-        if 'diffusers:StableDiffusionXLPipeline' in tags:
-            info.append("SDXL")
-        elif 'diffusers:StableDiffusionPipeline' in tags:
-            info.append("SD1.5")
+        for k, v in MODEL_TYPE_DICT.items():
+            if k in tags: info.append(v)
         if model.card_data and model.card_data.tags:
             info.extend(list_sub(model.card_data.tags, ['text-to-image', 'stable-diffusion', 'stable-diffusion-api', 'safetensors', 'stable-diffusion-xl']))
         if "pony" in info:
@@ -374,7 +381,7 @@ def get_civitai_info(path):
 
 
 def get_lora_model_list():
-    loras = list_uniq(get_private_lora_model_lists() + get_local_model_list(directory_loras))
+    loras = list_uniq(get_private_lora_model_lists() + get_local_model_list(directory_loras) + DIFFUSERS_FORMAT_LORAS)
     loras.insert(0, "None")
     loras.insert(0, "")
     return loras
@@ -483,7 +490,7 @@ def download_my_lora(dl_urls: str, lora1: str, lora2: str, lora3: str, lora4: st
         gr.update(value=lora4, choices=choices), gr.update(value=lora5, choices=choices)
 
 
-def get_valid_lora_name(query: str):
+def get_valid_lora_name(query: str, model_name: str):
     path = "None"
     if not query or query == "None": return "None"
     if to_lora_key(query) in loras_dict.keys(): return query
@@ -497,7 +504,7 @@ def get_valid_lora_name(query: str):
         dl_file = download_lora(query)
         if dl_file and Path(dl_file).exists(): return dl_file
     else:
-        dl_file = find_similar_lora(query)
+        dl_file = find_similar_lora(query, model_name)
         if dl_file and Path(dl_file).exists(): return dl_file
     return "None"
 
@@ -521,14 +528,14 @@ def get_valid_lora_wt(prompt: str, lora_path: str, lora_wt: float):
     return wt
 
 
-def set_prompt_loras(prompt, prompt_syntax, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt):
+def set_prompt_loras(prompt, prompt_syntax, model_name, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt):
     import re
     if not "Classic" in str(prompt_syntax):  return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt
-    lora1 = get_valid_lora_name(lora1)
-    lora2 = get_valid_lora_name(lora2)
-    lora3 = get_valid_lora_name(lora3)
-    lora4 = get_valid_lora_name(lora4)
-    lora5 = get_valid_lora_name(lora5)
+    lora1 = get_valid_lora_name(lora1, model_name)
+    lora2 = get_valid_lora_name(lora2, model_name)
+    lora3 = get_valid_lora_name(lora3, model_name)
+    lora4 = get_valid_lora_name(lora4, model_name)
+    lora5 = get_valid_lora_name(lora5, model_name)
     if not "<lora" in prompt: return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt
     lora1_wt = get_valid_lora_wt(prompt, lora1, lora1_wt)
     lora2_wt = get_valid_lora_wt(prompt, lora2, lora2_wt)
@@ -790,16 +797,17 @@ def get_civitai_info(path):
         return items
 
 
-def search_lora_on_civitai(query: str, allow_model: list[str] = ["Pony", "SDXL 1.0"], limit: int = 100):
+def search_lora_on_civitai(query: str, allow_model: list[str] = ["Pony", "SDXL 1.0"], limit: int = 100,
+                           sort: str = "Highest Rated", period: str = "AllTime", tag: str = ""):
     import requests
     from requests.adapters import HTTPAdapter
     from urllib3.util import Retry
-    if not query: return None
     user_agent = get_user_agent()
     headers = {'User-Agent': user_agent, 'content-type': 'application/json'}
     base_url = 'https://civitai.com/api/v1/models'
-    params = {'query': query, 'types': ['LORA'], 'sort': 'Highest Rated', 'period': 'AllTime',
-              'nsfw': 'true', 'supportsGeneration ': 'true', 'limit': limit}
+    params = {'types': ['LORA'], 'sort': sort, 'period': period, 'limit': limit, 'nsfw': 'true'}
+    if query: params["query"] = query
+    if tag: params["tag"] = tag
     session = requests.Session()
     retries = Retry(total=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
     session.mount("https://", HTTPAdapter(max_retries=retries))
@@ -828,9 +836,9 @@ def search_lora_on_civitai(query: str, allow_model: list[str] = ["Pony", "SDXL 1
         return items
 
 
-def search_civitai_lora(query, base_model):
+def search_civitai_lora(query, base_model, sort="Highest Rated", period="AllTime", tag=""):
     global civitai_lora_last_results
-    items = search_lora_on_civitai(query, base_model)
+    items = search_lora_on_civitai(query, base_model, 100, sort, period, tag)
     if not items: return gr.update(choices=[("", "")], value="", visible=False),\
           gr.update(value="", visible=False), gr.update(visible=True), gr.update(visible=True)
     civitai_lora_last_results = {}
@@ -856,7 +864,27 @@ def select_civitai_lora(search_result):
     return gr.update(value=search_result), gr.update(value=md, visible=True)
 
 
-def find_similar_lora(q: str):
+LORA_BASE_MODEL_DICT = {
+    "diffusers:StableDiffusionPipeline": ["SD 1.5"],
+    "diffusers:StableDiffusionXLPipeline": ["Pony", "SDXL 1.0"],
+    "diffusers:FluxPipeline": ["Flux.1 D", "Flux.1 S"],
+}
+
+
+def get_lora_base_model(model_name: str):
+    api = HfApi(token=HF_TOKEN)
+    default = ["Pony", "SDXL 1.0"]
+    try:
+        model = api.model_info(repo_id=model_name, timeout=5.0)
+        tags = model.tags
+        for tag in tags:
+            if tag in LORA_BASE_MODEL_DICT.keys(): return LORA_BASE_MODEL_DICT.get(tag, default)
+    except Exception:
+        return default
+    return default
+
+
+def find_similar_lora(q: str, model_name: str):
     from rapidfuzz.process import extractOne
     from rapidfuzz.utils import default_process
     query = to_lora_key(q)
@@ -879,7 +907,7 @@ def find_similar_lora(q: str):
     print(f"Finding <lora:{query}:...> on Civitai...")
     civitai_query = Path(query).stem if Path(query).is_file() else query
     civitai_query = civitai_query.replace("_", " ").replace("-", " ")
-    base_model = ["Pony", "SDXL 1.0"]
+    base_model = get_lora_base_model(model_name)
     items = search_lora_on_civitai(civitai_query, base_model, 1)
     if items:
         item = items[0]
@@ -1241,11 +1269,11 @@ def set_textual_inversion_prompt(textual_inversion_gui, prompt_gui, neg_prompt_g
 
 def get_model_pipeline(repo_id: str):
     from huggingface_hub import HfApi
-    api = HfApi()
+    api = HfApi(token=HF_TOKEN)
     default = "StableDiffusionPipeline"
     try:
-        if " " in repo_id or not api.repo_exists(repo_id): return default
-        model = api.model_info(repo_id=repo_id)
+        if not is_repo_name(repo_id): return default
+        model = api.model_info(repo_id=repo_id, timeout=5.0)
     except Exception:
         return default
     if model.private or model.gated: return default

requirements.txt

@@ -2,7 +2,6 @@ git+https://github.com/R3gm/stablepy.git@flux_beta
 torch==2.2.0
 gdown
 opencv-python
-yt-dlp
 torchvision
 accelerate
 transformers