Update app.py

app.py

@@ -1,6 +1,6 @@
 # app.py
-# Whisper transcription app - Redesigned UI with fine-tune-from-old-files + large-v3 model option
-# Drop-in replacement. Requires dependencies: gradio, whisper, pydub, pyzipper, python-docx, ffmpeg.
+# Whisper Transcriber — Beautiful UI + Tabs (Audio Transcribe focused)
+# Drop-in replacement. Requires: gradio, whisper, pydub, pyzipper, python-docx, ffmpeg installed.
 
 import os
 import sys
@@ -19,20 +19,18 @@ os.environ["PYTHONUNBUFFERED"] = "1"
 
 print("DEBUG: app.py bootstrap starting", flush=True)
 
-# Third-party imports (must be installed in the environment)
+# Third-party imports
 try:
-    from docx import Document
-    import whisper
     import gradio as gr
-    import pyzipper
+    import whisper
     from pydub import AudioSegment
+    import pyzipper
+    from docx import Document
 except Exception as e:
     print("FATAL: import error for third-party libs:", e, flush=True)
     traceback.print_exc()
     raise
 
-print("DEBUG: imports OK", flush=True)
-
 # ---------- Config ----------
 MEMORY_FILE = "memory.json"
 MEMORY_LOCK = threading.Lock()
@@ -44,15 +42,12 @@ FFMPEG_CANDIDATES = [
     ("pcm_s16le", 44100, 2),
     ("mulaw", 8000, 1),
 ]
-# Fine-tune globals
-FINETUNE_PROC = None
-FINETUNE_LOCK = threading.Lock()
-FINETUNE_LOG = os.path.join(tempfile.gettempdir(), "finetune_logs.txt")
+
+MODEL_CACHE = {}
 FINETUNE_WORKDIR = os.path.join(tempfile.gettempdir(), "finetune_workdir")
 os.makedirs(FINETUNE_WORKDIR, exist_ok=True)
-# ----------------------------
 
-# ---------- Utilities / Memory / Postprocessing ----------
+# ---------- Helpers (conversion, whisper, memory, small postprocessing) ----------
 def load_memory():
     try:
         if os.path.exists(MEMORY_FILE):
@@ -73,7 +68,6 @@ def load_memory():
         pass
     return mem
 
-
 def save_memory(mem):
     with MEMORY_LOCK:
         try:
@@ -82,53 +76,31 @@ def save_memory(mem):
         except Exception:
             traceback.print_exc()
 
-
 memory = load_memory()
 
-
-MEDICAL_ABBREVIATIONS = {
-    "pt": "patient",
-    "dx": "diagnosis",
-    "hx": "history",
-    "sx": "symptoms",
-    "c/o": "complains of",
-    "bp": "blood pressure",
-    "hr": "heart rate",
-    "o2": "oxygen",
-    "r/o": "rule out",
-    "adm": "admit",
-    "disch": "discharge",
-}
-
-DRUG_NORMALIZATION = {
-    "metformin": "Metformin",
-    "aspirin": "Aspirin",
-    "amoxicillin": "Amoxicillin",
-}
-
+MEDICAL_ABBREVIATIONS = {"pt":"patient","dx":"diagnosis","hx":"history","sx":"symptoms","c/o":"complains of","bp":"blood pressure","hr":"heart rate","o2":"oxygen","r/o":"rule out","adm":"admit","disch":"discharge"}
+DRUG_NORMALIZATION = {"metformin":"Metformin","aspirin":"Aspirin","amoxicillin":"Amoxicillin"}
 
 def expand_abbreviations(text):
     tokens = re.split(r"(\s+)", text)
-    out = []
+    out=[]
     for t in tokens:
         key = t.lower().strip(".,;:")
         if key in MEDICAL_ABBREVIATIONS:
-            trailing = ""
-            m = re.match(r"([A-Za-z0-9/]+)([.,;:]*)", t)
+            trailing=""
+            m=re.match(r"([A-Za-z0-9/]+)([.,;:]*)",t)
             if m:
-                trailing = m.group(2) or ""
-            out.append(MEDICAL_ABBREVIATIONS[key] + trailing)
+                trailing=m.group(2) or ""
+            out.append(MEDICAL_ABBREVIATIONS[key]+trailing)
         else:
             out.append(t)
     return "".join(out)
 
-
 def normalize_drugs(text):
-    for k, v in DRUG_NORMALIZATION.items():
+    for k,v in DRUG_NORMALIZATION.items():
         text = re.sub(rf"\b{k}\b", v, text, flags=re.IGNORECASE)
     return text
 
-
 def punctuation_and_capitalization(text):
     text = text.strip()
     if not text:
@@ -136,7 +108,7 @@ def punctuation_and_capitalization(text):
     if not re.search(r"[.?!]\s*$", text):
         text = text.rstrip() + "."
     parts = re.split(r"([.?!]\s+)", text)
-    out = []
+    out=[]
     for p in parts:
         if p and not re.match(r"[.?!]\s+", p):
             out.append(p.capitalize())
@@ -144,67 +116,40 @@ def punctuation_and_capitalization(text):
             out.append(p)
     return "".join(out)
 
-
-def postprocess_transcript(text, format_soap=False):
+def postprocess_transcript(text):
     if not text:
         return text
-    t = re.sub(r"\s+", " ", text).strip()
+    t = re.sub(r"\s+"," ",text).strip()
     t = expand_abbreviations(t)
     t = normalize_drugs(t)
     t = punctuation_and_capitalization(t)
-    if format_soap:
-        sentences = re.split(r"(?<=[.?!])\s+", t)
-        subj = sentences[0] if len(sentences) >= 1 else ""
-        obj = sentences[1] if len(sentences) >= 2 else ""
-        assessment = ""
-        for kw in ["diagnosis", "dx", "rule out", "r/o", "probable"]:
-            if kw in t.lower():
-                assessment = "Assessment: " + subj
-                break
-        soap = f"S: {subj}\nO: {obj}\nA: {assessment}\nP: Plan: follow up as indicated."
-        return soap
     return t
 
-
 def extract_words_and_phrases(text):
     words = re.findall(r"[A-Za-z0-9\-']+", text)
     sentences = [s.strip() for s in re.split(r"(?<=[.?!])\s+", text) if s.strip()]
     return [w for w in words if w.strip()], sentences
 
-
 def update_memory_with_transcript(transcript):
     global memory
     words, sentences = extract_words_and_phrases(transcript)
-    changed = False
+    changed=False
     with MEMORY_LOCK:
         for w in words:
-            lw = w.lower()
-            if lw in memory["words"]:
-                memory["words"][lw] += 1
-            else:
-                memory["words"][lw] = 1
-                changed = True
+            lw=w.lower()
+            memory["words"][lw]=memory["words"].get(lw,0)+1
+            changed=True
         for s in sentences:
-            key = s.strip()
-            if key in memory["phrases"]:
-                memory["phrases"][key] += 1
-            else:
-                memory["phrases"][key] = 1
-                changed = True
+            memory["phrases"][s]=memory["phrases"].get(s,0)+1
+            changed=True
         if changed:
-            try:
-                with open(MEMORY_FILE, "w", encoding="utf-8") as fh:
-                    json.dump(memory, fh, ensure_ascii=False, indent=2)
-            except Exception:
-                pass
-
+            save_memory(memory)
 
-def memory_correct_text(text, min_ratio=0.85):
+def memory_correct_text(text,min_ratio=0.85):
     if not text or (not memory.get("words") and not memory.get("phrases")):
         return text
-
     def fix_word(w):
-        lw = w.lower()
+        lw=w.lower()
         if lw in memory["words"]:
             return w
         candidates = get_close_matches(lw, memory["words"].keys(), n=1, cutoff=min_ratio)
