feat: add jobs tracking and reverb effect

- Add Jobs tab with real-time job status display
- Show job ID, model, status, elapsed time, and download link
- Add queue status summary (waiting, running, done, failed)
- Add refresh and clear completed jobs buttons
- Display download link as clickable emoji (⬇️) in markdown format
- Add reverb effect using pedalboard library
- Add UI controls for reverb (enable checkbox, mix slider)
- Remove in-memory log buffer, use file logs instead

app.py

@@ -4,7 +4,6 @@ Simple, fast, GPU/CPU auto-detected.
 """
 from __future__ import annotations
 
-import collections
 import logging
 import os
 import queue
@@ -31,28 +30,11 @@ OUTPUT_DIR.mkdir(exist_ok=True)
 
 os.environ.setdefault("URVC_MODELS_DIR", str(MODELS_DIR / "urvc"))
 
-# ── In-memory log buffer (feeds the Logs tab) ────────────────────────────────
-_LOG_BUFFER: collections.deque[str] = collections.deque(maxlen=200)
-
-
-class _UILogHandler(logging.Handler):
-    def emit(self, record: logging.LogRecord) -> None:
-        _LOG_BUFFER.append(self.format(record))
-
-
-_ui_handler = _UILogHandler()
-_ui_handler.setLevel(logging.INFO)
-_ui_handler.setFormatter(logging.Formatter(
-    fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-    datefmt="%H:%M:%S",
-))
-
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
     datefmt="%H:%M:%S",
 )
-logging.getLogger().addHandler(_ui_handler)
 
 for _noisy in ("httpx", "httpcore", "faiss", "faiss.loader", "transformers", "torch"):
     logging.getLogger(_noisy).setLevel(logging.WARNING)
@@ -271,22 +253,40 @@ def toggle_autotune(enabled):
     return gr.update(visible=enabled)
 
 
-# ── Reverb IR generator ────────────────────────────────────────────────────────
-def _generate_reverb_ir(sr: int, decay: float = 0.5, length_ms: int = 500) -> np.ndarray:
-    """Generate a simple reverb impulse response."""
-    import numpy as np
-    length_samples = int(sr * length_ms / 1000)
-    t = np.arange(length_samples) / sr
-    ir = np.exp(-t / (decay * 0.5)) * np.random.randn(length_samples)
-    ir = ir / np.max(np.abs(ir))
-    return ir
-
-
 # ── ffmpeg is pre-installed on HuggingFace Spaces ────────────────────────────
 def _ffmpeg_bin() -> str:
     return "ffmpeg"
 
 
+# ── Reverb effect via pedalboard ─────────────────────────────────────────────
+def _apply_reverb(audio_path: str, room_size: float, damping: float, wet_level: float) -> None:
+    """Apply reverb in-place to a WAV file using pedalboard."""
+    try:
+        from pedalboard import Pedalboard, Reverb
+        from pedalboard.io import AudioFile
+        import tempfile, shutil
+
+        tmp = audio_path + ".reverb.tmp.wav"
+        board = Pedalboard([
+            Reverb(
+                room_size=room_size,
+                damping=damping,
+                wet_level=wet_level,
+                dry_level=1.0 - wet_level,
+                width=1.0,
+            )
+        ])
+        with AudioFile(audio_path) as f:
+            with AudioFile(tmp, "w", f.samplerate, f.num_channels) as out:
+                while f.tell() < f.frames:
+                    chunk = f.read(f.samplerate)
+                    out.write(board(chunk, f.samplerate, reset=False))
+        shutil.move(tmp, audio_path)
+        logger.info("Reverb applied (room=%.2f, damp=%.2f, wet=%.2f)", room_size, damping, wet_level)
+    except Exception as exc:
+        logger.warning("Reverb failed: %s", exc)
+
+
 # ── Upload to temp.sh ────────────────────────────────────────────────────────
 def _upload_to_tempsh(file_path: str) -> str | None:
     """Upload a file to temp.sh and return the download URL, or None on failure."""
@@ -324,6 +324,7 @@ def _worker() -> None:
         job = _job_queue.get()
         job_id  = job["id"]
         try:
+            _start_time = time.time()
             with _jobs_lock:
                 _jobs[job_id]["status"] = "⏳ Converting…"
 
@@ -341,41 +342,25 @@ def _worker() -> None:
                 else f"output-{ts}.{job['output_format'].lower()}"
             )
 
-        vc = _get_vc()
-        vc.convert_audio(
-            audio_input_path=job["audio_input"],
-            audio_output_path=str(wav_path),
-            model_path=model_path,
-            index_path=index_path,
-            pitch=job["pitch"],
-            f0_method=job["f0_method"],
-            index_rate=job["index_rate"],
-            volume_envelope=job["volume_envelope"],
-            protect=job["protect"],
-            split_audio=job["split_audio"],
-            f0_autotune=job["autotune"],
-            f0_autotune_strength=job["autotune_strength"],
-            clean_audio=job["clean_audio"],
-            clean_strength=job["clean_strength"],
-            export_format=engine_format,
-            filter_radius=job["filter_radius"],
-        )
-
-        if job["reverb"]:
-            import numpy as np
-            import soundfile as sf
-            from scipy.signal import convolve
-
-            audio_data, sr = sf.read(str(wav_path))
-            if audio_data.ndim > 1:
-                audio_data = audio_data.mean(axis=1)
-
-            reverb_ir = _generate_reverb_ir(sr, decay=job["reverb_mix"])
-            reverb_signal = convolve(audio_data, reverb_ir, mode="same")
-            mix = job["reverb_mix"]
-            audio_data = audio_data * (1 - mix) + reverb_signal * mix
-
-            sf.write(str(wav_path), audio_data, sr)
+            vc = _get_vc()
+            vc.convert_audio(
+                audio_input_path=job["audio_input"],
+                audio_output_path=str(wav_path),
+                model_path=model_path,
+                index_path=index_path,
+                pitch=job["pitch"],
+                f0_method=job["f0_method"],
+                index_rate=job["index_rate"],
+                volume_envelope=job["volume_envelope"],
+                protect=job["protect"],
+                split_audio=job["split_audio"],
+                f0_autotune=job["autotune"],
+                f0_autotune_strength=job["autotune_strength"],
+                clean_audio=job["clean_audio"],
+                clean_strength=job["clean_strength"],
+                export_format=engine_format,
+                filter_radius=job["filter_radius"],
+            )
 
             if is_opus:
                 import subprocess
@@ -393,25 +378,40 @@ def _worker() -> None:
                 )
                 wav_path.unlink(missing_ok=True)
 
+            # Apply reverb if enabled (operates on the final output file)
+            if job.get("reverb"):
+                _apply_reverb(
+                    str(out_path),
+                    room_size=job.get("reverb_room_size", 0.15),
+                    damping=job.get("reverb_damping", 0.7),
+                    wet_level=job.get("reverb_wet_level", 0.15),
+                )
+
             # Upload to temp.sh
             temp_url = _upload_to_tempsh(str(out_path))
 
+            _elapsed = time.time() - _start_time
+            _elapsed_str = f"{_elapsed:.0f}s" if _elapsed < 60 else f"{_elapsed/60:.1f}m"
             with _jobs_lock:
+                _jobs[job_id]["elapsed"] = _elapsed_str
                 if temp_url:
-                    _jobs[job_id]["status"] = f"✅ Done!"
+                    _jobs[job_id]["status"] = "✅ Done"
                     _jobs[job_id]["url"]    = temp_url
                     _jobs[job_id]["file"]   = str(out_path)
-                    logger.info("[Job %s] Complete → %s", job_id, temp_url)
+                    logger.info("[Job %s] Complete in %s → %s", job_id, _elapsed_str, temp_url)
                 else:
-                    _jobs[job_id]["status"] = "✅ Done! (temp.sh unavailable — download from Logs)"
+                    _jobs[job_id]["status"] = "✅ Done"
                     _jobs[job_id]["file"]   = str(out_path)
-                    logger.info("[Job %s] Complete (no temp.sh URL)", job_id)
+                    logger.info("[Job %s] Complete in %s (no temp.sh URL)", job_id, _elapsed_str)
 
         except Exception as exc:
-            logger.exception("[Job %s] Failed: %s", job_id, exc)
+            _elapsed = time.time() - _start_time if "_start_time" in dir() else 0
+            _elapsed_str = f"{_elapsed:.0f}s" if _elapsed < 60 else f"{_elapsed/60:.1f}m"
+            logger.exception("[Job %s] Failed after %s: %s", job_id, _elapsed_str, exc)
             with _jobs_lock:
-                _jobs[job_id]["status"] = f"❌ Failed: {exc}"
-                _jobs[job_id]["file"]   = None
+                _jobs[job_id]["status"]  = f"❌ Failed"
+                _jobs[job_id]["elapsed"] = _elapsed_str
+                _jobs[job_id]["file"]    = None
         finally:
             _job_queue.task_done()
 
@@ -431,7 +431,10 @@ def convert(
     split_audio, autotune, autotune_strength,
     filter_radius,
     output_format,
-    reverb, reverb_mix,
+    reverb=False,
+    reverb_room_size=0.15,
+    reverb_damping=0.7,
+    reverb_wet_level=0.15,
 ):
     """Submit a job to the background worker and return immediately."""
     audio_input = audio_mic or audio_file
@@ -462,23 +465,25 @@ def convert(
 
     job_id = uuid.uuid4().hex[:8]
     job = {
-        "id": job_id,
-        "audio_input": audio_input,
-        "model_name": model_name,
-        "pitch": pitch,
-        "f0_method": f0_method,
-        "index_rate": index_rate,
-        "volume_envelope": volume_envelope,
-        "protect": protect,
-        "split_audio": split_audio,
-        "autotune": autotune,
+        "id":               job_id,
+        "audio_input":      audio_input,
+        "model_name":       model_name,
+        "pitch":            pitch,
+        "f0_method":        f0_method,
+        "index_rate":       index_rate,
+        "volume_envelope":  volume_envelope,
+        "protect":          protect,
+        "split_audio":      split_audio,
+        "autotune":         autotune,
         "autotune_strength": autotune_strength,
-        "clean_audio": clean_audio,
-        "clean_strength": clean_strength,
-        "filter_radius": filter_radius,
-        "output_format": output_format,
-        "reverb": reverb,
-        "reverb_mix": reverb_mix,
+        "clean_audio":      clean_audio,
+        "clean_strength":   clean_strength,
+        "filter_radius":    filter_radius,
+        "output_format":    output_format,
+        "reverb":           reverb,
+        "reverb_room_size": reverb_room_size,
+        "reverb_damping":   reverb_damping,
+        "reverb_wet_level": reverb_wet_level,
     }
 
     with _jobs_lock:
@@ -490,9 +495,9 @@ def convert(
     logger.info("[Job %s] Queued (model: %s, queue depth: %d)", job_id, model_name, queue_size)
 
     msg = (
-        f"🕐 Job **{job_id}** queued — you can close this tab. "
-        f"Check the **📋 Logs** tab for your temp.sh download link when done. "
-        f"_(Queue position: {queue_size})_"
+        "🕐 Job **" + job_id + "** queued — you can close this tab.\n\n"
+        "Check the **📋 Logs** tab for your temp.sh link when done.\n\n"
+        "_(Queue position: " + str(queue_size) + ")_"
     )
     return msg, None
 
@@ -528,8 +533,42 @@ _initial_value = _default_model if _default_model in _initial_models else (
 
 
 # ── Log helpers ───────────────────────────────────────────────────────────────
-def get_logs() -> str:
-    return "\n".join(_LOG_BUFFER) if _LOG_BUFFER else "(no logs yet)"
+
+
+def get_jobs_table() -> list[list]:
+    """Return job list as rows: [ID, Model, Status, Time, Download Link]."""
+    with _jobs_lock:
+        jobs = list(_jobs.items())
+    if not jobs:
+        return [["—", "—", "No jobs yet", "—", "—"]]
+    rows = []
+    for job_id, info in reversed(jobs):
+        url = info.get("url")
+        link = f"[⬇️]({url})" if url else "—"
+        rows.append([
+            job_id,
+            info.get("model", ""),
+            info.get("status", ""),
+            info.get("elapsed", "—"),
+            link,
+        ])
+    return rows
+
+
+def get_queue_info() -> str:
+    """Return a short queue status string."""
+    qs = _job_queue.qsize()
+    total = len(_jobs)
+    running = sum(1 for j in _jobs.values() if j.get("status", "").startswith("⏳"))
+    done    = sum(1 for j in _jobs.values() if j.get("status", "").startswith("✅"))
+    failed  = sum(1 for j in _jobs.values() if j.get("status", "").startswith("❌"))
+    return (
+        f"**Queue:** {qs} waiting  ·  "
+        f"**Running:** {running}  ·  "
+        f"**Done:** {done}  ·  "
+        f"**Failed:** {failed}  ·  "
+        f"**Total:** {total}"
+    )
 
 
 # ── Gradio UI ─────────────────────────────────────────────────────────────────
@@ -625,42 +664,50 @@ with gr.Blocks(title="RVC Voice Conversion", css=_CSS, delete_cache=(3600, 3600)
                                 0.0, 1.0, value=0.5, step=0.05,
                                 label="Reduction Strength",
                             )
-            with gr.Row():
-                split_cb = gr.Checkbox(value=False, label="Split Long Audio")
-                autotune_cb = gr.Checkbox(value=False, label="Autotune")
-                autotune_sl = gr.Slider(
-                    0.0, 1.0, value=1.0, step=0.05,
-                    label="Autotune Strength",
-                    visible=False,
-                )
-                autotune_cb.change(
-                    fn=toggle_autotune,
-                    inputs=autotune_cb,
-                    outputs=autotune_sl,
-                )
-            with gr.Row():
-                reverb_cb = gr.Checkbox(value=False, label="Reverb Effect")
-                reverb_sl = gr.Slider(
-                    0.0, 1.0, value=0.5, step=0.05,
-                    label="Reverb Mix",
-                    visible=False,
-                )
-                reverb_cb.change(
-                    fn=lambda x: gr.Slider(visible=x),
-                    inputs=reverb_cb,
-                    outputs=reverb_sl,
-                )
+                        with gr.Row():
+                            split_cb    = gr.Checkbox(value=False, label="Split Long Audio")
+                            autotune_cb = gr.Checkbox(value=False, label="Autotune")
+                        autotune_sl = gr.Slider(
+                            0.0, 1.0, value=1.0, step=0.05,
+                            label="Autotune Strength",
+                            visible=False,
+                        )
                         autotune_cb.change(
                             fn=toggle_autotune,
                             inputs=autotune_cb,
                             outputs=autotune_sl,
                         )
 
+                        gr.Markdown("**🎛️ Reverb**")
+                        reverb_cb = gr.Checkbox(value=False, label="Enable Reverb")
+                        with gr.Group(visible=False) as reverb_group:
+                            reverb_room_sl = gr.Slider(
+                                0.0, 1.0, value=0.15, step=0.05,
+                                label="Room Size",
+                                info="Larger = bigger sounding space",
+                            )
+                            reverb_damp_sl = gr.Slider(
+                                0.0, 1.0, value=0.7, step=0.05,
+                                label="Damping",
+                                info="Higher = more absorption, less echo tail",
+                            )
+                            reverb_wet_sl = gr.Slider(
+                                0.0, 1.0, value=0.15, step=0.05,
+                                label="Wet Level",
+                                info="How much reverb is mixed in (0.15 = subtle)",
+                            )
+                        reverb_cb.change(
+                            fn=lambda v: gr.update(visible=v),
+                            inputs=reverb_cb,
+                            outputs=reverb_group,
+                        )
+
                     fmt_radio = gr.Radio(
-        choices=["WAV", "MP3", "FLAC", "OPUS"],
-        value="WAV",
-        label="Output Format",
-    )
+                        choices=["WAV", "MP3", "FLAC", "OPUS"],
+                        value="WAV",
+                        label="Output Format",
+                        info="OPUS = small file (~64 kbps, Telegram/Discord quality)",
+                    )
                     convert_btn = gr.Button(
                         "🚀  Convert Voice",
                         variant="primary",
@@ -721,26 +768,35 @@ with gr.Blocks(title="RVC Voice Conversion", css=_CSS, delete_cache=(3600, 3600)
                 outputs=[models_table, model_dd],
             )
 
-        # ── TAB 3: Logs ───────────────────────────────────────────────────────
-        with gr.Tab("📋  Logs"):
-            gr.Markdown("Live log output from the conversion engine. Click **Refresh** to update.")
-            logs_box = gr.Textbox(
-                value=get_logs,
-                label="",
-                lines=20,
-                max_lines=20,
+        # ── TAB 3: Jobs ───────────────────────────────────────────────────────
+        with gr.Tab("📋 Jobs"):
+            gr.Markdown("All submitted jobs, newest first. Click **Refresh** to update.")
+            queue_status = gr.Markdown(value=get_queue_info)
+            jobs_table = gr.Dataframe(
+                headers=["Job ID", "Model", "Status", "Time", "Download"],
+                col_count=(5, "fixed"),
+                value=get_jobs_table,
                 interactive=False,
+                wrap=True,
+                datatype=["str", "str", "str", "str", "markdown"],
             )
             with gr.Row():
-                refresh_logs_btn = gr.Button("🔄  Refresh Logs")
-                clear_logs_btn   = gr.Button("🗑️  Clear")
+                refresh_jobs_btn = gr.Button("🔄  Refresh")
+                clear_jobs_btn   = gr.Button("🗑️  Clear Done")
 
-            def clear_logs():
-                _LOG_BUFFER.clear()
-                return ""
+            def _refresh_jobs():
+                return get_queue_info(), get_jobs_table()
 
-            refresh_logs_btn.click(fn=get_logs, outputs=logs_box)
-            clear_logs_btn.click(fn=clear_logs, outputs=logs_box)
+            def _clear_done_jobs():
+                with _jobs_lock:
+                    done_ids = [jid for jid, j in _jobs.items()
+                                if j.get("status", "").startswith(("✅", "❌"))]
+                    for jid in done_ids:
+                        del _jobs[jid]
+                return get_queue_info(), get_jobs_table()
+
+            refresh_jobs_btn.click(fn=_refresh_jobs, outputs=[queue_status, jobs_table])
+            clear_jobs_btn.click(fn=_clear_done_jobs, outputs=[queue_status, jobs_table])
 
         # ── TAB 4: Help ───────────────────────────────────────────────────────
         with gr.Tab("ℹ️  Help"):
@@ -812,36 +868,40 @@ with gr.Blocks(title="RVC Voice Conversion", css=_CSS, delete_cache=(3600, 3600)
             Engine: [Ultimate RVC](https://github.com/JackismyShephard/ultimate-rvc)
             """)
 
