Upload 7 files

README.md

@@ -4,7 +4,8 @@ emoji: 🤗
 colorFrom: yellow
 colorTo: blue
 sdk: gradio
-sdk_version: 5.49.0
+sdk_version: 6.11.0
+python_version: "3.10.13"
 app_file: app.py
 pinned: false
 license: mit

app.py

@@ -1,24 +1,98 @@
+import asyncio.base_events as _asyncio_base_events
+
+
+def _patch_asyncio_event_loop_del():
+    original_del = getattr(_asyncio_base_events.BaseEventLoop, "__del__", None)
+    if original_del is None:
+        return
+    def patched_del(self):
+        try:
+            original_del(self)
+        except ValueError as e:
+            if "Invalid file descriptor" not in str(e):
+                raise
+    _asyncio_base_events.BaseEventLoop.__del__ = patched_del
+
+
+_patch_asyncio_event_loop_del()
+
+import os
 import gradio as gr
-from civitai_to_hf import (search_civitai, download_civitai, select_civitai_item, add_civitai_item, get_civitai_tag, select_civitai_all_item,
-                           update_civitai_selection, update_civitai_checkbox, from_civitai_checkbox,
-                           CIVITAI_TYPE, CIVITAI_BASEMODEL, CIVITAI_SORT, CIVITAI_PERIOD, CIVITAI_FILETYPE)
+from civitai_to_hf import (
+    search_civitai,
+    download_civitai,
+    smoke_test_civitai,
+    add_civitai_item,
+    get_civitai_tag,
+    get_civitai_creator,
+    refresh_civitai_creators,
+    request_run_cancel,
+    from_civitai_dropdown,
+    update_civitai_selection,
+    from_civitai_checkbox,
+    select_civitai_all_item_fast,
+    load_more_civitai,
+    load_all_civitai,
+    refresh_civitai_key_status,
+    probe_civitai_api,
+    probe_civitai_green_api,
+    update_civitai_gallery_mode,
+    begin_probe_civitai,
+    begin_probe_civitai_green,
+    clear_retry_state,
+    CIVITAI_TYPE,
+    CIVITAI_BASEMODEL,
+    CIVITAI_SORT,
+    CIVITAI_PERIOD,
+    CIVITAI_FILETYPE,
+    uniq_urls,
+)
+
+
+def update_upload_target_note(upload_type: str):
+    note = "Bucket mode note: if the bucket does not exist, it will be created as private. The privacy checkbox is ignored for new buckets. Existing bucket visibility is kept as-is."
+    return gr.update(value=note, visible=(upload_type == "bucket"))
+
+
+def use_remaining_urls(remaining_urls: str, current_urls: str):
+    next_urls = remaining_urls.strip() if remaining_urls and remaining_urls.strip() else current_urls
+    return gr.update(value=uniq_urls(next_urls) if next_urls else "")
+
+
+def use_failed_urls(failed_urls: str, current_urls: str):
+    next_urls = failed_urls.strip() if failed_urls and failed_urls.strip() else current_urls
+    return gr.update(value=uniq_urls(next_urls) if next_urls else "")
+
+
+CIVITAI_TAGS = get_civitai_tag()
+CIVITAI_CREATORS = get_civitai_creator()
+
+def env_flag(name: str) -> bool:
+    value = os.environ.get(name, "")
+    return value.strip().lower() in {"1", "true", "yes", "on", "y", "t"}
+
+
+CIVITAI_HF_DEBUG = env_flag("CIVITAI_HF_DEBUG")
 
 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; }
