Upload 9 files

README.md

@@ -1,12 +1,14 @@
----
-title: Safetensors To Diffusers
-emoji: 👁
-colorFrom: yellow
-colorTo: pink
-sdk: gradio
-sdk_version: 5.3.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Download safetensors and convert to HF🤗 Diffusers format (SDXL / SD 1.5 / FLUX.1 / SD 3.5) Alpha
+emoji: 🎨➡️🧨
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 5.1.0
+app_file: app.py
+pinned: false
+license: mit
+short_description: Convert SDXL/1.5/3.5/FLUX.1 safetensors to HF🤗 Diffusers
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,243 @@
+import gradio as gr
+from convert_url_to_diffusers_multi_gr import convert_url_to_diffusers_repo, get_dtypes, FLUX_BASE_REPOS, SD35_BASE_REPOS
+from presets import (DEFAULT_DTYPE, schedulers, clips, t5s, sdxl_vaes, sdxl_loras, sdxl_preset_dict, sdxl_set_presets,
+                     sd15_vaes, sd15_loras, sd15_preset_dict, sd15_set_presets, flux_vaes, flux_loras, flux_preset_dict, flux_set_presets,
+                     sd35_vaes, sd35_loras, sd35_preset_dict, sd35_set_presets)
+
+css = """
+.title { font-size: 3em; align-items: center; text-align: center; }
+.info { align-items: center; text-align: center; }
+.block.result { margin: 1em 0; padding: 1em; box-shadow: 0 0 3px 3px #664422, 0 0 3px 2px #664422 inset; border-radius: 6px; background: #665544; }
+"""
+
+with gr.Blocks(theme="NoCrypt/miku@>=1.2.2", fill_width=True, css=css, delete_cache=(60, 3600)) as demo:
+    gr.Markdown("# Download SDXL / SD 1.5 / SD 3.5 / FLUX.1 safetensors and convert to HF🤗 Diffusers format and create your repo", elem_classes="title")
+    gr.Markdown(f"""
+### ⚠️IMPORTANT NOTICE⚠️<br>
+It's dangerous to expose your access token or key to others.
+If you do use it, I recommend that you duplicate this space on your own HF account in advance.
+Keys and tokens could be set to **Secrets** (`HF_TOKEN`, `CIVITAI_API_KEY`) if it's placed in your own space.
+It saves you the trouble of typing them in.<br>
+It barely works in the CPU space, but larger files can be converted if duplicated on the more powerful **Zero GPU** space.
+In particular, conversion of FLUX.1 or SD 3.5 is almost impossible in CPU space.
+### The steps are the following:
+1. Paste a write-access token from [hf.co/settings/tokens](https://huggingface.co/settings/tokens).
+1. Input a model download url of the Hugging Face or Civitai or other sites.
+1. If you want to download a model from Civitai, paste a Civitai API Key.
+1. Input your HF user ID. e.g. 'yourid'.
+1. Input your new repo name. If empty, auto-complete. e.g. 'newrepo'.
+1. Set the parameters. If not sure, just use the defaults.
+1. Click "Submit".
+1. Patiently wait until the output changes. It takes approximately 2 to 3 minutes (on SDXL models downloading from HF).
+            """)
+    with gr.Column():
+        dl_url = gr.Textbox(label="URL to download", placeholder="https://huggingface.co/bluepen5805/blue_pencil-XL/blob/main/blue_pencil-XL-v7.0.0.safetensors", value="", max_lines=1)
+        with gr.Group():
+            with gr.Row():
+                hf_user = gr.Textbox(label="Your HF user ID", placeholder="username", value="", max_lines=1)
+                hf_repo = gr.Textbox(label="New repo name", placeholder="reponame", info="If empty, auto-complete", value="", max_lines=1)
+            with gr.Row(equal_height=True):
+                with gr.Column():
+                    hf_token = gr.Textbox(label="Your HF write token", placeholder="hf_...", value="", max_lines=1)
+                    gr.Markdown("Your token is available at [hf.co/settings/tokens](https://huggingface.co/settings/tokens).", elem_classes="info")
+                with gr.Column():
+                    civitai_key = gr.Textbox(label="Your Civitai API Key (Optional)", info="If you download model from Civitai...", placeholder="", value="", max_lines=1)
+                    gr.Markdown("Your Civitai API key is available at [https://civitai.com/user/account](https://civitai.com/user/account).", elem_classes="info")
+            with gr.Row():
+                is_upload_sf = gr.Checkbox(label="Upload single safetensors file into new repo", value=False)
+                is_private = gr.Checkbox(label="Create private repo", value=True)
+                is_overwrite = gr.Checkbox(label="Overwrite repo", value=False)
+        with gr.Tab("SDXL"):
+            with gr.Group():
+                sdxl_presets = gr.Radio(label="Presets", choices=list(sdxl_preset_dict.keys()), value=list(sdxl_preset_dict.keys())[0])
+                sdxl_mtype = gr.Textbox(value="SDXL", visible=False)
+                with gr.Row():
+                    sdxl_dtype = gr.Radio(label="Output data type", choices=get_dtypes(), value=DEFAULT_DTYPE)
+                    sdxl_ema = gr.Checkbox(label="Extract EMA", info="For SD 1.5", value=True, visible=False)
+                    sdxl_base_repo = gr.Dropdown(label="Base repo ID", choices=FLUX_BASE_REPOS, value=FLUX_BASE_REPOS[0], allow_custom_value=True, visible=False)
+                with gr.Accordion("Advanced settings", open=False):
+                    with gr.Row():
+                        sdxl_vae = gr.Dropdown(label="VAE", choices=sdxl_vaes, value="", allow_custom_value=True)
+                        sdxl_clip = gr.Dropdown(label="CLIP", choices=clips, value="", allow_custom_value=True)
+                        sdxl_t5 = gr.Dropdown(label="T5", choices=t5s, value="", allow_custom_value=True, visible=False)
+                        sdxl_scheduler = gr.Dropdown(label="Scheduler (Sampler)", choices=schedulers, value="Euler a")
+                    with gr.Row():
+                        with gr.Column():
+                            sdxl_lora1 = gr.Dropdown(label="LoRA1", choices=sdxl_loras, value="", allow_custom_value=True, min_width=320)
+                            sdxl_lora1s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA1 weight scale")
+                        with gr.Column():
+                            sdxl_lora2 = gr.Dropdown(label="LoRA2", choices=sdxl_loras, value="", allow_custom_value=True, min_width=320)
+                            sdxl_lora2s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA2 weight scale")
+                        with gr.Column():
+                            sdxl_lora3 = gr.Dropdown(label="LoRA3", choices=sdxl_loras, value="", allow_custom_value=True, min_width=320)
+                            sdxl_lora3s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA3 weight scale")
+                        with gr.Column():
+                            sdxl_lora4 = gr.Dropdown(label="LoRA4", choices=sdxl_loras, value="", allow_custom_value=True, min_width=320)
+                            sdxl_lora4s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA4 weight scale")
+                        with gr.Column():
+                            sdxl_lora5 = gr.Dropdown(label="LoRA5", choices=sdxl_loras, value="", allow_custom_value=True, min_width=320)
+                            sdxl_lora5s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA5 weight scale")
+            sdxl_run_button = gr.Button(value="Submit", variant="primary")
+        with gr.Tab("SD 1.5"):
+            with gr.Group():
+                sd15_presets = gr.Radio(label="Presets", choices=list(sd15_preset_dict.keys()), value=list(sd15_preset_dict.keys())[0])
+                sd15_mtype = gr.Textbox(value="SD 1.5", visible=False)
+                with gr.Row():
+                    sd15_dtype = gr.Radio(label="Output data type", choices=get_dtypes(), value=DEFAULT_DTYPE)
+                    sd15_ema = gr.Checkbox(label="Extract EMA", info="For SD 1.5", value=True, visible=True)
+                    sd15_base_repo = gr.Dropdown(label="Base repo ID", choices=FLUX_BASE_REPOS, value=FLUX_BASE_REPOS[0], allow_custom_value=True, visible=False)
+                with gr.Accordion("Advanced settings", open=False):
+                    with gr.Row():
+                        sd15_vae = gr.Dropdown(label="VAE", choices=sd15_vaes, value="", allow_custom_value=True)
+                        sd15_clip = gr.Dropdown(label="CLIP", choices=clips, value="", allow_custom_value=True)
+                        sd15_t5 = gr.Dropdown(label="T5", choices=t5s, value="", allow_custom_value=True, visible=False)
+                        sd15_scheduler = gr.Dropdown(label="Scheduler (Sampler)", choices=schedulers, value="Euler")
+                    with gr.Row():
+                        with gr.Column():
+                            sd15_lora1 = gr.Dropdown(label="LoRA1", choices=sd15_loras, value="", allow_custom_value=True, min_width=320)
+                            sd15_lora1s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA1 weight scale")
+                        with gr.Column():
+                            sd15_lora2 = gr.Dropdown(label="LoRA2", choices=sd15_loras, value="", allow_custom_value=True, min_width=320)
+                            sd15_lora2s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA2 weight scale")
+                        with gr.Column():
+                            sd15_lora3 = gr.Dropdown(label="LoRA3", choices=sd15_loras, value="", allow_custom_value=True, min_width=320)
+                            sd15_lora3s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA3 weight scale")
+                        with gr.Column():
+                            sd15_lora4 = gr.Dropdown(label="LoRA4", choices=sd15_loras, value="", allow_custom_value=True, min_width=320)
+                            sd15_lora4s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA4 weight scale")
+                        with gr.Column():
+                            sd15_lora5 = gr.Dropdown(label="LoRA5", choices=sd15_loras, value="", allow_custom_value=True, min_width=320)
+                            sd15_lora5s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA5 weight scale")
+            sd15_run_button = gr.Button(value="Submit", variant="primary")
+        with gr.Tab("FLUX.1"):
+            with gr.Group():
+                flux_presets = gr.Radio(label="Presets", choices=list(flux_preset_dict.keys()), value=list(flux_preset_dict.keys())[0])
+                flux_mtype = gr.Textbox(value="FLUX", visible=False)
+                with gr.Row():
+                    flux_dtype = gr.Radio(label="Output data type", choices=get_dtypes(), value="bf16")
+                    flux_ema = gr.Checkbox(label="Extract EMA", info="For SD 1.5", value=True, visible=False)
+                    flux_base_repo = gr.Dropdown(label="Base repo ID", choices=FLUX_BASE_REPOS, value=FLUX_BASE_REPOS[0], allow_custom_value=True, visible=True)
+                with gr.Accordion("Advanced settings", open=False):
+                    with gr.Row():
+                        flux_vae = gr.Dropdown(label="VAE", choices=flux_vaes, value="", allow_custom_value=True)
+                        flux_clip = gr.Dropdown(label="CLIP", choices=clips, value="", allow_custom_value=True)
+                        flux_t5 = gr.Dropdown(label="T5", choices=t5s, value="", allow_custom_value=True)
+                        flux_scheduler = gr.Dropdown(label="Scheduler (Sampler)", choices=[""], value="", visible=False)
+                    with gr.Row():
+                        with gr.Column():
+                            flux_lora1 = gr.Dropdown(label="LoRA1", choices=flux_loras, value="", allow_custom_value=True, min_width=320)
+                            flux_lora1s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA1 weight scale")
+                        with gr.Column():
+                            flux_lora2 = gr.Dropdown(label="LoRA2", choices=flux_loras, value="", allow_custom_value=True, min_width=320)
+                            flux_lora2s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA2 weight scale")
+                        with gr.Column():
+                            flux_lora3 = gr.Dropdown(label="LoRA3", choices=flux_loras, value="", allow_custom_value=True, min_width=320)
+                            flux_lora3s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA3 weight scale")
+                        with gr.Column():
+                            flux_lora4 = gr.Dropdown(label="LoRA4", choices=flux_loras, value="", allow_custom_value=True, min_width=320)
+                            flux_lora4s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA4 weight scale")
+                        with gr.Column():
+                            flux_lora5 = gr.Dropdown(label="LoRA5", choices=flux_loras, value="", allow_custom_value=True, min_width=320)
+                            flux_lora5s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA5 weight scale")
+            flux_run_button = gr.Button(value="Submit", variant="primary")
+        with gr.Tab("SD 3.5"):
+            with gr.Group():
+                sd35_presets = gr.Radio(label="Presets", choices=list(sd35_preset_dict.keys()), value=list(sd35_preset_dict.keys())[0])
+                sd35_mtype = gr.Textbox(value="SD 3.5", visible=False)
+                with gr.Row():
+                    sd35_dtype = gr.Radio(label="Output data type", choices=get_dtypes(), value="bf16")
+                    sd35_ema = gr.Checkbox(label="Extract EMA", info="For SD 1.5", value=True, visible=False)
+                    sd35_base_repo = gr.Dropdown(label="Base repo ID", choices=SD35_BASE_REPOS, value=SD35_BASE_REPOS[0], allow_custom_value=True, visible=True)
+                with gr.Accordion("Advanced settings", open=False):
+                    with gr.Row():
+                        sd35_vae = gr.Dropdown(label="VAE", choices=sd35_vaes, value="", allow_custom_value=True)
+                        sd35_clip = gr.Dropdown(label="CLIP", choices=clips, value="", allow_custom_value=True)
+                        sd35_t5 = gr.Dropdown(label="T5", choices=t5s, value="", allow_custom_value=True)
+                        sd35_scheduler = gr.Dropdown(label="Scheduler (Sampler)", choices=[""], value="", visible=False)
+                    with gr.Row():
+                        with gr.Column():
+                            sd35_lora1 = gr.Dropdown(label="LoRA1", choices=sd35_loras, value="", allow_custom_value=True, min_width=320)
+                            sd35_lora1s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA1 weight scale")
+                        with gr.Column():
+                            sd35_lora2 = gr.Dropdown(label="LoRA2", choices=sd35_loras, value="", allow_custom_value=True, min_width=320)
+                            sd35_lora2s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA2 weight scale")
+                        with gr.Column():
+                            sd35_lora3 = gr.Dropdown(label="LoRA3", choices=sd35_loras, value="", allow_custom_value=True, min_width=320)
+                            sd35_lora3s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA3 weight scale")
+                        with gr.Column():
+                            sd35_lora4 = gr.Dropdown(label="LoRA4", choices=sd35_loras, value="", allow_custom_value=True, min_width=320)
+                            sd35_lora4s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA4 weight scale")
+                        with gr.Column():
+                            sd35_lora5 = gr.Dropdown(label="LoRA5", choices=sd35_loras, value="", allow_custom_value=True, min_width=320)
+                            sd35_lora5s = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="LoRA5 weight scale")
+            sd35_run_button = gr.Button(value="Submit", variant="primary")
+        with gr.Group():
+            repo_urls = gr.CheckboxGroup(visible=False, choices=[], value=[])
+            output_md = gr.Markdown(label="Output", value="<br><br>", elem_classes="result")
+            clear_button = gr.Button(value="Clear Output", variant="secondary")
+        gr.DuplicateButton(value="Duplicate Space")
+
+    gr.on(
+        triggers=[sdxl_run_button.click],
+        fn=convert_url_to_diffusers_repo,
+        inputs=[dl_url, hf_user, hf_repo, hf_token, civitai_key, is_private, is_overwrite, is_upload_sf, repo_urls,
+                sdxl_dtype, sdxl_vae, sdxl_clip, sdxl_t5, sdxl_scheduler, sdxl_ema, sdxl_base_repo, sdxl_mtype,
+                sdxl_lora1, sdxl_lora1s, sdxl_lora2, sdxl_lora2s, sdxl_lora3, sdxl_lora3s, sdxl_lora4, sdxl_lora4s, sdxl_lora5, sdxl_lora5s],
+        outputs=[repo_urls, output_md],
+    )
+    sdxl_presets.change(
+        fn=sdxl_set_presets,
+        inputs=[sdxl_presets],
+        outputs=[sdxl_dtype, sdxl_vae, sdxl_scheduler, sdxl_lora1, sdxl_lora1s, sdxl_lora2, sdxl_lora2s, sdxl_lora3, sdxl_lora3s,
+                 sdxl_lora4, sdxl_lora4s, sdxl_lora5, sdxl_lora5s],
+        queue=False,
+    )
+    gr.on(
+        triggers=[sd15_run_button.click],
+        fn=convert_url_to_diffusers_repo,
+        inputs=[dl_url, hf_user, hf_repo, hf_token, civitai_key, is_private, is_overwrite, is_upload_sf, repo_urls,
+                sd15_dtype, sd15_vae, sd15_clip, sd15_t5, sd15_scheduler, sd15_ema, sd15_base_repo, sd15_mtype,
+                sd15_lora1, sd15_lora1s, sd15_lora2, sd15_lora2s, sd15_lora3, sd15_lora3s, sd15_lora4, sd15_lora4s, sd15_lora5, sd15_lora5s],
+        outputs=[repo_urls, output_md],
+    )
+    sd15_presets.change(
+        fn=sd15_set_presets,
+        inputs=[sd15_presets],
+        outputs=[sd15_dtype, sd15_vae, sd15_scheduler, sd15_lora1, sd15_lora1s, sd15_lora2, sd15_lora2s, sd15_lora3, sd15_lora3s,
+                 sd15_lora4, sd15_lora4s, sd15_lora5, sd15_lora5s, sd15_ema],
+        queue=False,
+    )
+    gr.on(
+        triggers=[flux_run_button.click],
+        fn=convert_url_to_diffusers_repo,
+        inputs=[dl_url, hf_user, hf_repo, hf_token, civitai_key, is_private, is_overwrite, is_upload_sf, repo_urls,
+                flux_dtype, flux_vae, flux_clip, flux_t5, flux_scheduler, flux_ema, flux_base_repo, flux_mtype,
+                flux_lora1, flux_lora1s, flux_lora2, flux_lora2s, flux_lora3, flux_lora3s, flux_lora4, flux_lora4s, flux_lora5, flux_lora5s],
+        outputs=[repo_urls, output_md],
+    )
+    flux_presets.change(
+        fn=flux_set_presets,
+        inputs=[flux_presets],
+        outputs=[flux_dtype, flux_vae, flux_scheduler, flux_lora1, flux_lora1s, flux_lora2, flux_lora2s, flux_lora3, flux_lora3s,
+                 flux_lora4, flux_lora4s, flux_lora5, flux_lora5s, flux_base_repo],
+        queue=False,
+    )
+    gr.on(
+        triggers=[sd35_run_button.click],
+        fn=convert_url_to_diffusers_repo,
+        inputs=[dl_url, hf_user, hf_repo, hf_token, civitai_key, is_private, is_overwrite, is_upload_sf, repo_urls,
+                sd35_dtype, sd35_vae, sd35_clip, sd35_t5, sd35_scheduler, sd35_ema, sd35_base_repo, sd35_mtype,
+                sd35_lora1, sd35_lora1s, sd35_lora2, sd35_lora2s, sd35_lora3, sd35_lora3s, sd35_lora4, sd35_lora4s, sd35_lora5, sd35_lora5s],
+        outputs=[repo_urls, output_md],
+    )
+    sd35_presets.change(
+        fn=sd35_set_presets,
+        inputs=[sd35_presets],
+        outputs=[sd35_dtype, sd35_vae, sd35_scheduler, sd35_lora1, sd35_lora1s, sd35_lora2, sd35_lora2s, sd35_lora3, sd35_lora3s,
+                 sd35_lora4, sd35_lora4s, sd35_lora5, sd35_lora5s, sd35_base_repo],
+        queue=False,
+    )
+    clear_button.click(lambda: ([], "<br><br>"), None, [repo_urls, output_md], queue=False, show_api=False)
+
+demo.queue()
+demo.launch()

