Update app.py

app.py

@@ -1,29 +1,26 @@
 # -*- coding: utf-8 -*-
 """ 
-ROBOTSMALI — Sous-titrage Bambara (VERSION 7.4 - DEBUG & SHARE)
-- Correction Moov Atom pour le streaming (FastStart)
-- Interface stable avec partage public activé
-- Suivi détaillé des phases de transcription
+ROBOTSMALI — Sous-titrage Bambara (VERSION 7.7 - INTÉGRALE)
+-=
 """
 import os
 import shlex
 import subprocess
 import tempfile
 import traceback
-import random
 import textwrap
 import time
 from pathlib import Path
 
-import numpy as np
 import torch
 from huggingface_hub import snapshot_download
 from nemo.collections import asr as nemo_asr
 import gradio as gr
 
-# ---------------------------- # CONFIGURATION # ----------------------------
+# ---------------------------- # CONFIGURATION DES MODÈLES # ----------------------------
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
+# La liste complète et correcte des modèles RobotsMali
 MODELS = {
     "Soloba V1 (CTC)":         ("RobotsMali/soloba-ctc-0.6b-v1", "ctc"),           
     "Soloni V1 (RNNT)":        ("RobotsMali/soloni-114m-tdt-ctc-v1", "rnnt"),
@@ -33,27 +30,24 @@ MODELS = {
     "QuartzNet V0 (CTC-char)": ("RobotsMali/stt-bm-quartznet15x5-v0", "ctc_char"),
 }
 
-# Détection automatique du fichier d'exemple
-def get_example():
-    paths = ["examples/MARALINKE.mp4", "MARALINKE.mp4"]
+# Détection du chemin absolu pour la vidéo d'exemple
+def get_absolute_example():
+    paths = [
+        os.path.abspath("MARALINKE.mp4"),
+        os.path.abspath("examples/MARALINKE.mp4"),
+        "/home/user/app/MARALINKE.mp4",
+        "/home/user/app/examples/MARALINKE.mp4"
+    ]
     for p in paths:
         if os.path.exists(p): return p
     return None
 
-EXAMPLE_PATH = get_example()
+EXAMPLE_PATH = get_absolute_example()
 _cache = {}
 
-# ---------------------------- # MOTEUR DE TRAITEMENT # ----------------------------
-
-def run_cmd(cmd):
-    """Exécute une commande système et capture les erreurs."""
-    res = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
-    if res.returncode != 0:
-        raise RuntimeError(f"Erreur système : {res.stdout}")
-    return res.stdout
+# ---------------------------- # MOTEUR IA & VIDÉO # ----------------------------
 
 def load_model(name):
-    """Charge le modèle IA en mémoire avec mise en cache."""
     if name in _cache: return _cache[name]
     _cache.clear()
     if torch.cuda.is_available(): torch.cuda.empty_cache()
@@ -67,19 +61,20 @@ def load_model(name):
     elif mode == "ctc_char":
         model = nemo_asr.models.EncDecCTCModel.restore_from(nemo_file)
     else:
-        try: model = nemo_asr.models.EncDecCTCModelBPE.restore_from(nemo_file)
-        except: model = nemo_asr.models.EncDecCTCModel.restore_from(nemo_file)
+        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 process_video(video_path, words, duration):
-    """Génère la vidéo finale avec sous-titres et optimisation streaming."""
-    out_name = f"robotsmali_final_{int(time.time())}.mp4"
+def burn_subtitles(video_path, words, duration):
+    out_name = f"robotsmali_output_{int(time.time())}.mp4"
     out_path = os.path.abspath(out_name)
     
-    # Génération du fichier SRT temporaire
+    # Génération du 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)):
@@ -93,14 +88,14 @@ def process_video(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 FFmpeg avec le flag crucial +faststart
+    # Rendu FFmpeg avec optimisation FastStart pour corriger la durée web
     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)} '
         f'-vf {shlex.quote(vf)} -c:v libx264 -pix_fmt yuv420p -preset ultrafast -crf 28 '
         f'-c:a aac -b:a 128k -movflags +faststart {shlex.quote(out_path)}'
     )
-    run_cmd(cmd)
+    subprocess.run(cmd, shell=True, check=True)
     if os.path.exists(srt_name): os.remove(srt_name)
     return out_path
 
@@ -109,69 +104,67 @@ def process_video(video_path, words, duration):
 def pipeline(video_input, model_name):
     try:
         if not video_input:
-            yield "### ❌ État\n*Aucune vidéo détectée.*", None
+            yield "### ❌ Erreur : Vidéo manquante.", None
             return
         