-.desc [src$='#float'] { float: right; margin: 20px; }
+#gallery img { aspect-ratio: 3 / 4; object-fit: cover; }
+#gallery { min-height: 620px; }
+#civitai-detail img { object-fit: contain; background: rgba(0, 0, 0, 0.15); }
 """
 
-with gr.Blocks(theme="NoCrypt/miku@>=1.2.2", fill_width=True, css=css, delete_cache=(60, 3600)) as demo:
+with gr.Blocks(fill_width=True, delete_cache=(60, 3600)) as demo:
     with gr.Column():
         gr.Markdown("# CivitAI to HF🤗 Downloader & Uploader", elem_classes="title")
-        state = gr.State(value={})
+        state = gr.State(value={"civitai_search_preview_dir": "", "civitai_last_choices": [("", "")], "civitai_last_results": {}, "civitai_last_selects": [], "civitai_last_items": [], "civitai_visible_count": 0, "civitai_detail_url": "", "civitai_preview_cache": {}, "civitai_preview_fail_urls": [], "civitai_gallery_enabled": True})
+        session_state = gr.State(value={})
         with gr.Accordion("Search Civitai", open=True):
             with gr.Row():
-                search_civitai_type = gr.CheckboxGroup(label="Type", choices=CIVITAI_TYPE, value=["Checkpoint", "LORA"])
-                search_civitai_sort = gr.Radio(label="Sort", choices=CIVITAI_SORT, value=CIVITAI_SORT[0])
-                search_civitai_period = gr.Radio(label="Period", choices=CIVITAI_PERIOD, value="Month")
+                search_civitai_type = gr.Dropdown(label="Type", choices=CIVITAI_TYPE, value=["LORA"], multiselect=True)
+                search_civitai_sort = gr.Dropdown(label="Sort", choices=CIVITAI_SORT, value=CIVITAI_SORT[0])
+                search_civitai_period = gr.Dropdown(label="Period", choices=CIVITAI_PERIOD, value="Month")
             with gr.Accordion("Advanced", open=False):
                 search_civitai_basemodel = gr.CheckboxGroup(label="Base Model", choices=CIVITAI_BASEMODEL, value=[])
                 with gr.Row():
@@ -27,75 +101,125 @@ with gr.Blocks(theme="NoCrypt/miku@>=1.2.2", fill_width=True, css=css, delete_ca
                     search_civitai_page = gr.Number(label="Page", info="If 0, retrieve all pages", minimum=0, maximum=10, step=1, value=1)
             with gr.Row(equal_height=True):
                 search_civitai_query = gr.Textbox(label="Query", placeholder="flux", lines=1)
-                search_civitai_tag = gr.Dropdown(label="Tag", choices=get_civitai_tag(), value=get_civitai_tag()[0], allow_custom_value=True)
-                search_civitai_user = gr.Textbox(label="Username", lines=1)
+                search_civitai_tag = gr.Dropdown(label="Tag", choices=CIVITAI_TAGS, value=CIVITAI_TAGS[0], allow_custom_value=True)
+                search_civitai_user = gr.Dropdown(label="Username", choices=CIVITAI_CREATORS, value="", allow_custom_value=True)
                 search_civitai_submit = gr.Button("Search on Civitai")
             with gr.Accordion("Results", open=True):
-                with gr.Row():
-                    search_civitai_desc = gr.Markdown(value="", visible=False, elem_classes="desc")
-                    search_civitai_json = gr.JSON(value={}, visible=False)
+                with gr.Row(equal_height=False):
+                    with gr.Column(scale=8):
+                        with gr.Row():
+                            search_civitai_page_label = gr.Markdown("Showing 0/0", elem_classes="info")
+                            search_civitai_gallery_enabled = gr.Checkbox(label="Gallery", value=True)
+                            search_civitai_load_more = gr.Button("Load More", variant="secondary", size="sm")
+                            search_civitai_load_all = gr.Button("Load All", variant="secondary", size="sm")
+                        search_civitai_gallery = gr.Gallery([], label="Results", allow_preview=False, columns=4, height=620, object_fit="cover", format="webp", elem_id="gallery", buttons=[], interactive=False)
+                        search_civitai_result_info = gr.Markdown("Search result.", elem_classes="info")
+                    with gr.Column(scale=5):
+                        search_civitai_detail_image = gr.Image(label="Selected Preview", value=None, height=520, elem_id="civitai-detail", interactive=False, visible=False, format="webp")
+                        search_civitai_desc = gr.Markdown(value="", visible=False, elem_classes="desc")
+                        search_civitai_json = gr.JSON(value={}, visible=False)
                 with gr.Row(equal_height=True):
                     with gr.Column(scale=9):
-                        with gr.Accordion("Select from Gallery", open=False):
-                            search_civitai_gallery = gr.Gallery([], label="Results", allow_preview=False, columns=5, elem_id="gallery", show_share_button=False, interactive=False)
                         with gr.Accordion("Select by Checkbox", open=False):
-                            search_civitai_result_checkbox = gr.CheckboxGroup(label="", choices=[], value=[])
-                        search_civitai_result = gr.Dropdown(label="Search Results", choices=[("", "")], value=[],
-                                                            allow_custom_value=True, visible=True, multiselect=True)
-                        search_civitai_result_info = gr.Markdown("Search result.", elem_classes="info")
+                            search_civitai_result_checkbox = gr.CheckboxGroup(label="All Results", choices=[], value=[])
+                        search_civitai_result = gr.Dropdown(label="Selected Results", choices=[("", "")], value=[], allow_custom_value=True, visible=True, multiselect=True)
                     with gr.Column(scale=1):
                         search_civitai_add = gr.Button("Add to download URLs")
                         search_civitai_select_all = gr.Button("Select All", variant="secondary", size="sm")
-        with gr.Group():
+        with gr.Accordion("Civitai", open=True):
             dl_url = gr.Textbox(label="Download URL(s)", placeholder="https://civitai.com/api/download/models/28907\n...", value="", lines=3, max_lines=255)
             with gr.Column():
-                civitai_key = gr.Textbox(label="Your Civitai Key", 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.Group():
+                civitai_key = gr.Textbox(label="Your Civitai Key(s)", value="", lines=2, max_lines=4)
+                civitai_key_status = gr.Markdown(value=refresh_civitai_key_status(""), elem_classes="info")
+                gr.Markdown("Your Civitai API key is available at [https://civitai.com/user/account](https://civitai.com/user/account). You can enter multiple keys separated by newline, comma, or space.", elem_classes="info")
+        with gr.Accordion("Hugging Face", open=True):
             with gr.Row():
                 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")
                 newrepo_id = gr.Textbox(label="Upload repo ID", placeholder="yourid/yourrepo", value="", max_lines=1)
             with gr.Row():
-                newrepo_type = gr.Radio(label="Upload repo type", choices=["model", "dataset"], value="model")
+                newrepo_type = gr.Radio(label="Upload repo type", choices=["model", "dataset", "bucket"], value="model")
                 is_private = gr.Checkbox(label="Create private repo", value=True)
                 is_info = gr.Checkbox(label="Upload Civitai information files", value=False)
                 is_rename = gr.Checkbox(label="Auto rename", value=True)
+            bucket_mode_note = gr.Markdown(value="", visible=False, elem_classes="info")
         with gr.Row():
             run_button = gr.Button(value="Download and Upload", variant="primary")
             stop_button = gr.Button(value="Cancel", variant="stop")
-        uploaded_urls = gr.CheckboxGroup(visible=False, choices=[], value=None) # hidden
-        urls_md = gr.Markdown("<br><br>", elem_classes="result")
-        urls_remain = gr.Textbox(label="Remaining URLs", value="", show_copy_button=True, visible=False)
-    gr.DuplicateButton(value="Duplicate Space")
+        with gr.Accordion("Results", open=True):
+            uploaded_urls = gr.CheckboxGroup(visible=False, choices=[], value=None)
+            urls_md = gr.Markdown("<br><br>", elem_classes="result")
+            with gr.Row():
+                urls_remain = gr.Textbox(label="Remaining URLs", value="", buttons=["copy"], visible=False, scale=6)
+                urls_failed = gr.Textbox(label="Failed URLs", value="", buttons=["copy"], visible=False, scale=6)
+            with gr.Row():
+                use_remaining_button = gr.Button(value="Use Remaining URLs", visible=True, variant="secondary")
+                use_failed_button = gr.Button(value="Retry Failed Only", visible=True, variant="secondary")
+                clear_remaining_button = gr.Button(value="Clear Remaining", visible=True, variant="secondary")
+        with gr.Accordion("Probe / Experimental", open=False, visible=CIVITAI_HF_DEBUG):
+            probe_md = gr.Markdown(value="", visible=False)
+            with gr.Row():
+                smoke_test_button = gr.Button(value="Smoke Test", variant="secondary")
+                probe_button = gr.Button("Probe Civitai", variant="secondary")
+                probe_green_button = gr.Button("Probe civitai.green", variant="secondary")
+        gr.DuplicateButton(value="Duplicate Space")
+
+    heavy_outputs = [uploaded_urls, urls_md, urls_remain, urls_failed, civitai_key_status, session_state]
+    search_outputs = [search_civitai_select_all, search_civitai_result, search_civitai_desc, search_civitai_json, search_civitai_gallery,
+                      search_civitai_result_checkbox, search_civitai_result_info, search_civitai_page_label,
+                      search_civitai_detail_image, civitai_key_status, state]
 
     download_evt = gr.on(
         triggers=[run_button.click],
         fn=download_civitai,
-        inputs=[dl_url, civitai_key, hf_token, uploaded_urls, newrepo_id, newrepo_type, is_private, is_info, is_rename],
-        outputs=[uploaded_urls, urls_md, urls_remain],
+        inputs=[dl_url, civitai_key, hf_token, uploaded_urls, newrepo_id, newrepo_type, is_private, is_info, is_rename, session_state],
+        outputs=heavy_outputs,
+        queue=True,
+        concurrency_limit=1,
+        concurrency_id="heavy-run",
+    )
+    smoke_evt = gr.on(
+        triggers=[smoke_test_button.click],
+        fn=smoke_test_civitai,
+        inputs=[civitai_key, hf_token, uploaded_urls, newrepo_type, is_private, is_info, is_rename, session_state],
+        outputs=heavy_outputs,
         queue=True,
+        api_visibility="undocumented",
+        concurrency_limit=1,
+        concurrency_id="heavy-run",
     )
-    stop_button.click(fn=None, cancels=[download_evt], queue=False, show_api=False)
-    stop_button.click(fn=lambda: gr.update(visible=True), inputs=None, outputs=[urls_remain], queue=False, show_api=False)
+    stop_button.click(request_run_cancel, [session_state], [session_state], queue=False, api_visibility="undocumented")
+    stop_button.click(fn=None, cancels=[download_evt, smoke_evt], queue=False, api_visibility="undocumented")
+    use_remaining_button.click(use_remaining_urls, [urls_remain, dl_url], [dl_url], queue=False, api_visibility="undocumented")
+    use_failed_button.click(use_failed_urls, [urls_failed, dl_url], [dl_url], queue=False, api_visibility="undocumented")
+    clear_remaining_button.click(clear_retry_state, [session_state], [urls_remain, urls_failed, session_state], queue=False, api_visibility="undocumented")
+
     gr.on(
-        triggers=[search_civitai_submit.click, search_civitai_query.submit, search_civitai_user.submit],
+        triggers=[search_civitai_submit.click, search_civitai_query.submit],
         fn=search_civitai,
         inputs=[search_civitai_query, search_civitai_type, search_civitai_basemodel, search_civitai_sort,
                 search_civitai_period, search_civitai_tag, search_civitai_user, search_civitai_limit,
-                search_civitai_page, search_civitai_filetype, civitai_key, search_civitai_gallery, state],
-        outputs=[search_civitai_result, search_civitai_desc, search_civitai_submit, search_civitai_query, search_civitai_gallery,
-                 search_civitai_result_checkbox, search_civitai_result_info, state],
+                search_civitai_page, search_civitai_filetype, civitai_key, state],
+        outputs=search_outputs,
         queue=False,
-        show_api=False,
+        api_visibility="undocumented",
     )
-    search_civitai_result.change(select_civitai_item, [search_civitai_result, state], [search_civitai_desc, search_civitai_json, state], queue=False, show_api=False)\
-    .success(update_civitai_checkbox, [search_civitai_result], [search_civitai_result_checkbox], queue=True, show_api=False)
-    search_civitai_result_checkbox.select(from_civitai_checkbox, [search_civitai_result_checkbox], [search_civitai_result], queue=False, show_api=False)
-    search_civitai_add.click(add_civitai_item, [search_civitai_result, dl_url], [dl_url], queue=False, show_api=False)
-    search_civitai_select_all.click(select_civitai_all_item, [search_civitai_select_all, state], [search_civitai_select_all, search_civitai_result], queue=False, show_api=False)
-    search_civitai_gallery.select(update_civitai_selection, [search_civitai_result, state], [search_civitai_result], queue=False, show_api=False)
+    search_civitai_load_more.click(load_more_civitai, [state, civitai_key], search_outputs, queue=False, api_visibility="undocumented")
+    search_civitai_load_all.click(load_all_civitai, [state, civitai_key], search_outputs, queue=True, api_visibility="undocumented")
+    search_civitai_result.input(from_civitai_dropdown, [search_civitai_result, civitai_key, state], search_outputs, queue=False, api_visibility="undocumented")
+    search_civitai_result_checkbox.input(from_civitai_checkbox, [search_civitai_result_checkbox, civitai_key, state], search_outputs, queue=False, api_visibility="undocumented")
+    search_civitai_add.click(add_civitai_item, [search_civitai_result, dl_url], [dl_url], queue=False, api_visibility="undocumented")
+    newrepo_type.input(update_upload_target_note, [newrepo_type], [bucket_mode_note], queue=False, api_visibility="undocumented")
+    search_civitai_select_all.click(select_civitai_all_item_fast, [search_civitai_select_all, civitai_key, state], search_outputs, queue=False, api_visibility="undocumented")
+    search_civitai_gallery.select(update_civitai_selection, [search_civitai_result, civitai_key, state], search_outputs, queue=False, api_visibility="undocumented")
+    search_civitai_gallery_enabled.change(update_civitai_gallery_mode, [search_civitai_gallery_enabled, civitai_key, state], search_outputs, queue=False, api_visibility="undocumented")
+    search_civitai_user.focus(refresh_civitai_creators, [search_civitai_user, civitai_key], [search_civitai_user], queue=False, api_visibility="undocumented")
+    search_civitai_user.change(refresh_civitai_creators, [search_civitai_user, civitai_key], [search_civitai_user], queue=False, api_visibility="undocumented")
+    civitai_key.change(refresh_civitai_key_status, [civitai_key], [civitai_key_status], queue=False, api_visibility="undocumented")
+    probe_button.click(begin_probe_civitai, [], [probe_md], queue=False, api_visibility="undocumented").then(probe_civitai_api, [search_civitai_query, civitai_key], [probe_md, civitai_key_status], queue=False, api_visibility="undocumented")
+    probe_green_button.click(begin_probe_civitai_green, [], [probe_md], queue=False, api_visibility="undocumented").then(probe_civitai_green_api, [search_civitai_query, civitai_key], [probe_md, civitai_key_status], queue=False, api_visibility="undocumented")
+
 
 demo.queue()
-demo.launch(ssr_mode=False, mcp_server=False)
+demo.launch(theme="NoCrypt/miku@>=1.2.2", css=css, ssr_mode=False, mcp_server=False)

bucket_ops.py

@@ -0,0 +1,108 @@
+import os
+from pathlib import Path
+import importlib
+from utils import retry_call
+
+
+BUCKET_CREATE_PRIVATE_DEFAULT = True
+
+
+def _get_bucket_api_module():
+    hh = importlib.import_module("huggingface_hub")
+    required = ["create_bucket", "list_bucket_tree", "batch_bucket_files"]
+    missing = [name for name in required if not hasattr(hh, name)]
+    if missing:
+        raise RuntimeError(f"Bucket API is unavailable in current huggingface_hub build. Missing: {', '.join(missing)}")
+    return hh
+
+
+def is_bucket_api_available():
+    try:
+        _get_bucket_api_module()
+        return True
+    except Exception:
+        return False
+
+
+def get_bucket_url(bucket_id: str):
+    return f"https://huggingface.co/buckets/{bucket_id}"
+
+
+def get_bucket_handle(bucket_id: str, remote_path: str = ""):
+    bucket_id = str(bucket_id).strip().strip("/")
+    remote_path = str(remote_path).strip().strip("/")
+    return f"hf://buckets/{bucket_id}/{remote_path}" if remote_path else f"hf://buckets/{bucket_id}"
+
+
+def ensure_bucket(bucket_id: str, hf_token: str, private: bool = BUCKET_CREATE_PRIVATE_DEFAULT):
+    hh = _get_bucket_api_module()
+    create_bucket = getattr(hh, "create_bucket")
+    bucket_info = getattr(hh, "bucket_info")
+    retry_call(
+        lambda: create_bucket(bucket_id, private=private, exist_ok=True, token=hf_token),
+        action=f"create_bucket {bucket_id}",
+    )
+    return retry_call(
+        lambda: bucket_info(bucket_id, token=hf_token),
+        action=f"bucket_info {bucket_id}",
+    )
+
+
+def get_bucket_file_info(bucket_id: str, remote_path: str, hf_token: str):
+    hh = _get_bucket_api_module()
+    list_bucket_tree = getattr(hh, "list_bucket_tree")
+
+    def _list():
+        return list(list_bucket_tree(bucket_id, prefix=remote_path, recursive=True, token=hf_token))
+
+    items = retry_call(_list, action=f"list_bucket_tree {bucket_id}:{remote_path}")
+    for item in items:
+        if getattr(item, "type", "") == "file" and getattr(item, "path", "") == remote_path:
+            return item
+    return None
+
+
+def bucket_file_exists(bucket_id: str, remote_path: str, hf_token: str):
+    return get_bucket_file_info(bucket_id, remote_path, hf_token) is not None
+
+
+def get_safe_bucket_filename(filename: str, bucket_id: str, hf_token: str):
+    ensure_bucket(bucket_id=bucket_id, hf_token=hf_token, private=BUCKET_CREATE_PRIVATE_DEFAULT)
+    path = Path(filename)
+    remote_name = path.name
+    existing = get_bucket_file_info(bucket_id, remote_name, hf_token)
+    if existing is None:
+        return filename
+    try:
+        remote_size = getattr(existing, "size", None)
+        local_size = os.path.getsize(filename)
+        if remote_size is not None and int(remote_size) == int(local_size):
+            print(f"{remote_name} already exists in bucket with same size. keeping original name for skip check.")
+            return filename
+    except Exception:
+        pass
+    i = 1
+    while True:
+        candidate = str(Path(path.parent, f"{path.stem}_{i}{path.suffix}"))
+        if get_bucket_file_info(bucket_id, Path(candidate).name, hf_token) is None:
+            print(f"{path.name} is already exists in bucket but file size is different. renaming to {Path(candidate).name}.")
+            Path(filename).rename(candidate)
+            return candidate
+        i += 1
+
+
+def upload_file_to_bucket(local_path: str, bucket_id: str, hf_token: str, remote_path: str = "", private: bool = BUCKET_CREATE_PRIVATE_DEFAULT):
+    hh = _get_bucket_api_module()
+    batch_bucket_files = getattr(hh, "batch_bucket_files")
+    remote_path = remote_path or Path(local_path).name
+    ensure_bucket(bucket_id=bucket_id, hf_token=hf_token, private=private)
+    if bucket_file_exists(bucket_id, remote_path, hf_token):
+        print(f"{remote_path} already exists in bucket. skipping.")
+        return get_bucket_handle(bucket_id, remote_path), "skipped"
+    retry_call(
+        lambda: batch_bucket_files(bucket_id, add=[(str(local_path), remote_path)], token=hf_token),
+        action=f"batch_bucket_files {bucket_id}:{remote_path}",
+    )
+    if not bucket_file_exists(bucket_id, remote_path, hf_token):
+        raise RuntimeError(f"Bucket verify failed for {bucket_id}:{remote_path}")
+    return get_bucket_handle(bucket_id, remote_path), "uploaded"

packages.txt

@@ -1 +1,3 @@
-git-lfs aria2
+git-lfs
+aria2
+ffmpeg

requirements.txt

@@ -1,5 +1,5 @@
 huggingface-hub
 gdown
 hf_xet
-hf_transfer
-pydantic==2.10.6
+#hf_transfer
+#pydantic==2.10.6

utils.py

@@ -1,5 +1,11 @@
 import gradio as gr
-from huggingface_hub import HfApi, HfFolder, hf_hub_download, snapshot_download
+from huggingface_hub import HfApi, hf_hub_download, snapshot_download
+try:
+    from huggingface_hub.utils import disable_progress_bars as hf_disable_progress_bars, enable_progress_bars as hf_enable_progress_bars, are_progress_bars_disabled as hf_are_progress_bars_disabled
+except Exception:
+    hf_disable_progress_bars = None
+    hf_enable_progress_bars = None
+    hf_are_progress_bars_disabled = None
 import os
 from pathlib import Path
 import shutil
@@ -7,23 +13,104 @@ import gc
 import re
 import urllib.parse
 import subprocess
+import random
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
 import time
 from typing import Any
+from contextvars import ContextVar
+from contextlib import contextmanager
 
 
-def get_token():
+@contextmanager
+def suppress_hf_hub_progress_bars():
+    if hf_disable_progress_bars is None or hf_enable_progress_bars is None:
+        yield
+        return
+    was_disabled = False
     try:
-        token = HfFolder.get_token()
+        was_disabled = bool(hf_are_progress_bars_disabled()) if hf_are_progress_bars_disabled is not None else False
     except Exception:
-        token = False
-    return token
-
-
-def set_token(token):
+        was_disabled = False
+    if not was_disabled:
+        try:
+            hf_disable_progress_bars()
+        except Exception:
+            pass
     try:
-        HfFolder.save_token(token)
-    except Exception:
-        print(f"Error: Failed to save token.")
+        yield
+    finally:
+        if not was_disabled:
+            try:
+                hf_enable_progress_bars()
+            except Exception:
+                pass
+
+
+CIVITAI_KEY_SWITCH_STATUS_CODES = frozenset([401, 403, 429])
+
+
+HF_FOLDER_TOKEN = os.getenv("HF_TOKEN", False) or False
+HF_FOLDER_TOKEN_CONTEXT = ContextVar("hf_folder_token", default=False)
+CIVITAI_KEY_STATUS_CONTEXT = ContextVar("civitai_key_status", default={})
+
+
+def reset_civitai_key_status(raw_keys: Any=None, source: str=""):
+    count = len(parse_civitai_api_keys(raw_keys)) if raw_keys not in [None, "", False] else 0
+    status = {"count": count, "active_index": 1 if count else 0, "last_switch_reason": "", "last_status": "", "source": source}
+    CIVITAI_KEY_STATUS_CONTEXT.set(status)
+    return dict(status)
+
+
+def update_civitai_key_status(*, raw: Any=None, count: int | None=None, active_index: int | None=None, last_switch_reason: str | None=None, last_status: str | None=None, source: str | None=None):
+    status = dict(CIVITAI_KEY_STATUS_CONTEXT.get() or {})
+    if raw is not None:
+        status["count"] = len(parse_civitai_api_keys(raw))
+    if count is not None:
+        status["count"] = int(count)
+    if active_index is not None:
+        status["active_index"] = int(active_index)
+    if last_switch_reason is not None:
+        status["last_switch_reason"] = str(last_switch_reason)
+    if last_status is not None:
+        status["last_status"] = str(last_status)
+    if source is not None:
+        status["source"] = str(source)
+    CIVITAI_KEY_STATUS_CONTEXT.set(status)
+    return dict(status)
+
+
+def get_civitai_key_status(raw_keys: Any=None):
+    status = dict(CIVITAI_KEY_STATUS_CONTEXT.get() or {})
+    if raw_keys is not None:
+        status["count"] = len(parse_civitai_api_keys(raw_keys))
+    count = int(status.get("count") or 0)
+    if count == 0:
+        status["active_index"] = 0
+    elif int(status.get("active_index") or 0) <= 0:
+        status["active_index"] = 1
+    return status
+
+
+def get_token(session_state=None):
+    if isinstance(session_state, dict):
+        token = session_state.get("hf_token", False)
+        if token not in [None, "", False]:
+            return token
+    token = HF_FOLDER_TOKEN_CONTEXT.get()
+    if token not in [None, "", False]:
+        return token
+    env_token = os.getenv("HF_TOKEN", False) or HF_FOLDER_TOKEN
+    return env_token if env_token not in [None, "", False] else False
+
+
+def set_token(token, session_state=None):
+    normalized = token if token else False
+    HF_FOLDER_TOKEN_CONTEXT.set(normalized)
+    if isinstance(session_state, dict):
+        session_state["hf_token"] = normalized
+    return normalized
 
 
 def get_state(state: dict, key: str):
@@ -37,21 +124,198 @@ def set_state(state: dict, key: str, value: Any):
     state[key] = value
 
 
-def get_user_agent():
-    return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:127.0) Gecko/20100101 Firefox/127.0'
-
-
+def get_user_agent():
+    return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:127.0) Gecko/20100101 Firefox/127.0'
+
+CIVITAI_REFERER = 'https://civitai.com/'
+RETRYABLE_STATUS_CODES = frozenset([408, 409, 425, 429, 500, 502, 503, 504])
+ARIA2_CIVITAI_OPTIONS = [
+    "--console-log-level=notice",
+    "--log-level=notice",
+    "--summary-interval=0",
+    "--stderr=true",
+    "--log=-",
+    "--check-certificate=true",
+    "--connect-timeout=15",
+    "--timeout=60",
+    "--max-tries=1",
+    "-c",
+    "-x", "1",
+    "-s", "1",
+    "-k", "20M",
+]
+ARIA2_GENERIC_OPTIONS = [
+    "--console-log-level=error",
+    "--summary-interval=10",
+    "-c",
+    "-x", "16",
+    "-k", "1M",
+    "-s", "16",
+]
+
+
+def build_retry(total: int = 5, backoff_factor: float = 1.0, status_forcelist=RETRYABLE_STATUS_CODES):
+    kwargs = {
+        'total': total,
+        'connect': total,
+        'read': total,
+        'status': total,
+        'backoff_factor': backoff_factor,
+        'status_forcelist': status_forcelist,
+        'respect_retry_after_header': True,
+        'raise_on_status': False,
+    }
+    try:
+        return Retry(allowed_methods=frozenset(['HEAD', 'GET', 'OPTIONS']), **kwargs)
+    except TypeError:
+        return Retry(method_whitelist=frozenset(['HEAD', 'GET', 'OPTIONS']), **kwargs)
+
+
+def create_retry_session(total: int = 5, backoff_factor: float = 1.0):
+    session = requests.Session()
+    adapter = HTTPAdapter(max_retries=build_retry(total=total, backoff_factor=backoff_factor))
+    session.mount('https://', adapter)
+    session.mount('http://', adapter)
+    return session
+
+
+def is_retryable_exception(exc: Exception):
+    msg = f"{type(exc).__name__}: {exc}".lower()
+    tokens = [
+        '429', '408', '425', '500', '502', '503', '504',
+        'timed out', 'timeout', 'connection', 'temporarily unavailable',
+        'remote end closed', 'reset by peer', 'server error', 'service unavailable',
+        'gateway timeout', 'too many requests', 'network',
+    ]
+    return any(token in msg for token in tokens)
+
+
+def format_error_short(exc: Exception):
+    return f"{type(exc).__name__}: {exc}"
+
+
+def parse_civitai_api_keys(raw: Any):
+    if raw is None: return []
+    if isinstance(raw, (list, tuple, set)):
+        parts = []
+        for item in raw:
+            parts.extend(re.split(r'[\s,;]+', str(item or '')))
+    else:
+        parts = re.split(r'[\s,;]+', str(raw or ''))
+    keys = []
+    for part in parts:
+        key = str(part).strip()
+        if key and key not in keys:
+            keys.append(key)
+    return keys
+
+
+def should_switch_civitai_key(status_code: int | None):
+    return status_code in CIVITAI_KEY_SWITCH_STATUS_CODES
+
+
+def sanitize_url_for_log(url: str):
+    try:
+        parts = urllib.parse.urlsplit(url)
+        query = urllib.parse.parse_qsl(parts.query, keep_blank_values=True)
+        safe_query = []
+        for key, value in query:
+            if key.lower() in {"token", "authorization", "auth", "key", "api_key"}:
+                safe_query.append((key, "***"))
+            else:
+                safe_query.append((key, value))
+        return urllib.parse.urlunsplit((parts.scheme, parts.netloc, parts.path, urllib.parse.urlencode(safe_query), parts.fragment))
+    except Exception:
+        return url
+
+
+def log_subprocess_tail(label: str, result: subprocess.CompletedProcess, success_tail: int = 1200, failure_tail: int = 4000):
+    tail = success_tail if result.returncode == 0 else failure_tail
+    if result.stdout:
+        print(f"{label} stdout:\n", result.stdout[-tail:])
+    if result.stderr:
+        print(f"{label} stderr:\n", result.stderr[-tail:])
+    print(f"{label} returncode:", result.returncode)
+
+
+def retry_call(func, attempts: int = 4, base_wait: float = 1.0, action: str = 'operation'):
+    last_error = None
+    for attempt in range(1, attempts + 1):
+        try:
+            return func()
+        except Exception as e:
+            last_error = e
+            should_retry = is_retryable_exception(e) and attempt < attempts
+            if not should_retry:
+                print(f"[fail] action={action} error={format_error_short(e)}")
+                raise
+            delay = min(8.0, base_wait * (2 ** (attempt - 1))) + random.uniform(0.0, 0.3)
+            print(f"[retry] action={action} attempt={attempt}/{attempts} wait={round(delay, 2)}s error={format_error_short(e)}")
+            time.sleep(delay)
+    if last_error is not None:
+        raise last_error
+
+
+def resolve_civitai_download_url(url: str, civitai_api_key: str, max_tries: int = 3):
+    user_agent = get_user_agent()
+    keys = parse_civitai_api_keys(civitai_api_key)
+    if not keys: keys = [""]
+    reset_civitai_key_status(civitai_api_key, source="resolve")
+    last_error = None
+    for key_index, key in enumerate(keys, start=1):
+        update_civitai_key_status(raw=civitai_api_key, active_index=key_index, source="resolve")
+        dl_url = f"{url}&token={key}" if "?" in url else f"{url}?token={key}"
+        headers = {"User-Agent": user_agent, "Referer": CIVITAI_REFERER}
+        allow_key_switch = True
+        for i in range(max_tries):
+            try:
+                r = create_retry_session(total=3, backoff_factor=1.0).get(dl_url, headers=headers, allow_redirects=False, stream=True, timeout=(10, 30))
+                status = r.status_code
+                location = r.headers.get("Location", "")
+                resolved_url = location or r.url
+                host = urllib.parse.urlparse(resolved_url).netloc
+                print(f"Civitai resolve attempt {i + 1} key {key_index}/{len(keys)}: status={status} host={host}")
+                update_civitai_key_status(raw=civitai_api_key, active_index=key_index, last_status=str(status), source="resolve")
+                if status in (301, 302, 303, 307, 308) and location:
+                    r.close()
+                    return resolved_url
+                if r.ok and resolved_url:
+                    r.close()
+                    return resolved_url
+                last_error = RuntimeError(f"Failed to resolve Civitai download URL. status={status}")
+                allow_key_switch = should_switch_civitai_key(status)
+                r.close()
+                if allow_key_switch and key_index < len(keys):
+                    print(f"Switching Civitai key {key_index}/{len(keys)} after resolve status={status}")
+                    update_civitai_key_status(raw=civitai_api_key, active_index=min(key_index + 1, len(keys)), last_switch_reason=f"resolve status={status}", last_status=str(status), source="resolve")
+                    break
+            except Exception as e:
+                last_error = e
+                print(f"Civitai resolve attempt {i + 1} key {key_index}/{len(keys)} failed: {format_error_short(e)}")
+            if i + 1 < max_tries: time.sleep(2)
+        if last_error is None or not allow_key_switch:
+            break
+    raise last_error if last_error else RuntimeError("Failed to resolve Civitai download URL.")
+
 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
+        if retry_call(lambda: api.repo_exists(repo_id=repo_id, repo_type=repo_type, token=hf_token), action=f'repo_exists {repo_id}'): return True
         else: return False
     except Exception as e:
         print(f"Error: Failed to connect {repo_id} ({repo_type}). {e}")
         return True # for safe
 
 
+def ensure_repo(api: HfApi, repo_id: str, repo_type: str="model", is_private: bool=True, hf_token=None):
+    if hf_token is None: hf_token = get_token()
+    return retry_call(
+        lambda: api.create_repo(repo_id=repo_id, repo_type=repo_type, token=hf_token, private=is_private, exist_ok=True),
+        action=f'create_repo {repo_id}'
+    )
+
+
 MODEL_TYPE_CLASS = {
     "diffusers:StableDiffusionPipeline": "SD 1.5",
     "diffusers:StableDiffusionXLPipeline": "SDXL",
@@ -66,9 +330,9 @@ def get_model_type(repo_id: str):
     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)
+        if retry_call(lambda: api.file_exists(repo_id=repo_id, filename=lora_filename, token=hf_token), action=f'file_exists {repo_id}:{lora_filename}'): return "LoRA"
+        if not retry_call(lambda: api.file_exists(repo_id=repo_id, filename=diffusers_filename, token=hf_token), action=f'file_exists {repo_id}:{diffusers_filename}'): return "None"
+        model = retry_call(lambda: api.model_info(repo_id=repo_id, token=hf_token), action=f'model_info {repo_id}')
         tags = model.tags
         for tag in tags:
             if tag in MODEL_TYPE_CLASS.keys(): return MODEL_TYPE_CLASS.get(tag, default)
@@ -111,42 +375,89 @@ def split_hf_url(url: str):
         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
-    try:
-        url = url.strip()
-        if "drive.google.com" in url:
-            original_dir = os.getcwd()
-            os.chdir(directory)
-            subprocess.run(f"gdown --fuzzy {url}", shell=True)
-            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 civitai_api_key:
-                url = f"'{url}&token={civitai_api_key}'" if "?" in url else f"{url}?token={civitai_api_key}"
-                print(f"Downloading {url}")
-                subprocess.run(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 -d {directory} {url}", shell=True)
-            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}")
-    except Exception as e:
-        print(f"Failed to download: {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 = retry_call(
+                lambda: hf_hub_download(repo_id=repo_id, filename=filename, subfolder=subfolder, repo_type=repo_type, local_dir=directory, token=hf_token),
+                action=f'hf_hub_download {repo_id}/{subfolder}/{filename}'
+            )
+        else:
+            path = retry_call(
+                lambda: hf_hub_download(repo_id=repo_id, filename=filename, repo_type=repo_type, local_dir=directory, token=hf_token),
+                action=f'hf_hub_download {repo_id}/{filename}'
+            )
+        return path
+    except Exception as e:
+        print(f"Failed to download HF file: {url} {e}")
+        return None
+
+
+def download_thing(directory, url, civitai_api_key="", progress=gr.Progress(track_tqdm=True)): # requires aria2, gdown
+    try:
+        url = url.strip()
+        if "drive.google.com" in url:
+            original_dir = os.getcwd()
+            try:
+                os.chdir(directory)
+                subprocess.run(["gdown", "--fuzzy", url], check=False)
+            finally:
+                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:
+            keys = parse_civitai_api_keys(civitai_api_key)
+            if keys:
+                user_agent = get_user_agent()
+                last_error = None
+                success = False
+                for i in range(3):
+                    for key_index, key in enumerate(keys, start=1):
+                        try:
+                            signed_url = resolve_civitai_download_url(url, key, max_tries=1 if len(keys) > 1 else 3)
+                        except Exception as e:
+                            last_error = e
+                            if len(keys) > 1:
+                                print(f"Switching Civitai key {key_index}/{len(keys)} after resolve failure: {format_error_short(e)}")
+                            continue
+                        signed_host = urllib.parse.urlparse(signed_url).netloc
+                        print(f"Downloading {sanitize_url_for_log(url)} -> {signed_host} (key {key_index}/{len(keys)})")
+                        cmd = [
+                            "aria2c",
+                            *ARIA2_CIVITAI_OPTIONS,
+                            "--user-agent", user_agent,
+                            "--referer", CIVITAI_REFERER,
+                            "-d", directory,
+                            signed_url,
+                        ]
+                        print("Running:", " ".join(cmd[:-1]), "[signed URL omitted]")
+                        result = subprocess.run(cmd, capture_output=True, text=True)
+                        log_subprocess_tail("aria2", result)
+                        if result.returncode == 0:
+                            last_error = None
+                            success = True
+                            break
+                        last_error = RuntimeError(f"aria2c failed with rc={result.returncode} host={signed_host}")
+                        if len(keys) > 1 and key_index < len(keys):
+                            print(f"Switching Civitai key {key_index}/{len(keys)} after aria2 failure.")
+                    if success:
+                        break
+                    if i + 1 < 3:
+                        time.sleep(2)
+                if last_error is not None and not success:
+                    raise last_error
+            else:
+                print("You need an API key to download Civitai models.")
+        else:
+            cmd = ["aria2c", *ARIA2_GENERIC_OPTIONS, "-d", directory, url]
+            subprocess.run(cmd, check=False)
+    except Exception as e:
+        print(f"Failed to download: {format_error_short(e)}")
 
 
 def get_local_file_list(dir_path, recursive=False):
@@ -168,7 +479,7 @@ def get_download_file(temp_dir, url, civitai_key, progress=gr.Progress(track_tqd
             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}")
+            print(f"File to download already exists: {url}")
             new_file = f"{temp_dir}/{url.split('/')[-1]}"
         elif "huggingface.co" in url:
             url = url.replace("?download=true", "")
@@ -184,18 +495,21 @@ def get_download_file(temp_dir, url, civitai_key, progress=gr.Progress(track_tqd
         if not new_file:
             print(f"Download failed: {url}")
             return ""
-        print(f"Download completed: {url}")
+        print(f"Download completed: {sanitize_url_for_log(url)}")
         return new_file
     except Exception as e:
-        print(f"Download failed: {url} {e}")
+        print(f"Download failed: {sanitize_url_for_log(url)} {format_error_short(e)}")
         return ""
 
 
 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)
+        retry_call(
+            lambda: 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),
+            action=f'snapshot_download {repo_id}'
+        )
         return True
     except Exception as e:
         print(f"Error: Failed to download {repo_id}. {e}")
@@ -208,8 +522,8 @@ def upload_repo(repo_id: str, dir_path: str, is_private: bool, is_pr: bool=False
     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)
-        api.upload_folder(repo_id=repo_id, folder_path=dir_path, path_in_repo="", create_pr=is_pr, token=hf_token)
+        ensure_repo(api, repo_id=repo_id, repo_type='model', is_private=is_private, hf_token=hf_token)
+        retry_call(lambda: api.upload_folder(repo_id=repo_id, folder_path=dir_path, path_in_repo="", create_pr=is_pr, token=hf_token), action=f'upload_folder {repo_id}')
         progress(1, desc="Uploaded.")
         return get_hf_url(repo_id, "model")
     except Exception as e:
@@ -240,16 +554,16 @@ def duplicate_hf_repo(src_repo: str, dst_repo: str, src_repo_type: str, dst_repo
         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)
+        ensure_repo(api, repo_id=dst_repo, repo_type=dst_repo_type, is_private=is_private, hf_token=hf_token)
+        for path in retry_call(lambda: api.list_repo_files(repo_id=src_repo, repo_type=src_repo_type, token=hf_token), action=f'list_repo_files {src_repo}'):
+            file = retry_call(lambda: hf_hub_download(repo_id=src_repo, filename=path, repo_type=src_repo_type, token=hf_token), action=f'hf_hub_download {src_repo}/{path}')
             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)
+                retry_call(lambda: 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), action=f'upload_folder {dst_repo}:{path}')
             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)
+                retry_call(lambda: 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), action=f'upload_file {dst_repo}:{path}')
             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)
@@ -276,7 +590,7 @@ def git_clone(url: str, path: str, pip: bool=False, addcmd: str=""): # requires
     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 not Path(p).exists(): return
     if pip:
         os.chdir(Path(BASE_DIR, path, p))
         cmd = f'pip install -r requirements.txt'