Update app.py

app.py

@@ -1,335 +1,547 @@
-# app.py — Atharium Batch Renderer (CPU, HF Spaces compatible)
-# UI & workflow: 2 tab (Prepare Batch, Monitor & Outputs)
-
-import os, io, json, time, threading, zipfile, glob, uuid
-from typing import Dict, Tuple, List, Any, Optional
+# app.py (patched 2025-08-21)
+# Ultimate Batch Rendering — stable UI + resilient worker
+# - Forced: SOLO + IDLE POSE + NO BACKGROUND (transparan)
+# - Optional: Faceless
+# - Solid UI/Workflow: Prepare Batch + Monitor & Outputs
+# - Background worker (resume-ish), Cancel, ZIP, Preview
+# - Gradio 4.x compatible (tanpa .style/.scale chaining)
+
+import os, io, json, time, uuid, glob, zipfile, threading, queue
+from datetime import datetime
+from typing import List, Tuple
 
 import gradio as gr
 import pandas as pd
-from PIL import Image
-import numpy as np
-
-from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
+from PIL import Image, ImageDraw, ImageFont
 
-# -------------------- Config --------------------
+APP_TITLE   = "Ultimate Batch Rendering"
 OUTPUT_ROOT = "outputs"
+ASSET_IDLE  = "assets/idle_pose.png"
 os.makedirs(OUTPUT_ROOT, exist_ok=True)
