Update app.py

app.py

@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
 """ 
-ROBOTSMALI — Sous-titrage Bambara (VERSION COMPLÈTE V6.6)
-- Interface à deux colonnes (Entrée / Résultat unique)
-- Conservation du Statut détaillé (Phases de traitement)
-- Tous les modèles RobotsMali inclus
+ROBOTSMALI — Sous-titrage Bambara (VERSION 7.0 - STABLE & ÉPURÉE)
+- Case de résultat unique (Lecture + Téléchargement)
+- Statut de traitement détaillé (Audio -> IA -> Vidéo)
+- Correction automatique des chemins d'exemples
 """
 import os
 import shlex
@@ -23,40 +23,41 @@ from huggingface_hub import snapshot_download
 from nemo.collections import asr as nemo_asr
 import gradio as gr
 
-# ---------------------------- # CONFIGURATION # ----------------------------
+# ---------------------------- # CONFIGURATION TECHNIQUE # ----------------------------
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-random.seed(1234)
-np.random.seed(1234)
-torch.manual_seed(1234)
 
 MODELS = {
-    "Soloni V1 (RNNT)":        ("RobotsMali/soloni-114m-tdt-ctc-v1", "rnnt"),
-    "Soloni V0 (RNNT)":        ("RobotsMali/soloni-114m-tdt-ctc-v0", "rnnt"),
     "Soloba V1 (CTC)":         ("RobotsMali/soloba-ctc-0.6b-v1", "ctc"),           
-    "Soloba V0 (CTC)":         ("RobotsMali/soloba-ctc-0.6b-v0", "ctc"),           
+    "Soloni V1 (RNNT)":        ("RobotsMali/soloni-114m-tdt-ctc-v1", "rnnt"),
     "QuartzNet V1 (CTC-char)": ("RobotsMali/stt-bm-quartznet15x5-v1", "ctc_char"),       
+    "Soloba V0 (CTC)":         ("RobotsMali/soloba-ctc-0.6b-v0", "ctc"),           
+    "Soloni V0 (RNNT)":        ("RobotsMali/soloni-114m-tdt-ctc-v0", "rnnt"),
     "QuartzNet V0 (CTC-char)": ("RobotsMali/stt-bm-quartznet15x5-v0", "ctc_char"),
 }
 
-VIDEO_EXAMPLES = [
-    ["examples/MARALINKE.mp4", "Soloba V1 (CTC)"]
-]
+# Recherche intelligente du fichier exemple
+def find_example():
+    paths = ["examples/MARALINKE.mp4", "MARALINKE.mp4", "examples/maralinke.mp4"]
+    for p in paths:
+        if os.path.exists(p):
+            return p
+    return None
 
+EXAMPLE_PATH = find_example()
 _cache = {}
 
-# ---------------------------- # FONCTIONS TECHNIQUES # ----------------------------
+# ---------------------------- # MOTEUR DE TRAITEMENT # ----------------------------
 
 def run_cmd(cmd):
     res = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
     if res.returncode != 0:
-        raise RuntimeError(f"FFmpeg Error: {res.stdout}")
+        raise RuntimeError(f"Erreur système: {res.stdout}")
     return res.stdout
 
 def load_model(name):
     if name in _cache: return _cache[name]
-    if len(_cache) > 0:
-        _cache.clear()
-        if torch.cuda.is_available(): torch.cuda.empty_cache()
+    _cache.clear()
+    if torch.cuda.is_available(): torch.cuda.empty_cache()
     
     repo, mode = MODELS[name]
     folder = snapshot_download(repo, local_dir_use_symlinks=False)
@@ -69,14 +70,17 @@ def load_model(name):
     else:
         try: model = nemo_asr.models.EncDecCTCModelBPE.restore_from(nemo_file)
         except: model = nemo_asr.models.EncDecCTCModel.restore_from(nemo_file)
+    
     model.to(DEVICE).eval()
     _cache[name] = model
     return model
 
 def burn_subtitles(video_path, words, duration):
-    out_name = f"robotsmali_output_{int(time.time())}.mp4"
+    # Sortie dans le dossier courant pour éviter les pertes de fichiers temporaires
+    out_name = f"robotsmali_final_{int(time.time())}.mp4"
     out_path = os.path.abspath(out_name)
     
+    # Génération du fichier SRT
     chunk_size = 7
     with tempfile.NamedTemporaryFile(suffix=".srt", mode="w", encoding="utf-8", delete=False) as tf:
         for i, idx in enumerate(range(0, len(words), chunk_size)):
@@ -90,6 +94,7 @@ def burn_subtitles(video_path, words, duration):
             tf.write(f"{i+1}\n{t_srt(start)} --> {t_srt(end)}\n{txt}\n\n")
         srt_name = tf.name
 
+    # Encodage H.264 ultra-compatible (MP4 Progressif)
     vf = f"subtitles={shlex.quote(srt_name)}:force_style='Fontsize=22,PrimaryColour=&HFFFFFF&,OutlineColour=&H000000&'"
     cmd = (
         f'ffmpeg -hide_banner -loglevel error -y -i {shlex.quote(video_path)} '
@@ -97,19 +102,18 @@ def burn_subtitles(video_path, words, duration):
         f'-c:a aac -b:a 128k -movflags +faststart {shlex.quote(out_path)}'
     )
     run_cmd(cmd)
