Update app.py

app.py

@@ -1,68 +1,266 @@
+# -*- coding: utf-8 -*-
+"""Video_Captioning_Space_V8_0_MINIMALIST_BLUE.ipynb
+Architecture NeMo + ctc-segmentation pour l'alignement sur tous les modèles.
+Design Minimalist Blue.
+"""
 import gradio as gr
 import numpy as np
 import torch
 import soundfile as sf
 import os
 import tempfile
-from moviepy.editor import VideoFileClip, CompositeVideoClip, ImageClip
-from PIL import Image, ImageDraw, ImageFont
-from nemo.collections import asr as nemo_asr
-from huggingface_hub import hf_hub_download, snapshot_download
-from ctc_segmentation import ctc_segmentation, CtcSegmentationParameters, prepare_text
+import warnings
+from moviepy.editor import VideoFileClip, TextClip, CompositeVideoClip
+from typing import List, Tuple, Union
 
+# --- Installation des dépendances pour Google Colab (À exécuter avant ce script) ---
+# !pip install gradio moviepy numpy torch soundfile
+# !pip install nemo_toolkit['asr']
+# !pip install ctc-segmentation huggingface-hub
+
+try:
+    from nemo.collections import asr as nemo_asr
+    from huggingface_hub import hf_hub_download, snapshot_download
+    from ctc_segmentation import ctc_segmentation, CtcSegmentationParameters, prepare_text
+    NEMO_LOADED = True
+except ImportError as e:
+    NEMO_LOADED = False
+    print(f"Erreur d'importation des dépendances NeMo/CTC : {e}")
+    # Classes/Fonctions de substitution pour éviter le crash au lancement
+    class DummyASRModel:
+        def from_pretrained(self, *args, **kwargs):
+            raise RuntimeError("Dépendances ASR manquantes. Veuillez exécuter la cellule d'installation.")
+    nemo_asr = type('nemo_asr', (object,), {'models': type('models', (object,), {'EncDecHybridRNNTCTCBPEModel': DummyASRModel, 'EncDecCTCModelBPE': DummyASRModel})})
+    hf_hub_download = lambda *args, **kwargs: None
+    snapshot_download = lambda *args, **kwargs: None
+
+
+# --- CONFIGURATION DES MODÈLES (Utilisation de votre liste complète) ---
 MODELS = {
-    "Soloni V0": ("RobotsMali/soloni-114m-tdt-ctc-V0", "soloni-114m-tdt-ctc-V0.nemo", "rnnt"),
-    "Soloni V1": ("RobotsMali/soloni-114m-tdt-ctc-V1", "soloni-114m-tdt-ctc-V1.nemo", "rnnt"),
-    "Soloba V0": ("RobotsMali/soloba-ctc-0.6b-V0", None, "ctc"),
-    "Soloba V1": ("RobotsMali/soloba-ctc-0.6b-V1", None, "ctc"),
-    "QuartzNet V0": ("RobotsMali/stt-bm-quartznet15x5-V0", None, "ctc"),
-    "QuartzNet V1": ("RobotsMali/stt-bm-quartznet15x5-V1", None, "ctc"),
+    "Soloni V1 (RNnT - Précis)": ("RobotsMali/soloni-114m-tdt-ctc-V1", "soloni-114m-tdt-ctc-V1.nemo", "rnnt"),
+    "Soloba V1 (CTC - Équilibré)": ("RobotsMali/soloba-ctc-0.6b-V1", None, "ctc"),
+    "QuartzNet V1 (CTC - Rapide)": ("RobotsMali/stt-bm-quartznet15x5-V1", None, "ctc"),
+    # Anciennes versions (Gardées pour la compatibilité, mais V1 recommandées)
+    "Soloni V0 (RNnT)": ("RobotsMali/soloni-114m-tdt-ctc-V0", "soloni-114m-tdt-ctc-V0.nemo", "rnnt"),
+    "Soloba V0 (CTC)": ("RobotsMali/soloba-ctc-0.6b-V0", None, "ctc"),
+    "QuartzNet V0 (CTC)": ("RobotsMali/stt-bm-quartznet15x5-V0", None, "ctc"),
 }
