Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import shutil
 import zipfile
+import torch
 from pathlib import Path
 
 import gradio as gr
@@ -10,7 +11,6 @@ from transformers import pipeline
 # -------------------------------------------------
 # Configuration
 # -------------------------------------------------
-
 MODEL_NAME = "openai/whisper-large-v3"
 device = 0 if torch.cuda.is_available() else "cpu"
 
@@ -24,80 +24,49 @@ pipe = pipeline(
 TEMP_DIR = "./temp_audio"
 os.makedirs(TEMP_DIR, exist_ok=True)
 
-# -------------------------------------------------
-# Gestion de l'état
-# -------------------------------------------------
 def init_metadata_state():
-    """
-    Initialise l'état pour stocker les informations des segments validés.
-    """
     return []
 
-# -------------------------------------------------
-# Étape 2 : Transcription avec Whisper
-# -------------------------------------------------
 def transcribe_audio(audio_path):
-    """
-    Retourne la transcription brute, un tableau de segments vides et le chemin de l'audio.
-    """
     if not audio_path:
-        return "Aucun fichier audio fourni", [["", None, None, ""] for _ in range(20)], None
-
-    # Transcrire
-    result = pipe(audio_path, return_timestamps="word")
-    text = result["text"]
-
-    # Transcription brute
-    raw_transcription = " ".join([chunk["text"] for chunk in result["chunks"]])
-
-    # Tableau de 20 lignes vides pour l'édition
-    table_init = [["", None, None, ""] for _ in range(20)]
-
-    return raw_transcription, table_init, audio_path
-
-# -------------------------------------------------
-# Étape 5 : Validation + découpe
-# -------------------------------------------------
-def validate_segments(audio_path, table_data, metadata_state):
-    """
-    Découpe l'audio en fonction des segments validés et met à jour l'état.
-    """
-    if not audio_path:
-        return [None] * 20, metadata_state
-
-    # Nettoyer le dossier temporaire
+        return "Aucun fichier audio fourni", [], None
+    
+    result = pipe(audio_path, return_timestamps=True)
+    words = result.get("chunks", [])
+    
+    raw_transcription = " ".join([w["text"] for w in words])
+    word_timestamps = [(w["text"], w["timestamp"]) for w in words]
+    
+    return raw_transcription, [], audio_path, word_timestamps
+
+def validate_segments(audio_path, table_data, metadata_state, word_timestamps):
+    if not audio_path or not word_timestamps:
+        return [], metadata_state
+    
     if os.path.exists(TEMP_DIR):
         shutil.rmtree(TEMP_DIR)
     os.makedirs(TEMP_DIR, exist_ok=True)
 
     original_audio = AudioSegment.from_file(audio_path)
-
     segment_paths = []
     updated_metadata = []
 
     for i, row in enumerate(table_data):
-        if len(row) < 4:
-            continue  # Ligne incomplète
         text, start_time, end_time, segment_id = row
-
         if not text or start_time is None or end_time is None:
-            continue  # Ligne vide ou incomplète
-        if not segment_id:
-            segment_id = f"seg_{i+1:02d}"
-
-        start_ms = int(float(start_time) * 1000)
-        end_ms = int(float(end_time) * 1000)
+            continue
+        
+        segment_id = segment_id or f"seg_{i+1:02d}"
+        start_ms, end_ms = int(float(start_time) * 1000), int(float(end_time) * 1000)
         if start_ms < 0 or end_ms <= start_ms:
             continue
-
+        
         segment_filename = f"{Path(audio_path).stem}_{segment_id}.wav"
         segment_path = os.path.join(TEMP_DIR, segment_filename)
-
-        # Découpe et export
+        
         extract = original_audio[start_ms:end_ms]
         extract.export(segment_path, format="wav")
-
-        # Stocker les informations
+        
         segment_paths.append(segment_path)
         updated_metadata.append({
             "audio_file": segment_filename,
@@ -106,107 +75,51 @@ def validate_segments(audio_path, table_data, metadata_state):
             "end_time": end_time,
             "id": segment_id,
         })
+    
+    return segment_paths, updated_metadata
 
-    # Remplir les sorties audio (20 max)
-    output_paths = segment_paths + [None] * (20 - len(segment_paths))
-
-    return output_paths, updated_metadata
-
-# -------------------------------------------------
-# Étape 8 : Génération du ZIP
-# -------------------------------------------------
 def generate_zip(metadata_state):
-    """
-    Génère un fichier ZIP contenant les segments audio et un fichier metadata.csv.
-    """
     if not metadata_state:
         return None
-
+    
     zip_path = os.path.join(TEMP_DIR, "dataset.zip")
     if os.path.exists(zip_path):
         os.remove(zip_path)
-
-    # Créer le fichier metadata.csv
+    
     metadata_csv_path = os.path.join(TEMP_DIR, "metadata.csv")
     with open(metadata_csv_path, "w", encoding="utf-8") as f:
         f.write("audio_file|text|speaker_name|API\n")
         for seg in metadata_state:
-            line = f"{seg['audio_file']}|{seg['text']}|projectname|/API_PHONETIC/\n"
-            f.write(line)
-
-    # Ajouter les fichiers au ZIP
+            f.write(f"{seg['audio_file']}|{seg['text']}|projectname|/API_PHONETIC/\n")
+    
     with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
         zf.write(metadata_csv_path, "metadata.csv")
         for seg in metadata_state:
             file_path = os.path.join(TEMP_DIR, seg["audio_file"])
             if os.path.exists(file_path):
                 zf.write(file_path, seg["audio_file"])
-
+    
     return zip_path
 
 # -------------------------------------------------
-# Construction de l'interface Gradio
+# Interface Gradio
 # -------------------------------------------------
-with gr.Blocks(css="style.css") as demo:
-    gr.Markdown("# Application de Découpe Audio (jusqu'à 20 segments)")
-
-    # State global
+with gr.Blocks() as demo:
+    gr.Markdown("# Application de Découpe Audio")
     metadata_state = gr.State(init_metadata_state())
 
-    # Étape 1 : Téléversement audio
-    with gr.Column():
-        gr.Markdown("### 1. Téléversez un fichier audio (MP3/WAV)")
-        audio_input = gr.Audio(source="upload", type="filepath", label="Fichier audio")
-
-    # Étape 2 : Transcription brute
-    raw_transcription = gr.Textbox(
-        label="Transcription (Whisper)",
-        placeholder="Le texte apparaîtra ici après chargement.",
-        interactive=False,
-    )
-
-    # Étape 3 : Table des segments
-    gr.Markdown("### 2. Définissez vos segments")
-    table = gr.Dataframe(
-        headers=["Texte", "Début (s)", "Fin (s)", "ID"],
-        datatype=["str", "number", "number", "str"],
-        row_count=20,
-        col_count=4,
-    )
-
-    # Bouton de validation
-    validate_button = gr.Button("Valider et générer les extraits")
-
-    # 20 lecteurs audio
+    audio_input = gr.Audio(type="filepath", label="Fichier audio")
+    raw_transcription = gr.Textbox(label="Transcription", interactive=False)
+    table = gr.Dataframe(headers=["Texte", "Début (s)", "Fin (s)", "ID"], datatype=["str", "number", "number", "str"], row_count="dynamic")
+    validate_button = gr.Button("Valider")
     audio_players = [gr.Audio(label=f"Extrait {i+1}", interactive=False) for i in range(20)]
-
-    # Bouton pour générer le fichier ZIP
-    generate_button = gr.Button("Générer le fichier ZIP")
+    generate_button = gr.Button("Générer ZIP")
     zip_file = gr.File(label="Télécharger le ZIP")
 
-    # ----------------
-    # Callbacks
-    # ----------------
-
-    # Étape 1 : Transcription audio
-    audio_input.change(
-        fn=transcribe_audio,
-        inputs=audio_input,
-        outputs=[raw_transcription, table, audio_input],
-    )
-
-    # Étape 5 : Validation des segments
-    validate_button.click(
-        fn=validate_segments,
-        inputs=[audio_input, table, metadata_state],
-        outputs=audio_players + [metadata_state],
-    )
+    word_timestamps = gr.State()
 
-    # Étape 8 : Génération du fichier ZIP
-    generate_button.click(
-        fn=generate_zip,
-        inputs=metadata_state,
-        outputs=zip_file,
-    )
+    audio_input.change(transcribe_audio, inputs=audio_input, outputs=[raw_transcription, table, audio_input, word_timestamps])
+    validate_button.click(validate_segments, inputs=[audio_input, table, metadata_state, word_timestamps], outputs=audio_players + [metadata_state])
+    generate_button.click(generate_zip, inputs=metadata_state, outputs=zip_file)
 
-demo.queue().launch()
+demo.queue().launch()