Update app.py

app.py

@@ -1,45 +1,65 @@
 """
 ClearWave AI Studio
-Fixed app.py — compatible with:
-  - New denoiser.py (Cleanvoice API)
-  - Our transcriber.py (Groq Whisper large-v3)
-  - Our translator.py (Helsinki-NLP + Google fallback)
-
-FIXES:
-  - transcriber.transcribe() returns tuple (text, lang, method) — handled correctly
-  - translator.translate() takes (text, src_lang, tgt_lang) — handled correctly
-  - Added all languages not just English
-  - Added microphone input tab
-  - Added stats output
-  - Added API routes for /api/health and /api/process-url
-  - Background job system for long audio (no timeouts)
-  - Format converter for .mpeg/.mp4/.m4a etc.
+
+STARTUP FIX:
+  Root cause of "stuck at startup":
+    - Transcriber() was initializing Groq client at import time
+    - Translator() was firing a background thread that downloaded
+      Helsinki-NLP models (~600MB) from HuggingFace immediately at startup
+    - On HuggingFace Spaces, this causes the container health check to time out
+
+  Fix: All three services are now lazy-initialized — nothing downloads or
+  connects until the first actual audio is processed.
 """
 
 import gradio as gr
 import os
-import uuid
-import json
-import base64
 import tempfile
 import subprocess
 import threading
 import time
 import requests as req
-import numpy as np
 import logging