+asr_pipeline = {}
+
+# --- CSS : ROBOTSMALI MINIMALIST BLUE ---
+CUSTOM_CSS = """
+    @import url('https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap');
+
+    /* Couleurs */
+    :root {
+        --primary-color: #007bff; /* Bleu de base */
+        --accent-color: #00BFFF; /* Bleu Cyan Électrique */
+        --background-light: #F8F9FA; /* Gris très clair */
+        --surface-color: #FFFFFF; /* Blanc */
+        --text-color: #212529; /* Gris très foncé */
+        --border-color: #E9ECEF;
+    }
+
+    body {
+        background-color: var(--background-light) !important;
+        font-family: 'Roboto', sans-serif !important;
+        color: var(--text-color) !important;
+    }
+    .gradio-container {
+        max-width: 1200px;
+        margin: 0 auto;
+        padding: 20px 10px;
+        background-color: var(--background-light) !important;
+        border-radius: 0 !important;
+    }
+    
+    /* Conteneurs et cartes (Blocs) */
+    .block {
+        border: 1px solid var(--border-color);
+        border-radius: 8px;
+        background-color: var(--surface-color);
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+        padding: 20px;
+    }
+
+    /* Titres */
+    h1 {
+        color: var(--accent-color) !important; 
+        text-align: center;
+        margin-bottom: 5px;
+        font-weight: 700;
+    }
+    h3 {
+        color: var(--primary-color) !important;
+        font-weight: 500;
+        border-bottom: 1px solid var(--border-color);
+        padding-bottom: 5px;
+        margin-bottom: 15px;
+    }
+    
+    /* Boutons d'action : Bleu Primair */
+    .primary {
+        background-color: var(--primary-color) !important;
+        border: none !important;
+        color: white !important;
+        font-weight: 700;
+        text-transform: uppercase;
+        transition: background-color 0.2s;
+    }
+    .primary:hover {
+        background-color: #0056b3 !important; /* Bleu foncé au survol */
+        box-shadow: 0 0 8px rgba(0, 123, 255, 0.4);
+    }
+
+    /* Inputs et Dropdowns */
+    .gr-input, .gr-dropdown {
+        background-color: #FFFFFF !important;
+        border: 1px solid #CED4DA !important;
+        color: var(--text-color) !important;
+        border-radius: 4px;
+    }
+    .gr-file-input {
+        border: 2px dashed var(--primary-color) !important; 
+        background-color: #F0F5FF !important;
+    }
+
+    /* Statut d'exécution */
+    .gr-status {
+        background-color: #E6F0FF !important;
+        border-left: 5px solid var(--primary-color);
+        color: var(--text-color) !important;
+        padding: 10px;
+    }
+"""
+
+# ----------------------------------------------------------------------
+# FONCTIONS DE CHARGEMENT ET D'ALIGEMENT
+# ----------------------------------------------------------------------
 
 def load_ctc_model_safe(repo_id):
-    """Charge les modèles CTC de manière robuste"""
+    """Charge les modèles CTC de manière robuste (votre fonction)"""
+    # Votre logique de chargement stable est conservée
     try:
         # Essai 1: Chargement standard
         return nemo_asr.models.EncDecCTCModelBPE.from_pretrained(model_name=repo_id)
     except Exception as e:
-        print(f"Erreur lors du chargement standard: {e}")
+        # Essai 2: Téléchargement manuel via snapshot si l'essai 1 échoue
+        print(f"Erreur lors du chargement standard du CTC: {e}. Tentative de téléchargement manuel...")
+        with tempfile.TemporaryDirectory() as tmpdir:
+            try:
+                model_path = snapshot_download(
+                    repo_id=repo_id,
+                    cache_dir=tmpdir,
+                    local_dir_use_symlinks=False
+                )
+                
+                # Chercher le fichier .nemo
+                nemo_file = None
+                for file in os.listdir(model_path):
+                    if file.endswith('.nemo'):
+                        nemo_file = os.path.join(model_path, file)
+                        break
+                
+                if nemo_file and os.path.exists(nemo_file):
+                    print(f"Chargement réussi depuis: {nemo_file}")
+                    return nemo_asr.models.EncDecCTCModelBPE.restore_from(nemo_file)
+                else:
+                    raise FileNotFoundError("Fichier .nemo non trouvé dans le repo téléchargé.")
+                    
+            except Exception as e2:
+                raise Exception(f"Échec du téléchargement/chargement manuel du modèle CTC: {e2}")
+
+def load_asr_model(model_name: str):
+    """Gestion centralisée du chargement de modèles (RNNT et CTC)"""
+    global asr_pipeline
+    repo_id, nemo_file, mode = MODELS[model_name]
+
+    if model_name not in asr_pipeline:
+        print(f"-> Chargement initial du modèle : {model_name} (Mode: {mode})")
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        if mode == "rnnt":
+            # RNNT (Soloni) : Téléchargement du fichier .nemo spécifique
+            if not nemo_file: raise ValueError("Nom de fichier .nemo manquant pour le modèle RNNT.")
+            nemo_path = hf_hub_download(repo_id, filename=nemo_file)
+            model_instance = nemo_asr.models.EncDecHybridRNNTCTCBPEModel.restore_from(nemo_path)
+        else:
+            # CTC (Soloba, QuartzNet) : Utilisation de la fonction sécurisée
+            model_instance = load_ctc_model_safe(repo_id)
         
