Delete app.py

app.py

@@ -1,158 +0,0 @@
-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]
-"""