convert_url_to_diffusers_multi_gr.py

@@ -0,0 +1,461 @@
+import os
+if os.environ.get("SPACES_ZERO_GPU") is not None:
+    import spaces
+else:
+    class spaces:
+        @staticmethod
+        def GPU(func):
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+            return wrapper
+import argparse
+from pathlib import Path
+import os
+import torch
+from diffusers import (DiffusionPipeline,  AutoencoderKL, FlowMatchEulerDiscreteScheduler, StableDiffusionXLPipeline, StableDiffusionPipeline,
+                       FluxPipeline,  FluxTransformer2DModel, SD3Transformer2DModel, StableDiffusion3Pipeline)
+from transformers import CLIPTokenizer, CLIPTextModel, CLIPTextModelWithProjection, AutoTokenizer, T5EncoderModel, BitsAndBytesConfig as TFBitsAndBytesConfig
+from huggingface_hub import save_torch_state_dict, snapshot_download
+from diffusers.loaders.single_file_utils import (convert_flux_transformer_checkpoint_to_diffusers, convert_sd3_transformer_checkpoint_to_diffusers,
+                                                 convert_sd3_t5_checkpoint_to_diffusers)
+import safetensors.torch
+import gradio as gr
+import shutil
+import gc
+import tempfile
+# also requires aria, gdown, peft, huggingface_hub, safetensors, transformers, accelerate, pytorch_lightning
+from utils import (get_token, set_token, is_repo_exists, is_repo_name, get_download_file, upload_repo)
+from sdutils import (SCHEDULER_CONFIG_MAP, get_scheduler_config, fuse_loras, DTYPE_DEFAULT, get_dtype, get_dtypes, get_model_type_from_key, get_process_dtype)
+
+
+@spaces.GPU
+def fake_gpu():
+    pass
+
+
+try:
+    from diffusers import BitsAndBytesConfig
+    is_nf4 = True
+except Exception:
+    is_nf4 = False
+
+
+FLUX_BASE_REPOS = ["camenduru/FLUX.1-dev-diffusers", "black-forest-labs/FLUX.1-schnell", "John6666/flux1-dev-fp8-flux", "John6666/flux1-schnell-fp8-flux"]
+FLUX_T5_URL = "https://huggingface.co/camenduru/FLUX.1-dev/blob/main/t5xxl_fp8_e4m3fn.safetensors"
+SD35_BASE_REPOS = ["adamo1139/stable-diffusion-3.5-large-ungated", "adamo1139/stable-diffusion-3.5-large-turbo-ungated"]
+SD35_T5_URL = "https://huggingface.co/adamo1139/stable-diffusion-3.5-large-turbo-ungated/blob/main/text_encoders/t5xxl_fp8_e4m3fn.safetensors"
+TEMP_DIR = tempfile.mkdtemp()
+IS_ZERO = os.environ.get("SPACES_ZERO_GPU") is not None
+IS_CUDA = torch.cuda.is_available()
+
+
+def safe_clean(path: str):
+    try:
+        if Path(path).exists():
+            if Path(path).is_dir(): shutil.rmtree(str(Path(path)))
+            else: Path(path).unlink()
+            print(f"Deleted: {path}")
+        else: print(f"File not found: {path}")
+    except Exception as e:
+        print(f"Failed to delete: {path} {e}")
+
+
+def save_readme_md(dir, url):
+    orig_url = ""
+    orig_name = ""
+    if is_repo_name(url): 
+        orig_name = url
+        orig_url = f"https://huggingface.co/{url}/"
+    elif "http" in url:
+        orig_name = url
+        orig_url = url
+    if orig_name and orig_url:
+       md = f"""---
+license: other
+language:
+- en
+library_name: diffusers
+pipeline_tag: text-to-image
+tags:
+- text-to-image
+---
+Converted from [{orig_name}]({orig_url}).
+"""
+    else:
+        md = f"""---
+license: other
+language:
+- en
+library_name: diffusers
+pipeline_tag: text-to-image
+tags:
+- text-to-image
+---
+"""
+    path = str(Path(dir, "README.md"))
+    with open(path, mode='w', encoding="utf-8") as f:
+        f.write(md)
+
+
+def save_module(model, name: str, dir: str, dtype: str="fp8", progress=gr.Progress(track_tqdm=True)): # doesn't work
+    if name in ["vae", "transformer", "unet"]: pattern = "diffusion_pytorch_model{suffix}.safetensors"
+    else: pattern = "model{suffix}.safetensors"
+    if name in ["transformer", "unet"]: size = "10GB"
+    else: size = "5GB"
+    path = str(Path(f"{dir.removesuffix('/')}/{name}"))
+    os.makedirs(path, exist_ok=True)
+    progress(0, desc=f"Saving {name} to {dir}...")
+    print(f"Saving {name} to {dir}...")
+    model.to("cpu")
+    sd = dict(model.state_dict())
+    new_sd = {}
+    for key in list(sd.keys()):
+        q = sd.pop(key)
+        if dtype == "fp8": new_sd[key] = q if q.dtype == torch.float8_e4m3fn else q.to(torch.float8_e4m3fn)
+        else: new_sd[key] = q
+    del sd
+    gc.collect()
+    save_torch_state_dict(state_dict=new_sd, save_directory=path, filename_pattern=pattern, max_shard_size=size)
+    del new_sd
+    gc.collect()
+
+
+def save_module_sd(sd: dict, name: str, dir: str, dtype: str="fp8", progress=gr.Progress(track_tqdm=True)):
+    if name in ["vae", "transformer", "unet"]: pattern = "diffusion_pytorch_model{suffix}.safetensors"
+    else: pattern = "model{suffix}.safetensors"
+    if name in ["transformer", "unet"]: size = "10GB"
+    else: size = "5GB"
+    path = str(Path(f"{dir.removesuffix('/')}/{name}"))
+    os.makedirs(path, exist_ok=True)
+    progress(0, desc=f"Saving state_dict of {name} to {dir}...")
+    print(f"Saving state_dict of {name} to {dir}...")
+    new_sd = {}
+    for key in list(sd.keys()):
+        q = sd.pop(key).to("cpu")
+        if dtype == "fp8": new_sd[key] = q if q.dtype == torch.float8_e4m3fn else q.to(torch.float8_e4m3fn)
+        else: new_sd[key] = q
+    save_torch_state_dict(state_dict=new_sd, save_directory=path, filename_pattern=pattern, max_shard_size=size)
+    del new_sd
+    gc.collect()
+
+
+def convert_flux_fp8_cpu(new_file: str, new_dir: str, dtype: str, base_repo: str, civitai_key: str, kwargs: dict, progress=gr.Progress(track_tqdm=True)):
+    temp_dir = TEMP_DIR
+    down_dir = str(Path(f"{TEMP_DIR}/down"))
+    os.makedirs(down_dir, exist_ok=True)
+    hf_token = get_token()
+    progress(0.25, desc=f"Loading {new_file}...")
+    orig_sd = safetensors.torch.load_file(new_file)
+    progress(0.3, desc=f"Converting {new_file}...")
+    conv_sd = convert_flux_transformer_checkpoint_to_diffusers(orig_sd)
+    del orig_sd
+    gc.collect()
+    progress(0.35, desc=f"Saving {new_file}...")
+    save_module_sd(conv_sd, "transformer", new_dir, dtype)
+    del conv_sd
+    gc.collect()
+    progress(0.5, desc=f"Loading text_encoder_2 from {FLUX_T5_URL}...")
+    t5_file = get_download_file(temp_dir, FLUX_T5_URL, civitai_key)
+    if not t5_file: raise Exception(f"Safetensors file not found: {FLUX_T5_URL}")
+    t5_sd = safetensors.torch.load_file(t5_file)
+    safe_clean(t5_file)
+    save_module_sd(t5_sd, "text_encoder_2", new_dir, dtype)
+    del t5_sd
+    gc.collect()
+    progress(0.6, desc=f"Loading other components from {base_repo}...")
+    pipe = FluxPipeline.from_pretrained(base_repo, transformer=None, text_encoder_2=None, use_safetensors=True, **kwargs,
+                                        torch_dtype=torch.bfloat16, token=hf_token)
+    pipe.save_pretrained(new_dir)
+    progress(0.75, desc=f"Loading nontensor files from {base_repo}...")
+    snapshot_download(repo_id=base_repo, local_dir=down_dir, token=hf_token, force_download=True,
+                      ignore_patterns=["*.safetensors", "*.sft", ".*", "README*", "*.md", "*.index", "*.jpg", "*.jpeg", "*.png", "*.webp"])
+    shutil.copytree(down_dir, new_dir, ignore=shutil.ignore_patterns(".*", "README*", "*.md", "*.jpg", "*.jpeg", "*.png", "*.webp"), dirs_exist_ok=True)
+    safe_clean(down_dir)
+
+
+def convert_sd35_fp8_cpu(new_file: str, new_dir: str, dtype: str, base_repo: str, civitai_key: str, kwargs: dict, progress=gr.Progress(track_tqdm=True)):
+    temp_dir = TEMP_DIR
+    down_dir = str(Path(f"{TEMP_DIR}/down"))
+    os.makedirs(down_dir, exist_ok=True)
+    hf_token = get_token()
+    progress(0.25, desc=f"Loading {new_file}...")
+    orig_sd = safetensors.torch.load_file(new_file)
+    progress(0.3, desc=f"Converting {new_file}...")
+    conv_sd = convert_sd3_transformer_checkpoint_to_diffusers(orig_sd)
+    del orig_sd
+    gc.collect()
+    progress(0.35, desc=f"Saving {new_file}...")
+    save_module_sd(conv_sd, "transformer", new_dir, dtype)
+    del conv_sd
+    gc.collect()
+    progress(0.5, desc=f"Loading text_encoder_3 from {SD35_T5_URL}...")
+    t5_file = get_download_file(temp_dir, SD35_T5_URL, civitai_key)
+    if not t5_file: raise Exception(f"Safetensors file not found: {SD35_T5_URL}")
+    t5_sd = safetensors.torch.load_file(t5_file)
+    safe_clean(t5_file)
+    conv_t5_sd = convert_sd3_t5_checkpoint_to_diffusers(t5_sd)
+    del t5_sd
+    gc.collect()
+    save_module_sd(conv_t5_sd, "text_encoder_3", new_dir, dtype)
+    del conv_t5_sd
+    gc.collect()
+    progress(0.6, desc=f"Loading other components from {base_repo}...")
+    pipe = StableDiffusion3Pipeline.from_pretrained(base_repo, transformer=None, text_encoder_3=None, use_safetensors=True, **kwargs,
+                                                    torch_dtype=torch.bfloat16, token=hf_token)
+    pipe.save_pretrained(new_dir)
+    progress(0.75, desc=f"Loading nontensor files from {base_repo}...")
+    snapshot_download(repo_id=base_repo, local_dir=down_dir, token=hf_token, force_download=True,
+                      ignore_patterns=["*.safetensors", "*.sft", ".*", "README*", "*.md", "*.index", "*.jpg", "*.jpeg", "*.png", "*.webp"])
+    shutil.copytree(down_dir, new_dir, ignore=shutil.ignore_patterns(".*", "README*", "*.md", "*.jpg", "*.jpeg", "*.png", "*.webp"), dirs_exist_ok=True)
+    safe_clean(down_dir)
+
+
+#@spaces.GPU(duration=60)
+def load_and_save_pipeline(pipe, model_type: str, url: str, new_file: str, new_dir: str, dtype: str,
+                           scheduler: str, base_repo: str, civitai_key: str, lora_dict: dict,
+                           my_vae, my_clip_tokenizer, my_clip_encoder, my_t5_tokenizer, my_t5_encoder,
+                           kwargs: dict, dkwargs: dict, progress=gr.Progress(track_tqdm=True)):
+    try:
+        hf_token = get_token()
+        temp_dir = TEMP_DIR
+        qkwargs = {}
+        tfqkwargs = {}
+        if is_nf4:
+            nf4_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
+                                            bnb_4bit_use_double_quant=True, bnb_4bit_compute_dtype=torch.bfloat16)
+            nf4_config_tf = TFBitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
+                                                 bnb_4bit_use_double_quant=True, bnb_4bit_compute_dtype=torch.bfloat16)
+        else:
+            nf4_config = None
+            nf4_config_tf = None
+        if dtype == "NF4" and nf4_config is not None and nf4_config_tf is not None:
+            qkwargs["quantization_config"] = nf4_config
+            tfqkwargs["quantization_config"] = nf4_config_tf
+        
+        #t5 = None
+        
+        if model_type == "SDXL":
+            if is_repo_name(url): pipe = StableDiffusionXLPipeline.from_pretrained(url, use_safetensors=True, **kwargs, **dkwargs, token=hf_token)
+            else: pipe = StableDiffusionXLPipeline.from_single_file(new_file, use_safetensors=True, **kwargs, **dkwargs)
+            pipe = fuse_loras(pipe, lora_dict, temp_dir, civitai_key, dkwargs)
+            sconf = get_scheduler_config(scheduler)
+            pipe.scheduler = sconf[0].from_config(pipe.scheduler.config, **sconf[1])
+            pipe.save_pretrained(new_dir)
+        elif model_type == "SD 1.5":
+            if is_repo_name(url): pipe = StableDiffusionPipeline.from_pretrained(url, extract_ema=ema, requires_safety_checker=False,
+                                                                                 use_safetensors=True, **kwargs, **dkwargs, token=hf_token)
+            else: pipe = StableDiffusionPipeline.from_single_file(new_file, extract_ema=ema, requires_safety_checker=False, use_safetensors=True, **kwargs, **dkwargs)
+            pipe = fuse_loras(pipe, lora_dict, temp_dir, civitai_key, dkwargs)
+            sconf = get_scheduler_config(scheduler)
+            pipe.scheduler = sconf[0].from_config(pipe.scheduler.config, **sconf[1])
+            pipe.save_pretrained(new_dir)
+        elif model_type == "FLUX":
+            if dtype != "fp8":
+                if is_repo_name(url):
+                    transformer = FluxTransformer2DModel.from_pretrained(url, subfolder="transformer", config=base_repo, **dkwargs, **qkwargs)
+                    #if my_t5_encoder is None:
+                    #    t5 = T5EncoderModel.from_pretrained(url, subfolder="text_encoder_2", config=base_repo, **dkwargs, **tfqkwargs)
+                    #    kwargs["text_encoder_2"] = t5
+                    pipe = FluxPipeline.from_pretrained(url, transformer=transformer, use_safetensors=True, **kwargs, **dkwargs, token=hf_token)
+                else:
+                    transformer = FluxTransformer2DModel.from_single_file(new_file, subfolder="transformer", config=base_repo, **dkwargs, **qkwargs)
+                    #if my_t5_encoder is None:
+                    #    t5 = T5EncoderModel.from_pretrained(base_repo, subfolder="text_encoder_2", config=base_repo, **dkwargs, **tfqkwargs)
+                    #    kwargs["text_encoder_2"] = t5
+                    pipe = FluxPipeline.from_pretrained(base_repo, transformer=transformer, use_safetensors=True, **kwargs, **dkwargs, token=hf_token)
+                pipe = fuse_loras(pipe, lora_dict, temp_dir, civitai_key, dkwargs)
+                pipe.save_pretrained(new_dir)
+            elif not is_repo_name(url): convert_flux_fp8_cpu(new_file, new_dir, dtype, base_repo, civitai_key, kwargs)
+        elif model_type == "SD 3.5":
+            if dtype != "fp8":
+                if is_repo_name(url):
+                    transformer = SD3Transformer2DModel.from_pretrained(url, subfolder="transformer", config=base_repo, **dkwargs, **qkwargs)
+                    #if my_t5_encoder is None:
+                    #    t5 = T5EncoderModel.from_pretrained(url, subfolder="text_encoder_3", config=base_repo, **dkwargs, **tfqkwargs)
+                    #    kwargs["text_encoder_3"] = t5
+                    pipe = StableDiffusion3Pipeline.from_pretrained(url, transformer=transformer, use_safetensors=True, **kwargs, **dkwargs, token=hf_token)
+                else:
+                    transformer = SD3Transformer2DModel.from_single_file(new_file, subfolder="transformer", config=base_repo, **dkwargs, **qkwargs)
+                    #if my_t5_encoder is None:
+                    #    t5 = T5EncoderModel.from_pretrained(base_repo, subfolder="text_encoder_3", config=base_repo, **dkwargs, **tfqkwargs)
+                    #    kwargs["text_encoder_3"] = t5
+                    pipe = StableDiffusion3Pipeline.from_pretrained(base_repo, transformer=transformer, use_safetensors=True, **kwargs, **dkwargs, token=hf_token)
+                pipe = fuse_loras(pipe, lora_dict, temp_dir, civitai_key, dkwargs)
+                pipe.save_pretrained(new_dir)
+            elif not is_repo_name(url): convert_sd35_fp8_cpu(new_file, new_dir, dtype, base_repo, civitai_key, kwargs)
+        else: # unknown model type
+            if is_repo_name(url): pipe = DiffusionPipeline.from_pretrained(url, use_safetensors=True, **kwargs, **dkwargs, token=hf_token)
+            else: pipe = DiffusionPipeline.from_single_file(new_file, use_safetensors=True, **kwargs, **dkwargs)
+            pipe = fuse_loras(pipe, lora_dict, temp_dir, civitai_key, dkwargs)
+            pipe.save_pretrained(new_dir)
+    except Exception as e:
+        raise Exception("Failed to load pipeline.") from e
+    finally:
+        return pipe
+
+
+def convert_url_to_diffusers(url: str, civitai_key: str="", is_upload_sf: bool=False, dtype: str="fp16", vae: str="", clip: str="", t5: str="",
+                             scheduler: str="Euler a", ema: bool=True, base_repo: str="", mtype: str="", lora_dict: dict={}, is_local: bool=True, progress=gr.Progress(track_tqdm=True)):
+    try:
+        hf_token = get_token()
+        progress(0, desc="Start converting...")
+        temp_dir = TEMP_DIR
+
+        if is_repo_name(url) and is_repo_exists(url):
+            new_file = url
+            model_type = mtype
+        else:
+            new_file = get_download_file(temp_dir, url, civitai_key)
+            if not new_file: raise Exception(f"Safetensors file not found: {url}")
+            model_type = get_model_type_from_key(new_file)
+        new_dir = Path(new_file).stem.replace(" ", "_").replace(",", "_").replace(".", "_") #
+        
+        kwargs = {}
+        dkwargs = {}
+        if dtype != DTYPE_DEFAULT: dkwargs["torch_dtype"] = get_process_dtype(dtype, model_type)
+        pipe = None
+
+        print(f"Model type: {model_type} / VAE: {vae} / CLIP: {clip} / T5: {t5} / Scheduler: {scheduler} / dtype: {dtype} / EMA: {ema} / Base repo: {base_repo} / LoRAs: {lora_dict}")
+
+        my_vae = None
+        if vae:
+            progress(0, desc=f"Loading VAE: {vae}...")
+            if is_repo_name(vae): my_vae = AutoencoderKL.from_pretrained(vae, **dkwargs, token=hf_token)
+            else:
+                new_vae_file = get_download_file(temp_dir, vae, civitai_key)
+                my_vae = AutoencoderKL.from_single_file(new_vae_file, **dkwargs) if new_vae_file else None
+                safe_clean(new_vae_file)
+            if my_vae: kwargs["vae"] = my_vae
+
+        my_clip_tokenizer = None
+        my_clip_encoder = None
+        if clip:
+            progress(0, desc=f"Loading CLIP: {clip}...")
+            if is_repo_name(clip):
+                my_clip_tokenizer = CLIPTokenizer.from_pretrained(clip, token=hf_token)
+                if model_type == "SD 3.5": my_clip_encoder = CLIPTextModelWithProjection.from_pretrained(clip, **dkwargs, token=hf_token)
+                else: my_clip_encoder = CLIPTextModel.from_pretrained(clip, **dkwargs, token=hf_token)
+            else:
+                new_clip_file = get_download_file(temp_dir, clip, civitai_key)
+                if model_type == "SD 3.5": my_clip_encoder = CLIPTextModelWithProjection.from_single_file(new_clip_file, **dkwargs) if new_clip_file else None
+                else: my_clip_encoder = CLIPTextModel.from_single_file(new_clip_file, **dkwargs) if new_clip_file else None
+                safe_clean(new_clip_file)
+            if model_type == "SD 3.5":
+                if my_clip_tokenizer:
+                    kwargs["tokenizer"] = my_clip_tokenizer
+                    kwargs["tokenizer_2"] = my_clip_tokenizer
+                if my_clip_encoder:
+                    kwargs["text_encoder"] = my_clip_encoder
+                    kwargs["text_encoder_2"] = my_clip_encoder
+            else:
+                if my_clip_tokenizer: kwargs["tokenizer"] = my_clip_tokenizer
+                if my_clip_encoder: kwargs["text_encoder"] = my_clip_encoder
+
+        my_t5_tokenizer = None
+        my_t5_encoder = None
+        if t5:
+            progress(0, desc=f"Loading T5: {t5}...")
+            if is_repo_name(t5):
+                my_t5_tokenizer = AutoTokenizer.from_pretrained(t5, token=hf_token)
+                my_t5_encoder = T5EncoderModel.from_pretrained(t5, **dkwargs, token=hf_token)
+            else:
+                new_t5_file = get_download_file(temp_dir, t5, civitai_key)
+                my_t5_encoder = T5EncoderModel.from_single_file(new_t5_file, **dkwargs) if new_t5_file else None
+                safe_clean(new_t5_file)
+            if model_type == "SD 3.5":
+                if my_t5_tokenizer: kwargs["tokenizer_3"] = my_t5_tokenizer
+                if my_t5_encoder: kwargs["text_encoder_3"] = my_t5_encoder
+            else:
+                if my_t5_tokenizer: kwargs["tokenizer_2"] = my_t5_tokenizer
+                if my_t5_encoder: kwargs["text_encoder_2"] = my_t5_encoder
+
+        pipe = load_and_save_pipeline(pipe, model_type, url, new_file, new_dir, dtype, scheduler, base_repo, civitai_key, lora_dict,
+                                      my_vae, my_clip_tokenizer, my_clip_encoder, my_t5_tokenizer, my_t5_encoder, kwargs, dkwargs)
+        
+        if Path(new_dir).exists(): save_readme_md(new_dir, url)
+
+        if not is_local:
+            if not is_repo_name(new_file) and is_upload_sf: shutil.move(str(Path(new_file).resolve()), str(Path(new_dir, Path(new_file).name).resolve()))
+            else: safe_clean(new_file)
+
+        progress(1, desc="Converted.")
+        return new_dir
+    except Exception as e:
+        print(f"Failed to convert. {e}")
+        raise Exception("Failed to convert.") from e
+    finally:
+        del pipe
+        torch.cuda.empty_cache()
+        gc.collect()
+
+
+def convert_url_to_diffusers_repo(dl_url: str, hf_user: str, hf_repo: str, hf_token: str, civitai_key="", is_private: bool=True, is_overwrite: bool=False,
+                                  is_upload_sf: bool=False, urls: list=[], dtype: str="fp16", vae: str="", clip: str="", t5: str="", scheduler: str="Euler a", ema: bool=True,
+                                  base_repo: str="", mtype: str="", lora1: str="", lora1s=1.0, lora2: str="", lora2s=1.0, lora3: str="", lora3s=1.0,
+                                  lora4: str="", lora4s=1.0, lora5: str="", lora5s=1.0, progress=gr.Progress(track_tqdm=True)):
+    try:
+        is_local = False
+        if not civitai_key and os.environ.get("CIVITAI_API_KEY"): civitai_key = os.environ.get("CIVITAI_API_KEY") # default Civitai API key
+        if not hf_token and os.environ.get("HF_TOKEN"): hf_token = os.environ.get("HF_TOKEN") # default HF write token
+        if not hf_user and os.environ.get("HF_USER"): hf_user = os.environ.get("HF_USER") # default username
+        if not hf_user: raise gr.Error(f"Invalid user name: {hf_user}")
+        if not hf_repo and os.environ.get("HF_REPO"): hf_repo = os.environ.get("HF_REPO") # default reponame
+        if not is_overwrite and os.environ.get("HF_OW"): is_overwrite = os.environ.get("HF_OW") # for debugging
+        if not dl_url and os.environ.get("HF_URL"): dl_url = os.environ.get("HF_URL") # for debugging
+        set_token(hf_token)
+        lora_dict = {lora1: lora1s, lora2: lora2s, lora3: lora3s, lora4: lora4s, lora5: lora5s}
+        new_path = convert_url_to_diffusers(dl_url, civitai_key, is_upload_sf, dtype, vae, clip, t5, scheduler, ema, base_repo, mtype, lora_dict, is_local)
+        if not new_path: return ""
+        new_repo_id = f"{hf_user}/{Path(new_path).stem}"
+        if hf_repo != "": new_repo_id = f"{hf_user}/{hf_repo}"
+        if not is_repo_name(new_repo_id): raise gr.Error(f"Invalid repo name: {new_repo_id}")
+        if not is_overwrite and is_repo_exists(new_repo_id): raise gr.Error(f"Repo already exists: {new_repo_id}")
+        repo_url = upload_repo(new_repo_id, new_path, is_private)
+        safe_clean(new_path)
+        if not urls: urls = []
+        urls.append(repo_url)
+        md = "### Your new repo:\n"
+        for u in urls:
+            md += f"[{str(u).split('/')[-2]}/{str(u).split('/')[-1]}]({str(u)})<br>"
+        return gr.update(value=urls, choices=urls), gr.update(value=md)
+    except Exception as e:
+        print(f"Error occured. {e}")
+        raise gr.Error(f"Error occured. {e}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--url", type=str, required=True, help="URL of the model to convert.")
+    parser.add_argument("--dtype", default="fp16", type=str, choices=get_dtypes(), help='Output data type. (Default: "fp16")')
+    parser.add_argument("--scheduler", default="Euler a", type=str, choices=list(SCHEDULER_CONFIG_MAP.keys()), required=False, help="Scheduler name to use.")
+    parser.add_argument("--vae", default="", type=str, required=False, help="URL or Repo ID of the VAE to use.")
+    parser.add_argument("--clip", default="", type=str, required=False, help="URL or Repo ID of the CLIP to use.")
+    parser.add_argument("--t5", default="", type=str, required=False, help="URL or Repo ID of the T5 to use.")
+    parser.add_argument("--base", default="", type=str, required=False, help="Repo ID of the base repo.")
+    parser.add_argument("--nonema", action="store_true", default=False, help="Don't extract EMA (for SD 1.5).")
+    parser.add_argument("--civitai_key", default="", type=str, required=False, help="Civitai API Key (If you want to download file from Civitai).")
+    parser.add_argument("--lora1", default="", type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora1s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora1.")
+    parser.add_argument("--lora2", default="", type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora2s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora2.")
+    parser.add_argument("--lora3", default="", type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora3s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora3.")
+    parser.add_argument("--lora4", default="", type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora4s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora4.")
+    parser.add_argument("--lora5", default="", type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora5s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora5.")
+    parser.add_argument("--loras", default="", type=str, required=False, help="Folder of the LoRA to use.")
+
+    args = parser.parse_args()
+    assert args.url is not None, "Must provide a URL!"
+
+    is_local = True
+    lora_dict = {args.lora1: args.lora1s, args.lora2: args.lora2s, args.lora3: args.lora3s, args.lora4: args.lora4s, args.lora5: args.lora5s}
+    if args.loras and Path(args.loras).exists():
+        for p in Path(args.loras).glob('**/*.safetensors'):
+            lora_dict[str(p)] = 1.0
+    ema = not args.nonema
+    mtype = "SDXL"
+
+    convert_url_to_diffusers(args.url, args.civitai_key, args.dtype, args.vae, args.clip, args.t5, args.scheduler, ema, args.base, mtype, lora_dict, is_local)

packages.txt

@@ -0,0 +1 @@
+git-lfs aria2

presets.py

@@ -0,0 +1,134 @@
+from sdutils import get_dtypes, SCHEDULER_CONFIG_MAP
+
+
+DEFAULT_DTYPE = get_dtypes()[0]
+schedulers = list(SCHEDULER_CONFIG_MAP.keys())
+
+
+clips = [
+    "",
+    "openai/clip-vit-large-patch14",
+]
+
+
+t5s = [
+    "",
+    "https://huggingface.co/camenduru/FLUX.1-dev/blob/main/t5xxl_fp8_e4m3fn.safetensors",
+]
+
+
+sdxl_vaes = [
+    "",
+    "https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/blob/main/sdxl.vae.safetensors",
+    "https://huggingface.co/nubby/blessed-sdxl-vae-fp16-fix/blob/main/sdxl_vae-fp16fix-blessed.safetensors",
+    "https://huggingface.co/John6666/safetensors_converting_test/blob/main/xlVAEC_e7.safetensors",
+    "https://huggingface.co/John6666/safetensors_converting_test/blob/main/xlVAEC_f1.safetensors",
+]
+
+
+sdxl_loras = [
+    "",
+    "https://huggingface.co/SPO-Diffusion-Models/SPO-SDXL_4k-p_10ep_LoRA/blob/main/spo_sdxl_10ep_4k-data_lora_diffusers.safetensors",
+    "https://huggingface.co/wangfuyun/PCM_Weights/blob/main/sdxl/pcm_sdxl_smallcfg_2step_converted.safetensors",
+    "https://huggingface.co/wangfuyun/PCM_Weights/blob/main/sdxl/pcm_sdxl_smallcfg_4step_converted.safetensors",
+    "https://huggingface.co/wangfuyun/PCM_Weights/blob/main/sdxl/pcm_sdxl_smallcfg_8step_converted.safetensors",
+    "https://huggingface.co/wangfuyun/PCM_Weights/blob/main/sdxl/pcm_sdxl_normalcfg_8step_converted.safetensors",
+    "https://huggingface.co/wangfuyun/PCM_Weights/blob/main/sdxl/pcm_sdxl_normalcfg_16step_converted.safetensors",
+    "https://huggingface.co/ByteDance/Hyper-SD/blob/main/Hyper-SDXL-1step-lora.safetensors",
+    "https://huggingface.co/ByteDance/Hyper-SD/blob/main/Hyper-SDXL-2steps-lora.safetensors",
+    "https://huggingface.co/ByteDance/Hyper-SD/blob/main/Hyper-SDXL-4steps-lora.safetensors",
+    "https://huggingface.co/ByteDance/Hyper-SD/blob/main/Hyper-SDXL-8steps-CFG-lora.safetensors",
+    "https://huggingface.co/ByteDance/Hyper-SD/blob/main/Hyper-SDXL-12steps-CFG-lora.safetensors",
+    "https://huggingface.co/latent-consistency/lcm-lora-sdxl/blob/main/pytorch_lora_weights.safetensors",
+]
+
+
+sdxl_preset_dict = {
+    "Default": [DEFAULT_DTYPE, "", "Euler a", "", 1.0, "", 1.0, "", 1.0, "", 1.0, "", 1.0],
+    "Bake in standard VAE": [DEFAULT_DTYPE, "https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/blob/main/sdxl.vae.safetensors",
+                             "Euler a", "", "", 1.0, "", 1.0, "", 1.0, "", 1.0, "", 1.0],
+    "Hyper-SDXL / SPO": [DEFAULT_DTYPE, "https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/blob/main/sdxl.vae.safetensors",
+     "TCD", "https://huggingface.co/ByteDance/Hyper-SD/blob/main/Hyper-SDXL-8steps-CFG-lora.safetensors", 1.0,
+     "https://huggingface.co/SPO-Diffusion-Models/SPO-SDXL_4k-p_10ep_LoRA/blob/main/spo_sdxl_10ep_4k-data_lora_diffusers.safetensors",
+       1.0, "", 1.0, "", 1.0, "", 1.0],
+}
+
+
+def sdxl_set_presets(preset: str="Default"):
+    p = []
+    if preset in sdxl_preset_dict.keys(): p = sdxl_preset_dict[preset]
+    else: p = sdxl_preset_dict["Default"]
+    return p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12]
+
+
+sd15_vaes = [
+    "",
+    "https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.ckpt",
+    "https://huggingface.co/stabilityai/sd-vae-ft-ema-original/resolve/main/vae-ft-ema-560000-ema-pruned.ckpt",
+]
+
+
+sd15_loras = [
+    "",
+    "https://huggingface.co/SPO-Diffusion-Models/SPO-SD-v1-5_4k-p_10ep_LoRA/blob/main/spo-sd-v1-5_4k-p_10ep_lora_diffusers.safetensors",
+]
+
+
+sd15_preset_dict = {
+    "Default": [DEFAULT_DTYPE, "", "Euler", "", 1.0, "", 1.0, "", 1.0, "", 1.0, "", 1.0, True],
+    "Bake in standard VAE": [DEFAULT_DTYPE, "https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.ckpt",
+                             "Euler", "", 1.0, "", 1.0, "", 1.0, "", 1.0, "", 1.0, True],
+}
+
+
+def sd15_set_presets(preset: str="Default"):
+    p = []
+    if preset in sd15_preset_dict.keys(): p = sd15_preset_dict[preset]
+    else: p = sd15_preset_dict["Default"]
+    return p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13]
+
+
+flux_vaes = [
+    "",
+]
+
+
+flux_loras = [
+    "",
+]
+
+
+flux_preset_dict = {
+    "dev": ["bf16", "", "", "", 1.0, "", 1.0, "", 1.0, "", 1.0, "", 1.0, "camenduru/FLUX.1-dev-diffusers"],
+    "schnell": ["bf16", "", "", "", 1.0, "", 1.0, "", 1.0, "", 1.0, "", 1.0, "black-forest-labs/FLUX.1-schnell"],
+}
+
+
+def flux_set_presets(preset: str="dev"):
+    p = []
+    if preset in flux_preset_dict.keys(): p = flux_preset_dict[preset]
+    else: p = flux_preset_dict["dev"]
+    return p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13]
+
+
+
+sd35_vaes = [
+    "",
+]
+
+
+sd35_loras = [
+    "",
+]
+
+
+sd35_preset_dict = {
+    "Default": ["bf16", "", "", "", 1.0, "", 1.0, "", 1.0, "", 1.0, "", 1.0, "adamo1139/stable-diffusion-3.5-large-ungated"],
+}
+
+
+def sd35_set_presets(preset: str="dev"):
+    p = []
+    if preset in sd35_preset_dict.keys(): p = sd35_preset_dict[preset]
+    else: p = sd35_preset_dict["Default"]
+    return p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13]

requirements.txt

@@ -0,0 +1,11 @@
+huggingface_hub
+safetensors
+transformers==4.44.0
+diffusers==0.30.3
+peft
+sentencepiece
+torch
+pytorch_lightning
+gdown
+bitsandbytes
+accelerate

sdutils.py

@@ -0,0 +1,157 @@
+import torch
+from pathlib import Path
+from utils import get_download_file
+from stkey import read_safetensors_key
+try:
+    from diffusers import BitsAndBytesConfig
+    is_nf4 = True
+except Exception:
+    is_nf4 = False
+
+
+DTYPE_DEFAULT = "default"
+DTYPE_DICT = {
+    "fp16": torch.float16,
+    "bf16": torch.bfloat16,
+    "fp32": torch.float32,
+    "fp8": torch.float8_e4m3fn,
+}
+#QTYPES = ["NF4"] if is_nf4 else []
+QTYPES = []
+
+def get_dtypes():
+    return list(DTYPE_DICT.keys()) + [DTYPE_DEFAULT] + QTYPES
+
+
+def get_dtype(dtype: str):
+    if dtype in set(QTYPES): return torch.bfloat16
+    return DTYPE_DICT.get(dtype, torch.float16)
+
+
+from diffusers import (
+    DPMSolverMultistepScheduler,
+    DPMSolverSinglestepScheduler,
+    KDPM2DiscreteScheduler,
+    EulerDiscreteScheduler,
+    EulerAncestralDiscreteScheduler,
+    HeunDiscreteScheduler,
+    LMSDiscreteScheduler,
+    DDIMScheduler,
+    DEISMultistepScheduler,
+    UniPCMultistepScheduler,
+    LCMScheduler,
+    PNDMScheduler,
+    KDPM2AncestralDiscreteScheduler,
+    DPMSolverSDEScheduler,
+    EDMDPMSolverMultistepScheduler,
+    DDPMScheduler,
+    EDMEulerScheduler,
+    TCDScheduler,
+)
+
+
+SCHEDULER_CONFIG_MAP = {
+    "DPM++ 2M": (DPMSolverMultistepScheduler, {"use_karras_sigmas": False}),
+    "DPM++ 2M Karras": (DPMSolverMultistepScheduler, {"use_karras_sigmas": True}),
+    "DPM++ 2M SDE": (DPMSolverMultistepScheduler, {"use_karras_sigmas": False, "algorithm_type": "sde-dpmsolver++"}),
+    "DPM++ 2M SDE Karras": (DPMSolverMultistepScheduler, {"use_karras_sigmas": True, "algorithm_type": "sde-dpmsolver++"}),
+    "DPM++ 2S": (DPMSolverSinglestepScheduler, {"use_karras_sigmas": False}),
+    "DPM++ 2S Karras": (DPMSolverSinglestepScheduler, {"use_karras_sigmas": True}),
+    "DPM++ 1S": (DPMSolverMultistepScheduler, {"solver_order": 1}),
+    "DPM++ 1S Karras": (DPMSolverMultistepScheduler, {"solver_order": 1, "use_karras_sigmas": True}),
+    "DPM++ 3M": (DPMSolverMultistepScheduler, {"solver_order": 3}),
+    "DPM++ 3M Karras": (DPMSolverMultistepScheduler, {"solver_order": 3, "use_karras_sigmas": True}),
+    "DPM++ SDE": (DPMSolverSDEScheduler, {"use_karras_sigmas": False}),
+    "DPM++ SDE Karras": (DPMSolverSDEScheduler, {"use_karras_sigmas": True}),
+    "DPM2": (KDPM2DiscreteScheduler, {}),
+    "DPM2 Karras": (KDPM2DiscreteScheduler, {"use_karras_sigmas": True}),
+    "DPM2 a": (KDPM2AncestralDiscreteScheduler, {}),
+    "DPM2 a Karras": (KDPM2AncestralDiscreteScheduler, {"use_karras_sigmas": True}),
+    "Euler": (EulerDiscreteScheduler, {}),
+    "Euler a": (EulerAncestralDiscreteScheduler, {}),
+    "Euler trailing": (EulerDiscreteScheduler, {"timestep_spacing": "trailing", "prediction_type": "sample"}),
+    "Euler a trailing": (EulerAncestralDiscreteScheduler, {"timestep_spacing": "trailing"}),
+    "Heun": (HeunDiscreteScheduler, {}),
+    "Heun Karras": (HeunDiscreteScheduler, {"use_karras_sigmas": True}),
+    "LMS": (LMSDiscreteScheduler, {}),
+    "LMS Karras": (LMSDiscreteScheduler, {"use_karras_sigmas": True}),
+    "DDIM": (DDIMScheduler, {}),
+    "DDIM trailing": (DDIMScheduler, {"timestep_spacing": "trailing"}),
+    "DEIS": (DEISMultistepScheduler, {}),
+    "UniPC": (UniPCMultistepScheduler, {}),
+    "UniPC Karras": (UniPCMultistepScheduler, {"use_karras_sigmas": True}),
+    "PNDM": (PNDMScheduler, {}),
+    "Euler EDM": (EDMEulerScheduler, {}),
+    "Euler EDM Karras": (EDMEulerScheduler, {"use_karras_sigmas": True}),
+    "DPM++ 2M EDM": (EDMDPMSolverMultistepScheduler, {"solver_order": 2, "solver_type": "midpoint", "final_sigmas_type": "zero", "algorithm_type": "dpmsolver++"}),
+    "DPM++ 2M EDM Karras": (EDMDPMSolverMultistepScheduler, {"use_karras_sigmas": True, "solver_order": 2, "solver_type": "midpoint", "final_sigmas_type": "zero", "algorithm_type": "dpmsolver++"}),
+    "DDPM": (DDPMScheduler, {}),
+
+    "DPM++ 2M Lu": (DPMSolverMultistepScheduler, {"use_lu_lambdas": True}),
+    "DPM++ 2M Ef": (DPMSolverMultistepScheduler, {"euler_at_final": True}),
+    "DPM++ 2M SDE Lu": (DPMSolverMultistepScheduler, {"use_lu_lambdas": True, "algorithm_type": "sde-dpmsolver++"}),
+    "DPM++ 2M SDE Ef": (DPMSolverMultistepScheduler, {"algorithm_type": "sde-dpmsolver++", "euler_at_final": True}),
+
+    "LCM": (LCMScheduler, {}),
+    "TCD": (TCDScheduler, {}),
+    "LCM trailing": (LCMScheduler, {"timestep_spacing": "trailing"}),
+    "TCD trailing": (TCDScheduler, {"timestep_spacing": "trailing"}),
+    "LCM Auto-Loader": (LCMScheduler, {}),
+    "TCD Auto-Loader": (TCDScheduler, {}),
+}
+
+
+def get_scheduler_config(name: str):
+    if not name in SCHEDULER_CONFIG_MAP.keys(): return SCHEDULER_CONFIG_MAP["Euler a"]
+    return SCHEDULER_CONFIG_MAP[name]
+
+
+def fuse_loras(pipe, lora_dict: dict, temp_dir: str, civitai_key: str="", dkwargs: dict={}):
+    if not lora_dict or not isinstance(lora_dict, dict): return pipe
+    a_list = []
+    w_list = []
+    for k, v in lora_dict.items():
+        if not k: continue
+        new_lora_file = get_download_file(temp_dir, k, civitai_key)
+        if not new_lora_file or not Path(new_lora_file).exists():
+            print(f"LoRA file not found: {k}")
+            continue
+        w_name = Path(new_lora_file).name
+        a_name = Path(new_lora_file).stem
+        pipe.load_lora_weights(new_lora_file, weight_name=w_name, adapter_name=a_name, low_cpu_mem_usage=False, **dkwargs)
+        a_list.append(a_name)
+        w_list.append(v)
+        if Path(new_lora_file).exists(): Path(new_lora_file).unlink()
+    if len(a_list) == 0: return pipe
+    pipe.set_adapters(a_list, adapter_weights=w_list)
+    pipe.fuse_lora(adapter_names=a_list, lora_scale=1.0)
+    pipe.unload_lora_weights()
+    return pipe
+
+
+MODEL_TYPE_KEY = {
+    "model.diffusion_model.output_blocks.1.1.norm.bias": "SDXL",
+    "model.diffusion_model.input_blocks.11.0.out_layers.3.weight": "SD 1.5",
+    "double_blocks.0.img_attn.norm.key_norm.scale": "FLUX",
+    "model.diffusion_model.double_blocks.0.img_attn.norm.key_norm.scale": "FLUX",
+    "model.diffusion_model.joint_blocks.9.x_block.attn.ln_k.weight": "SD 3.5",
+}
+
+
+def get_model_type_from_key(path: str):
+    default = "SDXL"
+    try:
+        keys = read_safetensors_key(path)
+        for k, v in MODEL_TYPE_KEY.items():
+            if k in set(keys):
+                print(f"Model type is {v}.")
+                return v
+        print("Model type could not be identified.")
+    except Exception:
+        return default
+    return default
+
+
+def get_process_dtype(dtype: str, model_type: str):
+    if dtype in set(["fp8"] + QTYPES): return torch.bfloat16 if model_type in ["FLUX", "SD 3.5"] else torch.float16
+    return DTYPE_DICT.get(dtype, torch.float16)

stkey.py

@@ -0,0 +1,122 @@
+import argparse
+from pathlib import Path
+import json
+import re
+import gc
+from safetensors.torch import load_file, save_file
+import torch
+
+
+SDXL_KEYS_FILE = "keys/sdxl_keys.txt"
+
+
+def list_uniq(l):
+    return sorted(set(l), key=l.index)
+
+
+def read_safetensors_metadata(path: str):
+    with open(path, 'rb') as f:
+        header_size = int.from_bytes(f.read(8), 'little')
+        header_json = f.read(header_size).decode('utf-8')
+        header = json.loads(header_json)
+        metadata = header.get('__metadata__', {})
+        return metadata
+
+
+def keys_from_file(path: str):
+    keys = []
+    try:
+        with open(str(Path(path)), encoding='utf-8', mode='r') as f:
+            lines = f.readlines()
+        for line in lines:
+            keys.append(line.strip())
+    except Exception as e:
+        print(e)
+    finally:
+        return keys
+
+
+def validate_keys(keys: list[str], rfile: str=SDXL_KEYS_FILE):
+    missing = []
+    added = []
+    try:
+        rkeys = keys_from_file(rfile)
+        all_keys = list_uniq(keys + rkeys)
+        for key in all_keys:
+            if key in set(rkeys) and key not in set(keys): missing.append(key)
+            if key in set(keys) and key not in set(rkeys): added.append(key)
+    except Exception as e:
+        print(e)
+    finally:
+        return missing, added
+
+
+def read_safetensors_key(path: str):
+    try:
+        keys = []
+        state_dict = load_file(str(Path(path)))
+        for k in list(state_dict.keys()):
+            keys.append(k)
+            state_dict.pop(k)
+    except Exception as e:
+        print(e)
+    finally:
+        del state_dict
+        torch.cuda.empty_cache()
+        gc.collect()
+        return keys
+
+
+def write_safetensors_key(keys: list[str], path: str, is_validate: bool=True, rpath: str=SDXL_KEYS_FILE):
+    if len(keys) == 0: return False
+    try:
+        with open(str(Path(path)), encoding='utf-8', mode='w') as f:
+            f.write("\n".join(keys))
+        if is_validate:
+            missing, added = validate_keys(keys, rpath)
+            with open(str(Path(path).stem + "_missing.txt"), encoding='utf-8', mode='w') as f:
+                f.write("\n".join(missing))
+            with open(str(Path(path).stem + "_added.txt"), encoding='utf-8', mode='w') as f:
+                f.write("\n".join(added))
+        return True
+    except Exception as e:
+        print(e)
+        return False
+
+
+def stkey(input: str, out_filename: str="", is_validate: bool=True, rfile: str=SDXL_KEYS_FILE):
+    keys = read_safetensors_key(input)
+    if len(keys) != 0 and out_filename: write_safetensors_key(keys, out_filename, is_validate, rfile)
+    if len(keys) != 0:
+        print("Metadata:")
+        print(read_safetensors_metadata(input))
+        print("\nKeys:")
+        print("\n".join(keys))
+        if is_validate:
+            missing, added = validate_keys(keys, rfile)
+            print("\nMissing Keys:")
+            print("\n".join(missing))
+            print("\nAdded Keys:")
+            print("\n".join(added))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", type=str, help="Input safetensors file.")
+    parser.add_argument("-s", "--save", action="store_true", default=False, help="Output to text file.")
+    parser.add_argument("-o", "--output", default="", type=str, help="Output to specific text file.")
+    parser.add_argument("-v", "--val", action="store_false", default=True, help="Disable key validation.")
+    parser.add_argument("-r", "--rfile", default=SDXL_KEYS_FILE, type=str, help="Specify reference file to validate keys.")
+
+    args = parser.parse_args()
+
+    if args.save: out_filename = Path(args.input).stem + ".txt"
+    out_filename = args.output if args.output else out_filename
+
+    stkey(args.input, out_filename, args.val, args.rfile)
+
+
+# Usage:
+# python stkey.py sd_xl_base_1.0_0.9vae.safetensors
+# python stkey.py sd_xl_base_1.0_0.9vae.safetensors -s
+# python stkey.py sd_xl_base_1.0_0.9vae.safetensors -o key.txt

utils.py

@@ -0,0 +1,275 @@
+import gradio as gr
+from huggingface_hub import HfApi, HfFolder, hf_hub_download, snapshot_download
+import os
+from pathlib import Path
+import shutil
+import gc
+import re
+import urllib.parse
+import subprocess
+import time
+
+
+def get_token():
+    try:
+        token = HfFolder.get_token()
+    except Exception:
+        token = ""
+    return token
+
+
+def set_token(token):
+    try:
+        HfFolder.save_token(token)
+    except Exception:
+        print(f"Error: Failed to save token.")
+
+
+def get_user_agent():
+    return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:127.0) Gecko/20100101 Firefox/127.0'
+
+
+def is_repo_exists(repo_id: str, repo_type: str="model"):
+    hf_token = get_token()
+    api = HfApi(token=hf_token)
+    try:
+        if api.repo_exists(repo_id=repo_id, repo_type=repo_type, token=hf_token): return True
+        else: return False
+    except Exception as e:
+        print(f"Error: Failed to connect {repo_id} ({repo_type}). {e}")
+        return True # for safe
+
+
+MODEL_TYPE_CLASS = {
+    "diffusers:StableDiffusionPipeline": "SD 1.5",
+    "diffusers:StableDiffusionXLPipeline": "SDXL",
+    "diffusers:FluxPipeline": "FLUX",
+}
+
+
+def get_model_type(repo_id: str):
+    hf_token = get_token()
+    api = HfApi(token=hf_token)
+    lora_filename = "pytorch_lora_weights.safetensors"
+    diffusers_filename = "model_index.json"
+    default = "SDXL"
+    try:
+        if api.file_exists(repo_id=repo_id, filename=lora_filename, token=hf_token): return "LoRA"
+        if not api.file_exists(repo_id=repo_id, filename=diffusers_filename, token=hf_token): return "None"
+        model = api.model_info(repo_id=repo_id, token=hf_token)
+        tags = model.tags
+        for tag in tags:
+            if tag in MODEL_TYPE_CLASS.keys(): return MODEL_TYPE_CLASS.get(tag, default)
+    except Exception:
+        return default
+    return default
+
+
+def list_uniq(l):
+    return sorted(set(l), key=l.index)
+
+
+def list_sub(a, b):
+    return [e for e in a if e not in b]
+
+
+def is_repo_name(s):
+    return re.fullmatch(r'^[\w_\-\.]+/[\w_\-\.]+$', s)
+
+
+def get_hf_url(repo_id: str, repo_type: str="model"):
+    if repo_type == "dataset": url = f"https://huggingface.co/datasets/{repo_id}"
+    elif repo_type == "space": url = f"https://huggingface.co/spaces/{repo_id}"
+    else: url = f"https://huggingface.co/{repo_id}"
+    return url
+
+
+def split_hf_url(url: str):
+    try:
+        s = list(re.findall(r'^(?:https?://huggingface.co/)(?:(datasets|spaces)/)?(.+?/.+?)/\w+?/.+?/(?:(.+)/)?(.+?.\w+)(?:\?download=true)?$', url)[0])
+        if len(s) < 4: return "", "", "", ""
+        repo_id = s[1]
+        if s[0] == "datasets": repo_type = "dataset"
+        elif s[0] == "spaces": repo_type = "space"
+        else: repo_type = "model"
+        subfolder = urllib.parse.unquote(s[2]) if s[2] else None
+        filename = urllib.parse.unquote(s[3])
+        return repo_id, filename, subfolder, repo_type
+    except Exception as e:
+        print(e)
+
+
+def download_hf_file(directory, url, progress=gr.Progress(track_tqdm=True)):
+    hf_token = get_token()
+    repo_id, filename, subfolder, repo_type = split_hf_url(url)
+    try:
+        print(f"Downloading {url} to {directory}")
+        if subfolder is not None: path = hf_hub_download(repo_id=repo_id, filename=filename, subfolder=subfolder, repo_type=repo_type, local_dir=directory, token=hf_token)
+        else: path = hf_hub_download(repo_id=repo_id, filename=filename, repo_type=repo_type, local_dir=directory, token=hf_token)
+        return path
+    except Exception as e:
+        print(f"Failed to download: {e}")
+        return None
+
+
+def download_thing(directory, url, civitai_api_key="", progress=gr.Progress(track_tqdm=True)): # requires aria2, gdown
+    url = url.strip()
+    if "drive.google.com" in url:
+        original_dir = os.getcwd()
+        os.chdir(directory)
+        os.system(f"gdown --fuzzy {url}")
+        os.chdir(original_dir)
+    elif "huggingface.co" in url:
+        url = url.replace("?download=true", "")
+        if "/blob/" in url: url = url.replace("/blob/", "/resolve/")
+        download_hf_file(directory, url)
+    elif "civitai.com" in url:
+        if "?" in url:
+            url = url.split("?")[0]
+        if civitai_api_key:
+            url = url + f"?token={civitai_api_key}"
+            os.system(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 -d {directory} {url}")
+        else:
+            print("You need an API key to download Civitai models.")
+    else:
+        os.system(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 -d {directory} {url}")
+
+
+def get_local_file_list(dir_path):
+    file_list = []
+    for file in Path(dir_path).glob("**/*.*"):
+        if file.is_file():
+            file_path = str(file)
+            file_list.append(file_path)
+    return file_list
+
+
+def get_download_file(temp_dir, url, civitai_key, progress=gr.Progress(track_tqdm=True)):
+    if not "http" in url and is_repo_name(url) and not Path(url).exists():
+        print(f"Use HF Repo: {url}")
+        new_file = url
+    elif not "http" in url and Path(url).exists():
+        print(f"Use local file: {url}")
+        new_file = url
+    elif Path(f"{temp_dir}/{url.split('/')[-1]}").exists():
+        print(f"File to download alreday exists: {url}")
+        new_file = f"{temp_dir}/{url.split('/')[-1]}"
+    else:
+        print(f"Start downloading: {url}")
+        before = get_local_file_list(temp_dir)
+        try:
+            download_thing(temp_dir, url.strip(), civitai_key)
+        except Exception:
+            print(f"Download failed: {url}")
+            return ""
+        after = get_local_file_list(temp_dir)
+        new_file = list_sub(after, before)[0] if list_sub(after, before) else ""
+    if not new_file:
+        print(f"Download failed: {url}")
+        return ""
+    print(f"Download completed: {url}")
+    return new_file
+
+
+def download_repo(repo_id: str, dir_path: str, progress=gr.Progress(track_tqdm=True)): # for diffusers repo
+    hf_token = get_token()
+    try:
+        snapshot_download(repo_id=repo_id, local_dir=dir_path, token=hf_token, allow_patterns=["*.safetensors", "*.bin"],
+                          ignore_patterns=["*.fp16.*", "/*.safetensors", "/*.bin"], force_download=True)
+        return True
+    except Exception as e:
+        print(f"Error: Failed to download {repo_id}. {e}")
+        gr.Warning(f"Error: Failed to download {repo_id}. {e}")
+        return False
+
+
+def upload_repo(repo_id: str, dir_path: str, is_private: bool, progress=gr.Progress(track_tqdm=True)): # for diffusers repo
+    hf_token = get_token()
+    api = HfApi(token=hf_token)
+    try:
+        progress(0, desc="Start uploading...")
+        api.create_repo(repo_id=repo_id, token=hf_token, private=is_private, exist_ok=True)
+        for path in Path(dir_path).glob("*"):
+            if path.is_dir():
+                api.upload_folder(repo_id=repo_id, folder_path=str(path), path_in_repo=path.name, token=hf_token)
+            elif path.is_file():
+                api.upload_file(repo_id=repo_id, path_or_fileobj=str(path), path_in_repo=path.name, token=hf_token)
+        progress(1, desc="Uploaded.")
+        return get_hf_url(repo_id, "model")
+    except Exception as e:
+        print(f"Error: Failed to upload to {repo_id}. {e}")
+        return ""
+
+
+HF_SUBFOLDER_NAME = ["None", "user_repo"]
+
+
+def duplicate_hf_repo(src_repo: str, dst_repo: str, src_repo_type: str, dst_repo_type: str,
+                      is_private: bool, subfolder_type: str=HF_SUBFOLDER_NAME[1], progress=gr.Progress(track_tqdm=True)):
+    hf_token = get_token()
+    api = HfApi(token=hf_token)
+    try:
+        if subfolder_type == "user_repo": subfolder = src_repo.replace("/", "_")
+        else: subfolder = ""
+        progress(0, desc="Start duplicating...")
+        api.create_repo(repo_id=dst_repo, repo_type=dst_repo_type, private=is_private, exist_ok=True, token=hf_token)
+        for path in api.list_repo_files(repo_id=src_repo, repo_type=src_repo_type, token=hf_token):
+            file = hf_hub_download(repo_id=src_repo, filename=path, repo_type=src_repo_type, token=hf_token)
+            if not Path(file).exists(): continue
+            if Path(file).is_dir(): # unused for now
+                api.upload_folder(repo_id=dst_repo, folder_path=file, path_in_repo=f"{subfolder}/{path}" if subfolder else path,
+                                  repo_type=dst_repo_type, token=hf_token)
+            elif Path(file).is_file():
+                api.upload_file(repo_id=dst_repo, path_or_fileobj=file, path_in_repo=f"{subfolder}/{path}" if subfolder else path,
+                                repo_type=dst_repo_type, token=hf_token)
+            if Path(file).exists(): Path(file).unlink()
+        progress(1, desc="Duplicated.")
+        return f"{get_hf_url(dst_repo, dst_repo_type)}/tree/main/{subfolder}" if subfolder else get_hf_url(dst_repo, dst_repo_type)
+    except Exception as e:
+        print(f"Error: Failed to duplicate repo {src_repo} to {dst_repo}. {e}")
+        return ""
+
+
+BASE_DIR = str(Path(__file__).resolve().parent.resolve())
+CIVITAI_API_KEY = os.environ.get("CIVITAI_API_KEY")
+
+
+def get_file(url: str, path: str): # requires aria2, gdown
+    print(f"Downloading {url} to {path}...")
+    get_download_file(path, url, CIVITAI_API_KEY)
+
+
+def git_clone(url: str, path: str, pip: bool=False, addcmd: str=""): # requires git
+    os.makedirs(str(Path(BASE_DIR, path)), exist_ok=True)
+    os.chdir(Path(BASE_DIR, path))
+    print(f"Cloning {url} to {path}...")
+    cmd = f'git clone {url}'
+    print(f'Running {cmd} at {Path.cwd()}')
+    i = subprocess.run(cmd, shell=True).returncode
+    if i != 0: print(f'Error occured at running {cmd}')
+    p = url.split("/")[-1]
+    if not Path(p).exists: return
+    if pip:
+        os.chdir(Path(BASE_DIR, path, p))
+        cmd = f'pip install -r requirements.txt'
+        print(f'Running {cmd} at {Path.cwd()}')
+        i = subprocess.run(cmd, shell=True).returncode
+        if i != 0: print(f'Error occured at running {cmd}')
+    if addcmd:
+        os.chdir(Path(BASE_DIR, path, p))
+        cmd = addcmd
+        print(f'Running {cmd} at {Path.cwd()}')
+        i = subprocess.run(cmd, shell=True).returncode
+        if i != 0: print(f'Error occured at running {cmd}')
+
+
+def run(cmd: str, timeout: float=0):
+    print(f'Running {cmd} at {Path.cwd()}')
+    if timeout == 0:
+        i = subprocess.run(cmd, shell=True).returncode
+        if i != 0: print(f'Error occured at running {cmd}')
+    else:
+        p = subprocess.Popen(cmd, shell=True)
+        time.sleep(timeout)
+        p.terminate()
+        print(f'Terminated in {timeout} seconds')