-        yield "### ⏳ État\n*Phase 1/3 : Analyse audio en cours...*", None
+        yield "### ⏳ Étape 1/3 : Extraction 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)}')
+        subprocess.run(f"ffmpeg -y -i {shlex.quote(video_input)} -vn -ac 1 -ar 16000 {wav_path}", shell=True, check=True)
         
+        # Détection précise de la durée
         dur_out = subprocess.run(f'ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 {shlex.quote(video_input)}', 
                                  shell=True, stdout=subprocess.PIPE, text=True).stdout
         duration = float(dur_out.strip()) if dur_out.strip() else 10.0
         
-        yield f"### ⏳ État\n*Phase 2/3 : Transcription IA ({model_name})...*", None
+        yield f"### ⏳ Étape 2/3 : Transcription avec {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]
+        words = (res.text if hasattr(res, 'text') else str(res)).split()
         
         if not words:
-            yield "### ⚠️ État\n*Aucune parole détectée.*", None
+            yield "### ⚠️ Aucune parole détectée.", None
             return
         
-        yield "### ⏳ État\n*Phase 3/3 : Finalisation de la vidéo...*", None
-        final_v = process_video(video_input, words, duration)
+        yield "### ⏳ Étape 3/3 : Finalisation Vidéo...", None
+        final_video = burn_subtitles(video_input, words, duration)
         
         if os.path.exists(wav_path): os.remove(wav_path)
-        yield "### ✅ État\n*Traitement terminé avec succès !*", final_v
+        yield "### ✅ Succès !", final_video
 
     except Exception as e:
         traceback.print_exc()
-        yield f"### ❌ État\n*Erreur critique : {str(e)}*", None
+        yield f"### ❌ Erreur : {str(e)}", None
 
-# ---------------------------- # INTERFACE GRADIO # ----------------------------
+def force_load_demo():
+    return EXAMPLE_PATH
 
-custom_css = """
-body { background-color: #0b0e14; }
-.gradio-container { background: rgba(17, 25, 40, 0.9) !important; border-radius: 20px; border: 1px solid rgba(255, 255, 255, 0.1); }
-#header { text-align: center; padding: 20px; }
-.gr-button-primary { background: linear-gradient(135deg, #059669, #10b981) !important; border: none !important; }
-"""
+# ---------------------------- # INTERFACE # ----------------------------
 
-with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
-    with gr.Column(elem_id="header"):
-        gr.HTML("<h1 style='color:#facc15; margin:0;'>🤖 ROBOTSMALI</h1><p style='color:#94a3b8;'>Intelligence Artificielle pour le Bambara</p>")
+with gr.Blocks(theme=gr.themes.Soft(), css="body { background-color: #0b0e14; }") as demo:
+    gr.HTML("<h1 style='text-align:center; color:#facc15;'>🤖 ROBOTSMALI V7.7</h1>")
 
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### 📥 1. CHARGEMENT")
-            v_in = gr.Video(label="Vidéo source", mirror_webcam=False)
+            gr.Markdown("### 📥 CHARGEMENT")
+            v_in = gr.Video(label="Vidéo source", interactive=True)
+            
+            if EXAMPLE_PATH:
+                btn_demo = gr.Button("📂 CHARGER LA DÉMO (MARALINKE)", variant="secondary")
+            
             m_sel = gr.Dropdown(list(MODELS.keys()), value="Soloba V1 (CTC)", label="Modèle IA")
-            btn = gr.Button("🚀 GÉNÉRER", variant="primary")
+            btn_run = gr.Button("🚀 GÉNÉRER", variant="primary")
         
         with gr.Column():
-            gr.Markdown("### 📤 2. RÉSULTAT")
-            status = gr.Markdown("### État\n*Prêt*")
+            gr.Markdown("### 📤 RÉSULTAT")
+            status = gr.Markdown("### État\nPrêt")
             v_out = gr.Video(label="Vidéo finale")
 
-    # Désactivation du cache pour éviter le gel de l'interface sur Hugging Face
+    # Actions
     if EXAMPLE_PATH:
+        btn_demo.click(fn=force_load_demo, outputs=v_in)
         gr.Examples(examples=[[EXAMPLE_PATH, "Soloba V1 (CTC)"]], inputs=[v_in, m_sel], cache_examples=False)
 
-    btn.click(pipeline, [v_in, m_sel], [status, v_out])
+    btn_run.click(pipeline, [v_in, m_sel], [status, v_out])
 
 if __name__ == "__main__":
-    # share=True : Crée un lien public .gradio.live
-    # debug=True : Affiche les erreurs détaillées dans la console
     demo.launch(share=True, debug=True)