-        # Essai 2: Téléchargement manuel via snapshot
-        try:
-            print("Tentative de téléchargement manuel...")
-            model_path = snapshot_download(
-                repo_id=repo_id,
-                cache_dir=tempfile.mkdtemp(),
-                local_dir_use_symlinks=False
-            )
-            
-            # Chercher le fichier .nemo
-            nemo_file = None
-            for file in os.listdir(model_path):
-                if file.endswith('.nemo'):
-                    nemo_file = os.path.join(model_path, file)
-                    break
+        model_instance = model_instance.to(device)
+        model_instance.eval()
+        asr_pipeline[model_name] = model_instance
+        print(f"-> Modèle {model_name} chargé sur {device}.")
+
+    return asr_pipeline[model_name]
+
+
+# --- Logique de Segmentation et d'Optimisation des Lignes ---
+
+MAX_SUBTITLE_WORDS = 4
+MAX_SUBTITLE_CHARS = 45
+MAX_SUBTITLE_DURATION = 3.5 # Durée maximale en secondes pour une ligne de sous-titre
+
+def group_words_to_subtitles(words_with_timestamps: List[Tuple[float, float, str]]) -> List[Tuple[float, float, str]]:
+    """
+    Formate la liste de mots horodatés en lignes de sous-titres optimisées
+    selon les règles de mots, caractères et durée maximum.
+    Cette fonction assure l'optimisation pour les 6 modèles.
+    """
+    subtitles = []
+    if not words_with_timestamps: return []
+
+    current_group = []
+
+    def finalize_group(group):
+        if not group: return
+        start_time = group[0][0]
+        end_time = group[-1][1]
+        line_text = " ".join([w[2] for w in group])
+        subtitles.append((start_time, end_time, line_text))
+    
+    for word_data in words_with_timestamps:
+        # Tentative d'ajouter le mot au groupe actuel
+        test_group = current_group + [word_data]
+        test_text = " ".join([w[2] for w in test_group])
+        
+        # Calcul de la durée du groupe test
+        test_duration = test_group[-1][1] - test_group[0][0] if test_group else 0
+        
+        should_cut = False
+
+        # Règle 1: Dépasser la limite de mots
+        if len(current_group) >= MAX_SUBTITLE_WORDS:
+            should_cut = True
             
-            if nemo_file and os.path.exists(nemo_file):
-                print(f"Chargement depuis: {nemo_file}")
-                return nemo_asr.models.EncDecCTCModelBPE.restore_from(nemo_file)
-            else:
-                raise FileNotFoundError("Fichier .nemo non trouvé dans le repo")
-                
-        except Exception as e2:
-            print(f"Échec du téléchargement manuel: {e2}")
-            raise
+        # Règle 2: Dépasser la limite de caractères (avant l'ajout)
+        elif len(test_text) > MAX_SUBTITLE_CHARS and current_group:
+            should_cut = True
+
+        # Règle 3: Dépasser la durée maximum (avant l'ajout)
+        # On coupe si la durée est trop longue, mais seulement si le groupe a
+        # déjà une taille raisonnable (>= 2 mots) pour éviter des coupures trop courtes.
+        elif len(current_group) >= 2 and test_duration > MAX_SUBTITLE_DURATION:
+            should_cut = True
+
+        if should_cut:
+            finalize_group(current_group)
+            current_group = [word_data]
+        else:
+            # Si aucune règle de coupure n'est déclenchée, on ajoute le mot au groupe
+            current_group.append(word_data)
+    
+    # Finalisation du dernier groupe
+    finalize_group(current_group)
+    
+    return subtitles
 
-def extract_audio(video_path, wav_path):
-    """Extrait l'audio de la vidéo"""
-    video = VideoFileClip(video_path)
-    video.audio.write_audiofile(
-        wav_path, fps=16000, codec="pcm_s16le", verbose=False, logger=None
-    )
-    video.close()
 
 def transcribe(model, device, wav, model_name):