-
-MODEL_CHOICES = {
-    "DreamShaper 8 (SD1.5)": "Lykon/DreamShaper-8",
-    # Tambahin model lain kalau mau, tapi default tetap DS8
+os.makedirs("assets", exist_ok=True)
+
+# ---------------- Model catalog ----------------
+# Beberapa model komunitas TIDAK selalu tersedia dalam format diffusers.
+# Kita siapkan kandidat repo (prioritas kiri ke kanan). Yang tidak bisa diload akan otomatis di-skip.
+MODEL_CANDIDATES = {
+    "Stable Diffusion 1.5": ["runwayml/stable-diffusion-v1-5"],
+    "DreamShaper 8": ["Lykon/DreamShaper-8"],
+    "Counterfeit": ["gsdf/Counterfeit-V3.0", "gsdf/Counterfeit-V2.5"],
+    "PastelMix": [
+        # Kandidat umum — jika tidak tersedia diffusers, akan auto-skip
+        "andite/pastel-mix", "stablediffusionapi/pastel-mix"
+    ],
+    "ReVAnimated": [
+        "stablediffusionapi/rev-animated",  # sering ckpt-only; jika gagal akan skip
+        "xyn-ai/RevAnimated"                # placeholder kandidat; auto-skip jika tak ada
+    ],
+    "EimisAnime": [
+        "eimiss/EimisAnimeDiffusion_1",     # jika tidak ada, auto-skip
+        "eimiss/EimisAnimeDiffusion"        # kandidat alternatif
+    ],
+    # Tetap sediakan Anything v4.5 (anime aman)
+    "Anything v4.5": ["andite/anything-v4.5"],
 }
 
-# “Booster” agar single character + idle + faceless + bg polos (chroma green)
-POSITIVE_FORCE = (
-    "full body solo character, 1 person, single subject, centered, "
-    "idle stance, neutral pose, arms relaxed by sides, front view, symmetrical, "
-    "studio shot, high detail outfit and gear, "
-    "solid chroma key green background, evenly lit, no shadows on background, "
-    "featureless face, masked face or visor or helmet, minimal facial details"
-)
-
-NEGATIVE_FORCE = (
-    "multiple people, group, crowd, extra arms, extra legs, extra heads, "
-    "deformed, mutated, distorted anatomy, blurry, lowres, low quality, "
-    "busy background, scenery, environment, props, "
-    "profile view, dynamic action pose, crouching, jumping, running, "
-    "text, watermark, logo, frame, border"
-)
-
-# -------------------- Globals --------------------
-JOBS: Dict[str, Dict[str, Any]] = {}
-PIPE_CACHE: Dict[str, StableDiffusionPipeline] = {}
-LOCK = threading.Lock()
-
-# -------------------- Utils --------------------
-def _namedfile_to_path(x) -> Optional[str]:
-    if x is None:
-        return None
-    # Gradio dapat mengirim str path / UploadFile-like / NamedString
-    if isinstance(x, str):
-        return x
-    # gradio.types.NamedString / TemporaryFileWrapper: punya .name
-    name = getattr(x, "name", None)
-    if isinstance(name, str):
-        return name
-    return None
-
-def _ensure_pipe(model_id: str) -> StableDiffusionPipeline:
-    if model_id in PIPE_CACHE:
-        return PIPE_CACHE[model_id]
-    # CPU pipeline
-    pipe = StableDiffusionPipeline.from_pretrained(
-        model_id,
-        safety_checker=None,      # kita enforce via prompt saja; jangan expose konten publik eksplisit
-        torch_dtype=None          # CPU → float32
-    )
-    pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
-    pipe.enable_attention_slicing()
-    if hasattr(pipe, "enable_vae_slicing"):
-        pipe.enable_vae_slicing()
-    PIPE_CACHE[model_id] = pipe
-    return pipe
-
-def _chroma_green_to_alpha(img: Image.Image) -> Image.Image:
-    """Ganti background hijau-chroma menjadi transparan (alpha)."""
-    img = img.convert("RGBA")
-    a = np.array(img)
-    r, g, b = a[:, :, 0].astype(np.int32), a[:, :, 1].astype(np.int32), a[:, :, 2].astype(np.int32)
-    # deteksi 'hijau kuat' dengan toleransi
-    green_mask = (g > 120) & (g > r + 30) & (g > b + 30)
-    # perluas sedikit agar tepi bersih
-    from scipy.ndimage import binary_dilation  # tersedia di HF cpu image
-    green_mask = binary_dilation(green_mask, iterations=1)
-    a[:, :, 3] = np.where(green_mask, 0, 255).astype(np.uint8)
-    return Image.fromarray(a, mode="RGBA")
-
-def _save_json(path: str, obj: Any):
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(obj, f, ensure_ascii=False, indent=2)
-
-def _zip_folder(folder: str, zip_path: str):
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as z:
-        for p in sorted(glob.glob(os.path.join(folder, "*"))):
-            z.write(p, os.path.basename(p))
-
-def _read_table(path: str, sheet: Optional[str]) -> pd.DataFrame:
-    if path.lower().endswith(".csv"):
-        df = pd.read_csv(path)
-    else:
-        df = pd.read_excel(path, sheet_name=sheet if sheet else 0)
-    # normalisasi kolom
-    cols = {c.strip(): c for c in df.columns}
-    need = "FinalPrompt"
-    if need not in cols and need not in df.columns:
-        # fallback: gabung kolom-kolom umum (Name, Tier, Faction, Region, Role, Lore, Prompt, Style)
-        parts = []
-        for c in ["Name","Tier","Faction","Region","Role","Lore","Prompt","Style"]:
-            if c in df.columns:
-                parts.append(df[c].astype(str))
-        if parts:
-            df["FinalPrompt"] = ((" | ").join([f"{{{c}}}" for c in ["Name","Tier","Faction","Region","Role","Lore","Prompt","Style"] if c in df.columns]))
-            df["FinalPrompt"] = pd.Series([" | ".join([str(r.get(c,"")) for c in ["Name","Tier","Faction","Region","Role","Lore","Prompt","Style"] if c in df.index]) for _, r in df.iterrows()])
-        else:
-            raise ValueError("Tidak menemukan kolom 'FinalPrompt' dan kolom-kolom sumber.")
-    return df
+# UI dropdown default
+MODEL_DEFAULT = "DreamShaper 8"
 
-def _mk_job(status="queued") -> str:
-    job_id = f"job-{int(time.time())}-{uuid.uuid4().hex[:8]}"
-    job_dir = os.path.join(OUTPUT_ROOT, job_id)
-    os.makedirs(job_dir, exist_ok=True)
-    with LOCK:
-        JOBS[job_id] = dict(
-            id=job_id, dir=job_dir, status=status,
-            total=0, done=0, last="", error="",
-            started=time.time(), model="", zip_path=""
-        )
-    return job_id
-
-def job_status(job_id: str) -> Tuple[Tuple[str, str, str, str], List[str]]:
-    with LOCK:
-        info = JOBS.get(job_id)
-    if not info:
-        return (("unknown","0/0","","Job not found"), [] )
-    # thumbnails
-    pngs = sorted(glob.glob(os.path.join(info["dir"], "*_img.png")))
-    thumbs = pngs[-18:]  # ambil terakhir untuk preview
-    stat = (
-        info["status"],
-        f"{info['done']}/{info['total']}",
-        info["last"],
-        info.get("error",""),
-    )
-    return stat, thumbs
+# ---------------- utils ----------------
+def _safe_int(x, dv=0):
+    try: return int(x)
+    except: return dv
+
+def _safe_float(x, dv=7.5):
+    try: return float(x)
+    except: return dv
 
-# -------------------- Worker --------------------
-def _render_job(job_id: str, model_id: str, steps: int, guidance: float, w: int, h: int,
-                seed_base: int, df: pd.DataFrame):
+def _save_json(fp, data):
+    tmp = fp + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+    os.replace(tmp, fp)
+
+def _read_json(fp, dv=None):
+    try:
+        with open(fp, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except:
+        return dv
+
+def _read_excel(fileobj, sheet_name):
+    try:
+        if hasattr(fileobj, "read"):
+            data = fileobj.read()
+        else:
+            path = getattr(fileobj, "name", None) or str(fileobj)
+            with open(path, "rb") as f:
+                data = f.read()
+        return pd.read_excel(io.BytesIO(data), sheet_name=sheet_name if sheet_name != "" else 0)
+    except Exception as e:
+        raise gr.Error(f"Gagal membaca Excel: {e}")
+
+def _wrap_text(s, draw, font, maxw):
+    words = s.split()
+    line, out = "", []
+    for w in words:
+        test = (line+" "+w).strip()
+        if draw.textlength(test, font=font) > maxw and line:
+            out.append(line); line = w
+        else:
+            line = test
+    if line: out.append(line)
+    return out
+
+def _dummy_image(text, size=(768,1024), transparent=False):
+    mode = "RGBA" if transparent else "RGB"
+    bg   = (0,0,0,0) if transparent else (242,242,242)
+    img  = Image.new(mode, size, bg)
+    d    = ImageDraw.Draw(img)
     try:
-        pipe = _ensure_pipe(model_id)
-        with LOCK:
-            JOBS[job_id]["model"] = model_id
-            JOBS[job_id]["status"] = "running"
-            JOBS[job_id]["total"] = len(df)
-
-        rng = np.random.RandomState(seed_base if seed_base else None)
-        for idx, row in df.iterrows():
-            with LOCK:
-                if JOBS[job_id].get("status") == "canceled":
-                    break
-
-            base_prompt = str(row.get("FinalPrompt","")).strip()
-            user_neg = str(row.get("Negative","")).strip()
-            prompt = f"{base_prompt}, {POSITIVE_FORCE}"
-            negative = f"{NEGATIVE_FORCE}"
-            if user_neg:
-                negative = f"{negative}, {user_neg}"
-
-            # seed per baris
-            seed = int(seed_base + idx) if seed_base else int(rng.randint(0, 2**31-1))
+        font = ImageFont.truetype("DejaVuSans.ttf", 22)
+    except:
+        font = ImageFont.load_default()
+    margin, y = 20, 20
+    for line in _wrap_text(text, d, font, size[0]-2*margin):
+        d.text((margin,y), line, fill=(30,30,30,255), font=font)
+        y += 26
+        if y > size[1]-40: break
+    footer = "[SOLO • IDLE • TRANSPARENT BG]"
+    d.text((margin, size[1]-30), footer, fill=(90,90,90,255), font=font)
+    return img
+
+# ---------------- diffusers (optional) ----------------
+_PIPE_CACHE = {}
+_PIPE_LOCK  = threading.Lock()
+
+def _resolve_repo(model_key: str) -> str:
+    """Ambil repo pertama yang berhasil di-load; jika semua gagal, fallback ke SD1.5."""
+    candidates = MODEL_CANDIDATES.get(model_key, []) or MODEL_CANDIDATES["Stable Diffusion 1.5"]
+    # Cek cache yang pernah sukses
+    for rid in candidates:
+        if ("ok_repo", rid) in _PIPE_CACHE:
+            return rid
+    # Kalau belum ada, coba satu-satu secara ringan via from_pretrained (ditangani di _get_pipe)
+    return candidates[0]
+
+def _get_pipe(model_key: str, device="cpu"):
+    # pilih repo kandidat
+    repo_id = _resolve_repo(model_key)
+    with _PIPE_LOCK:
+        key = (repo_id, device)
+        if key in _PIPE_CACHE:
+            return _PIPE_CACHE[key]
+
+        # coba load diffusers; jika gagal, fallback try kandidat lain; terakhir fallback SD1.5
+        try:
+            from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
+            import torch
+        except Exception:
+            # diffusers tidak tersedia → pakai dummy
+            return None
+
+        candidates = MODEL_CANDIDATES.get(model_key, []) or MODEL_CANDIDATES["Stable Diffusion 1.5"]
+        tried = []
+        for rid in candidates + MODEL_CANDIDATES["Stable Diffusion 1.5"]:
+            if rid in tried:  # hindari duplikat
+                continue
+            tried.append(rid)
+            try:
+                pipe = StableDiffusionPipeline.from_pretrained(
+                    rid,
+                    torch_dtype=torch.float16 if device.startswith("cuda") else torch.float32,
+                    safety_checker=None,
+                )
+                # scheduler yang cepat & stabil
+                try:
+                    pipe.scheduler = DPMSolverMultistepScheduler.from_config(
+                        pipe.scheduler.config, use_karras_sigmas=True
+                    )
+                except Exception:
+                    pass
+                pipe.enable_attention_slicing()
+                pipe = pipe.to(device)
+                _PIPE_CACHE[key] = pipe
+                _PIPE_CACHE[("ok_repo", rid)] = True  # tandai repo sukses
+                return pipe
+            except Exception:
+                continue
+
+        # semua gagal
+        return None
 
+def _to_transparent_best_effort(img: Image.Image) -> Image.Image:
+    """
+    Usaha terbaik bikin BG transparan.
+    1) Jika rembg tersedia, pakai rembg.
+    2) Jika tidak, chroma-key corner (warna dominan di (0,0)).
+    """
+    try:
+        from rembg import remove as rembg_remove
+        arr = rembg_remove(img.convert("RGBA"))
+        if isinstance(arr, bytes):
+            from io import BytesIO
+            return Image.open(BytesIO(arr))
+        return Image.open(arr.fp)
+    except Exception:
+        pass
+
+    # Fallback: chroma key corner
+    img = img.convert("RGBA")
+    corner = img.getpixel((0,0))[:3]
+    px = img.getdata()
+    new = []
+    thr = 6
+    for r,g,b,a in px:
+        if abs(r-corner[0])<thr and abs(g-corner[1])<thr and abs(b-corner[2])<thr:
+            new.append((0,0,0,0))
+        else:
+            new.append((r,g,b,a))
+    img.putdata(new)
+    return img
+
+def _render_image(prompt, negative, w, h, steps, guidance, seed, model_key, faceless, device="cpu"):
+    """
+    Enforce:
+      - SOLO
+      - IDLE POSE
+      - TRANSPARENT BACKGROUND (selalu)
+    """
+    # Hints dipaksakan
+    pose_hint  = "solo, full body, idle stance, neutral standing, arms relaxed by sides, front view, symmetrical"
+    face_hint  = "featureless face, masked face, visor, minimal facial details" if faceless else ""
+    bg_hint    = "simple studio background"
+
+    # Final positive (dibatasi agar tidak over panjang token)
+    base_pieces = [prompt, pose_hint, bg_hint, face_hint]
+    final_p = ", ".join([p for p in base_pieces if p]).strip(", ")[:300]
+
+    # Negative — keras untuk cegah multi-person & cacat
+    base_neg = (
+        "(multiple people:1.4), two persons, group, crowd, duplicate, clone, "
+        "extra head, extra body, extra arms, extra legs, siamese, mutated, deformed, bad anatomy, bad hands, "
+        "text, watermark, logo, caption, frame, lowres, blurry"
+    )
+    if faceless:
+        base_neg += ", detailed face, realistic face, expressive face, eyes, nose, mouth, teeth, smile"
+    if negative:
+        base_neg += ", " + negative
+    neg_final = base_neg[:300]
+
+    # Coba diffusers
+    pipe = _get_pipe(model_key, device)
+    if pipe is not None:
+        try:
+            import torch
+            gen = None
+            if seed is not None and seed != -1:
+                gen = torch.Generator(device=device).manual_seed(int(seed))
             img = pipe(
-                prompt=prompt,
-                negative_prompt=negative,
+                prompt=final_p,
+                negative_prompt=neg_final,
+                width=int(w), height=int(h),
                 num_inference_steps=int(steps),
                 guidance_scale=float(guidance),
-                height=int(h),
-                width=int(w),
-                generator=None,
+                generator=gen
             ).images[0]
-
-            # chroma key → alpha
+            # Wajib transparan
+            img = _to_transparent_best_effort(img)
+            return img
+        except Exception as e:
+            # jatuh ke dummy
+            pass
+
+    # Dummy fallback jika pipeline gagal
+    return _dummy_image(final_p, size=(int(w), int(h)), transparent=True)
+
+# ---------------- background worker ----------------
+class Worker(threading.Thread):
+    def __init__(self):
+        super().__init__(daemon=True)
+        self.q = queue.Queue()
+        self._stop = threading.Event()
+
+    def submit(self, job_id): self.q.put(job_id)
+
+    def run(self):
+        while not self._stop.is_set():
             try:
-                img = _chroma_green_to_alpha(img)
-            except Exception:
-                pass
+                jid = self.q.get(timeout=0.5)
+            except queue.Empty:
+                # auto-resume ringan
+                for d in os.listdir(OUTPUT_ROOT):
+                    meta = _read_json(os.path.join(OUTPUT_ROOT,d,"job_meta.json"))
+                    if meta and meta.get("status")=="running" and not os.path.exists(os.path.join(OUTPUT_ROOT,d,"_busy.lock")):
+                        self.q.put(d)
+                continue
+            try:
+                self._run_job(jid)
+            except Exception as e:
+                _write_error(jid, f"Worker crash: {e}")
+            finally:
+                self.q.task_done()
+
+    def _run_job(self, job_id):
+        job_dir   = os.path.join(OUTPUT_ROOT, job_id)
+        meta_fp   = os.path.join(job_dir, "job_meta.json")
+        rows_fp   = os.path.join(job_dir, "rows.json")
+        params_fp = os.path.join(job_dir, "params.json")
+        cancel_fl = os.path.join(job_dir, "cancel.flag")
+        busy_fl   = os.path.join(job_dir, "_busy.lock")
+        open(busy_fl, "w").close()
+
+        meta   = _read_json(meta_fp, {})
+        params = _read_json(params_fp, {})
+        rows   = _read_json(rows_fp, [])
+
+        meta["status"] = "running"
+        meta["total"]  = len(rows)
+        _save_json(meta_fp, meta)
+
+        done_prefix = set(os.path.splitext(os.path.basename(p))[0].split("_")[0]
+                          for p in glob.glob(os.path.join(job_dir,"*.png")))
+
+        for i, r in enumerate(rows):
+            if os.path.exists(cancel_fl):
+                meta["status"] = "cancelled"; _save_json(meta_fp, meta); break
+
+            rid = int(r.get("_rid", i+1))
+            if str(rid) in done_prefix or f"{rid:0>5}" in done_prefix:
+                continue
+
+            # Ambil prompt/negative dari kolom
+            prompt_col = params.get("prompt_col","FinalPrompt")
+            prompt = str(r.get(prompt_col, "")).strip()
+            neg    = str(r.get(params.get("neg_col",""), "")).strip() if params.get("neg_col") else params.get("negative_prompt","")
+
+            img = _render_image(
+                prompt=prompt, negative=neg,
+                w=params.get("width",768), h=params.get("height",1024),
+                steps=params.get("steps",18), guidance=params.get("guidance",7.0),
+                seed=params.get("seed",-1),
+                model_key=params.get("model_key", MODEL_DEFAULT),
+                faceless=bool(params.get("faceless", True)),
+                device=params.get("device","cpu")
+            )
 
-            out_dir = JOBS[job_id]["dir"]
-            out_name = os.path.join(out_dir, f"{idx+1:05d}_img.png")
-            img.save(out_name)
+            fn = f"{rid:0>5}_img.png"; fp = os.path.join(job_dir, fn)
+            img.save(fp)
 
-            with LOCK:
-                JOBS[job_id]["done"] += 1
-                JOBS[job_id]["last"] = os.path.basename(out_name)
+            meta["done"] = len(glob.glob(os.path.join(job_dir,"*.png")))
+            meta["last_file"] = fn
+            meta["status"] = "running"
+            _save_json(meta_fp, meta)
 
-        with LOCK:
-            if JOBS[job_id]["status"] != "canceled":
-                JOBS[job_id]["status"] = "done"
+        if meta.get("status") == "running":
+            meta["status"] = "done"; _save_json(meta_fp, meta)
+        try: os.remove(busy_fl)
+        except: pass
 
-        # dump job meta
-        _save_json(os.path.join(JOBS[job_id]["dir"], "job.json"), JOBS[job_id])
+def _write_error(job_id, msg):
+    job_dir = os.path.join(OUTPUT_ROOT, job_id)
+    os.makedirs(job_dir, exist_ok=True)
+    with open(os.path.join(job_dir,"error.txt"),"a",encoding="utf-8") as f:
+        f.write(f"[{datetime.now().isoformat()}] {msg}\n")
+    meta_fp = os.path.join(job_dir,"job_meta.json")
+    meta = _read_json(meta_fp, {}) or {}
+    meta["status"]="error"; _save_json(meta_fp, meta)
+
+RUNNER = Worker(); RUNNER.start()
+
+# ---------------- job api ----------------
+def new_job_from_excel(xlsx, sheet_name, prompt_col, neg_col,
+                       model_key, steps, guidance, width, height,
+                       seed, negative_base, faceless, device):
+    if not xlsx: raise gr.Error("Upload Excel dulu.")
+    df = _read_excel(xlsx, sheet_name).copy()
+    if "_rid" not in df.columns:
+        df["_rid"] = list(range(1, len(df)+1))
+    rows = df.to_dict(orient="records")
+
+    job_id  = f"job-{int(time.time())}-{uuid.uuid4().hex[:8]}"
+    job_dir = os.path.join(OUTPUT_ROOT, job_id)
+    os.makedirs(job_dir, exist_ok=True)
 
-    except Exception as e:
-        with LOCK:
-            JOBS[job_id]["status"] = "error"
-            JOBS[job_id]["error"] = str(e)
-
-# -------------------- Gradio Callbacks --------------------
-def ui_start_batch(xlsx, sheet_name, model_key, steps, guidance, w, h, seed_base):
-    path = _namedfile_to_path(xlsx)
-    if not path or not os.path.exists(path):
-        return "File Excel/CSV tidak ditemukan.", ""
+    _save_json(os.path.join(job_dir,"rows.json"), rows)
+    _save_json(os.path.join(job_dir,"job_meta.json"), {
+        "job_id": job_id, "status":"queued", "created_at": datetime.now().isoformat(),
+        "total": len(rows), "done": 0, "last_file":""
+    })
+    _save_json(os.path.join(job_dir,"params.json"), {
+        "prompt_col": prompt_col or "FinalPrompt",
+        "neg_col": neg_col or "",
+        "model_key": model_key or MODEL_DEFAULT,
+        "steps": _safe_int(steps, 18), "guidance": _safe_float(guidance, 7.0),
+        "width": _safe_int(width, 768), "height": _safe_int(height, 1024),
+        "seed": _safe_int(seed, -1),
+        "negative_prompt": (negative_base or "").strip(),
+        # Forced no background → parameter transparent tidak dipakai (tetap transparan)
+        "faceless": bool(faceless),
+        "device": device or "cpu",
+    })
+
+    # simpan excel mentah (opsional)
     try:
-        df = _read_table(path, sheet_name)
-    except Exception as e:
-        return f"Read table error: {e}", ""
-
-    model_id = MODEL_CHOICES.get(model_key, list(MODEL_CHOICES.values())[0])
-    jid = _mk_job("queued")
-    th = threading.Thread(
-        target=_render_job,
-        args=(jid, model_id, steps, guidance, w, h, int(seed_base) if str(seed_base).strip() else 0, df),
-        daemon=True,
-    )
-    th.start()
-    return f"Job started: {jid}", jid
-
-def ui_cancel_batch(jid):
-    if not jid:
-        return "Isi JobID dulu."
-    with LOCK:
-        if jid in JOBS:
-            JOBS[jid]["status"] = "canceled"
-            return f"Job {jid} ditandai canceled."
-    return "Job tidak ditemukan."
-
-def ui_status(jid):
+        if hasattr(xlsx, "read"): raw = xlsx.read()
+        else:
+            path = getattr(xlsx, "name", None) or str(xlsx)
+            with open(path,"rb") as f: raw = f.read()
+        with open(os.path.join(job_dir,"source.xlsx"),"wb") as f: f.write(raw)
+    except: pass
+
+    RUNNER.submit(job_id)
+    return job_id, f"Job dibuat: {job_id}"
+
+def cancel_job(job_id):
+    if not job_id: return "Pilih Job dulu."
+    job_dir = os.path.join(OUTPUT_ROOT, job_id)
+    if not os.path.isdir(job_dir): return "Job tidak ditemukan."
+    open(os.path.join(job_dir,"cancel.flag"),"w").close()
+    return f"Cancel dikirim ke {job_id}"
+
+def make_zip(job_id):
+    if not job_id: raise gr.Error("Pilih Job dulu.")
+    job_dir = os.path.join(OUTPUT_ROOT, job_id)
+    if not os.path.isdir(job_dir): raise gr.Error("Job tidak ditemukan.")
+    zip_fp = os.path.join(job_dir, f"{job_id}.zip")
+    with zipfile.ZipFile(zip_fp, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for p in sorted(glob.glob(os.path.join(job_dir,"*.png"))):
+            zf.write(p, arcname=os.path.basename(p))
+    return zip_fp
+
+def list_jobs() -> List[str]:
+    res=[]
+    for d in sorted(os.listdir(OUTPUT_ROOT)):
+        jp = os.path.join(OUTPUT_ROOT, d, "job_meta.json")
+        if os.path.exists(jp): res.append(d)
+    return res
+
+def job_status(job_id):
+    """Return (stat, thumbs). stat=(status, 'done/total', last_file, err)"""
+    if not job_id:
+        return ("unknown", "0/0", "", ""), []
+    job_dir = os.path.join(OUTPUT_ROOT, job_id)
+    if not os.path.isdir(job_dir):
+        return ("unknown", "0/0", "", "job folder not found"), []
+    meta = _read_json(os.path.join(job_dir,"job_meta.json"), {}) or {}
+    status = meta.get("status","unknown")
+    total  = int(meta.get("total", 0))
+    done   = int(meta.get("done", 0))
+    lastf  = meta.get("last_file","")
+    err    = ""
+    err_fp = os.path.join(job_dir,"error.txt")
+    if os.path.exists(err_fp):
+        try:
+            err = open(err_fp,"r",encoding="utf-8").read().strip()[-900:]
+            if err and status not in ("done","cancelled"): status="error"
+        except: pass
+
+    pngs = sorted(glob.glob(os.path.join(job_dir,"*.png")))
+    if pngs:
+        done  = len(pngs)
+        lastf = os.path.basename(pngs[-1])
+
+    thumbs = [(p, os.path.basename(p)) for p in pngs[-120:]]
+    return (status, f"{done}/{total}", lastf, err), thumbs
+
+# ---------------- UI helpers ----------------
+def _ui_status(jid: str):
     stat, thumbs = job_status(jid)
-    s, dt, lastf, err = stat
-    return s, dt, lastf, err, thumbs
+    try:
+        s, d, l, e = stat
+    except Exception:
+        s, d, l, e = "unknown", "0/0", "", "invalid stat"
+    return s, d, l, e, thumbs
+
+def _refresh_job_list():
+    jobs = list_jobs()
+    val = jobs[-1] if jobs else None
+    return gr.Dropdown(choices=jobs, value=val)
+
+def _browse(jid: str):
+    if not jid: return []
+    return job_status(jid)[1]
+
+# ---------------- UI ----------------
+with gr.Blocks(title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+
+    with gr.Tabs():
+        with gr.Tab("1) Prepare Batch"):
+            with gr.Row():
+                xlsx_in   = gr.File(label="Excel (wajib kolom FinalPrompt)", file_count="single", file_types=[".xlsx",".xls"])
+                sheet_tb  = gr.Textbox(label="Sheet name (kosongkan=sheet pertama)", value="")
+            with gr.Row():
+                prompt_col_tb = gr.Textbox(label="Kolom Prompt (default=FinalPrompt)", value="FinalPrompt")
+                neg_col_tb    = gr.Textbox(label="Kolom Negative (opsional)", value="")
+            with gr.Row():
+                model_dd  = gr.Dropdown(label="Model", choices=list(MODEL_CANDIDATES.keys()), value=MODEL_DEFAULT)
+                device_dd = gr.Dropdown(label="Device", choices=["cpu","cuda"], value="cpu")
+                steps_sl  = gr.Slider(10, 50, value=18, step=1, label="Steps")
+                guid_sl   = gr.Slider(1.0, 15.0, value=7.0, step=0.5, label="Guidance")
+            with gr.Row():
+                w_nb = gr.Number(label="Width",  value=768, precision=0)
+                h_nb = gr.Number(label="Height", value=1024, precision=0)
+                seed_nb = gr.Number(label="Seed (-1=random per row)", value=-1, precision=0)
+            with gr.Row():
+                # Checkbox transparan ditampilkan agar UI tetap sama, tapi akan diabaikan (forced transparan)
+                transp_cb  = gr.Checkbox(label="Transparent background (forced ON)", value=True, interactive=False)
+                faceless_cb= gr.Checkbox(label="Faceless (disarankan)", value=True)
+            neg_tb = gr.Textbox(label="Negative Prompt dasar (bila kolom Negative kosong)",
+                                value="lowres, blurry, deformed, bad anatomy, extra limbs, watermark, logo, text")
 
-def ui_zip(jid):
-    if not jid:
-        return None
-    with LOCK:
-        info = JOBS.get(jid)
-    if not info:
-        return None
-    folder = info["dir"]
-    zip_path = os.path.join(folder, f"{jid}.zip")
-    _zip_folder(folder, zip_path)
-    with LOCK:
-        JOBS[jid]["zip_path"] = zip_path
-    return zip_path
-
-def ui_browse_job(jid):
-    if not jid:
-        return []
-    with LOCK:
-        info = JOBS.get(jid)
-    if not info:
-        return []
-    return sorted(glob.glob(os.path.join(info["dir"], "*_img.png")))
-
-# -------------------- UI --------------------
-with gr.Blocks(title="Atharium Batch Renderer") as demo:
-    gr.Markdown("## 🧪 Atharium Batch Renderer (CPU)")
-
-    with gr.Tab("1) Prepare Batch"):
-        with gr.Group():
-            xlsx = gr.File(label="Excel/CSV (wajib kolom: FinalPrompt; opsional: Negative)")
-            sheet_name = gr.Textbox(label="Sheet name (kosongkan untuk sheet pertama)")
             with gr.Row():
-                model = gr.Dropdown(choices=list(MODEL_CHOICES.keys()), value="DreamShaper 8 (SD1.5)", label="Model")
-                steps = gr.Slider(5, 30, value=18, step=1, label="Steps (CPU optimal)")
-                guidance = gr.Slider(3, 12, value=6.5, step=0.1, label="Guidance")
+                start_btn = gr.Button("Start Batch", variant="primary")
+                job_created_md = gr.Markdown()
+
+            gr.Markdown("**Idle Pose Guide (optional)** — letakkan file `assets/idle_pose.png`.")
+            gr.Image(value=ASSET_IDLE if os.path.exists(ASSET_IDLE) else None, label="Idle reference", interactive=False)
+
+        with gr.Tab("2) Monitor & Outputs"):
             with gr.Row():
-                w = gr.Slider(512, 768, value=640, step=64, label="Width")
-                h = gr.Slider(512, 768, value=640, step=64, label="Height")
-                seed_base = gr.Number(value=0, precision=0, label="Seed base (0=random)")
-
-            start_btn = gr.Button("Start Batch", variant="primary")
-            start_msg = gr.Markdown()
-            job_id_tb = gr.Textbox(label="Current Job ID", interactive=False)
-
-            def _start(*args):
-                msg, jid = ui_start_batch(*args)
-                return msg, jid
-            start_btn.click(
-                fn=_start,
-                inputs=[xlsx, sheet_name, model, steps, guidance, w, h, seed_base],
-                outputs=[start_msg, job_id_tb],
-                show_progress=False
-            )
+                job_id_dd = gr.Dropdown(label="Pilih Job", choices=list_jobs(), value=None, allow_custom_value=False)
+                refresh_jobs_btn = gr.Button("Refresh daftar Job")
+                cancel_btn = gr.Button("Cancel Batch", variant="stop")
+                zip_btn    = gr.Button("Create ZIP")
+            with gr.Row():
+                st_out  = gr.Textbox(label="Status", interactive=False)
+                dn_out  = gr.Textbox(label="Done/Total", interactive=False)
+                last_out= gr.Textbox(label="Last file", interactive=False)
+            err_out = gr.Textbox(label="Error (jika ada)", interactive=False)
+            gallery = gr.Gallery(label="Browse Outputs")
+            browse_btn = gr.Button("Refresh Preview")
+            zip_file = gr.File(label="ZIP (download)")
+
+    # ---- events
+    def _start(xlsx, sheet, pcol, ncol, model_key, device, steps, guide, w, h, seed, neg, _transp_forced, faceless):
+        # transparan selalu dipaksa ON; parameter _transp_forced hanya untuk kompat UI
+        jid, msg = new_job_from_excel(
+            xlsx, sheet, pcol, ncol,
+            model_key, steps, guide, int(w), int(h),
+            int(seed), neg, bool(faceless), device
+        )
+        return msg, gr.Dropdown(choices=list_jobs(), value=jid)
+
+    start_btn.click(
+        _start,
+        inputs=[xlsx_in, sheet_tb, prompt_col_tb, neg_col_tb, model_dd, device_dd, steps_sl, guid_sl,
+                w_nb, h_nb, seed_nb, neg_tb, transp_cb, faceless_cb],
+        outputs=[job_created_md, job_id_dd]
+    )
+
+    refresh_jobs_btn.click(_refresh_job_list, outputs=job_id_dd)
+    cancel_btn.click(cancel_job, inputs=job_id_dd, outputs=err_out)
+    zip_btn.click(make_zip, inputs=job_id_dd, outputs=zip_file)
+
+    def _status_once(jid):
+        if not jid:
+            return "idle", "0/0", "", "", []
+        return _ui_status(jid)
+
+    browse_btn.click(lambda jid: _browse(jid) if jid else [], inputs=job_id_dd, outputs=gallery)
+    browse_btn.click(_status_once, inputs=job_id_dd, outputs=[st_out, dn_out, last_out, err_out, gallery])
+    job_id_dd.change(_status_once, inputs=job_id_dd, outputs=[st_out, dn_out, last_out, err_out, gallery])
 
-    with gr.Tab("2) Monitor & Outputs"):
-        with gr.Row():
-            sel_job = gr.Textbox(label="JobID")
-            cancel_btn = gr.Button("Cancel Batch", variant="stop")
-            zip_btn = gr.Button("Create ZIP")
-
-        with gr.Row():
-            stat_status = gr.Textbox(label="Status")
-            stat_done = gr.Textbox(label="Done/Total")
-            stat_last = gr.Textbox(label="Last file")
-        stat_err = gr.Textbox(label="Error (jika ada)")
-
-        preview = gr.Gallery(label="Browse Outputs")
-        refresh_btn = gr.Button("Refresh Preview")
-
-        zip_file = gr.File(label="ZIP file (download)")
-
-        # events
-        def _cancel(jid):
-            return ui_cancel_batch(jid)
-        cancel_btn.click(fn=_cancel, inputs=[sel_job], outputs=[stat_err], show_progress=False)
-
-        def _status_once(jid):
-            s, dt, lf, err, thumbs = ui_status(jid)
-            return s, dt, lf, err, thumbs
-        refresh_btn.click(fn=_status_once, inputs=[sel_job],
-                          outputs=[stat_status, stat_done, stat_last, stat_err, preview],
-                          show_progress=False)
-
-        def _make_zip(jid):
-            return ui_zip(jid)
-        zip_btn.click(fn=_make_zip, inputs=[sel_job], outputs=[zip_file], show_progress=False)
-
-        # juga update otomatis saat JobID diisi
-        sel_job.change(fn=_status_once, inputs=[sel_job],
-                       outputs=[stat_status, stat_done, stat_last, stat_err, preview],
-                       show_progress=False)
-
-# Peluncuran (queue tanpa argumen aneh supaya kompatibel Gradio lama)
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)
+    # ssr_mode=False untuk menghindari glitch di beberapa versi Gradio
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, show_error=True, ssr_mode=False)