Upload folder using huggingface_hub

app.py

@@ -0,0 +1,157 @@
+import os, re, json, shutil, tempfile
+from typing import Dict, Any, List, Optional, Tuple
+import requests
+import gradio as gr
+
+try:
+    from huggingface_hub import HfApi, create_repo, upload_folder, whoami
+except Exception as e:
+    HfApi = None  # Will error at runtime with a clear message
+
+CIVITAI_API_TOKEN = os.getenv("CIVITAI_API_TOKEN", "").strip()
+COOKIE_INFO       = os.getenv("COOKIE_INFO", "").strip()
+
+BASE_MODEL_MAP: Dict[str, str] = {
+    "sd 1.4": "CompVis/stable-diffusion-v1-4",
+    "sd 1.5": "runwayml/stable-diffusion-v1-5",
+    "sd 2.1": "stabilityai/stable-diffusion-2-1",
+    "sdxl": "stabilityai/stable-diffusion-xl-base-1.0",
+    "sdxl 1.0": "stabilityai/stable-diffusion-xl-base-1.0",
+    "flux.1 dev": "black-forest-labs/FLUX.1-dev",
+    "flux.1 schnell": "black-forest-labs/FLUX.1-schnell",
+    "flux": "black-forest-labs/FLUX.1-dev",
+}
+
+LICENSE_ALLOWLIST = {
+    "cc0-1.0", "cc0", "mit", "apache-2.0", "bsd-3-clause", "bsd-2-clause",
+    "openrail", "openrail+", "openrail++", "bigscience-openrail-m",
+}
+
+def _slugify(s: str, maxlen: int = 64) -> str:
+    s = s.strip().lower()
+    s = re.sub(r"[^a-z0-9\-_]+", "-", s)
+    s = re.sub(r"-{2,}", "-", s).strip("-")
+    if not s:
+        s = "model"
+    return s[:maxlen]
+
+def http_get(url: str, stream: bool = False):
+    headers = {"User-Agent": "HF-Space-CivitAI-Importer/1.0"}
+    if COOKIE_INFO:
+        headers["Cookie"] = COOKIE_INFO
+    if CIVITAI_API_TOKEN:
+        headers["Authorization"] = f"Bearer {CIVITAI_API_TOKEN}"
+    resp = requests.get(url, headers=headers, stream=stream, timeout=60)
+    resp.raise_for_status()
+    return resp
+
+def parse_civitai_model_id(url: str) -> Optional[str]:
+    m = re.search(r"civitai\.com/(?:models|api/v1/models)/(\d+)", url)
+    return m.group(1) if m else None
+
+def fetch_civitai_model_json(url: str) -> Dict[str, Any]:
+    mid = parse_civitai_model_id(url)
+    if not mid:
+        raise gr.Error("Invalid CivitAI model URL.")
+    api_url = f"https://civitai.com/api/v1/models/{mid}"
+    return http_get(api_url).json()
+
+def detect_nsfw(model_json: Dict[str, Any]) -> bool:
+    try:
+        if model_json.get("nsfw", False):
+            return True
+        if int(model_json.get("nsfwLevel") or 0) != 0:
+            return True
+        for mv in model_json.get("modelVersions", []):
+            if int(mv.get("nsfwLevel") or 0) != 0:
+                return True
+            for im in mv.get("images", []):
+                if int(im.get("nsfwLevel") or 0) != 0:
+                    return True
+        return False
+    except Exception:
+        return True
+
+def guess_base_model(model_json: Dict[str, Any]) -> Tuple[str, bool]:
+    base = ""
+    is_video = False
+    if "modelVersions" in model_json and model_json["modelVersions"]:
+        mv0 = model_json["modelVersions"][0]
+        base = (mv0.get("baseModel") or "").strip().lower()
+        is_video = "video" in base or "hunyuan" in base or "wan" in base
+    hf = BASE_MODEL_MAP.get(base, "stabilityai/stable-diffusion-xl-base-1.0")
+    return hf, is_video
+
+def pick_primary_weight(model_json: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    candidates = []
+    for mv in model_json.get("modelVersions", []):
+        for f in mv.get("files", []):
+            url = f.get("downloadUrl") or f.get("url") or ""
+            if url.endswith(".safetensors"):
+                size = int(f.get("sizeKB", 0))
+                candidates.append((size, f))
+    if not candidates:
+        return None
+    candidates.sort(key=lambda x: x[0], reverse=True)
+    return candidates[0][1]
+
+def download_file(url: str, dest: str):
+    r = http_get(url, stream=True)
+    with open(dest, "wb") as f:
+        for chunk in r.iter_content(chunk_size=1024 * 512):
+            if chunk: f.write(chunk)
+
+def collect_previews(model_json: Dict[str, Any], dest_dir: str, max_items=6) -> List[str]:
+    paths = []
+    count = 0
+    for mv in model_json.get("modelVersions", []):
+        for im in mv.get("images", []):
+            if count >= max_items: break
+            url = im.get("url") or im.get("urlSmall") or ""
+            if not url: continue
+            ext = os.path.splitext(url.split("?")[0])[1] or ".jpg"
+            name = f"preview_{count+1}{ext}"
+            p = os.path.join(dest_dir, name)
+            try:
+                download_file(url, p)
+                paths.append(p); count += 1
+            except: continue
+        if count >= max_items: break
+    return paths
+
+def extract_trained_words(model_json: Dict[str, Any]) -> List[str]:
+    words = []
+    for mv in model_json.get("modelVersions", []):
+        for w in (mv.get("trainedWords") or []):
+            if isinstance(w, str) and w.strip():
+                words.append(w.strip())
+    return list(dict.fromkeys(words))
+
+def build_readme(out_dir: str, repo_name: str, model_json: Dict[str, Any],
+                 hf_base_model: str, is_video: bool, is_nsfw: bool,
+                 weight_filename: Optional[str], previews: List[str]) -> None:
+    name = model_json.get("name") or f"CivitAI-{model_json.get('id','model')}"
+    trained_words = extract_trained_words(model_json)
+
+    tags = ["lora","diffusers"]
+    if is_video: tags.append("video")
+    else: tags += ["text-to-image","stable-diffusion","template:sd-lora"]
+    if is_nsfw: tags.append("not-for-all-audiences")
+
+    yaml_header = f"""---
+tags:
+  - {'\n  - '.join(sorted(set(tags)))}
+base_model: {hf_base_model}
+instance_prompt: {trained_words[0] if trained_words else ''}
+---
+"""
+
+    diffusers_md = f"""
+```py
+from diffusers import AutoPipelineForText2Image
+import torch
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+pipe = AutoPipelineForText2Image.from_pretrained("{hf_base_model}").to(device)
+pipe.load_lora_weights("{repo_name}", weight_name="{weight_filename or 'your_lora.safetensors'}")
+image = pipe("{trained_words[0] if trained_words else 'A sample prompt'}").images[0]

requirements.txt

@@ -0,0 +1,5 @@
+python-slugify
+selenium
+webdriver-manager
+huggingface-hub==0.22.2
+beautifulsoup4