Upload 4 files

app.py

@@ -486,10 +486,7 @@ class GuiSD:
             retain_task_model_in_cache=False,
         )
 
-    @spaces.GPU
     def infer_short(self, model, pipe_params, progress=gr.Progress(track_tqdm=True)):
-        # Maybe fix lora issue: 'Cannot copy out of meta tensor; no data!''
-        model.pipe.to("cuda:0" if torch.cuda.is_available() else "cpu")
         progress(0, desc="Start inference...")
         images, image_list = model(**pipe_params)
         progress(1, desc="Inference completed.")
@@ -524,6 +521,7 @@ class GuiSD:
         )
         yield f"Model loaded: {model_name}"
 
+    @spaces.GPU
     def generate_pipeline(
         self,
         prompt,
@@ -843,7 +841,10 @@ class GuiSD:
             "ip_adapter_scale": params_ip_scale,
         }
 
-        progress(1, desc="Preparing completed.")
+        # Maybe fix lora issue: 'Cannot copy out of meta tensor; no data!''
+        self.model.pipe.to("cuda:0" if torch.cuda.is_available() else "cpu")
+
+        progress(0, desc="Preparation completed. Starting inference...")
         info_state = f"PROCESSING "
         info_state += ">"
         info_state = f"COMPLETED. Seeds: {str(seed)}"

modutils.py

@@ -4,15 +4,15 @@ import gradio as gr
 from PIL import Image
 from huggingface_hub import HfApi
 from requests import HTTPError, Timeout
-
+from pathlib import Path
 
 HF_LORA_PRIVATE_REPOS1 = ['John6666/loratest1', 'John6666/loratest3', 'John6666/loratest4', 'John6666/loratest6']
-HF_LORA_PRIVATE_REPOS2 = ['John6666/loratest10', 'John6666/loratest']
+HF_LORA_PRIVATE_REPOS2 = ['John6666/loratest10', 'John6666/loratest'] # to be sorted as 1 repo
 HF_LORA_PRIVATE_REPOS = HF_LORA_PRIVATE_REPOS1 + HF_LORA_PRIVATE_REPOS2
-HF_LORA_ESSENTIAL_PRIVATE_REPO = 'John6666/loratest1'
+HF_LORA_ESSENTIAL_PRIVATE_REPO = 'John6666/loratest1' # to be downloaded on run app
 directory_loras = 'loras'
 CIVITAI_API_KEY = os.environ.get("CIVITAI_API_KEY")
-
+hf_read_token = os.environ.get('HF_READ_TOKEN')
 
 def get_user_agent():
     return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:127.0) Gecko/20100101 Firefox/127.0'
@@ -38,7 +38,6 @@ def change_interface_mode(mode: str):
 
 
 def get_local_model_list(dir_path):
-    from pathlib import Path
     model_list = []
     valid_extensions = ('.ckpt', '.pt', '.pth', '.safetensors', '.bin')
     for file in Path(dir_path).glob("*"):
@@ -71,43 +70,37 @@ def escape_lora_basename(basename: str):
 
 def download_private_repo(repo_id, dir_path, is_replace):
     from huggingface_hub import snapshot_download
-    hf_read_token = os.environ.get('HF_READ_TOKEN')
     if not hf_read_token: return
     try:
         snapshot_download(repo_id=repo_id, local_dir=dir_path, allow_patterns=['*.ckpt', '*.pt', '*.pth', '*.safetensors', '*.bin'], use_auth_token=hf_read_token)
     except Exception as e:
         return
-    else:
-        if is_replace:
-            from pathlib import Path
-            for file in Path(dir_path).glob("*"):
-                if file.exists() and "." in file.stem or " " in file.stem and file.suffix in ['.ckpt', '.pt', '.pth', '.safetensors', '.bin']:
-                    newpath = Path(f'{file.parent.name}/{escape_lora_basename(file.stem)}{file.suffix}')
-                    file.resolve().rename(newpath.resolve())
+    if is_replace:
+        for file in Path(dir_path).glob("*"):
+            if file.exists() and "." in file.stem or " " in file.stem and file.suffix in ['.ckpt', '.pt', '.pth', '.safetensors', '.bin']:
+                newpath = Path(f'{file.parent.name}/{escape_lora_basename(file.stem)}{file.suffix}')
+                file.resolve().rename(newpath.resolve())
 
 
-private_model_path_repo_dict = {}
+private_model_path_repo_dict = {} # {"local filepath": "huggingface repo_id", ...}
 
 
 def get_private_model_list(repo_id, dir_path):
     global private_model_path_repo_dict
     api = HfApi()
