Update app.py

app.py

@@ -7,18 +7,13 @@ import os
 import datetime
 
 # --- Configuration ---
-# Assurez-vous d'avoir ajouté votre token Hugging Face dans les secrets de votre Space (nommé HF_TOKEN)
 HF_TOKEN = os.environ.get("HF_TOKEN")
-# MODEL_NAME = "openai/whisper-large-v3"
 MODEL_NAME = "openai/whisper-medium"
 
-# Détermine si un GPU est disponible et configure le device en conséquence
 device = 0 if torch.cuda.is_available() else "cpu"
 torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
 
 # --- Initialisation des modèles ---
-
-# Pipeline de transcription (Whisper)
 pipe = pipeline(
     "automatic-speech-recognition",
     model=MODEL_NAME,
@@ -26,8 +21,6 @@ pipe = pipeline(
     device=device,
 )
 
-# Pipeline de diarisation (Pyannote)
-# S'assure que le token est disponible avant de charger le modèle
 if HF_TOKEN:
     pyannote_pipeline = Pipeline.from_pretrained(
         "pyannote/speaker-diarization-3.1",
@@ -38,14 +31,12 @@ else:
     pyannote_pipeline = None
     print("Avertissement : Le token Hugging Face n'est pas défini. La diarisation sera désactivée.")
 
-
 # --- Fonctions de traitement audio ---
 
 def convert_to_wav(audio_path):
     """Convertit n'importe quel fichier audio en format WAV mono."""
     try:
         audio = AudioSegment.from_file(audio_path)
-        # Convertit en mono pour la compatibilité avec les modèles
         audio = audio.set_channels(1)
         wav_path = os.path.splitext(audio_path)[0] + ".wav"
         audio.export(wav_path, format="wav")
@@ -54,80 +45,78 @@ def convert_to_wav(audio_path):
         print(f"Erreur lors de la conversion en WAV : {e}")
         return None
 
+def detect_language_on_upload(filepath):
+    if filepath is None:
+        return "auto"
+    wav_filepath = convert_to_wav(filepath)
+    if not wav_filepath:
+        return "auto"
+    outputs = pipe(wav_filepath, chunk_length_s=30, batch_size=24, return_timestamps=False)
+    detected_lang = outputs.get("language", "auto")
+    return detected_lang
+
+def save_txt(content, filename):
+    if not content or content.strip() == "":
+        return None
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(content)
+    return filename
+
 def transcribe_audio(filepath, diarize, language_choice):
-    """Fonction principale qui transcrit et optionnellement diarise l'audio."""
     if filepath is None:
-        return "Aucun fichier audio fourni.", "Veuillez télécharger un fichier audio.", ""
+        return "Aucun fichier audio fourni.", "Veuillez télécharger un fichier audio.", "", None, None
 
-    # Convertit le fichier en WAV, format requis par les modèles
     wav_filepath = convert_to_wav(filepath)
     if not wav_filepath:
-        return "Erreur : Le fichier audio n'a pas pu être converti.", "Conversion échouée.", ""
+        return "Erreur : Le fichier audio n'a pas pu être converti.", "Conversion échouée.", "", None, None
 
-    # Prépare les paramètres pour Whisper
     whisper_params = {
         "chunk_length_s": 30,
         "batch_size": 24,
         "return_timestamps": True
     }
-    
-    # Ajoute la langue si elle est spécifiée
     if language_choice != "auto":
         whisper_params["generate_kwargs"] = {"language": language_choice}
 
-    # Transcription avec Whisper
     outputs = pipe(wav_filepath, **whisper_params)
     transcription = outputs["text"].strip()
-    
-    # Récupère la langue détectée (si disponible)
-    detected_language = "Non disponible"
-    if "chunks" in outputs and len(outputs["chunks"]) > 0:
-        # Essaie de récupérer la langue du premier chunk
-        first_chunk = outputs["chunks"][0]
-        if "language" in first_chunk:
-            detected_language = first_chunk["language"]
-    
-    # Message d'information sur la langue
+
+    detected_language = outputs.get("language", "Non disponible")
     language_info = f"Langue détectée: {detected_language}"
     if language_choice != "auto":
         language_info += f" (Langue forcée: {language_choice})"
 
-    # Diarisation si l'option est activée et le modèle disponible
+    diarized_transcription = ""
     if diarize and pyannote_pipeline:
         try:
             diarization = pyannote_pipeline(wav_filepath)
-            diarized_transcription = ""
-            # Parcourt les segments de parole identifiés par la diarisation
             for turn, _, speaker in diarization.itertracks(yield_label=True):
                 segment_start = turn.start
                 segment_end = turn.end
-
-                # Associe le texte transcrit au segment de parole actuel
                 segment_text = ""
                 for chunk in outputs["chunks"]:
                     chunk_start = chunk['timestamp'][0]
                     chunk_end = chunk['timestamp'][1]
                     if chunk_start is not None and chunk_end is not None:
-                        # Vérifie si le chunk de texte se superpose avec le segment de parole
                         if max(segment_start, chunk_start) < min(segment_end, chunk_end):
                             segment_text += chunk['text']
-
-                # Formate la sortie
                 start_time = str(datetime.timedelta(seconds=int(segment_start)))
                 diarized_transcription += f"[{start_time}] {speaker}:{segment_text.strip()}\n"
-
-            return transcription, diarized_transcription, language_info
         except Exception as e:
-            return transcription, f"Erreur pendant la diarisation : {e}", language_info
+            diarized_transcription = f"Erreur pendant la diarisation : {e}"
     elif diarize:
-        return transcription, "Diarisation activée mais le modèle n'a pas pu être chargé (token manquant ?).", language_info
+        diarized_transcription = "Diarisation activée mais le modèle n'a pas pu être chargé (token manquant ?)."
     else:
-        return transcription, "Diarisation non activée.", language_info
+        diarized_transcription = "Diarisation non activée."
+
+    transcription_file = save_txt(transcription, "transcription.txt")
+    diarization_file = save_txt(diarized_transcription, "transcription_diarized.txt")
+    return transcription, diarized_transcription, language_info, transcription_file, diarization_file
 
 # --- Interface Gradio ---
 
 with gr.Blocks() as demo:
-    gr.Markdown("<h1 style='text-align: center;'>Application de Transcription et Diarisation Audio</h1>")
+    gr.HTML("<div style='text-align:center;'><h1>Application de Transcription et Diarisation Audio</h1></div>")
     # gr.Markdown("## Objectif")
     gr.Markdown("Transcrivez et diarisez automatiquement vos fichiers audio (WhatsApp, réunions, interviews, etc.) grâce à Whisper et pyannote, directement dans ce Space.")
 
@@ -155,39 +144,30 @@ with gr.Blocks() as demo:
             reset_btn = gr.Button("Reset", variant="secondary")
         with gr.Column():
             language_info_output = gr.Textbox(label="Information sur la langue", lines=1)
+            transcription_file = gr.File(label="Télécharger la transcription (.txt)")
             transcription_output = gr.Textbox(label="Transcription Complète", lines=10)
+            diarization_file = gr.File(label="Télécharger la transcription diarizée (.txt)")
             diarization_output = gr.Textbox(label="Transcription avec Diarisation (par locuteur)", lines=15)
-            download_btn = gr.Button("Télécharger la transcription (.txt)")
-            download_file = gr.File(label="Fichier .txt à télécharger")
+
+    audio_input.change(
+        fn=detect_language_on_upload,
+        inputs=audio_input,
+        outputs=language_dropdown
+    )
 
     submit_btn.click(
         fn=transcribe_audio,
         inputs=[audio_input, diarize_checkbox, language_dropdown],
-        outputs=[transcription_output, diarization_output, language_info_output]
+        outputs=[transcription_output, diarization_output, language_info_output, transcription_file, diarization_file]
     )
 
     def reset_fields():
-        return "", "", "", None, "auto", True
+        return "", "", "", None, None, "auto", True
 
     reset_btn.click(
         fn=reset_fields,
         inputs=[],
-        outputs=[transcription_output, diarization_output, language_info_output, audio_input, language_dropdown, diarize_checkbox]
-    )
-
-    def save_transcription_to_txt(transcription):
-        if not transcription:
-            return None
-        filename = "transcription.txt"
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write(transcription)
-        return filename
-
-    download_btn.click(
-        fn=save_transcription_to_txt,
-        inputs=transcription_output,
-        outputs=download_file
+        outputs=[transcription_output, diarization_output, language_info_output, transcription_file, diarization_file, language_dropdown, diarize_checkbox]
     )
 
-# --- Lancement de l'application ---
 demo.launch(share=True)