-    """Transcrit l'audio avec alignement temporel"""
+    """Transcrit l'audio et génère des horodatages de LIGNES (start, end, text)"""
+    
+    # Lecture de l'audio
     audio, sr = sf.read(wav)
     if audio.ndim == 2:
         audio = np.mean(audio, axis=1)
@@ -70,87 +268,95 @@ def transcribe(model, device, wav, model_name):
     ln = torch.tensor([x.shape[1]]).to(device)
     total_s = len(audio) / sr
 
-    # Modèles RNNT (Soloni)
+    # --- Mode RNNT (Soloni) : Utilisation de l'alignement natif ---
     if "Soloni" in model_name:
         with torch.no_grad():
             proc, plen = model.preprocessor(input_signal=x, input_signal_length=ln)
+            # Utilisation du decode_and_align natif pour les word-timestamps
             hyps = model.decode_and_align(encoder_output=proc, encoded_lengths=plen)
+        
+        if not hyps or not hyps[0]: return []
+        
         hyp = hyps[0][0] if isinstance(hyps[0], list) else hyps[0]
-        return [(w.start_offset_ms/1000, w.end_offset_ms/1000, w.word) for w in hyp.words]
+        word_timestamps = [(w.start_offset_ms/1000, w.end_offset_ms/1000, w.word) for w in hyp.words]
+        
+        # Application de la logique d'optimisation
+        return group_words_to_subtitles(word_timestamps)
 
-    # Modèles CTC (Soloba, QuartzNet)
+    # --- Mode CTC (Soloba, QuartzNet) : Utilisation de ctc-segmentation ---
     text = model.transcribe([wav])[0].strip()
-    if not text:
-        return []
+    if not text: return []
 
     with torch.no_grad():
         logits, logit_len = model.forward(input_signal=x, input_signal_length=ln)
 
     words = text.split()
-    if not words:
-        return []
+    if not words: return []
 
+    # CTC Segmentation
     config = CtcSegmentationParameters()
     config.char_list = list(model.tokenizer.vocab.keys())
     gt, _ = prepare_text(config, words)
-
-    timings, _, _ = ctc_segmentation(config, logits.cpu().numpy()[0], gt)
+    
+    # Suppression des avertissements de ctc_segmentation
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        timings, _, _ = ctc_segmentation(config, logits.cpu().numpy()[0], gt)
+    
     tps = total_s / logit_len.cpu().numpy()[0]
 
+    # Alignement des mots
     aligned = [(timings[i] * tps,
                 timings[i+1] * tps if i+1 < len(timings) else total_s,
                 words[i]) for i in range(len(words))]
 
-    # Regroupement des mots
-    grouped, temp = [], []
-    for w in aligned:
-        temp.append(w)
-        if len(temp) >= 4:  # Groupe de 4 mots
-            grouped.append(temp)
-            temp = []
-    if temp:
-        grouped.append(temp)
+    # Application de la logique d'optimisation
+    return group_words_to_subtitles(aligned)
+
+
+# --- Fonction d'Extraction Audio (Optimisée) ---
+
+def extract_audio(video_path, wav_path):
+    """Extrait l'audio de la vidéo avec gestion des ressources"""
+    try:
+        video = VideoFileClip(video_path)
+        video.audio.write_audiofile(
+            wav_path, fps=16000, codec="pcm_s16le", verbose=False, logger=None
+        )
+        video.close()
+    except Exception as e:
+        raise Exception(f"Erreur lors de l'extraction audio: {e}")
 
-    return [(g[0][0], g[-1][1], " ".join([w[2] for w in g])) for g in grouped]
+# --- Fonction d'Incrustation Vidéo (Simplifiée et Stabilisée) ---
 
 def burn(video, subs):
-    """Ajoute les sous-titres à la vidéo"""
+    """Ajoute les sous-titres à la vidéo en utilisant TextClip (plus stable)"""
+    out_path = "RobotsMali_Subtitled.mp4"
+    if os.path.exists(out_path): os.remove(out_path)
+    
     clip = VideoFileClip(video)
     W, H = clip.size
     
-    # Tentative de chargement de police
-    try:
-        font_size = max(int(H/20), 20)  # Taille minimale
-        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
-    except:
-        try:
-            font = ImageFont.load_default()
-        except:
-            font = None
-
-    layers = []
+    subtitle_clips = []
     for start, end, text in subs:
-        # Création de l'image de sous-titre
-        img_height = int(H * 0.12)
-        img = Image.new("RGBA", (W, img_height), (0, 0, 0, 140))
-        draw = ImageDraw.Draw(img)
-        
-        if font:
-            bbox = draw.textbbox((0, 0), text, font=font)
-            tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
-            draw.text(((W - tw) // 2, (img_height - th) // 2), text, font=font, fill="white")
-        else:
-            # Fallback si police non disponible
-            draw.text((W//2, img_height//2), text, fill="white", anchor="mm")
+        # Utilisation de TextClip pour la stabilité, le style et l'alignement
+        # Fond sombre semi-transparent pour la lisibilité sur TOUS fonds vidéo
+        txt_clip = TextClip(
+            text.upper(),
+            fontsize=H // 20, 
+            color='white',
+            font='Roboto-Bold', # Utilisation d'une police web standard pour éviter les erreurs Colab
+            bg_color='rgba(0, 0, 0, 0.7)',
+            method='caption',
+            size=(W * 0.9, None) # 90% de la largeur pour le wrap
+        )
         
-        # Création du clip de sous-titre
-        subtitle_clip = ImageClip(np.array(img)).set_start(start).set_duration(end - start)
-        subtitle_clip = subtitle_clip.set_position(("center", int(H * 0.85)))
-        layers.append(subtitle_clip)
+        duration = max(0.1, end - start) # Durée minimale de 0.1s
+        txt_clip = txt_clip.set_pos(('center', H * 0.85)).set_duration(duration).set_start(start)
+        subtitle_clips.append(txt_clip)
 
     # Composition finale
-    final = CompositeVideoClip([clip] + layers)
-    out_path = "RobotsMali_Subtitled.mp4"
+    final = CompositeVideoClip([clip] + subtitle_clips)
     
     # Écriture de la vidéo finale
     final.write_videofile(
@@ -158,6 +364,8 @@ def burn(video, subs):
         codec="libx264", 
         audio_codec="aac", 
         fps=clip.fps, 
+        bitrate="4000k", # Bitrate fixé à 4000k pour une qualité HD standard
+        preset="medium",
         verbose=False, 
         logger=None,
         temp_audiofile="temp-audio.m4a",
@@ -167,78 +375,129 @@ def burn(video, subs):
     # Nettoyage
     clip.close()
     final.close()
-    for layer in layers:
+    for layer in subtitle_clips:
         layer.close()
         
     return out_path
 
+# --- Pipeline Principal ---
+
 def pipeline(video_file, model_name):
     """Pipeline principal de traitement"""
+    if not NEMO_LOADED:
+        return "❌ ERREUR FATALE : NeMo/CTC Segmentation n'a pas été importé. Exécutez la cellule d'installation.", None
+        
     if video_file is None:
         return "Veuillez importer une vidéo.", None
 
-    repo, nemo_file, mode = MODELS[model_name]
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
+    
+    yield f"🧠 Chargement du modèle {model_name} sur {device}..."
+    
     try:
-        # Chargement du modèle
-        if mode == "rnnt":
-            nemo_path = hf_hub_download(repo, filename=nemo_file)
-            model = nemo_asr.models.EncDecHybridRNNTCTCBPEModel.restore_from(nemo_path)
-        else:
-            model = load_ctc_model_safe(repo)  # Utilisation de la fonction sécurisée
-
-        model = model.to(device)
-        model.eval()
-
-        # Traitement
-        wav_path = "audio.wav"
+        model = load_asr_model(model_name)
+        
+        yield "🎶 Extraction audio en cours..."
+        wav_path = os.path.join(tempfile.gettempdir(), "audio.wav")
         extract_audio(video_file, wav_path)
+        
+        yield "📝 Transcription et alignement des mots en cours..."
         subs = transcribe(model, device, wav_path, model_name)
+        
+        if not subs:
+            return "⚠️ ALERTE : Aucune parole détectée ou alignement échoué. Vérifiez la qualité audio.", None
+
+        yield "🎬 Incrustation des sous-titres sur la vidéo..."
         final_video = burn(video_file, subs)
         
         # Nettoyage des fichiers temporaires
         if os.path.exists(wav_path):
             os.remove(wav_path)
             
-        return "✅ Sous-titres générés avec succès!", final_video
+        return "✅ PRODUCTION TERMINÉE avec succès!", final_video
 
     except Exception as e:
         print(f"Erreur dans le pipeline: {e}")
-        return f"❌ Erreur: {str(e)}", None
-
-# Interface Gradio
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🎙️ **RobotsMali — Sous-titrage automatique Bambara**
-    *Générez automatiquement des sous-titres en Bambara pour vos vidéos*
-    """)
-    
-    with gr.Row():
-        with gr.Column():
-            video = gr.Video(label="Vidéo d'entrée", height=300)
-            model = gr.Dropdown(
-                list(MODELS.keys()), 
-                value="Soloni V1", 
-                label="Modèle de reconnaissance vocale",
-                info="Soloni: plus précis • Soloba/QuartzNet: plus rapide"
-            )
-            btn = gr.Button("⚡ Générer les sous-titres", variant="primary")
-        
-        with gr.Column():
-            status = gr.Markdown("Prêt à traiter...")
-            out = gr.Video(label="Vidéo sous-titrée", height=300)
-    
-    # Exemples
-    gr.Examples(
-        examples=[],
-        inputs=[video, model],
-        outputs=[status, out],
-        fn=pipeline,
-        cache_examples=False,
+        # Nettoyage en cas d'erreur
+        if 'wav_path' in locals() and os.path.exists(wav_path): os.remove(wav_path)
+        return f"❌ ERREUR FATALE : {str(e)}", None
+
+
+# ----------------------------------------------------------------------
+# INTERFACE GRADIO - "ROBOTSMALI V8.0 : MINIMALIST BLUE"
+# ----------------------------------------------------------------------
+
+# Statut de l'application
+if NEMO_LOADED:
+    APP_STATUS = "✨ SYSTÈME PRÊT : Toutes les dépendances (NeMo/CTC) sont chargées."
+else:
+    APP_STATUS = "❌ DÉPENDANCES MANQUANTES : Veuillez exécuter la commande d'installation."
+
+
+with gr.Blocks(theme=gr.themes.Default(), title="RobotsMali V8.0", css=CUSTOM_CSS) as demo:
+    gr.Markdown(
+        f"""
+        # ⚡ **ROBOTSMALI V8.0 : MINIMALIST BLUE** ⚡
+        ### Sous-titrage et alignement de haute précision (RNNT & CTC).
+        *Statut : {APP_STATUS}*
+        ---
+        """
     )
+
+    with gr.Row(equal_height=True):
+        with gr.Column(scale=1):
+            with gr.Group(elem_classes=["block"]):
+                
+                gr.Markdown("### 1. Source & Configuration")
+                
+                video = gr.Video(
+                    label="Vidéo d'entrée (MP4, MOV, AVI)", 
+                    height=300,
+                    elem_classes=["gr-file-input"]
+                )
+                
+                model = gr.Dropdown(
+                    list(MODELS.keys()), 
+                    value="Soloni V1 (RNnT - Précis)", 
+                    label="Modèle de Reconnaissance Vocale",
+                    info="RNnT (Soloni): meilleur alignement. CTC (Soloba/QuartzNet): plus rapide.",
+                    interactive=NEMO_LOADED,
+                )
+                
+                btn = gr.Button("▶️ **INITIER LA PRODUCTION**", variant="primary", interactive=NEMO_LOADED)
+
+        with gr.Column(scale=2):
+            with gr.Group(elem_classes=["block"]):
+                gr.Markdown("### 2. Flux de Production & Résultat")
+                
+                status = gr.Markdown(
+                    value="En attente du fichier source...", 
+                    label="Journal de Bord",
+                    elem_classes=["gr-status"]
+                )
+                
+                out = gr.Video(
+                    label="Vidéo sous-titrée", 
+                    height=300,
+                    interactive=False
+                )
     
-    btn.click(pipeline, inputs=[video, model], outputs=[status, out])
+    # Explication de la correction :
+    gr.Markdown(
+        """
+        ---
+        **Note de l'Expert :** La logique d'alignement a été optimisée et unifiée pour les 6 modèles:
+        -   **Optimisation:** Chaque ligne de sous-titre respecte désormais simultanément les limites de **4 mots**, **45 caractères** et une durée maximale de **3.5 secondes**, assurant un rythme de lecture optimal.
+        -   **Unification:** La même fonction d'optimisation est appliquée à la sortie de tous les modèles (RNNT et CTC).
+        """
+    )
+
+    # L'utilisation de 'fn' dans gr.Examples est dépréciée. Le clic est le standard.
+    btn.click(
+        fn=pipeline, 
+        inputs=[video, model], 
+        outputs=[status, out]
+    )
 
 if __name__ == "__main__":
-    demo.launch(share=True, server_port=7860)
+    demo.launch(share=True)