-    hf_read_token = os.environ.get('HF_READ_TOKEN')
     if not hf_read_token: return []
     try:
         files = api.list_repo_files(repo_id, token=hf_read_token)
     except Exception as e:
         return []
-    else:
-        model_list = []
-        for file in files:
-            from pathlib import Path
-            path = Path(f"{dir_path}/{file}")
-            if path.suffix in ['.ckpt', '.pt', '.pth', '.safetensors', '.bin']:
-                model_list.append(str(path))
-        for model in model_list:
-            private_model_path_repo_dict[model] = repo_id
-        return model_list
+    model_list = []
+    for file in files:
+        path = Path(f"{dir_path}/{file}")
+        if path.suffix in ['.ckpt', '.pt', '.pth', '.safetensors', '.bin']:
+            model_list.append(str(path))
+    for model in model_list:
+        private_model_path_repo_dict[model] = repo_id
+    return model_list
 
 
 def get_private_lora_model_lists():
@@ -123,10 +116,8 @@ def get_private_lora_model_lists():
 
 def download_private_file(repo_id, path, is_replace):
     from huggingface_hub import hf_hub_download
-    from pathlib import Path
     file = Path(path)
     newpath = Path(f'{file.parent.name}/{escape_lora_basename(file.stem)}{file.suffix}') if is_replace else file
-    hf_read_token = os.environ.get('HF_READ_TOKEN')
     if not hf_read_token or newpath.exists(): return
     filename = file.name
     dirname = file.parent.name
@@ -134,9 +125,8 @@ def download_private_file(repo_id, path, is_replace):
         hf_hub_download(repo_id=repo_id, filename=filename, local_dir=dirname, use_auth_token=hf_read_token)
     except Exception as e:
         return
-    else:
-        if is_replace:
-            file.resolve().rename(newpath.resolve())
+    if is_replace:
+        file.resolve().rename(newpath.resolve())
 
 
 def download_private_file_from_somewhere(path, is_replace):
@@ -153,17 +143,16 @@ def get_model_id_list():
         models_john = api.list_models(author="John6666", cardData=True, sort="last_modified")
     except Exception as e:
         return model_ids
-    else:
-        for model in models_vp:
-            model_ids.append(model.id) if not model.private else ""
-        anime_models = []
-        real_models = []
-        for model in models_john:
-            if not model.private:
-                anime_models.append(model.id) if 'anime' in model.tags else real_models.append(model.id)
-        model_ids.extend(anime_models)
-        model_ids.extend(real_models)
-        return model_ids
+    for model in models_vp:
+        model_ids.append(model.id) if not model.private else ""
+    anime_models = []
+    real_models = []
+    for model in models_john:
+        if not model.private:
+            anime_models.append(model.id) if 'anime' in model.tags else real_models.append(model.id)
+    model_ids.extend(anime_models)
+    model_ids.extend(real_models)
+    return model_ids
 
 
 def get_t2i_model_info(repo_id: str):
@@ -171,25 +160,24 @@ def get_t2i_model_info(repo_id: str):
     try:
         if " " in repo_id or not api.repo_exists(repo_id): return ""
         model = api.model_info(repo_id=repo_id)
-    except (EnvironmentError, OSError, ValueError, HTTPError, Timeout) as e:
+    except Exception as e:
         return ""
-    else:
-        if model.private or model.gated: return ""
-        tags = model.tags
-        info = []
-        url = f"https://huggingface.co/{repo_id}/"
-        if not 'diffusers' in tags: return ""
-        if 'diffusers:StableDiffusionXLPipeline' in tags:
-            info.append("SDXL")
-        elif 'diffusers:StableDiffusionPipeline' in tags:
-            info.append("SD1.5")
-        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}")
-        info.append(f"likes: {model.likes}")
-        info.append(model.last_modified.strftime("lastmod: %Y-%m-%d"))
-        md = f"Model Info: {', '.join(info)}, [Model Repo]({url})"
-        return gr.update(value=md)
+    if model.private or model.gated: return ""
+    tags = model.tags
+    info = []
+    url = f"https://huggingface.co/{repo_id}/"
+    if not 'diffusers' in tags: return ""
+    if 'diffusers:StableDiffusionXLPipeline' in tags:
+        info.append("SDXL")
+    elif 'diffusers:StableDiffusionPipeline' in tags:
+        info.append("SD1.5")
+    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}")
+    info.append(f"likes: {model.likes}")
+    info.append(model.last_modified.strftime("lastmod: %Y-%m-%d"))
+    md = f"Model Info: {', '.join(info)}, [Model Repo]({url})"
+    return gr.update(value=md)
 
 
 def get_tupled_model_list(model_list):