+import uuid
 from datetime import datetime
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-from denoiser    import Denoiser
-from transcriber import Transcriber
-from translator  import Translator
-
-denoiser    = Denoiser()
-transcriber = Transcriber()
-translator  = Translator()
+# ══════════════════════════════════════════════════════════════════════
+# LAZY SERVICE INIT — nothing loads at startup
+# ══════════════════════════════════════════════════════════════════════
+_denoiser    = None
+_transcriber = None
+_translator  = None
+_init_lock   = threading.Lock()
+
+def get_denoiser():
+    global _denoiser
+    if _denoiser is None:
+        with _init_lock:
+            if _denoiser is None:
+                from denoiser import Denoiser
+                _denoiser = Denoiser()
+    return _denoiser
+
+def get_transcriber():
+    global _transcriber
+    if _transcriber is None:
+        with _init_lock:
+            if _transcriber is None:
+                from transcriber import Transcriber
+                _transcriber = Transcriber()
+    return _transcriber
+
+def get_translator():
+    global _translator
+    if _translator is None:
+        with _init_lock:
+            if _translator is None:
+                from translator import Translator
+                _translator = Translator()
+    return _translator
 
 LANGUAGES = {
     "Auto Detect": "auto",
@@ -90,23 +110,33 @@ threading.Thread(target=_cleanup, daemon=True).start()
 
 # ══════════════════════════════════════════════════════════════════════
 # FORMAT CONVERTER
+# NOTE: This is only used to handle exotic formats (mp4, webm, etc.)
+#       that Cleanvoice might not accept. For common formats (mp3, wav,
+#       aac, flac) we pass the file directly to Cleanvoice untouched.
 # ══════════════════════════════════════════════════════════════════════
-def convert_to_wav(path):
+CLEANVOICE_NATIVE = {".mp3", ".wav", ".flac", ".ogg", ".aac", ".m4a", ".opus"}
+
+def maybe_convert_for_cleanvoice(path):
+    """Only convert truly exotic formats. Leave common ones untouched."""
     if not path:
         return path
     ext = os.path.splitext(path)[1].lower()
-    if ext in [".wav", ".mp3", ".flac", ".ogg", ".aac"]:
-        return path
+    if ext in CLEANVOICE_NATIVE:
+        return path  # pass through untouched
+    # Exotic format (mp4, webm, mpeg, amr, wma...) → convert to wav
     try:
         out = path + "_converted.wav"
-        r   = subprocess.run(["ffmpeg", "-y", "-i", path,
-                               "-ar", "16000", "-ac", "1",
-                               "-acodec", "pcm_s16le", out],
-                              capture_output=True)
+        r   = subprocess.run([
+            "ffmpeg", "-y", "-i", path,
+            "-vn",                   # drop video if present
+            "-acodec", "pcm_s16le",  # PCM wav — universally accepted
+            out
+        ], capture_output=True)
         if r.returncode == 0 and os.path.exists(out):
+            print(f"[app] Converted exotic format {ext} → WAV")
             return out
     except Exception as e:
-        logger.warning(f"Convert error: {e}")
+        logger.warning(f"Format conversion failed: {e}")
     return path
 
 # ══════════════════════════════════════════════════════════════════════
@@ -126,8 +156,7 @@ def run_pipeline(audio_path, src_lang="auto", tgt_lang="te",
     try:
         # ── Step 1: Denoise ──────────────────────────────────────────
         yield progress(1, "⏳ Step 1/4 — Cleaning audio (Cleanvoice)...")
-        # FIX: Pass correct parameter names to denoiser
-        res   = denoiser.process(
+        res   = get_denoiser().process(
             audio_path, out_dir,
             remove_fillers=opt_fillers,
             remove_stutters=opt_stutters,
@@ -138,9 +167,7 @@ def run_pipeline(audio_path, src_lang="auto", tgt_lang="te",
 
         # ── Step 2: Transcribe ───────────────────────────────────────
         yield progress(2, "⏳ Step 2/4 — Transcribing...")
-
-        # transcriber.transcribe() returns (text, detected_lang, method)
-        t_result = transcriber.transcribe(clean, src_lang)
+        t_result = get_transcriber().transcribe(clean, src_lang)
         if isinstance(t_result, tuple):
             transcript, detected_lang, t_method = t_result
         elif isinstance(t_result, dict):
@@ -152,9 +179,8 @@ def run_pipeline(audio_path, src_lang="auto", tgt_lang="te",
             detected_lang = src_lang
             t_method      = "unknown"
 
-        # Clean fillers from transcript text too
         if opt_fillers:
-            transcript = denoiser.clean_transcript_fillers(transcript)
+            transcript = get_denoiser().clean_transcript_fillers(transcript)
 
         # ── Step 3: Translate ────────────────────────────────────────
         translation = transcript
@@ -162,8 +188,7 @@ def run_pipeline(audio_path, src_lang="auto", tgt_lang="te",
 
         if tgt_lang != "auto" and detected_lang != tgt_lang:
             yield progress(3, "⏳ Step 3/4 — Translating...")
-            # translator.translate() returns (translated_text, method)
-            t_out = translator.translate(transcript, detected_lang, tgt_lang)
+            t_out = get_translator().translate(transcript, detected_lang, tgt_lang)
             if isinstance(t_out, tuple):
                 translation, tl_method = t_out
             else:
@@ -172,13 +197,14 @@ def run_pipeline(audio_path, src_lang="auto", tgt_lang="te",
         # ── Step 4: Export MP3 ───────────────────────────────────────
         yield progress(4, "⏳ Step 4/4 — Exporting...")
         final_mp3 = os.path.join(out_dir, "ClearWave_Final.mp3")
-        # FIX: Use 320kbps MP3 + preserve original sample rate (was 46kbps at 16kHz — very low quality)
-        subprocess.run(["ffmpeg", "-y", "-i", clean,
-                        "-codec:a", "libmp3lame",
-                        "-b:a", "320k",          # 320kbps — high quality
-                        "-ar", "48000",          # restore 48kHz sample rate
-                        "-ac", "2",              # restore stereo
-                        final_mp3], capture_output=True)
+        subprocess.run([
+            "ffmpeg", "-y", "-i", clean,
+            "-codec:a", "libmp3lame",
+            "-b:a", "320k",
+            "-ar", "48000",
+            "-ac", "2",
+            final_mp3
+        ], capture_output=True)
 
         audio_path_out = final_mp3 if os.path.exists(final_mp3) else clean
 
@@ -229,7 +255,6 @@ def process_audio_gradio(upload_file, mic_audio, in_lang_name,
                           out_lang_name, opt_fillers, opt_stutters,
                           opt_silences):
 
-    # ── Resolve audio input ───────────────────────────────────────────
     audio_path = None
     if upload_file is not None:
         if isinstance(upload_file, dict):
@@ -254,10 +279,9 @@ def process_audio_gradio(upload_file, mic_audio, in_lang_name,
                "", "", None, "")
         return
 
-    # ── Convert format ────────────────────────────────────────────────
-    audio_path = convert_to_wav(audio_path)
+    # Only convert truly exotic formats — leave mp3/wav/aac untouched
+    audio_path = maybe_convert_for_cleanvoice(audio_path)
 
-    # ── Force booleans ────────────────────────────────────────────────
     opt_fillers  = bool(opt_fillers)
     opt_stutters = bool(opt_stutters)
     opt_silences = bool(opt_silences)
@@ -268,7 +292,6 @@ def process_audio_gradio(upload_file, mic_audio, in_lang_name,
     print(f"[Gradio] src={src_lang} tgt={tgt_lang} "
           f"fillers={opt_fillers} stutters={opt_stutters}")
 
-    # ── Background job ────────────────────────────────────────────────
     job_id = _new_job()
     threading.Thread(
         target=_bg_run,
@@ -277,7 +300,6 @@ def process_audio_gradio(upload_file, mic_audio, in_lang_name,
         daemon=True,
     ).start()
 
-    # ── Poll ──────────────────────────────────────────────────────────
     while True:
         time.sleep(1)
         job    = _get_job(job_id)
@@ -315,7 +337,6 @@ with gr.Blocks(title="ClearWave AI Studio") as demo:
     gr.Markdown("# 🎙️ ClearWave AI Studio\n### Professional Audio Enhancement")
     with gr.Row():
         with gr.Column(scale=1):
-
             with gr.Tabs():
                 with gr.Tab("📁 Upload File"):
                     audio_in = gr.File(
@@ -349,32 +370,24 @@ with gr.Blocks(title="ClearWave AI Studio") as demo:
                 opt_s = gr.Checkbox(label="🔁 Remove Stutters", value=True)
             opt_z = gr.Checkbox(label="🤫 Remove Silences", value=True)
 
-            btn        = gr.Button("🚀 Process Audio",
-                                   variant="primary", size="lg")
-            status_out = gr.Textbox(label="Status",
-                                    interactive=False, lines=2)
+            btn        = gr.Button("🚀 Process Audio", variant="primary", size="lg")
+            status_out = gr.Textbox(label="Status", interactive=False, lines=2)
 
         with gr.Column(scale=2):
             with gr.Tabs():
                 with gr.Tab("📝 Text"):
                     with gr.Row():
-                        transcript_out  = gr.Textbox(
-                            label="Transcript",  lines=12)
-                        translation_out = gr.Textbox(
-                            label="Translation", lines=12)
+                        transcript_out  = gr.Textbox(label="Transcript",  lines=12)
+                        translation_out = gr.Textbox(label="Translation", lines=12)
                 with gr.Tab("🔊 Clean Audio"):
-                    audio_out = gr.Audio(
-                        label="Enhanced Audio", type="filepath")
+                    audio_out = gr.Audio(label="Enhanced Audio", type="filepath")
                 with gr.Tab("📊 Stats"):
-                    stats_out = gr.Textbox(
-                        label="Stats", lines=10, interactive=False)
+                    stats_out = gr.Textbox(label="Stats", lines=10, interactive=False)
 
     btn.click(
         fn=process_audio_gradio,
-        inputs=[audio_in, mic_in, in_lang, out_lang,
-                opt_f, opt_s, opt_z],
-        outputs=[status_out, transcript_out, translation_out,
-                 audio_out, stats_out],
+        inputs=[audio_in, mic_in, in_lang, out_lang, opt_f, opt_s, opt_z],
+        outputs=[status_out, transcript_out, translation_out, audio_out, stats_out],
     )
 
 # ══════════════════════════════════════════════════════════════════════
@@ -431,7 +444,7 @@ async def api_process_url(request: _Req):
                         _update_job(job_id, status="downloading",
                                     message=f"Downloading... {pct}%")
             tmp.close()
-            audio_path = convert_to_wav(tmp_path)
+            audio_path = maybe_convert_for_cleanvoice(tmp_path)
             for _ in run_pipeline(audio_path, src_lang, tgt_lang,
                                   opt_fillers, opt_stutters, opt_silences,
                                   job_id=job_id):
@@ -445,7 +458,7 @@ async def api_process_url(request: _Req):
         finally:
             for p in [tmp_path, audio_path]:
                 try:
-                    if p and os.path.exists(p):
+                    if p and p != tmp_path and os.path.exists(p):
                         os.unlink(p)
                 except Exception:
                     pass
@@ -474,7 +487,7 @@ async def api_list_jobs():
              for k, v in _jobs.items()}
     return _JSON({"jobs": s, "total": len(s)})
 
-logger.info("✅ Routes: /api/health, /api/process-url, /api/job/{id}")
+logger.info("✅ ClearWave AI Studio ready — services lazy-loaded on first use")
 
 if __name__ == "__main__":
     demo.launch(ssr_mode=False)