Update app.py

app.py

@@ -1,10 +1,10 @@
 import os, warnings, logging, tempfile
 
-# --- Suppression warnings inutile ---
+# === STOP useless warnings ===
 warnings.filterwarnings("ignore")
 logging.getLogger("nemo_logger").setLevel(logging.ERROR)
 
-# --- CPU compatibility for HF Spaces ---
+# === CPU fallback for HuggingFace ===
 os.environ["NEMO_FORCE_CPU"] = "1"
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
@@ -14,22 +14,33 @@ torch.set_grad_enabled(False)
 import gradio as gr
 import numpy as np
 import soundfile as sf
+
+# === Force MoviePy to use ImageMagick ===
+import moviepy.config as mpconf
+mpconf.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
+
 from moviepy.editor import VideoFileClip, CompositeVideoClip, TextClip
 from nemo.collections import asr as nemo_asr
 
-# --- UNLOCK IMAGEMAGICK POLICY (Required on HF) ---
-for p in ("/etc/ImageMagick/policy.xml", "/etc/ImageMagick-6/policy.xml"):
-    if os.path.exists(p):
-        os.system(
-            'sed -i "s/rights=\\"none\\"/rights=\\"read|write\\"/g" "{}"'.format(p)
-        )
+
+# === FIX IMAGEMAGICK POLICY (Required on HF Spaces) ===
+def unlock_imagemagick():
+    POLICIES = [
+        "/etc/ImageMagick/policy.xml",
+        "/etc/ImageMagick-6/policy.xml"
+    ]
+    for p in POLICIES:
+        if os.path.exists(p):
+            print(f"⚙️ Patching ImageMagick security: {p}")
+            os.system(f"sed -i 's/rights=\"none\"/rights=\"read|write\"/g' {p}")
+
+unlock_imagemagick()
 
 
 # ---------------- CONFIG ---------------- #
 
 SR = 16000
-MAX_VIDEO_BYTES = 200_000_000  # 200MB limite
-TITLE = "RobotsMali Caption Studio — Sous-titrage Bambara Automatique"
+MAX_VIDEO_BYTES = 200_000_000  # Max 200MB video upload
 
 ASR_MODELS = {
     "Soloba CTC 0.6B V0": "RobotsMali/soloba-ctc-0.6b-v0",
@@ -56,22 +67,23 @@ def load_model(name):
     return model, device
 
 
-# ---------------- AUDIO EXTRACTION (FORCE MONO) ---------------- #
+# ---------------- EXTRACT AUDIO (FORCE MONO) ---------------- #
 
 def extract_audio(video_path, wav_path):
     if os.path.getsize(video_path) > MAX_VIDEO_BYTES:
-        raise RuntimeError("⚠️ Vidéo trop lourde (>200MB). Compressez puis réessayez.")
+        raise RuntimeError("⚠️ Vidéo trop lourde (>200MB). Compressez avant l’upload.")
 
+    # Force mono + 16kHz → prevents all ASR crashes
     os.system(f"ffmpeg -y -i '{video_path}' -ac 1 -ar {SR} -vn '{wav_path}' >/dev/null 2>&1")
     audio, sr = sf.read(wav_path)
 
     if sr == 0 or len(audio) == 0:
-        raise RuntimeError("⚠️ Audio introuvable ou illisible.")
+        raise RuntimeError("⚠️ Impossible de lire l’audio.")
 
-    return len(audio) / sr
+    return len(audio)/sr
 
 
-# ---------------- TRANSCRIBE (UNIFIÉ + SAFE) ---------------- #
+# ---------------- TRANSCRIBE (UNIFIED & SAFE) ---------------- #
 
 def transcribe(model, device, wav_path, model_key):
     audio, sr = sf.read(wav_path)
@@ -81,14 +93,14 @@ def transcribe(model, device, wav_path, model_key):
     if np.max(np.abs(audio)) > 1:
         audio = audio / np.max(np.abs(audio))
 
-    total_s = len(audio) / sr if sr else 0
+    total_s = len(audio)/sr if sr else 0
     if total_s <= 0:
         return []
 
     x = torch.tensor(audio, dtype=torch.float32).unsqueeze(0).to(device)
     ln = torch.tensor([x.shape[1]]).to(device)
 
-    # ---- Soloni: timestamps réels ---- #
+    # === SOLONI → true timestamps ===
     if "Soloni" in model_key and hasattr(model, "decode_and_align"):
         try:
             with torch.no_grad():
@@ -101,19 +113,16 @@ def transcribe(model, device, wav_path, model_key):
                     encoded_lengths=plen
                 )
             hyp = hyps[0][0] if isinstance(hyps[0], list) else hyps[0]
