Update app.py

app.py

@@ -17,6 +17,12 @@ from PIL import Image
 import torch
 from transformers import LlavaForConditionalGeneration, AutoProcessor
 
+# Optional deps for import/export (we handle gracefully if missing)
+try:
+    import pandas as pd
+except Exception:
+    pd = None
+
 # Hugging Face Spaces GPU decorator (no-op locally)
 try:
     import spaces
@@ -30,7 +36,9 @@ except Exception:
 # ------------------------------
 APP_DIR = os.getcwd()
 SESSION_FILE = "/tmp/forge_session.json"
-SETTINGS_FILE = "/tmp/forge_settings.json"
+CONFIG_DIR = os.path.expanduser("~/.cache/forgecaptions")
+os.makedirs(CONFIG_DIR, exist_ok=True)
+SETTINGS_FILE = os.path.join(CONFIG_DIR, "settings.json")
 JOURNAL_FILE = "/tmp/forge_journal.json"
 
 # IMPORTANT: keep caches in /tmp so Gradio will serve files safely
@@ -138,8 +146,8 @@ CAPTION_TYPE_MAP: Dict[str, str] = {
 EXTRA_CHOICES = [
     "Do NOT include information about people/characters that cannot be changed (like ethnicity, gender, etc), but do still include changeable attributes (like hair style).",
     "IGNORE all information about watermarks.",
-    "Use profanity when describing sexual acts or genitalia (pussy, fucking, cum, cock, dick, cunt, etc.)",   #You do NOT have permission to remove
-    "Be sexually graphic and highly detailed.",         #You do NOT have permission to remove
+    "Use profanity when describing sexual acts or genitalia (pussy, fucking, cum, cock, dick, cunt, etc.)",   # You do NOT have permission to remove
+    "Be sexually graphic and highly detailed.",         # You do NOT have permission to remove
     "Do NOT use any ambiguous language.",
     "ONLY describe the most important elements of the image.",
     "Include information about the ages of any people/characters when applicable.",
@@ -177,12 +185,15 @@ def save_settings(cfg: dict):
         json.dump(cfg, f, ensure_ascii=False, indent=2)
 
 def load_settings() -> dict:
+    cfg = {}
     if os.path.exists(SETTINGS_FILE):
-        with open(SETTINGS_FILE, "r", encoding="utf-8") as f:
-            cfg = json.load(f)
-    else:
-        cfg = {}
-    # defaults
+        try:
+            with open(SETTINGS_FILE, "r", encoding="utf-8") as f:
+                cfg = json.load(f) or {}
+        except Exception:
+            cfg = {}
+
+    # Defaults (add whatever else your app uses)
     defaults = {
         "dataset_name": "forgecaptions",
         "temperature": 0.6,
@@ -198,17 +209,26 @@ def load_settings() -> dict:
         "shape_aliases_enabled": True,
         "shape_aliases": [],
         "excel_thumb_px": 128,
-        # header controls
         "logo_auto": True,
         "logo_px": 180,
         "logo_scale": 1.0,
+        # NEW: persist flag for aliases
+        "shape_aliases_persist": True,
     }
+
+    # Merge defaults without overwriting existing values
     for k, v in defaults.items():
         cfg.setdefault(k, v)
+
+    # Normalize styles to a valid list
     styles = cfg.get("styles") or []
-    cfg["styles"] = [s for s in (styles if isinstance(styles, list) else [styles]) if s in STYLE_OPTIONS] or ["Character training (long)"]
+    if not isinstance(styles, list):
+        styles = [styles]
+    cfg["styles"] = [s for s in styles if s in STYLE_OPTIONS] or ["Character training (long)"]
+
     return cfg
 
+
 def save_journal(data: dict):
     with open(JOURNAL_FILE, "w", encoding="utf-8") as f:
         json.dump(data, f, ensure_ascii=False, indent=2)
@@ -223,26 +243,6 @@ def load_journal() -> dict:
 # ------------------------------
 # 5) Small utilities (thumbs, resize, prefix/suffix, names)
 # ------------------------------
-# put near your other small utils
-def _normalize_table_value(table_value):
-    """Return a list-of-lists no matter what Gradio gives us."""
-    if table_value is None:
-        return []
-    # handle pandas.DataFrame without importing pandas explicitly
-    if hasattr(table_value, "to_dict") and hasattr(table_value, "values"):
-        try:
-            return table_value.reset_index(drop=True).values.tolist()
-        except Exception:
-            try:
-                return table_value.values.tolist()
-            except Exception:
-                return []
-    # sometimes Gradio hands a dict with "data"
-    if isinstance(table_value, dict) and "data" in table_value:
-        return table_value["data"] or []
-    # already a list (or something list-like)
-    return table_value
-
 def sanitize_basename(s: str) -> str:
     s = (s or "").strip() or "forgecaptions"
     return re.sub(r"[^A-Za-z0-9._-]+", "_", s)[:120]
@@ -296,11 +296,37 @@ def logo_b64_img() -> str:
             return f"<img src='data:image/png;base64,{b64}' alt='ForgeCaptions' class='cf-logo'>"
     return ""
 
+def _plural_token_regex(tok: str) -> str:
+    """
+    Build a regex for a token that also matches simple English plurals.
+    Rules:
+      - box / class / dish / buzz / rhombus → + (?:es)?
+      - lady (consonant+y) → (?:y|ies)
+      - default → + s?
+    This is case-insensitive at compile time.
+    """
+    t = (tok or "").strip()
+    if not t:
+        return ""
+    t_low = t.lower()
+    # consonant + y → y|ies
+    if re.search(r"[^aeiou]y$", t_low):
+        return re.escape(t[:-1]) + r"(?:y|ies)"
+    # s, x, z, ch, sh → +es
+    if re.search(r"(?:s|x|z|ch|sh)$", t_low):
+        return re.escape(t) + r"(?:es)?"
+    # default → +s
+    return re.escape(t) + r"s?"
 
 # ------------------------------
 # 6) Shape Aliases (comma/pipe synonyms per row)
 # ------------------------------
 def _compile_shape_aliases_from_file():
+    """
+    Build regex list from settings["shape_aliases"].
+    Left cell accepts comma OR pipe separated synonyms (multi-word OK).
+    Matches are case-insensitive, whole-word, captures simple plurals, and allows '-shaped' or ' shaped'.
+    """
     s = load_settings()
     if not s.get("shape_aliases_enabled", True):
         return []
@@ -313,11 +339,17 @@ def _compile_shape_aliases_from_file():
         tokens = [t.strip() for t in re.split(r"[|,]", raw) if t.strip()]
         if not tokens:
             continue
-        tokens = sorted(set(tokens), key=lambda t: -len(t))
-        pat = r"\b(?:" + "|".join(re.escape(t) for t in tokens) + r")(?:[-\s]?shaped)?\b"
+        # Build plural-aware alternation for all synonyms
+        alts = [_plural_token_regex(t) for t in tokens]
+        alts = [a for a in alts if a]
+        if not alts:
+            continue
+        # word-boundaries + optional "-shaped"/" shaped"
+        pat = r"\b(?:" + "|".join(alts) + r")(?:[-\s]?shaped)?\b"
         compiled.append((re.compile(pat, flags=re.I), name))
     return compiled
 
+
 _SHAPE_ALIASES = _compile_shape_aliases_from_file()
 def _refresh_shape_aliases_cache():
     global _SHAPE_ALIASES
@@ -336,9 +368,12 @@ def get_shape_alias_rows_ui_defaults():
         rows = [["", ""]]
     return rows, enabled
 
-def save_shape_alias_rows(enabled, df_rows):
-    cfg = load_settings()
-    cfg["shape_aliases_enabled"] = bool(enabled)
+def save_shape_alias_rows(enabled, df_rows, persist):
+    """
+    Save or just apply alias rows.
+    - If persist=True → write to SETTINGS_FILE and recompile from file
+    - If persist=False → do NOT touch disk; just compile & apply in-memory
+    """
     cleaned = []
     for r in (df_rows or []):
         if not r:
@@ -347,12 +382,43 @@ def save_shape_alias_rows(enabled, df_rows):
         name  = (r[1] or "").strip()
         if shape and name:
             cleaned.append({"shape": shape, "name": name})
-    cfg["shape_aliases"] = cleaned
-    save_settings(cfg)
-    _refresh_shape_aliases_cache()
+
+    status = "✅ Applied for this session only."
+    if persist:
+        cfg = load_settings()
+        cfg["shape_aliases_enabled"] = bool(enabled)
+        cfg["shape_aliases"] = cleaned
+        save_settings(cfg)
+        status = "💾 Saved to disk (will persist across restarts)."
+
+    # Recompile in-memory, regardless of persist
+    global _SHAPE_ALIASES
+    if bool(enabled):
+        # Build from the just-edited rows
+        tokens = []
+        compiled = []
+        # Emulate compiler using cleaned rows directly
+        compiled = []
+        for item in cleaned:
+            raw = item["shape"]
+            name = item["name"]
+            toks = [t.strip() for t in re.split(r"[|,]", raw) if t.strip()]
+            alts = [_plural_token_regex(t) for t in toks]
+            alts = [a for a in alts if a]
+            if not alts:
+                continue
+            pat = r"\b(?:" + "|".join(alts) + r")(?:[-\s]?shaped)?\b"
+            compiled.append((re.compile(pat, flags=re.I), name))
+        _SHAPE_ALIASES = compiled
+    else:
+        _SHAPE_ALIASES = []
+
     normalized = [[it["shape"], it["name"]] for it in cleaned] + [["", ""]]
-    return ("✅ Saved shape alias options.",
-            gr.update(value=normalized, row_count=(max(1, len(normalized)), "dynamic")))
+    return (
+        status,
+        gr.update(value=normalized, row_count=(max(1, len(normalized)), "dynamic"))
+    )
+
 
 
 # ------------------------------
@@ -461,7 +527,7 @@ def run_batch(
         session_rows.append({"filename": filename, "caption": cap, "path": path, "thumb_path": thumb})
         processed += 1
 
-        if time_budget_s and (time.time() - start) >= float(time_budget_s):
+        if time_budget_s is not None and (time.time() - start) >= float(time_budget_s):
             leftover = files[idx+1:]
             break
 
@@ -491,13 +557,14 @@ def _gpu_startup_warm():
 
 
 # ------------------------------
-# 9) Export helpers (CSV/XLSX/TXT ZIP)
+# 9) Export/Import helpers (CSV/XLSX/TXT ZIP)
 # ------------------------------
 def _rows_to_table(rows: List[dict]) -> list:
     return [[r.get("filename",""), r.get("caption","")] for r in (rows or [])]
 
 def _table_to_rows(table_value: Any, rows: List[dict]) -> List[dict]:
-    tbl = _normalize_table_value(table_value)
+    # Expecting list-of-lists (Dataframe type="array")
+    tbl = table_value or []
     new = []
     for i, r in enumerate(rows or []):
         r = dict(r)
@@ -508,7 +575,7 @@ def _table_to_rows(table_value: Any, rows: List[dict]) -> List[dict]:
     return new
 
 def export_csv_from_table(table_value: Any, dataset_name: str) -> str:
-    data = _normalize_table_value(table_value)
+    data = table_value or []
     name = sanitize_basename(dataset_name)
     out = f"/tmp/{name}_{int(time.time())}.csv"
     with open(out, "w", newline="", encoding="utf-8") as f:
@@ -540,7 +607,7 @@ def export_excel_with_thumbs(table_value: Any, session_rows: List[dict], thumb_p
         raise RuntimeError("Excel export requires 'openpyxl' in requirements.txt.") from e
 
     caption_by_file = {}
-    for row in _normalize_table_value(table_value):
+    for row in (table_value or []):
         if not row:
             continue
         fn = str(row[0]) if len(row) > 0 else ""
@@ -580,7 +647,7 @@ def export_txt_zip(table_value: Any, dataset_name: str) -> str:
     """
     Create one .txt per caption, zip them.
     """
-    data = _normalize_table_value(table_value)
+    data = table_value or []
     # wipe old
     for fn in os.listdir(TXT_EXPORT_DIR):
         try:
@@ -612,6 +679,82 @@ def export_txt_zip(table_value: Any, dataset_name: str) -> str:
                 z.write(os.path.join(TXT_EXPORT_DIR, fn), arcname=fn)
     return zpath
 
+def import_captions_file(file_path: str, session_rows: List[dict]) -> Tuple[List[dict], list, list, str]:
+    """
+    Import captions from CSV or XLSX and merge by filename into current session.
+    - If filename exists → update its caption
+    - Otherwise append a new row (without image path/thumbnail)
+    """
+    if not file_path or not os.path.exists(file_path):
+        # No change
+        table_rows = _rows_to_table(session_rows)
+        gallery_pairs = [((r.get("thumb_path") or r.get("path")), r.get("caption",""))
+                         for r in session_rows if (r.get("thumb_path") or r.get("path"))]
+        return session_rows, gallery_pairs, table_rows, "No file selected."
+
+    ext = os.path.splitext(file_path)[1].lower()
+    imported: List[Tuple[str, str]] = []
+
+    try:
+        if ext == ".csv":
+            with open(file_path, "r", encoding="utf-8") as f:
+                reader = csv.reader(f)
+                rows = list(reader)
+            # Skip header if present
+            if rows and len(rows[0]) >= 2 and str(rows[0][0]).lower().strip() == "filename":
+                rows = rows[1:]
+            for r in rows:
+                if not r or len(r) < 2:
+                    continue
+                fn = str(r[0]).strip()
+                cap = str(r[1]).strip()
+                if fn:
+                    imported.append((fn, cap))
+
+        elif ext in (".xlsx", ".xls"):
+            try:
+                from openpyxl import load_workbook
+            except Exception as e:
+                raise RuntimeError("XLSX import requires 'openpyxl' in requirements.txt.") from e
+            wb = load_workbook(file_path, read_only=True, data_only=True)
+            ws = wb.active
+            rows = list(ws.iter_rows(values_only=True))
+            if rows and len(rows[0]) >= 2 and str(rows[0][0]).lower().strip() == "filename":
+                rows = rows[1:]
+            for r in rows:
+                if not r or len(r) < 2:
+                    continue
+                fn = str(r[0]).strip() if r[0] is not None else ""
+                cap = str(r[1]).strip() if r[1] is not None else ""
+                if fn:
+                    imported.append((fn, cap))
+        else:
+            return session_rows, _rows_to_table(session_rows), _rows_to_table(session_rows), f"Unsupported file type: {ext}"
+    except Exception as e:
+        # Best-effort graceful fallback
+        table_rows = _rows_to_table(session_rows)
+        gallery_pairs = [((r.get("thumb_path") or r.get("path")), r.get("caption",""))
+                         for r in session_rows if (r.get("thumb_path") or r.get("path"))]
+        return session_rows, gallery_pairs, table_rows, f"Import failed: {e}"
+
+    # Merge
+    idx_by_name = {r.get("filename",""): i for i, r in enumerate(session_rows)}
+    updates, inserts = 0, 0
+    for fn, cap in imported:
+        if fn in idx_by_name:
+            session_rows[idx_by_name[fn]]["caption"] = cap
+            updates += 1
+        else:
+            session_rows.append({"filename": fn, "caption": cap, "path": "", "thumb_path": ""})
+            inserts += 1
+
+    save_session(session_rows)
+    gallery_pairs = [((r.get("thumb_path") or r.get("path")), r.get("caption",""))
+                     for r in session_rows if (r.get("thumb_path") or r.get("path"))]
+    table_rows = _rows_to_table(session_rows)
+    stamp = f"Imported {len(imported)} rows • updated {updates} • added {inserts} • {time.strftime('%H:%M:%S')}"
+    return session_rows, gallery_pairs, table_rows, stamp
+
 
 # ------------------------------
 # 10) UI header helper (logo auto-fit)
@@ -619,75 +762,48 @@ def export_txt_zip(table_value: Any, dataset_name: str) -> str:
 def _render_header_html(auto: bool, px: int, scale: float) -> str:
     auto_js = "true" if auto else "false"
     return f"""
-<div class="cf-hero" id="cfHero">
-  {logo_b64_img() or '<div class="cf-logo"></div>'}
-  <div class="cf-text" id="cfText">
+<div class="cf-hero">
+  {logo_b64_img()}
+  <div class="cf-text">
     <h1 class="cf-title">ForgeCaptions</h1>
     <div class="cf-sub">Batch captioning</div>
     <div class="cf-sub">Scrollable editor & autosave</div>
-    <div class="cf-sub">CSV / Excel export</div>
+    <div class="cf-sub">CSV / Excel / TXT export · CSV/XLSX import</div>
   </div>
 </div>
 <hr>
 <style>
-  /* Let the hero stretch to tallest child; we’ll force exact height via JS */
-  #cfHero {{ align-items: stretch; }}
-  .cf-logo {{
-    display: block;
-    width: auto;
-    height: auto;            /* JS will set explicit px height */
-    object-fit: contain;
-    max-height: 480px;       /* safety clamp */
-  }}
+  .cf-logo {{ height: auto; width: auto; object-fit: contain; }}
 </style>
 <script>
 (function() {{
-  const AUTO  = {auto_js};
-  const PX    = {int(px)};
+  const AUTO = {auto_js};
+  const PX = {int(px)};
   const SCALE = {float(scale)};
-
   function fit() {{
-    const hero = document.getElementById("cfHero");
-    const text = document.getElementById("cfText");
     const logo = document.querySelector(".cf-logo");
-    if (!hero || !text || !logo) return;
-
-    // Include vertical margins so we truly match the whole text stack
-    const cs = getComputedStyle(text);
-    const rect = text.getBoundingClientRect();
-    const fullH = rect.height + parseFloat(cs.marginTop) + parseFloat(cs.marginBottom);
-
-    const target = AUTO
-      ? Math.max(80, Math.min(480, Math.round(fullH * SCALE)))
-      : Math.max(80, Math.min(480, PX));
-
-    hero.style.minHeight = target + "px";   // ensure the flex row is that tall
-    logo.style.height    = target + "px";   // logo matches exactly
-    logo.style.width     = "auto";          // preserve aspect ratio
+    const text = document.querySelector(".cf-text");
+    if (!logo || !text) return;
+    if (AUTO) {{
+      const h = text.getBoundingClientRect().height || 200;
+      const target = Math.max(80, Math.min(480, Math.round(h * SCALE)));
+      logo.style.height = target + "px";
+    }} else {{
+      logo.style.height = Math.max(80, Math.min(480, PX)) + "px";
+    }}
   }}
-
-  // Recompute on font load, hydration, resizes, and text changes
-  if (document.fonts && document.fonts.ready) {{
-    document.fonts.ready.then(fit);
+  const textNode = document.querySelector(".cf-text");
+  if (window.ResizeObserver && textNode) {{
+    const ro = new ResizeObserver(fit);
+    ro.observe(textNode);
   }}
-  window.addEventListener("load", fit, {{ passive: true }});
   window.addEventListener("resize", fit, {{ passive: true }});
-
-  const textEl = document.getElementById("cfText");
-  if (window.ResizeObserver && textEl) {{
-    new ResizeObserver(fit).observe(textEl);
-  }}
-
-  // A couple of deferred passes to catch late reflows
   setTimeout(fit, 0);
-  setTimeout(fit, 200);
-  setTimeout(fit, 800);
 }})();
 </script>
 """
 
 
-
 # ------------------------------
 # 11) UI (Blocks)
 # ------------------------------
@@ -696,17 +812,11 @@ BASE_CSS = """
 .gradio-container{max-width:100%!important}
 
 /* Header */
-.cf-hero{
-  display:flex;
-  align-items:stretch;     /* was center; stretch lets the logo fill the row */
-  justify-content:center;
-  gap:16px;
-  margin:4px 0 12px;
-  text-align:center;
-}
-.cf-hero .cf-text{ text-align:center; }
-.cf-title{ margin:0; font-size:3.25rem; line-height:1; letter-spacing:.2px; }
-.cf-sub{ margin:6px 0 0; font-size:1.1rem; color:#cfd3da; }
+.cf-hero{display:flex; align-items:center; justify-content:center; gap:16px;
+  margin:4px 0 12px; text-align:center;}
+.cf-hero .cf-text{text-align:center;}
+.cf-title{margin:0;font-size:3.25rem;line-height:1;letter-spacing:.2px}
+.cf-sub{margin:6px 0 0;font-size:1.1rem;color:#cfd3da}
 
 /* Results area + robust scrollbars */
 .cf-scroll{border:1px solid #e6e6e6; border-radius:10px; padding:8px}
@@ -722,8 +832,8 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
     # ---- Header
     settings = load_settings()
     header_html = gr.HTML(_render_header_html(settings.get("logo_auto", True),
-                                              settings.get("logo_px", 180),
-                                              settings.get("logo_scale", 1.0)))
+                                              settings.get("logo_px", 200),
+                                              settings.get("logo_scale", 1.10)))
 
     # ---- Controls group
     with gr.Group():
@@ -766,20 +876,16 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
                     value="Manual (step)", label="Batch mode"
                 )
                 chunk_size = gr.Slider(1, 50, value=10, step=1, label="Chunk size")
-                gpu_budget = gr.Slider(20, 120, value=55, step=5, label="Max seconds per GPU call")
-                no_time_limit = gr.Checkbox(
-                    value=True,
-                    label="No time limit (may time out on Zero GPU)"
-                )
-
+                gpu_budget = gr.Slider(20, 110, value=55, step=5, label="Max seconds per GPU call")
+                no_time_limit = gr.Checkbox(value=False, label="No time limit (ignore above)")
 
                 # Logo controls
                 logo_auto = gr.Checkbox(value=settings.get("logo_auto", True),
                                         label="Auto-match logo height to text")
-                logo_px   = gr.Slider(80, 420, value=settings.get("logo_px", 180),
+                logo_px   = gr.Slider(80, 480, value=settings.get("logo_px", 200),
                                       step=4, label="Logo height (px, if Auto off)")
-                logo_scale = gr.Slider(0.6, 1.6, value=settings.get("logo_scale", 1.0),
-                                       step=0.05, label="Logo scale × (if Auto on)")
+                logo_scale = gr.Slider(0.7, 1.6, value=settings.get("logo_scale", 1.10),
+                                       step=0.02, label="Logo scale × (if Auto on)")
 
     # Persist instruction + general settings
     def _refresh_instruction(styles, extra, name_value, trigv, begv, endv, excel_px, ms):
@@ -822,6 +928,7 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
     logo_auto.change(_update_header, inputs=[logo_auto, logo_px, logo_scale], outputs=[header_html])
     logo_scale.change(_update_header, inputs=[logo_auto, logo_px, logo_scale], outputs=[header_html])
 
+    # ---- Shape Aliases block (placed WITH other settings, before uploads)
     # ---- Shape Aliases block (placed WITH other settings, before uploads)
     with gr.Accordion("Shape Aliases", open=False):
         gr.Markdown(
@@ -830,10 +937,15 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
             "**How to use:**\n"
             "- Left column = a single token **or** comma/pipe-separated synonyms, e.g. `diamond, rhombus | lozenge`\n"
             "- Right column = replacement name, e.g. `starkey-emblem`\n"
-            "Matches are case-insensitive, whole-word, and also catch `*-shaped` or `* shaped`."
+            "Matches are case-insensitive, whole-word, also catches simple plurals (`box`→`boxes`, `lady`→`ladies`), "
+            "and `*-shaped` or `* shaped` variants."
         )
         init_rows, init_enabled = get_shape_alias_rows_ui_defaults()
         enable_aliases = gr.Checkbox(label="Enable shape alias replacements", value=init_enabled)
+        persist_aliases = gr.Checkbox(
+            label="Save aliases across sessions",
+            value=load_settings().get("shape_aliases_persist", True)
+        )
         alias_table = gr.Dataframe(
             headers=["shape (token or synonyms)", "name to insert"],
             value=init_rows,
@@ -842,11 +954,49 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
             type="array",
             interactive=True
         )
+    
         with gr.Row():
             add_row_btn = gr.Button("＋ Add row", variant="secondary")
             clear_btn   = gr.Button("Clear", variant="secondary")
             save_btn    = gr.Button("💾 Save", variant="primary")
+    
+        # status line for saves
         save_status = gr.Markdown("")
+    
+        def _add_row(cur):
+            cur = (cur or []) + [["", ""]]
+            return gr.update(value=cur, row_count=(max(1, len(cur)), "dynamic"))
+    
+        def _clear_rows():
+            return gr.update(value=[["", ""]], row_count=(1, "dynamic"))
+    
+        add_row_btn.click(_add_row, inputs=[alias_table], outputs=[alias_table])
+        clear_btn.click(_clear_rows, outputs=[alias_table])
+    
+        # Persist the "persist" toggle itself
+        def _save_alias_persist_flag(v):
+            cfg = load_settings()
+            cfg["shape_aliases_persist"] = bool(v)
+            save_settings(cfg)
+            return gr.update()
+    
+        persist_aliases.change(_save_alias_persist_flag, inputs=[persist_aliases], outputs=[])
+    
+        # Save/apply rows (persists to disk only if persist_aliases is checked)
+        save_btn.click(
+            save_shape_alias_rows,
+            inputs=[enable_aliases, alias_table, persist_aliases],
+            outputs=[save_status, alias_table]
+        )
+
+        # Also persist the user's choice of the toggle itself
+    def _save_alias_persist_flag(v):
+        cfg = load_settings()
+        cfg["shape_aliases_persist"] = bool(v)
+        save_settings(cfg)
+        return gr.update()
+
+    persist_aliases.change(_save_alias_persist_flag, inputs=[persist_aliases], outputs=[])
         def _add_row(cur):
             cur = (cur or []) + [["", ""]]
             return gr.update(value=cur, row_count=(max(1, len(cur)), "dynamic"))
@@ -873,6 +1023,10 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
                 input_files = gr.File(label="Drop images", file_types=["image"], file_count="multiple", type="filepath")
             run_button = gr.Button("Caption batch", variant="primary")
 
+            with gr.Accordion("Import captions from CSV/XLSX (merge by filename)", open=False):
+                import_file = gr.File(label="Choose .csv or .xlsx", file_types=[".csv", ".xlsx"], type="filepath")
+                import_btn = gr.Button("Import into current session")
+
     # ---- Results area (gallery left / table right)
     rows_state  = gr.State(load_session())
     autosave_md = gr.Markdown("Ready.")
@@ -895,6 +1049,7 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
                 headers=["filename", "caption"],
                 interactive=True,
                 wrap=True,
+                type="array",          # <— prevents DataFrame truth ambiguity
                 elem_id="cfTable"
             )
 
@@ -967,17 +1122,18 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
         s = load_settings()
         return s.get("temperature", 0.6), s.get("top_p", 0.9), s.get("max_tokens", 256)
 
-    def _run_click(files, rows, instr, ms, mode, csize, budget_s):
+    def _run_click(files, rows, instr, ms, mode, csize, budget_s, no_limit):
         t, p, m = _tpms()
         files = files or []
+        budget = None if no_limit else float(budget_s)
 
-        #Manual (Step)
+        # Manual step → process first chunk only
         if mode == "Manual (step)" and files:
             chunks = _split_chunks(files, int(csize))
             batch = chunks[0]
             remaining = sum(chunks[1:], [])
             new_rows, gal, tbl, stamp, leftover_from_batch, done, total = run_batch(
-                batch, rows or [], instr, t, p, m, int(ms), float(budget_s)
+                batch, rows or [], instr, t, p, m, int(ms), budget
             )
             remaining = (leftover_from_batch or []) + remaining
             panel_vis = gr.update(visible=bool(remaining))
@@ -985,9 +1141,9 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
             prog = f"Batch progress: {done}/{total} processed in this step • Remaining overall: {len(remaining)}"
             return new_rows, gal, tbl, stamp, remaining, panel_vis, gr.update(value=msg), gr.update(value=prog)
 
-        #Auto/all-at-once
+        # Auto / all-at-once
         new_rows, gal, tbl, stamp, leftover, done, total = run_batch(
-            files, rows or [], instr, t, p, m, int(ms), float(budget_s)
+            files, rows or [], instr, t, p, m, int(ms), budget
         )
         panel_vis = gr.update(visible=bool(leftover))
         msg = f"{len(leftover)} files remain. Process next chunk?" if leftover else ""
@@ -1000,13 +1156,22 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
         outputs=[rows_state, gallery, table, autosave_md, remaining_state, step_panel, step_msg, progress_md]
     )
 
-    def _step_next(remain, rows, instr, ms, csize, budget_s):
+    def _step_next(remain, rows, instr, ms, csize, budget_s, no_limit):
         t, p, m = _tpms()
         remain = remain or []
         budget = None if no_limit else float(budget_s)
-        
+
         if not remain:
-            return rows, gr.update(value="No files remaining."), gr.update(visible=False), [], [], [], "Saved.", gr.update(value="")
+            return (
+                rows,
+                gr.update(value="No files remaining."),
+                gr.update(visible=False),
+                [],
+                [],
+                [],
+                "Saved.",
+                gr.update(value="")
+            )
         batch = remain[:int(csize)]
         leftover = remain[int(csize):]
         new_rows, gal, tbl, stamp, leftover_from_batch, done, total = run_batch(
@@ -1039,6 +1204,17 @@ with gr.Blocks(css=BASE_CSS, title="ForgeCaptions") as demo:
 
     table.change(sync_table_to_session, inputs=[table, rows_state], outputs=[rows_state, gallery, autosave_md])
 
+    # ---- Import hook
+    def _do_import(fpath, rows):
+        new_rows, gal, tbl, stamp = import_captions_file(fpath, rows or [])
+        return new_rows, gal, tbl, stamp
+
+    import_btn.click(
+        _do_import,
+        inputs=[import_file, rows_state],
+        outputs=[rows_state, gallery, table, autosave_md]
+    )
+
     # ---- Exports
     export_csv_btn.click(
         lambda tbl, ds: (export_csv_from_table(tbl, ds), gr.update(visible=True)),