@@ -214,285 +159,178 @@ def memory_correct_text(text, min_ratio=0.85):
                 return cand.capitalize()
             return cand
         return w
-
     tokens = re.split(r"(\W+)", text)
-    corrected_tokens = []
+    corrected=[]
     for tok in tokens:
         if re.match(r"^[A-Za-z0-9\-']+$", tok):
-            corrected_tokens.append(fix_word(tok))
+            corrected.append(fix_word(tok))
         else:
-            corrected_tokens.append(tok)
-    corrected = "".join(corrected_tokens)
-
-    for phrase in sorted(memory.get("phrases", {}).keys(), key=lambda s: -len(s)):
+            corrected.append(tok)
+    corrected_text = "".join(corrected)
+    for phrase in sorted(memory.get("phrases",{}).keys(), key=lambda s:-len(s)):
         low_phrase = phrase.lower()
         if len(low_phrase) < 8:
             continue
-        if low_phrase in corrected.lower():
-            corrected = re.sub(re.escape(phrase), phrase, corrected, flags=re.IGNORECASE)
-    return corrected
-
-
-# ---------- Memory management helpers ----------
-def import_memory_file(uploaded):
-    global memory
-    if not uploaded:
-        return "No file provided."
-    path = None
-    try:
-        if isinstance(uploaded, (str, os.PathLike)):
-            path = str(uploaded)
-        elif hasattr(uploaded, "name"):
-            path = uploaded.name
-        elif isinstance(uploaded, dict) and uploaded.get("name"):
-            path = uploaded["name"]
-        else:
-            return "Unable to determine uploaded file path."
-        with open(path, "r", encoding="utf-8") as fh:
-            raw = fh.read()
-        try:
-            parsed = json.loads(raw)
-            if isinstance(parsed, dict):
-                with MEMORY_LOCK:
-                    parsed_words = parsed.get("words", {})
-                    parsed_phrases = parsed.get("phrases", {})
-                    for k, v in parsed_words.items():
-                        memory["words"][k.lower()] = memory["words"].get(k.lower(), 0) + int(v)
-                    for k, v in parsed_phrases.items():
-                        memory["phrases"][k] = memory["phrases"].get(k, 0) + int(v)
-                    save_memory(memory)
-                return f"Imported JSON memory (words={len(parsed_words)}, phrases={len(parsed_phrases)})."
-        except Exception:
-            pass
-        lines = [l.strip() for l in raw.splitlines() if l.strip()]
-        added_words = 0
-        added_phrases = 0
-        with MEMORY_LOCK:
-            for line in lines:
-                if "," in line:
-                    parts = [p.strip() for p in line.split(",", 1)]
-                    key = parts[0].lower()
-                    try:
-                        cnt = int(parts[1])
-                    except Exception:
-                        cnt = 1
-                    memory["words"][key] = memory["words"].get(key, 0) + cnt
-                    added_words += 1
-                else:
-                    if len(line.split()) <= 3:
-                        key = line.lower()
-                        memory["words"][key] = memory["words"].get(key, 0) + 1
-                        added_words += 1
-                    else:
-                        memory["phrases"][line] = memory["phrases"].get(line, 0) + 1
-                        added_phrases += 1
-            save_memory(memory)
-        return f"Imported {added_words} words and {added_phrases} phrases from file."
-    except Exception as e:
-        traceback.print_exc()
-        return f"Import failed: {e}"
-
+        if low_phrase in corrected_text.lower():
+            corrected_text = re.sub(re.escape(phrase), phrase, corrected_text, flags=re.IGNORECASE)
+    return corrected_text
 
-def add_memory_entry(entry):
-    global memory
-    if not entry or not entry.strip():
-        return "No entry provided."
-    e = entry.strip()
-    with MEMORY_LOCK:
-        if len(e.split()) <= 3:
-            key = e.lower()
-            memory["words"][key] = memory["words"].get(key, 0) + 1
-            save_memory(memory)
-            return f"Added/updated word: '{key}'."
-        else:
-            memory["phrases"][e] = memory["phrases"].get(e, 0) + 1
-            save_memory(memory)
-            return f"Added/updated phrase: '{e}'."
-
-
-def clear_memory():
-    global memory
-    with MEMORY_LOCK:
-        memory = {"words": {}, "phrases": {}}
-        save_memory(memory)
-    return "Memory cleared."
-
-
-def view_memory(limit=4000):
-    w = memory.get("words", {})
-    p = memory.get("phrases", {})
-    out_lines = []
-    out_lines.append("WORDS (top 50):")
-    for k, v in sorted(w.items(), key=lambda kv: -kv[1])[:50]:
-        out_lines.append(f"{k}: {v}")
-    out_lines.append("")
-    out_lines.append("PHRASES (top 50):")
-    for k, v in sorted(p.items(), key=lambda kv: -kv[1])[:50]:
-        out_lines.append(f"{k}: {v}")
-    out = "\n".join(out_lines)
-    if len(out) > limit:
-        out = out[:limit] + "\n...truncated..."
-    return out
-
-
-# ---------- File utilities ----------
-def save_as_word(text, filename=None):
-    if filename is None:
-        filename = os.path.join(tempfile.gettempdir(), "merged_transcripts.docx")
-    doc = Document()
-    doc.add_paragraph(text)
-    doc.save(filename)
-    return filename
-
-
-# ---------- Conversion helpers (pydub + ffmpeg fallback) ----------
+# ---------- Conversion helpers ----------
+MIN_WAV_SIZE = MIN_WAV_SIZE
 def _ffmpeg_convert(input_path, out_path, fmt, sr, ch):
+    cmd = ["ffmpeg","-hide_banner","-loglevel","error","-y"]
+    if fmt in ("s16le","pcm_s16le","mulaw"):
+        cmd += ["-f",fmt,"-ar",str(sr),"-ac",str(ch),"-i",input_path,out_path]
+    else:
+        cmd += ["-i",input_path,"-ar",str(sr),"-ac",str(ch),out_path]
     try:
-        cmd = ["ffmpeg", "-hide_banner", "-loglevel", "error", "-y"]
-        if fmt in ("s16le", "pcm_s16le", "mulaw"):
-            cmd += ["-f", fmt, "-ar", str(sr), "-ac", str(ch), "-i", input_path, out_path]
-        else:
-            cmd += ["-i", input_path, "-ar", str(sr), "-ac", str(ch), out_path]
         proc = subprocess.run(cmd, capture_output=True, timeout=60, text=True)
-        stdout_stderr = (proc.stdout or "") + (proc.stderr or "")
-        if proc.returncode == 0 and os.path.exists(out_path) and os.path.getsize(out_path) > MIN_WAV_SIZE:
+        stdout_stderr=(proc.stdout or "")+(proc.stderr or "")
+        if proc.returncode==0 and os.path.exists(out_path) and os.path.getsize(out_path)>MIN_WAV_SIZE:
             return True, stdout_stderr
         else:
             try:
-                if os.path.exists(out_path):
-                    os.unlink(out_path)
-            except Exception:
-                pass
+                if os.path.exists(out_path): os.unlink(out_path)
+            except Exception: pass
             return False, stdout_stderr
     except Exception as e:
         try:
-            if os.path.exists(out_path):
-                os.unlink(out_path)
-        except Exception:
-            pass
+            if os.path.exists(out_path): os.unlink(out_path)
+        except Exception: pass
         return False, str(e)
 
-
 def convert_to_wav_if_needed(input_path):
-    input_path = str(input_path)
-    lower = input_path.lower()
-    if lower.endswith(".wav"):
+    input_path=str(input_path)
+    if input_path.lower().endswith(".wav"):
         return input_path