+
             if hasattr(hyp, "words") and hyp.words:
                 return [(w.start_offset_ms/1000, w.end_offset_ms/1000, w.word) for w in hyp.words]
         except:
-            pass
+            pass  # fallback auto
 
-    # ---- Fallback universel (Soloba + QuartzNet + backup Soloni) ---- #
+    # === UNIVERSAL FALLBACK (Soloba + QuartzNet + backup Soloni) ===
     out = model.transcribe([wav_path])[0]
 
-    if hasattr(out, "text"):
-        text = out.text.strip()
-    else:
-        text = str(out).strip()
-
+    text = out.text.strip() if hasattr(out, "text") else str(out).strip()
     if not text:
         return []
 
@@ -123,12 +132,12 @@ def transcribe(model, device, wav_path, model_key):
 
     wps = max(2.0, len(words) / total_s)
     subs, t = [], 0
+
     for w in words:
         d = 1 / wps
-        subs.append((t, min(total_s, t + d), w))
+        subs.append((t, min(total_s, t+d), w))
         t += d
-        if t >= total_s:
-            break
+        if t >= total_s: break
 
     return subs
 
@@ -143,18 +152,17 @@ def burn(video_path, subs):
 
         layers = []
         for s, e, w in subs:
-            if e <= s:
-                continue
+            if e <= s: continue
             txt = TextClip(
                 w.upper(),
                 fontsize=int(H/20),
-                font="DejaVu-Sans",            # ✅ Police stable
+                font="DejaVu-Sans",        # ✅ Stable Linux font
                 color="white",
                 stroke_color="black",
                 stroke_width=2,
                 method="caption",
                 size=(int(W*0.9), None)
-            ).set_start(s).set_duration(e - s).set_position(("center", int(H*0.88)))
+            ).set_start(s).set_duration(e-s).set_position(("center", int(H*0.88)))
             layers.append(txt)
 
         final = CompositeVideoClip([clip] + layers)
@@ -172,24 +180,24 @@ def burn(video_path, subs):
 # ---------------- PIPELINE ---------------- #
 
 def pipeline(video, model_name, progress=gr.Progress()):
-    progress(0.3, "Chargement du modèle…")
+    progress(0.3, "📦 Chargement du modèle…")
     model, device = load_model(model_name)
 
     with tempfile.TemporaryDirectory() as td:
         wav = f"{td}/audio.wav"
-        progress(0.5, "Extraction audio…")
+        progress(0.5, "🔊 Extraction audio…")
         extract_audio(video, wav)
 
-        progress(0.75, "Transcription…")
+        progress(0.75, "🧠 Transcription en cours…")
         subs = transcribe(model, device, wav, model_name)
         if not subs:
             return "⚠️ Aucun mot détecté.", None
 
-    progress(0.95, "Incrustation…")
+    progress(0.95, "🎞️ Incrustation des sous-titres…")
     out = burn(video, subs)
 
-    progress(1.0, "✅ Terminé")
-    return f"✅ Sous-titrage terminé ({model_name})", out
+    progress(1.0, "✅ Terminé.")
+    return f"✅ Sous-titrage généré avec **{model_name}**", out
 
 
 # ---------------- UI ---------------- #
@@ -200,9 +208,9 @@ h1 { text-align:center; font-weight:800; color:#005BFF; margin-bottom:6px; }
 .gr-button { background:#005BFF !important; color:white !important; border-radius:8px; font-weight:700; }
 """
 
-with gr.Blocks(css=CSS, title=TITLE) as demo:
+with gr.Blocks(css=CSS, title="RobotsMali Caption Studio") as demo:
     gr.Markdown("<h1>RobotsMali Caption Studio</h1><p>Sous-titrage Automatique en Bambara</p>")
-    video = gr.File(label="🎥 Importer une vidéo (max 200MB)", type="filepath")
+    video = gr.File(label="🎥 Importer une vidéo")
     model = gr.Dropdown(list(ASR_MODELS.keys()), value="Soloni 114M TDT CTC V1", label="🧠 Modèle ASR")
     run = gr.Button("🚀 Générer les sous-titres")
     status = gr.Markdown()