@@ -202,28 +190,28 @@ def get_tupled_model_list(model_list):
             model = api.model_info(repo_id=repo_id)
         except Exception as e:
             continue
+        if model.private or model.gated: continue
+        tags = model.tags
+        info = []
+        if not 'diffusers' in tags: continue
+        if 'diffusers:StableDiffusionXLPipeline' in tags:
+            info.append("SDXL")
+        elif 'diffusers:StableDiffusionPipeline' in tags:
+            info.append("SD1.5")
+        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:
+            info.remove("pony")
+            name = f"{repo_id} (Pony🐴, {', '.join(info)})"
         else:
-            if model.private or model.gated: continue
-            tags = model.tags
-            info = []
-            if not 'diffusers' in tags: continue
-            if 'diffusers:StableDiffusionXLPipeline' in tags:
-                info.append("SDXL")
-            elif 'diffusers:StableDiffusionPipeline' in tags:
-                info.append("SD1.5")
-            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:
-                info.remove("pony")
-                name = f"{repo_id} (Pony🐴, {', '.join(info)})"
-            else:
-                name = f"{repo_id} ({', '.join(info)})"
-            tupled_list.append((name, repo_id))
+            name = f"{repo_id} ({', '.join(info)})"
+        tupled_list.append((name, repo_id))
     return tupled_list
 
 
-def save_gallery_images(images):
+def save_gallery_images(images, progress=gr.Progress(track_tqdm=True)):
     from datetime import datetime, timezone, timedelta
+    progress(0, desc="Updating gallery...")
     dt_now = datetime.now(timezone(timedelta(hours=9)))
     basename = dt_now.strftime('%Y%m%d_%H%M%S_')
     i = 1
@@ -231,13 +219,13 @@ def save_gallery_images(images):
     output_images = []
     output_paths = []
     for image in images:
-        from pathlib import Path
         filename = basename + str(i) + ".png"
         oldpath = Path(image[0]) # Path(image[0])
         newpath = oldpath.resolve().rename(Path(filename).resolve())
         output_paths.append(str(newpath))
         output_images.append((str(newpath), str(filename)))
         i += 1
+    progress(1, desc="Gallery updated.")
     return gr.update(value=output_images), gr.update(value=output_paths), gr.update(visible=True),
 
 
@@ -330,7 +318,6 @@ def get_civitai_info(path):
     from urllib3.util import Retry
     from requests.adapters import HTTPAdapter
     if path in set(civitai_not_exists_list): return ["", "", "", "", ""]
-    from pathlib import Path
     if not Path(path).exists(): return None
     user_agent = get_user_agent()
     headers = {'User-Agent': user_agent, 'content-type': 'application/json'}
@@ -348,24 +335,22 @@ def get_civitai_info(path):
         r = session.get(url, params=params, headers=headers, stream=True, timeout=(3.0, 15))
     except (HTTPError, Timeout) as e:
         return ["", "", "", "", ""]
-    else:
-        if not r.ok: return None
-        json = r.json()
-        if not 'baseModel' in json:
-            civitai_not_exists_list.append(path)
-            return ["", "", "", "", ""]
-        items = []
-        items.append(" / ".join(json['trainedWords']))
-        items.append(json['baseModel'])
-        items.append(json['model']['name'])
-        items.append(f"https://civitai.com/models/{json['modelId']}")
-        items.append(json['images'][0]['url'])
-        return items
+    if not r.ok: return None
+    json = r.json()
+    if not 'baseModel' in json:
+        civitai_not_exists_list.append(path)
+        return ["", "", "", "", ""]
+    items = []
+    items.append(" / ".join(json['trainedWords']))
+    items.append(json['baseModel'])
+    items.append(json['model']['name'])
+    items.append(f"https://civitai.com/models/{json['modelId']}")
+    items.append(json['images'][0]['url'])
+    return items
 
 
 def update_lora_dict(path):
     global lora_trigger_dict
-    from pathlib import Path
     key = escape_lora_basename(Path(path).stem)
     if key in lora_trigger_dict.keys(): return
     items = get_civitai_info(path)
@@ -375,7 +360,6 @@ def update_lora_dict(path):
 
 def get_lora_tupled_list(lora_model_list):
     global lora_trigger_dict