-
-    auto_err = ""
-    tmp = None
+    tmp=None
+    auto_err=""
     try:
         tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
         tmp.close()
         AudioSegment.from_file(input_path).export(tmp.name, format="wav")
-        if os.path.exists(tmp.name) and os.path.getsize(tmp.name) > MIN_WAV_SIZE:
+        if os.path.exists(tmp.name) and os.path.getsize(tmp.name)>MIN_WAV_SIZE:
             return tmp.name
         else:
-            try:
-                os.unlink(tmp.name)
-            except Exception:
-                pass
+            try: os.unlink(tmp.name)
+            except Exception: pass
     except Exception:
-        auto_err = traceback.format_exc()
+        auto_err=traceback.format_exc()
         try:
-            if tmp and os.path.exists(tmp.name):
-                os.unlink(tmp.name)
-        except Exception:
-            pass
-
+            if tmp and os.path.exists(tmp.name): os.unlink(tmp.name)
+        except Exception: pass
     diag_dir = tempfile.mkdtemp(prefix="dct_diag_")
     diag_log = os.path.join(diag_dir, "conversion_diagnostics.txt")
-    diagnostics = []
-    for fmt, sr, ch in FFMPEG_CANDIDATES:
+    diagnostics=[]
+    for fmt,sr,ch in FFMPEG_CANDIDATES:
         out_wav = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
         out_wav.close()
         success, debug = _ffmpeg_convert(input_path, out_wav.name, fmt, sr, ch)
         diagnostics.append(f"TRY fmt={fmt} sr={sr} ch={ch} success={success}\n{debug}\n")
         if success:
             try:
-                with open(diag_log, "w", encoding="utf-8") as fh:
+                with open(diag_log,"w",encoding="utf-8") as fh:
                     fh.write("pydub auto error:\n")
-                    fh.write(auto_err + "\n\n")
+                    fh.write(auto_err+"\n\n")
                     fh.write("Successful ffmpeg candidate:\n")
                     fh.write(f"fmt={fmt} sr={sr} ch={ch}\n\n")
                     fh.write("Diagnostics:\n")
                     fh.write("\n".join(diagnostics))
-            except Exception:
-                pass
+            except Exception: pass
             return out_wav.name
         else:
             try:
-                if os.path.exists(out_wav.name):
-                    os.unlink(out_wav.name)
-            except Exception:
-                pass
-
+                if os.path.exists(out_wav.name): os.unlink(out_wav.name)
+            except Exception: pass
     try:
-        fp = subprocess.run(
-            ["ffprobe", "-v", "error", "-show_format", "-show_streams", input_path],
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-        diagnostics.append("FFPROBE:\n" + (fp.stdout.strip() or fp.stderr.strip()))
+        fp = subprocess.run(["ffprobe","-v","error","-show_format","-show_streams",input_path], capture_output=True, text=True, timeout=10)
+        diagnostics.append("FFPROBE:\n"+(fp.stdout.strip() or fp.stderr.strip()))
     except Exception as e:
-        diagnostics.append("ffprobe failed: " + str(e))
+        diagnostics.append("ffprobe failed: "+str(e))
     try:
-        with open(input_path, "rb") as fh:
+        with open(input_path,"rb") as fh:
             head = fh.read(512)
-            diagnostics.append("HEX PREVIEW:\n" + head.hex())
+            diagnostics.append("HEX PREVIEW:\n"+head.hex())
     except Exception as e:
-        diagnostics.append("could not read head: " + str(e))
-
+        diagnostics.append("could not read head: "+str(e))
     try:
-        with open(diag_log, "w", encoding="utf-8") as fh:
+        with open(diag_log,"w",encoding="utf-8") as fh:
             fh.write("pydub auto error:\n")
-            fh.write(auto_err + "\n\n")
+            fh.write(auto_err+"\n\n")
             fh.write("Full diagnostics:\n\n")
             fh.write("\n\n".join(diagnostics))
     except Exception as e:
         raise Exception(f"Conversion failed; diagnostics write error: {e}")
-
     raise Exception(f"Could not convert file to WAV. Diagnostics saved to: {diag_log}")
 
-
-# ---------- Whisper model cache (supports large-v3 option) ----------
-MODEL_CACHE = {}
-
-
+# ---------- Whisper model loader ----------
 def get_whisper_model(name, device=None):
+    # caching
     if name not in MODEL_CACHE:
         print(f"DEBUG: loading whisper model '{name}'", flush=True)
-        # Whisper API may accept "large-v3" if installed; otherwise map it or change dropdown.
+        # whisper.load_model accepts model names like "small","medium", "large-v3" depending on installation
         if device:
-            MODEL_CACHE[name] = whisper.load_model(name, device=device)
+            try:
+                MODEL_CACHE[name] = whisper.load_model(name, device=device)
+            except TypeError:
+                # fallback signature
+                MODEL_CACHE[name] = whisper.load_model(name)
         else:
             MODEL_CACHE[name] = whisper.load_model(name)
     return MODEL_CACHE[name]
 
+# ---------- Transcription helpers ----------
+def transcribe_single(audio_path, model_name="small", enable_memory=False, device_choice="auto"):
+    logs=[]
+    transcript_text=""
+    download_path=None
+    try:
+        if not audio_path:
+            return None, "No audio provided.", ""
+        path = str(audio_path)
+        device = None if device_choice=="auto" else device_choice
+        model = get_whisper_model(model_name, device=device)
+        logs.append(f"Loaded model: {model_name}")
+        wav = convert_to_wav_if_needed(path)
+        logs.append(f"Converted to WAV: {os.path.basename(wav)}")
+        result = model.transcribe(wav)
+        text = result.get("text","").strip()
+        if enable_memory:
+            text = memory_correct_text(text)
+        text = postprocess_transcript(text)
+        transcript_text = text
+        if enable_memory:
+            try:
+                update_memory_with_transcript(text)
+                logs.append("Memory updated.")
+            except Exception:
+                pass
+        # don't delete original user-uploaded wav; delete tmp if created
+        if wav and wav != path and os.path.exists(wav):
+            try: os.unlink(wav)
+            except Exception: pass
+        return path, transcript_text, "\n".join(logs)
+    except Exception as e:
+        tb = traceback.format_exc()
+        return None, "", f"Error: {e}\n{tb}"
 
-# ---------- ZIP extraction helpers ----------
+# ---------- ZIP helpers (kept small, re-use earlier pattern) ----------
 def extract_zip_list(zip_file, zip_password):
     temp_extract_dir = os.path.join(tempfile.gettempdir(), "extracted_audio")
     try:
         if os.path.exists(temp_extract_dir):
-            try:
-                shutil.rmtree(temp_extract_dir)
-            except Exception:
-                pass
+            try: shutil.rmtree(temp_extract_dir)
+            except Exception: pass
         os.makedirs(temp_extract_dir, exist_ok=True)
-        extracted = []
-        logs = []
+        extracted=[]
+        logs=[]
         with pyzipper.ZipFile(zip_file, "r") as zf:
             if zip_password:
-                try:
-                    zf.setpassword(zip_password.encode())
-                except Exception:
-                    logs.append("Warning: failed to set zip password (unexpected).")
-            exts = [".mp3", ".wav", ".aac", ".flac", ".ogg", ".m4a", ".dat", ".dct"]
+                try: zf.setpassword(zip_password.encode())
+                except Exception: logs.append("Warning: failed to set zip password (unexpected).")
+            exts = [".mp3",".wav",".aac",".flac",".ogg",".m4a",".dat",".dct"]
             for info in zf.infolist():
-                if info.is_dir():
-                    continue
+                if info.is_dir(): continue
                 _, ext = os.path.splitext(info.filename)
                 if ext.lower() in exts:
                     try:
@@ -500,9 +338,6 @@ def extract_zip_list(zip_file, zip_password):
                     except RuntimeError as e:
                         logs.append(f"Password required/incorrect for {info.filename}: {e}")
                         continue
-                    except pyzipper.BadZipFile:
-                        logs.append(f"Bad zip entry: {info.filename}")
-                        continue
                     except Exception as e:
                         logs.append(f"Error extracting {info.filename}: {e}")
                         continue
@@ -518,411 +353,373 @@ def extract_zip_list(zip_file, zip_password):
         traceback.print_exc()
         return [], f"Extraction failed: {e}"
 
+# ---------- UI: Beautiful CSS ----------
+CSS = """
+:root{
+  --accent:#4f46e5;
+  --muted:#6b7280;
+  --card:#ffffff;
+  --bg:#f7f8fb;
+  --glass: rgba(255,255,255,0.65);
+}
+body { background: var(--bg); font-family: Inter, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial; }
+.header {
+  padding: 18px 24px;
+  border-radius: 12px;
+  background: linear-gradient(90deg, rgba(79,70,229,0.12), rgba(99,102,241,0.04));
+  margin-bottom: 18px;
+  display:flex;align-items:center;gap:16px;
+}
+.app-icon {
+  width:62px;height:62px;border-radius:12px;background:linear-gradient(135deg,var(--accent),#06b6d4);display:flex;align-items:center;justify-content:center;color:white;font-weight:700;font-size:24px;
+}
+.header-title h1 { margin:0;font-size:20px;}
+.header-sub { color:var(--muted); margin-top:4px;font-size:13px;}
+.card { background:var(--card); border-radius:12px; padding:14px; box-shadow: 0 6px 20px rgba(16,24,40,0.06); }
+.controls { display:flex;flex-direction:column; gap:10px; }
+.btn-primary { background: linear-gradient(90deg,var(--accent),#06b6d4); color:white; border-radius:10px; padding:10px 14px; border:none; cursor:pointer; font-weight:600;}
+.small-muted { color:var(--muted); font-size:13px; }
+.transcript-area { white-space:pre-wrap; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, "Roboto Mono", monospace; background:#0f172a; color:#e6eef8; padding:12px; border-radius:10px; min-height:220px; }
+.audio-player-card { border-radius:10px; padding:8px; background: linear-gradient(180deg, rgba(255,255,255,0.9), rgba(255,255,255,0.7)); box-shadow: 0 6px 18px rgba(15,23,42,0.04); }
+.small-note { color:var(--muted); font-size:12px;}
+.grid { display:grid; grid-template-columns: 1fr 1fr; gap:14px; }
+@media (max-width:900px){ .grid{ grid-template-columns: 1fr; } .header{flex-direction:column;align-items:flex-start;} }
+"""
+
+# ---------- Build Gradio UI (beautiful + audio transcribe tab) ----------
+with gr.Blocks(title="Whisper Transcriber — Beautiful UI", css=CSS) as demo:
+    # Header
+    with gr.Row(elem_classes="header"):
+        with gr.Column(scale=0):
+            gr.HTML("<div class='app-icon'>WT</div>")
+        with gr.Column(elem_id="header-title"):
+            gr.HTML("<h1 style='margin:0'>Whisper Transcriber</h1>")
+            gr.Markdown("<div class='header-sub'>Fast single-file transcribe, batch workflows, memory & fine-tune — now with a beautiful Audio tab ✨</div>")
 
-# ---------- Transcription generator ----------
-def transcribe_multiple(
-    selected_paths,
-    model_name,
-    advanced_options,
-    merge_checkbox,
-    enable_memory=False,
-    device=None,
-):
-    log = []
-    transcripts = []
-    word_file_path = None
-
-    if not selected_paths:
-        log.append("No audio files provided.")
-        yield "\n\n".join(log), "\n\n".join(transcripts), None, 100
-        return
-
-    yield "", "", None, 0
-
-    yield "\n\n".join(log), "\n\n".join(transcripts), None, 5
-    try:
-        model = get_whisper_model(model_name, device=device)
-        log.append(f"Loaded Whisper model: {model_name}")
-    except Exception as e:
-        log.append(f"Failed to load model {model_name}: {e}")
-        yield "\n\n".join(log), "\n\n".join(transcripts), None, 100
-        return
-
-    total = len(selected_paths)
-    for idx, p in enumerate(selected_paths, start=1):
-        log.append(f"Processing file ({idx}/{total}): {os.path.basename(str(p))}")
-        yield "\n\n".join(log), "\n\n".join(transcripts), None, int(5 + (idx - 1) * 80 / max(1, total))
-
-        wav = None
-        try:
-            wav = convert_to_wav_if_needed(p)
-            log.append(f"Converted to WAV: {os.path.basename(str(wav))}")
-        except Exception as e:
-            log.append(f"Conversion failed for {os.path.basename(str(p))}: {e}")
-            transcripts.append(f"FILE: {os.path.basename(str(p))}\nERROR: Conversion failed: {e}")
-            yield "\n\n".join(log), "\n\n".join(transcripts), None, int(5 + idx * 80 / max(1, total))
-            continue
-
-        try:
-            whisper_opts = {}
-            if isinstance(advanced_options, dict):
-                whisper_opts.update(advanced_options)
-
-            result = model.transcribe(wav, **whisper_opts)
-            text = result.get("text", "").strip()
-            log.append(f"Transcribed: {len(text)} chars")
+    with gr.Tabs():
+        # ---- Audio Transcribe Tab ----
+        with gr.TabItem("Audio Transcribe 🎙️"):
+            with gr.Row():
+                # Left: controls
+                with gr.Column(scale=1):
+                    gr.Markdown("### Quick Single Audio Transcribe")
+                    with gr.Box(elem_classes="card"):
+                        single_audio = gr.Audio(label="Upload or record audio", type="filepath")
+                        with gr.Row():
+                            model_select = gr.Dropdown(choices=["small","medium","large","large-v3","base"], value="large-v3", label="Model")
+                            device_select = gr.Dropdown(choices=["auto","cpu","cuda"], value="auto", label="Device")
+                        with gr.Row():
+                            mem_toggle = gr.Checkbox(label="Enable correction memory", value=False)
+                            format_button = gr.Dropdown(choices=["Plain","SOAP (medical)"], value="Plain", label="Format")
+                        transcribe_btn = gr.Button("Transcribe", elem_classes="btn-primary")
+                        gr.Markdown("<div class='small-note'>Tip: Use <strong>large-v3</strong> for best accuracy if your environment supports it.</div>")
+
+                # Right: player + transcript
+                with gr.Column(scale=1):
+                    with gr.Box(elem_classes="card audio-player-card"):
+                        gr.Markdown("### Preview & Player")
+                        audio_preview = gr.Audio(label="Player", interactive=False)
+                        gr.HTML("<div style='height:8px'></div>")
+                        gr.Markdown("<div class='small-muted'>Use the player to preview. Click Transcribe to generate the cleaned transcript on the right.</div>")
+
+                    gr.Markdown("<div style='height:12px'></div>")
+                    with gr.Box(elem_classes="card"):
+                        gr.Markdown("### Transcript")
+                        transcript_out = gr.Textbox(label="", lines=12, interactive=False, elem_classes="transcript-area")
+                        transcript_logs = gr.Textbox(label="Logs", lines=6, interactive=False)
+
+            # Transcribe action
+            def _do_single_transcribe(audio_file, model_name, device_choice, enable_memory, fmt_choice):
+                player_path, transcript, logs = transcribe_single(audio_file, model_name=model_name, enable_memory=enable_memory, device_choice=device_choice)
+                if fmt_choice == "SOAP":
+                    # minimal SOAP formatting if user selected it (basic)
+                    sentences = re.split(r"(?<=[.?!])\s+", transcript)
+                    subj = sentences[0] if sentences else ""
+                    obj = sentences[1] if len(sentences) > 1 else ""
+                    soap = f"S: {subj}\nO: {obj}\nA: Assessment pending\nP: Plan: follow up"
+                    transcript = soap
+                return player_path, transcript, logs
+
+            transcribe_btn.click(fn=_do_single_transcribe, inputs=[single_audio, model_select, device_select, mem_toggle, format_button], outputs=[audio_preview, transcript_out, transcript_logs])
+
+        # ---- Batch Transcribe Tab ----
+        with gr.TabItem("Batch Transcribe 📦"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    with gr.Box(elem_classes="card"):
+                        gr.Markdown("### Batch upload or ZIP")
+                        batch_files = gr.File(label="Upload audio files (multiple)", file_count="multiple", type="filepath")
+                        batch_zip = gr.File(label="Or upload ZIP (optional)", file_count="single", type="filepath")
+                        zip_password = gr.Textbox(label="ZIP password (optional)", placeholder="leave empty if none")
+                        batch_model = gr.Dropdown(choices=["small","medium","large","large-v3","base"], value="small", label="Model")
+                        batch_device = gr.Dropdown(choices=["auto","cpu","cuda"], value="auto", label="Device")
+                        batch_merge = gr.Checkbox(label="Merge all transcripts to .docx", value=True)
+                        batch_mem = gr.Checkbox(label="Enable memory corrections", value=False)
+                        batch_extract_btn = gr.Button("Extract ZIP & Show Files")
+                        batch_extract_logs = gr.Textbox(label="Extraction logs", lines=6, interactive=False)
+                        batch_select = gr.CheckboxGroup(choices=[], label="Select extracted files (optional)")
+                        batch_trans_btn = gr.Button("Start Batch Transcription", elem_classes="btn-primary")
+                with gr.Column(scale=1):
+                    with gr.Box(elem_classes="card"):
+                        gr.Markdown("### Batch Output")
+                        batch_trans_out = gr.Textbox(label="Transcript (combined)", lines=18, interactive=False)
+                        batch_logs = gr.Textbox(label="Logs", lines=10, interactive=False)
+                        batch_download = gr.File(label="Merged .docx (when available)")
+
+            def _extract_zip_for_ui(zip_file, password):
+                if not zip_file:
+                    return [], "No zip provided."
+                zip_path = zip_file.name if hasattr(zip_file, "name") else str(zip_file)
+                extracted, logs = extract_zip_list(zip_path, password)
+                # return full paths as values, but show basenames in logs
+                return extracted, logs + "\n\nFiles:\n" + "\n".join([os.path.basename(p) for p in extracted])
+
+            batch_extract_btn.click(fn=_extract_zip_for_ui, inputs=[batch_zip, zip_password], outputs=[batch_select, batch_extract_logs])
+
+            # reuse transcribe_multiple from earlier designs if available; simplified here to call transcribe_single sequentially
+            def _batch_transcribe(selected_check, uploaded_files, zip_selected, model_name, device_name, merge_flag, enable_mem):
+                # build list
+                paths=[]
+                if selected_check:
+                    paths.extend(selected_check)
+                if uploaded_files:
+                    if isinstance(uploaded_files, list):
+                        paths.extend([str(x) for x in uploaded_files])
+                    else:
+                        paths.append(str(uploaded_files))
+                if not paths and zip_selected:
+                    paths.extend(zip_selected if isinstance(zip_selected, list) else [zip_selected])
+                logs=[]
+                transcripts=[]
+                out_doc=None
+                for p in paths:
+                    try:
+                        _, txt, lg = transcribe_single(p, model_name=model_name, enable_memory=enable_mem, device_choice=device_name)
+                        logs.append(lg)
+                        transcripts.append(f"FILE: {os.path.basename(str(p))}\n{txt}\n")
+                    except Exception as e:
+                        logs.append(f"Failed {p}: {e}")
+                combined = "\n\n".join(transcripts)
+                if merge_flag:
+                    try:
+                        out_doc = save_as_word(combined)
+                        logs.append(f"Merged saved: {out_doc}")
+                    except Exception as e:
+                        logs.append(f"Merge failed: {e}")
+                return combined, "\n".join(logs), out_doc
 
-            if enable_memory:
-                text = memory_correct_text(text)
-            text = postprocess_transcript(text)
-            transcripts.append(f"FILE: {os.path.basename(str(p))}\n{text}\n")
+            batch_trans_btn.click(fn=_batch_transcribe, inputs=[batch_select, batch_files, batch_select, batch_model, batch_device, batch_merge, batch_mem], outputs=[batch_trans_out, batch_logs, batch_download])
 
-            if enable_memory:
+        # ---- Memory Tab ----
+        with gr.TabItem("Memory 🧠"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    with gr.Box(elem_classes="card"):
+                        gr.Markdown("### Correction Memory")
+                        mem_upload = gr.File(label="Import memory (JSON or text)", file_count="single", type="filepath")
+                        mem_import_btn = gr.Button("Import Memory")
+                        mem_add_text = gr.Textbox(label="Add word / phrase", placeholder="Type and click Add")
+                        mem_add_btn = gr.Button("Add to Memory")
+                        mem_clear_btn = gr.Button("Clear Memory")
+                        mem_view_btn = gr.Button("View Memory")
+                        mem_status = gr.Textbox(label="Memory status / preview", lines=12, interactive=False)
+
+            def _import_mem(uploaded):
+                if not uploaded:
+                    return "No file provided."
+                path = uploaded.name if hasattr(uploaded,"name") else str(uploaded)
                 try:
-                    update_memory_with_transcript(text)
-                    log.append("Memory updated.")
-                except Exception:
-                    pass
-
-            yield "\n\n".join(log), "\n\n".join(transcripts), None, int(10 + idx * 85 / max(1, total))
-        except Exception as e:
-            log.append(f"Transcription failed for {os.path.basename(str(p))}: {e}")
-            transcripts.append(f"FILE: {os.path.basename(str(p))}\nERROR: Transcription failed: {e}")
-            yield "\n\n".join(log), "\n\n".join(transcripts), None, int(10 + idx * 85 / max(1, total))
-            continue
-        finally:
-            try:
-                if wav and os.path.exists(wav):
-                    tmpdir = tempfile.gettempdir()
+                    with open(path,"r",encoding="utf-8") as fh:
+                        raw = fh.read()
+                    parsed = None
                     try:
-                        common = os.path.commonpath([os.path.abspath(tmpdir), os.path.abspath(wav)])
-                        if common == os.path.abspath(tmpdir) and not str(p).lower().endswith(".wav"):
-                            os.unlink(wav)
+                        parsed = json.loads(raw)
                     except Exception:
-                        try:
-                            if tmpdir in os.path.abspath(wav) and not str(p).lower().endswith(".wav"):
-                                os.unlink(wav)
-                        except Exception:
-                            pass
-            except Exception:
-                pass
-
-    if merge_checkbox:
-        try:
-            merged_text = "\n\n".join(transcripts)
-            word_file_path = save_as_word(merged_text)
-            log.append(f"Merged transcript saved: {word_file_path}")
-        except Exception as e:
-            log.append(f"Failed to save merged file: {e}")
-            word_file_path = None
-
-    yield "\n\n".join(log), "\n\n".join(transcripts), word_file_path, 100
-
-
-# ---------- Fine-tune helpers (updated to include old-files option) ----------
-def _safe_write_log(msg):
-    try:
-        with open(FINETUNE_LOG, "a", encoding="utf-8") as fh:
-            fh.write(msg + "\n")
-    except Exception:
-        pass
-
-
-def _collect_old_files_into(dst_dir, old_dir_path):
-    """
-    Copy audio + matching .txt transcripts from old_dir_path into dst_dir.
-    Returns count of copied pairs and messages.
-    """
-    msgs = []
-    copied = 0
-    try:
-        if not os.path.isdir(old_dir_path):
-            return 0, f"Old-files path is not a directory: {old_dir_path}"
-        for root, _, files in os.walk(old_dir_path):
-            for f in files:
-                if f.lower().endswith((".wav", ".mp3", ".flac", ".m4a", ".ogg")):
-                    src_audio = os.path.join(root, f)
-                    base = os.path.splitext(f)[0]
-                    # prefer .txt transcript with same basename
-                    possible_txt = os.path.join(root, base + ".txt")
-                    rel_subdir = os.path.relpath(root, old_dir_path)
-                    target_subdir = os.path.join(dst_dir, rel_subdir)
-                    os.makedirs(target_subdir, exist_ok=True)
-                    target_audio = os.path.join(target_subdir, f)
-                    shutil.copy2(src_audio, target_audio)
-                    if os.path.exists(possible_txt):
-                        shutil.copy2(possible_txt, os.path.join(target_subdir, base + ".txt"))
-                        msgs.append(f"Copied pair: {os.path.join(rel_subdir, f)} + .txt")
+                        parsed=None
+                    if isinstance(parsed, dict):
+                        with MEMORY_LOCK:
+                            for k,v in parsed.get("words",{}).items():
+                                memory["words"][k.lower()] = memory["words"].get(k.lower(),0)+int(v)
+                            for k,v in parsed.get("phrases",{}).items():
+                                memory["phrases"][k] = memory["phrases"].get(k,0)+int(v)
+                            save_memory(memory)
+                        return f"Imported JSON memory (words={len(parsed.get('words',{}))}, phrases={len(parsed.get('phrases',{}))})."
+                    # fallback parse lines
+                    lines=[l.strip() for l in raw.splitlines() if l.strip()]
+                    added=0
+                    with MEMORY_LOCK:
+                        for line in lines:
+                            if "," in line:
+                                k,c = line.split(",",1)
+                                try: cnt=int(c)
+                                except: cnt=1
+                                memory["words"][k.lower()]=memory["words"].get(k.lower(),0)+cnt
+                            else:
+                                memory["words"][line.lower()]=memory["words"].get(line.lower(),0)+1
+                            added+=1
+                        save_memory(memory)
+                    return f"Imported {added} entries."
+                except Exception as e:
+                    return f"Import failed: {e}"
+
+            def _add_mem(entry):
+                if not entry or not entry.strip():
+                    return "No entry provided."
+                e=entry.strip()
+                with MEMORY_LOCK:
+                    if len(e.split())<=3:
+                        memory["words"][e.lower()]=memory["words"].get(e.lower(),0)+1
+                        save_memory(memory)
+                        return f"Added word: {e.lower()}"
                     else:
-                        msgs.append(f"Copied audio (no transcript found): {os.path.join(rel_subdir, f)}")
-                    copied += 1
-        return copied, "\n".join(msgs)
-    except Exception as e:
-        traceback.print_exc()
-        return copied, f"Error copying old files: {e}"
-
-
-def prepare_finetune_dataset(uploaded_zip_or_dir, include_old_files=False, old_files_dir=""):
-    """
-    Prepares finetune working dir. If include_old_files=True and old_files_dir provided,
-    it will copy audio+transcripts from old_files_dir into the dataset area.
-    Returns (status_message, manifest_path_or_empty).
-    """
-    dst = os.path.join(FINETUNE_WORKDIR, "data")
-    try:
-        if os.path.exists(dst):
-            shutil.rmtree(dst)
-        os.makedirs(dst, exist_ok=True)
-    except Exception as e:
-        return f"Failed to prepare workdir: {e}", ""
-
-    path = None
-    try:
-        if uploaded_zip_or_dir:
-            if isinstance(uploaded_zip_or_dir, (str, os.PathLike)):
-                path = str(uploaded_zip_or_dir)
-            elif hasattr(uploaded_zip_or_dir, "name"):
-                path = uploaded_zip_or_dir.name
-            elif isinstance(uploaded_zip_or_dir, dict) and uploaded_zip_or_dir.get("name"):
-                path = uploaded_zip_or_dir["name"]
-    except Exception as e:
-        return f"Unable to determine uploaded path: {e}", ""
-
-    # If zip uploaded, extract into dst
-    if path and os.path.isfile(path) and path.lower().endswith(".zip"):
-        try:
-            with pyzipper.ZipFile(path, "r") as zf:
-                zf.extractall(dst)
-        except Exception as e:
-            return f"Failed to extract ZIP: {e}", ""
-    elif path and os.path.isdir(path):
-        try:
-            for item in os.listdir(path):
-                s = os.path.join(path, item)
-                d = os.path.join(dst, item)
-                if os.path.isdir(s):
-                    shutil.copytree(s, d)
-                else:
-                    shutil.copy2(s, d)
-        except Exception as e:
-            return f"Failed to copy dataset dir: {e}", ""
-
-    # If include_old_files, copy them into dst as well (allow merging)
-    old_msgs = ""
-    if include_old_files and old_files_dir:
-        # normalize path (uploads from Gradio may be filepaths)
-        old_path = None
-        if isinstance(old_files_dir, (str, os.PathLike)):
-            old_path = str(old_files_dir)
-        elif hasattr(old_files_dir, "name"):
-            old_path = old_files_dir.name
-        elif isinstance(old_files_dir, dict) and old_files_dir.get("name"):
-            old_path = old_files_dir["name"]
-        if old_path:
-            copied, msg = _collect_old_files_into(dst, old_path)
-            old_msgs = f"\nOld-files: copied {copied} audio files.\nDetails:\n{msg}"
-
-    # Now try to find a manifest/transcripts in dst or build one from .wav + .txt pairs
-    transcripts_candidates = [
-        os.path.join(dst, "transcripts.tsv"),
-        os.path.join(dst, "metadata.tsv"),
-        os.path.join(dst, "manifest.tsv"),
-        os.path.join(dst, "transcripts.txt"),
-        os.path.join(dst, "metadata.txt"),
-        os.path.join(dst, "manifest.jsonl"),
-    ]
-    manifest_path = os.path.join(FINETUNE_WORKDIR, "manifest.tsv")
-    found = False
-
-    for tpath in transcripts_candidates:
-        if os.path.exists(tpath):
-            try:
-                shutil.copy2(tpath, manifest_path)
-                found = True
-                break
-            except Exception:
-                pass
-
-    if not found:
-        # discover audio files and matching .txt transcripts (same basename)
-        audio_files = []
-        for root, _, files in os.walk(dst):
-            for f in files:
-                if f.lower().endswith((".wav", ".mp3", ".flac", ".m4a", ".ogg")):
-                    audio_files.append(os.path.join(root, f))
-        if not audio_files:
-            return f"No audio files found in dataset.{old_msgs}", ""
-        entries = []
-        missing_transcripts = 0
-        for a in audio_files:
-            base = os.path.splitext(a)[0]
-            t_candidate = base + ".txt"
-            transcript = ""
-            if os.path.exists(t_candidate):
-                try:
-                    with open(t_candidate, "r", encoding="utf-8") as fh:
-                        transcript = fh.read().strip().replace("\n", " ")
-                except Exception:
-                    transcript = ""
-            else:
-                missing_transcripts += 1
-            entries.append(f"{a}\t{transcript}")
-        try:
-            with open(manifest_path, "w", encoding="utf-8") as fh:
-                fh.write("\n".join(entries))
-            found = True
-        except Exception as e:
-            return f"Failed to write manifest: {e}{old_msgs}", ""
-
-    if not found:
-        return f"Failed to locate or build manifest.{old_msgs}", ""
-
-    status_msg = f"Dataset prepared. Manifest: {manifest_path}{old_msgs}"
-    if missing_transcripts > 0:
-        status_msg += f"\nWarning: {missing_transcripts} audio files have no matching .txt transcript (empty transcripts saved)."
-
-    return status_msg, manifest_path
-
-
-def start_finetune(manifest_path, base_model, epochs, batch_size, lr, output_dir):
-    global FINETUNE_PROC
-    with FINETUNE_LOCK:
-        if FINETUNE_PROC and FINETUNE_PROC.poll() is None:
-            return "Fine-tune already running."
-
-        outdir = output_dir or os.path.join(FINETUNE_WORKDIR, "output")
-        os.makedirs(outdir, exist_ok=True)
-
-        try:
-            if os.path.exists(FINETUNE_LOG):
-                os.remove(FINETUNE_LOG)
-        except Exception:
-            pass
-
-        START_CMD = [
-            sys.executable,
-            "fine_tune.py",
-            "--manifest",
-            manifest_path,
-            "--base_model",
-            base_model,
-            "--epochs",
-            str(epochs),
-            "--batch_size",
-            str(batch_size),
-            "--lr",
-            str(lr),
-            "--output_dir",
-            outdir,
-        ]
-        try:
-            logfile = open(FINETUNE_LOG, "a", encoding="utf-8")
-            proc = subprocess.Popen(START_CMD, stdout=logfile, stderr=logfile, cwd=os.getcwd())
-            FINETUNE_PROC = proc
-            _safe_write_log(f"Started fine-tune: PID={proc.pid}, cmd={' '.join(START_CMD)}")
-            return f"Fine-tune started (PID={proc.pid}). Logs: {FINETUNE_LOG}"
-        except FileNotFoundError as e:
-            return f"Training script not found: {e}. Put your training script 'fine_tune.py' in project root or change START_CMD."
-        except Exception as e:
-            return f"Failed to start fine-tune: {e}"
-
-
-def stop_finetune():
-    global FINETUNE_PROC
-    with FINETUNE_LOCK:
-        if not FINETUNE_PROC:
-            return "No running fine-tune process."
-        try:
-            FINETUNE_PROC.terminate()
-            FINETUNE_PROC.wait(timeout=10)
-            pid = FINETUNE_PROC.pid
-            FINETUNE_PROC = None
-            _safe_write_log(f"Terminated fine-tune PID={pid}")
-            return f"Terminated fine-tune PID={pid}"
-        except Exception as e:
-            try:
-                FINETUNE_PROC.kill()
-            except Exception:
-                pass
-            FINETUNE_PROC = None
-            return f"Force killed fine-tune process: {e}"
-
-
-def tail_finetune_logs(lines=50):
-    try:
-        if not os.path.exists(FINETUNE_LOG):
-            return "No logs yet."
-        with open(FINETUNE_LOG, "r", encoding="utf-8", errors="ignore") as fh:
-            all_lines = fh.read().splitlines()
-            last = all_lines[-lines:]
-            return "\n".join(last)
-    except Exception as e:
-        return f"Failed to read logs: {e}"
-
+                        memory["phrases"][e]=memory["phrases"].get(e,0)+1
+                        save_memory(memory)
+                        return f"Added phrase: {e}"
 
-# ----------------------- Gradio UI (updated fine-tune controls + large-v3) -----------------------
-print("DEBUG: building Gradio Blocks", flush=True)
-with gr.Blocks(title="Whisper Transcriber — Fine-tune from old files + large-v3") as demo:
-    gr.Markdown("<h1 style='margin-bottom:0.25rem;'>Whisper Transcriber — Fine-tune Enhancements</h1>")
-    gr.Markdown("<p style='margin-top:0.1rem;color:#666;'>Now supports including old audio+transcript folders in fine-tune dataset and a 'large-v3' model option.</p>")
-
-    with gr.Tabs():
-        # For brevity, include only Fine-tune tab here since transcribe tabs exist in your app.
-        with gr.TabItem("Fine-tune (with old-files)"):
+            def _clear_mem():
+                global memory
+                with MEMORY_LOCK:
+                    memory={"words":{}, "phrases":{}}
+                    save_memory(memory)
+                return "Memory cleared."
+
+            def _view_mem():
+                w=memory.get("words",{})
+                p=memory.get("phrases",{})
+                out=[]
+                out.append("WORDS (top 30):")
+                for k,v in sorted(w.items(), key=lambda kv:-kv[1])[:30]:
+                    out.append(f"{k}: {v}")
+                out.append("")
+                out.append("PHRASES (top 20):")
+                for k,v in sorted(p.items(), key=lambda kv:-kv[1])[:20]:
+                    out.append(f"{k}: {v}")
+                return "\n".join(out)
+
+            mem_import_btn.click(fn=_import_mem, inputs=[mem_upload], outputs=[mem_status])
+            mem_add_btn.click(fn=_add_mem, inputs=[mem_add_text], outputs=[mem_status])
+            mem_clear_btn.click(fn=_clear_mem, inputs=[], outputs=[mem_status])
+            mem_view_btn.click(fn=_view_mem, inputs=[], outputs=[mem_status])
+
+        # ---- Fine-tune Tab (compact) ----
+        with gr.TabItem("Fine-tune ⚙️"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### Dataset")
-                    ft_upload = gr.File(label="Upload training ZIP or folder (zip)", file_count="single", type="filepath")
-                    include_old_chk = gr.Checkbox(label="Include old audio+transcript folder", value=False)
-                    old_files_dir = gr.File(label="Old files folder (select directory path)", file_count="single", type="filepath")
-                    ft_prepare_btn = gr.Button("Prepare dataset (merge uploaded + old files)")
-                    ft_prepare_status = gr.Textbox(label="Prepare status / manifest", interactive=False, lines=6)
-
-                    gr.Markdown("### Training parameters")
-                    ft_base_model = gr.Dropdown(choices=["small", "base", "medium", "large", "large-v3"], value="small", label="Base model")
-                    ft_epochs = gr.Slider(minimum=1, maximum=100, value=3, step=1, label="Epochs")
-                    ft_batch = gr.Number(label="Batch size", value=8)
-                    ft_lr = gr.Number(label="Learning rate", value=1e-5, precision=8)
-                    ft_output_dir = gr.Textbox(label="Output dir (optional)", value="", placeholder="Leave blank to use temp output")
-
-                    ft_start_btn = gr.Button("Start Fine-tune")
-                    ft_stop_btn = gr.Button("Stop Fine-tune")
-                    ft_start_status = gr.Textbox(label="Start/Stop status", interactive=False, lines=6)
-
-                    ft_tail_btn = gr.Button("Tail training logs")
-                    ft_logs = gr.Textbox(label="Training logs (tail)", interactive=False, lines=12)
-                with gr.Column(scale=1):
-                    gr.Markdown("### Notes & Tips")
-                    gr.Markdown(
-                        "- Old-files folder: include audio files and matching `.txt` transcripts with same basename (e.g. `call1.wav` + `call1.txt`).\n"
-                        "- When preparing dataset with both uploaded ZIP and old-files enabled, contents are merged into the fine-tune workspace.\n"
-                        "- If you pick `large-v3` ensure your installed whisper package supports that model name; otherwise select an available model.\n"
-                    )
-
-            def _prepare_action_with_old(uploaded, include_old, old_dir):
-                status, manifest = prepare_finetune_dataset(uploaded, include_old_files=include_old, old_files_dir=old_dir)
-                return status
-
-            ft_prepare_btn.click(fn=_prepare_action_with_old, inputs=[ft_upload, include_old_chk, old_files_dir], outputs=[ft_prepare_status])
-
-            def _start_action(ft_prepare_status_txt, ft_base_model, ft_epochs, ft_batch, ft_lr, ft_output_dir):
-                manifest_guess = os.path.join(FINETUNE_WORKDIR, "manifest.tsv")
+                    with gr.Box(elem_classes="card"):
+                        gr.Markdown("### Prepare & Launch Fine-tune")
+                        ft_upload = gr.File(label="Upload dataset ZIP (optional)", file_count="single", type="filepath")
+                        ft_include_old = gr.Checkbox(label="Include old audio+transcript folder", value=False)
+                        ft_old = gr.File(label="Old files folder (optional)", file_count="single", type="filepath")
+                        ft_prepare_btn = gr.Button("Prepare dataset")
+                        ft_manifest_box = gr.Textbox(label="Prepare status / manifest", lines=4, interactive=False)
+                        ft_model = gr.Dropdown(choices=["small","base","medium","large","large-v3"], value="small", label="Base model")
+                        ft_epochs = gr.Slider(minimum=1, maximum=100, value=3, step=1, label="Epochs")
+                        ft_start = gr.Button("Start (uses fine_tune.py placeholder)")
+                        ft_stop = gr.Button("Stop")
+                        ft_status = gr.Textbox(label="Start/Stop status", lines=4, interactive=False)
+                        ft_logs = gr.Textbox(label="Training logs (tail)", lines=8, interactive=False)
+
+            # Minimal prepare function reusing earlier code (kept compact)
+            def _prepare_finetune(uploaded_zip, include_old, old_dir):
+                dst=os.path.join(FINETUNE_WORKDIR,"data")
+                try:
+                    if os.path.exists(dst): shutil.rmtree(dst)
+                    os.makedirs(dst, exist_ok=True)
+                except Exception as e:
+                    return f"Workdir creation failed: {e}"
+                # extract uploaded zip if provided
+                if uploaded_zip:
+                    zpath = uploaded_zip.name if hasattr(uploaded_zip,"name") else str(uploaded_zip)
+                    if os.path.isfile(zpath) and zpath.lower().endswith(".zip"):
+                        try:
+                            with pyzipper.ZipFile(zpath,"r") as zf:
+                                zf.extractall(dst)
+                        except Exception as e:
+                            return f"ZIP extract failed: {e}"
+                # include old files if requested
+                old_msgs=""
+                if include_old and old_dir:
+                    old_path = old_dir.name if hasattr(old_dir,"name") else str(old_dir)
+                    if os.path.isdir(old_path):
+                        copied=0; msgs=[]
+                        for root,_,files in os.walk(old_path):
+                            for f in files:
+                                if f.lower().endswith((".wav",".mp3",".flac",".m4a",".ogg")):
+                                    base=os.path.splitext(f)[0]
+                                    src=os.path.join(root,f)
+                                    rel = os.path.relpath(root, old_path)
+                                    tgt_dir = os.path.join(dst, rel)
+                                    os.makedirs(tgt_dir, exist_ok=True)
+                                    shutil.copy2(src, os.path.join(tgt_dir,f))
+                                    ttxt = os.path.join(root, base+".txt")
+                                    if os.path.exists(ttxt):
+                                        shutil.copy2(ttxt, os.path.join(tgt_dir, base+".txt"))
+                                    copied+=1
+                        old_msgs = f"\nCopied ~{copied} old audio files."
+                    else:
+                        old_msgs = "\nOld-files path not a directory."
+                # simple manifest builder: audio \t transcript(empty or from .txt)
+                manifest = os.path.join(FINETUNE_WORKDIR,"manifest.tsv")
+                auds=[]
+                for root,_,files in os.walk(dst):
+                    for f in files:
+                        if f.lower().endswith((".wav",".mp3",".flac",".m4a",".ogg")):
+                            auds.append(os.path.join(root,f))
+                if not auds:
+                    return "No audio files found in prepared dataset."+old_msgs
+                lines=[]
+                missing=0
+                for a in auds:
+                    base=os.path.splitext(a)[0]; tfile=base+".txt"
+                    txt=""
+                    if os.path.exists(tfile):
+                        try:
+                            with open(tfile,"r",encoding="utf-8") as fh: txt=fh.read().strip().replace("\n"," ")
+                        except: txt=""
+                    else:
+                        missing+=1
+                    lines.append(f"{a}\t{txt}")
+                try:
+                    with open(manifest,"w",encoding="utf-8") as fh: fh.write("\n".join(lines))
+                except Exception as e:
+                    return f"Manifest write failed: {e}"
+                out = f"Prepared manifest: {manifest}{old_msgs}"
+                if missing>0: out += f"\nWarning: {missing} audio files missing transcripts."
+                return out
+
+            def _start_ft(dummy, model, epochs):
+                # placeholder: you must supply fine_tune.py in root or change this behavior
+                manifest_guess = os.path.join(FINETUNE_WORKDIR,"manifest.tsv")
                 if not os.path.exists(manifest_guess):
-                    return "Manifest not found. Prepare dataset first or manually provide manifest."
-                status = start_finetune(manifest_guess, ft_base_model, int(ft_epochs), int(ft_batch), float(ft_lr), ft_output_dir)
-                return status
-
-            ft_start_btn.click(fn=_start_action, inputs=[ft_prepare_status, ft_base_model, ft_epochs, ft_batch, ft_lr, ft_output_dir], outputs=[ft_start_status])
-            ft_stop_btn.click(fn=lambda: stop_finetune(), inputs=[], outputs=[ft_start_status])
-            ft_tail_btn.click(fn=lambda: tail_finetune_logs(), inputs=[], outputs=[ft_logs])
-
-# ---------- Launch ----------
+                    return "Manifest not found. Prepare dataset first."
+                try:
+                    cmd = [sys.executable, "fine_tune.py", "--manifest", manifest_guess, "--base_model", model, "--epochs", str(int(epochs))]
+                    # run in background (simple)
+                    p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                    return f"Started fine-tune (PID {p.pid}). Make sure your training script exists."
+                except Exception as e:
+                    return f"Failed to start fine-tune: {e}"
+
+            ft_prepare.click(fn=_prepare_finetune, inputs=[ft_upload, ft_include_old, ft_old], outputs=[ft_manifest_box])
+            ft_start.click(fn=_start_ft, inputs=[ft_manifest_box, ft_model, ft_epochs], outputs=[ft_status])
+            ft_stop.click(fn=lambda: "Stop not implemented in placeholder", inputs=[], outputs=[ft_status])
+
+        # ---- Settings Tab ----
+        with gr.TabItem("Settings ⚙️"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Runtime & tips")
+                    gr.Markdown("- Use large-v3 only if your `whisper` package supports it.")
+                    gr.Markdown("- Extraction writes to system temp `extracted_audio`. Re-extracting overwrites it.")
+                    gr.Markdown("- Keep default ZIP password empty for safety.")
+                with gr.Column():
+                    gr.Markdown("### Diagnostics")
+                    diag_btn = gr.Button("Show memory summary")
+                    diag_out = gr.Textbox(label="Diagnostics", lines=12, interactive=False)
+                    diag_btn.click(fn=lambda: (lambda: view_memory())(), inputs=[], outputs=[diag_out])
+
+# Launch
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     print("DEBUG: launching Gradio on port", port, flush=True)
-    try:
-        demo.queue().launch(server_name="0.0.0.0", server_port=port)
-    except Exception as e:
-        print("FATAL: demo.launch failed:", e, flush=True)
-        traceback.print_exc()
-        raise
+    demo.queue().launch(server_name="0.0.0.0", server_port=port)