-    # Wire convert button after all tabs so logs_box is defined
+    # Wire convert button after all tabs so jobs_table is defined
     def _submit_and_extract_id(*args):
         status, audio = convert(*args)
-        # Extract job ID from status message for auto-populating the poll box
         import re
-        match = re.search(r"\*\*([a-f0-9]{8})\*\*", status or "")
-        job_id = match.group(1) if match else ""
-        return status, audio, job_id, get_logs()
-
-convert_btn.click(
-    fn=_submit_and_extract_id,
-    inputs=[
-        inp_mic, inp_file, model_dd,
-        pitch_sl, f0_radio,
-        index_rate_sl, protect_sl, vol_env_sl,
-        clean_cb, clean_sl,
-        split_cb, autotune_cb, autotune_sl,
-        filter_radius_sl,
-        fmt_radio,
-        reverb_cb, reverb_sl,
-    ],
-    outputs=[out_status, out_audio, job_id_box, logs_box],
-)
+        match = re.search(r"[a-f0-9]{8}", status or "")
+        job_id = match.group(0) if match else ""
+        return status, audio, job_id, get_queue_info(), get_jobs_table()
+
+    convert_btn.click(
+        fn=_submit_and_extract_id,
+        inputs=[
+            inp_mic, inp_file, model_dd,
+            pitch_sl, f0_radio,
+            index_rate_sl, protect_sl, vol_env_sl,
+            clean_cb, clean_sl,
+            split_cb, autotune_cb, autotune_sl,
+            filter_radius_sl,
+            fmt_radio,
+            reverb_cb, reverb_room_sl, reverb_damp_sl, reverb_wet_sl,
+        ],
+        outputs=[out_status, out_audio, job_id_box, queue_status, jobs_table],
+    )
+
+    def _poll_and_refresh(job_id):
+        status, file = poll_job(job_id)
+        return status, file, get_queue_info(), get_jobs_table()
 
     poll_btn.click(
-        fn=poll_job,
+        fn=_poll_and_refresh,
         inputs=[job_id_box],
-        outputs=[poll_status, poll_audio],
+        outputs=[poll_status, poll_audio, queue_status, jobs_table],
     )
 
+
 # ── Launch ────────────────────────────────────────────────────────────────────
 if __name__ == "__main__":
     demo.queue(default_concurrency_limit=5)