-    from pathlib import Path
     if not lora_model_list: return []
     tupled_list = []
     local_models = set(get_local_model_list(directory_loras))
@@ -402,7 +386,6 @@ def get_lora_tupled_list(lora_model_list):
 
 
 def set_lora_trigger(lora_gui: str):
-    from pathlib import Path
     if not lora_gui or lora_gui == "None": return gr.update(value="", visible=False), gr.update(visible=False),\
           gr.update(value="", visible=False), gr.update(value="None", visible=True)
     path = Path(lora_gui)
@@ -468,7 +451,6 @@ def upload_file_lora(files, progress=gr.Progress(track_tqdm=True)):
 
 def move_file_lora(filepaths):
     import shutil
-    from pathlib import Path
     for file in filepaths:
         path = Path(shutil.move(Path(file).resolve(), Path(f"./{directory_loras}").resolve()))
         newpath = Path(f'{path.parent.name}/{escape_lora_basename(path.stem)}{path.suffix}')
@@ -508,24 +490,23 @@ def search_lora_on_civitai(query: str, allow_model: list[str]):
         r = session.get(base_url, params=params, headers=headers, stream=True, timeout=(3.0, 30))
     except (HTTPError, Timeout) as e:
         return None
-    else:
-        if not r.ok: return None
-        json = r.json()
-        if not 'items' in json: return None
-        items = []
-        for j in json['items']:
-            for model in j['modelVersions']:
-                item = {}
-                if not model['baseModel'] in set(allow_model): continue
-                item['name'] = j['name']
-                item['creator'] = j['creator']['username']
-                item['tags'] = j['tags']
-                item['model_name'] = model['name']
-                item['base_model'] = model['baseModel']
-                item['dl_url'] = model['downloadUrl']
-                item['md'] = f'<img src="{model["images"][0]["url"]}" alt="thumbnail" width="150" height="240"><br>[LoRA Model URL](https://civitai.com/models/{j["id"]})'
-                items.append(item)
-        return items
+    if not r.ok: return None
+    json = r.json()
+    if not 'items' in json: return None
+    items = []
+    for j in json['items']:
+        for model in j['modelVersions']:
+            item = {}
+            if not model['baseModel'] in set(allow_model): continue
+            item['name'] = j['name']
+            item['creator'] = j['creator']['username']
+            item['tags'] = j['tags']
+            item['model_name'] = model['name']
+            item['base_model'] = model['baseModel']
+            item['dl_url'] = model['downloadUrl']
+            item['md'] = f'<img src="{model["images"][0]["url"]}" alt="thumbnail" width="150" height="240"><br>[LoRA Model URL](https://civitai.com/models/{j["id"]})'
+            items.append(item)
+    return items
 
 
 civitai_lora_last_results = {}
@@ -808,7 +789,6 @@ textual_inversion_file_token_list = []
 
 
 def get_tupled_embed_list(embed_list):
-    from pathlib import Path
     global textual_inversion_file_list
     tupled_list = []
     for file in embed_list:
@@ -837,7 +817,6 @@ def set_textual_inversion_prompt(textual_inversion_gui, prompt_gui, neg_prompt_g
     ti_prompts = []
     ti_neg_prompts = []
     for ti in textual_inversion_gui:
-        from pathlib import Path
         tokens = textual_inversion_dict.get(Path(ti).name, [Path(ti).stem.replace(",",""), False])
         is_positive = tokens[1] == True or "positive" in Path(ti).parent.name
         if is_positive: # positive prompt
@@ -861,14 +840,13 @@ def get_model_pipeline(repo_id: str):
         model = api.model_info(repo_id=repo_id)
     except Exception as e:
         return default
+    if model.private or model.gated: return default
+    tags = model.tags
+    if not 'diffusers' in tags: return default
+    if 'diffusers:StableDiffusionXLPipeline' in tags:
+        return "StableDiffusionXLPipeline"
+    elif 'diffusers:StableDiffusionPipeline' in tags:
+        return "StableDiffusionPipeline"
     else:
-        if model.private or model.gated: return default
-        tags = model.tags
-        if not 'diffusers' in tags: return default
-        if 'diffusers:StableDiffusionXLPipeline' in tags:
-            return "StableDiffusionXLPipeline"
-        elif 'diffusers:StableDiffusionPipeline' in tags:
-            return "StableDiffusionPipeline"
-        else:
-            return default
+        return default
 

tagger.py

@@ -49,6 +49,18 @@ DANBOORU_TO_E621_RATING_MAP = {
 }
 
 
+def to_list(s):
+    return [x.strip() for x in s.split(",") if not s == ""]
+
+
+def list_sub(a, b):
+    return [e for e in a if e not in b]
+
+
+def list_uniq(l):
+    return sorted(set(l), key=l.index)
+
+
 def load_dict_from_csv(filename):
     with open(filename, 'r', encoding="utf-8") as f:
         lines = f.readlines()
@@ -230,21 +242,16 @@ def convert_tags_to_ja(input_prompt: str = ""):
 enable_auto_recom_prompt = True
 
 
+animagine_ps = to_list("anime artwork, anime style, key visual, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres")
+animagine_nps = to_list("lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]")
+pony_ps = to_list("source_anime, score_9, score_8_up, score_7_up, masterpiece, best quality, very aesthetic, absurdres")
+pony_nps = to_list("source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends")
+other_ps = to_list("anime artwork, anime style, key visual, vibrant, studio anime, highly detailed, cinematic photo, 35mm photograph, film, bokeh, professional, 4k, highly detailed")
+other_nps = to_list("photo, deformed, black and white, realism, disfigured, low contrast, drawing, painting, crayon, sketch, graphite, impressionist, noisy, blurry, soft, deformed, ugly")
+default_ps = to_list("score_9, score_8_up, score_7_up, highly detailed, masterpiece, best quality, very aesthetic, absurdres")
+default_nps = to_list("score_6, score_5, score_4, lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]")
 def insert_recom_prompt(prompt: str = "", neg_prompt: str = "", type: str = "None"):
-    def to_list(s):
-        return [x.strip() for x in s.split(",") if not s == ""]
-    
-    def list_sub(a, b):
-        return [e for e in a if e not in b]
-    
-    def list_uniq(l):
-        return sorted(set(l), key=l.index)
-    
     global enable_auto_recom_prompt
-    animagine_ps = to_list("anime artwork, anime style, key visual, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres")
-    animagine_nps = to_list("lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]")
-    pony_ps = to_list("source_anime, score_9, score_8_up, score_7_up, masterpiece, best quality, very aesthetic, absurdres")
-    pony_nps = to_list("source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends")
     prompts = to_list(prompt)
     neg_prompts = to_list(neg_prompt)
 
@@ -283,22 +290,7 @@ model_prompt_dict = load_model_prompt_dict()
 
 
 def insert_model_recom_prompt(prompt: str = "", neg_prompt: str = "", model_name: str = "None"):
-    def to_list(s):
-        return [x.strip() for x in s.split(",") if not s == ""]
-    
-    def list_sub(a, b):
-        return [e for e in a if e not in b]
-    
-    def list_uniq(l):
-        return sorted(set(l), key=l.index)
-
     if not model_name or not enable_auto_recom_prompt: return prompt, neg_prompt
-    animagine_ps = to_list("anime artwork, anime style, key visual, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres")
-    animagine_nps = to_list("lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]")
-    pony_ps = to_list("source_anime, score_9, score_8_up, score_7_up, masterpiece, best quality, very aesthetic, absurdres")
-    pony_nps = to_list("source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends")
-    other_ps = to_list("anime artwork, anime style, key visual, vibrant, studio anime, highly detailed, cinematic photo, 35mm photograph, film, bokeh, professional, 4k, highly detailed")
-    other_nps = to_list("photo, deformed, black and white, realism, disfigured, low contrast, drawing, painting, crayon, sketch, graphite, impressionist, noisy, blurry, soft, deformed, ugly")
     prompts = to_list(prompt)
     neg_prompts = to_list(neg_prompt)
     prompts = list_sub(prompts, animagine_ps + pony_ps + other_ps)
@@ -311,8 +303,8 @@ def insert_model_recom_prompt(prompt: str = "", neg_prompt: str = "", model_name
         ps = to_list(model_prompt_dict[model_name]["prompt"])
         nps = to_list(model_prompt_dict[model_name]["negative_prompt"])
     else:
-        ps = to_list("score_9, score_8_up, score_7_up, highly detailed, masterpiece, best quality, very aesthetic, absurdres")
-        nps = to_list("score_6, score_5, score_4, lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]")
+        ps = default_ps
+        nps = default_nps
     prompts = prompts + ps
     neg_prompts = neg_prompts + nps
     prompt = ", ".join(list_uniq(prompts) + last_empty_p)