-    os.remove(srt_name)
+    if os.path.exists(srt_name): os.remove(srt_name)
     return out_path
 
-# ---------------------------- # PIPELINE # ----------------------------
+# ---------------------------- # PIPELINE PRINCIPALE # ----------------------------
 
 def pipeline(video_input, model_name):
     try:
         if not video_input:
-            yield "❌ Erreur : Aucune vidéo chargée.", None
+            yield "### ❌ État\n*Veuillez charger une vidéo.*", None
             return
         
-        # Phase 1 : Audio
-        yield "⏳ Phase 1/3 : Analyse et extraction de l'audio...", None
+        yield "### ⏳ État\n*Phase 1 : Extraction du signal audio...*", None
         wav_path = os.path.abspath("temp_audio.wav")
         run_cmd(f'ffmpeg -hide_banner -loglevel error -y -i {shlex.quote(video_input)} -vn -ac 1 -ar 16000 -f wav {shlex.quote(wav_path)}')
         
@@ -117,58 +121,58 @@ def pipeline(video_input, model_name):
                                  shell=True, stdout=subprocess.PIPE, text=True).stdout
         duration = float(dur_out.strip()) if dur_out.strip() else 10.0
         
-        # Phase 2 : Transcription
-        yield f"⏳ Phase 2/3 : Transcription IA ({model_name})...", None
+        yield f"### ⏳ État\n*Phase 2 : Transcription Bambara ({model_name})...*", None
         model = load_model(model_name)
         res = model.transcribe([wav_path])[0]
         text = res.text if hasattr(res, 'text') else str(res)
         words = [w for w in text.split() if len(w) > 1]
         
         if not words:
-            yield "⚠️ Phase 2 : Aucune parole détectée dans l'audio.", None
+            yield "### ⚠️ État\n*Aucune parole détectée dans la vidéo.*", None
             return
         
-        # Phase 3 : Encodage
-        yield "⏳ Phase 3/3 : Génération de la vidéo sous-titrée...", None
-        final_v = burn_subtitles(video_input, words, duration)
+        yield "### ⏳ État\n*Phase 3 : Incrustation et rendu final...*", None
+        final_video = burn_subtitles(video_input, words, duration)
         
         if os.path.exists(wav_path): os.remove(wav_path)
-        
-        yield "✅ Traitement terminé avec succès !", final_v
+        yield "### ✅ État\n*Traitement terminé !*", final_video
 
     except Exception as e:
         traceback.print_exc()
-        yield f"❌ Erreur critique : {str(e)}", None
+        yield f"### ❌ État\n*Erreur technique : {str(e)}*", None
 
-# ---------------------------- # INTERFACE GRADIO # ----------------------------
+# ---------------------------- # INTERFACE UTILISATEUR # ----------------------------
 
 custom_css = """
 body { background-color: #0b0e14; }
-.gradio-container { background: rgba(17, 25, 40, 0.8) !important; border-radius: 20px; border: 1px solid rgba(255, 255, 255, 0.1); }
-#header { text-align: center; padding: 20px; }
+.gradio-container { background: rgba(17, 25, 40, 0.9) !important; border-radius: 15px; border: 1px solid rgba(255, 255, 255, 0.1); }
+#header { text-align: center; padding: 15px; }
 .gr-button-primary { background: linear-gradient(135deg, #059669, #10b981) !important; border: none !important; }
 """
 
 with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
     with gr.Column(elem_id="header"):
-        gr.HTML("<h1 style='color:#facc15;'>🤖 ROBOTSMALI</h1><p style='color:#94a3b8;'>Sous-titrage Bambara Intégral</p>")
+        gr.HTML("<h1 style='color:#facc15; margin:0;'>🤖 ROBOTSMALI</h1><p style='color:#94a3b8;'>Intelligence Artificielle de Sous-titrage Bambara</p>")
 
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### 📥 Source")
-            v_in = gr.Video(label=None, mirror_webcam=False)
+            gr.Markdown("### 📥 1. ENTRÉE")
+            v_in = gr.Video(label="Vidéo à traiter")
             m_sel = gr.Dropdown(list(MODELS.keys()), value="Soloba V1 (CTC)", label="Modèle IA")
             btn = gr.Button("🚀 GÉNÉRER", variant="primary")
         
         with gr.Column():
-            gr.Markdown("### 📤 Résultat")
-            # Le Statut est conservé ici pour informer sur l'état des fichiers audio/vidéo
-            status = gr.Markdown("### État\n*En attente de démarrage...*")
-            v_out = gr.Video(label="Vidéo finale")
+            gr.Markdown("### 📤 2. SORTIE")
+            status = gr.Markdown("### État\n*Prêt*")
+            v_out = gr.Video(label="Résultat final")
+
+    # Gestion des exemples
+    if EXAMPLE_PATH:
+        gr.Examples(examples=[[EXAMPLE_PATH, "Soloba V1 (CTC)"]], inputs=[v_in, m_sel], label="📺 Exemple")
+    else:
+        gr.Markdown("⚠️ *Note : Aucun fichier exemple détecté sur le serveur.*")
 
-    gr.Examples(examples=VIDEO_EXAMPLES, inputs=[v_in, m_sel], cache_examples=False)
-    
     btn.click(pipeline, [v_in, m_sel], [status, v_out])
 
 if __name__ == "__main__":
-    demo.launch(share=True, debug=True)
+    demo.launch(debug=True,share=True)