Update app.py

app.py

@@ -2,21 +2,18 @@ import os
 import shutil
 import zipfile
 from pathlib import Path
-from datetime import datetime
 
 import gradio as gr
-import torch
 from pydub import AudioSegment
 from transformers import pipeline
 
-# ------------------------
-# Configuration générale
-# ------------------------
+# -------------------------------------------------
+# Configuration
+# -------------------------------------------------
 
 MODEL_NAME = "openai/whisper-large-v3"
 device = 0 if torch.cuda.is_available() else "cpu"
 
-# Pipeline Whisper pour la transcription
 pipe = pipeline(
     task="automatic-speech-recognition",
     model=MODEL_NAME,
@@ -24,237 +21,192 @@ pipe = pipeline(
     model_kwargs={"low_cpu_mem_usage": True},
 )
 
-# Dossier temporaire pour stocker extraits & ZIP
 TEMP_DIR = "./temp_audio"
 os.makedirs(TEMP_DIR, exist_ok=True)
 
-# On stocke la métadonnée globale dans un State
-# pour pouvoir y accéder lors de la génération du ZIP
-# (table de correspondance entre segments et infos)
+# -------------------------------------------------
+# Gestion de l'état
+# -------------------------------------------------
 def init_metadata_state():
+    """
+    Initialise l'état pour stocker les informations des segments validés.
+    """
     return []
 
-# ------------------------
-# Étape 2 : Transcription
-# ------------------------
+# -------------------------------------------------
+# Étape 2 : Transcription avec Whisper
+# -------------------------------------------------
 def transcribe_audio(audio_path):
     """
-    1) Transcrit l'audio avec Whisper large-v3
-    2) Retourne la transcription brute et une table pré-remplie
-       (l'utilisateur pourra remplir manuellement la partie 'Texte' s'il le souhaite)
+    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
+        return "Aucun fichier audio fourni", [["", None, None, ""] for _ in range(20)], None
 
-    # Transcription Whisper avec timestamps de chaque mot
+    # Transcrire
     result = pipe(audio_path, return_timestamps="word")
     text = result["text"]
-    chunks = result["chunks"]  # liste de { 'timestamp': (start, end), 'text': ... }
 
-    # Transcription brute (sans timestamps, par exemple)
-    raw_transcription = " ".join([w["text"] for w in chunks])
+    # Transcription brute
+    raw_transcription = " ".join([chunk["text"] for chunk in result["chunks"]])
 
-    # On conserve le chemin de l'audio dans un State (pour la découpe ultérieure)
-    return raw_transcription, [], audio_path
+    # 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 des segments + découpe
-# ------------------------
-def validate_segments_with_timestamps(audio_path, table_data, metadata_state):
+# -------------------------------------------------
+# Étape 5 : Validation + découpe
+# -------------------------------------------------
+def validate_segments(audio_path, table_data, metadata_state):
     """
-    Valide les segments définis par l'utilisateur et ajoute automatiquement
-    les timestamps (`start_time` et `end_time`) pour les lignes sans valeurs.
+    Découpe l'audio en fonction des segments validés et met à jour l'état.
     """
     if not audio_path:
         return [None] * 20, metadata_state
 
-    # Charger l'audio complet
-    original_audio = AudioSegment.from_file(audio_path)
-    audio_duration = len(original_audio) / 1000  # Durée totale en secondes
-
     # Nettoyer le dossier temporaire
     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 = []
 
-    # Dernier temps utilisé (pour calculer les suivants)
-    last_end_time = 0.0
-
     for i, row in enumerate(table_data):
-        # Vérifier si la ligne contient des données
-        if len(row) < 4 or not row[0]:  # Texte vide
+        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)
+        if start_ms < 0 or end_ms <= start_ms:
             continue
 
-        segment_text = row[0]  # Texte
-        start_time = row[1] if row[1] is not None else last_end_time
-        end_time = row[2] if row[2] is not None else min(audio_duration, start_time + 5)  # Segment de 5s par défaut
-
-        # Ajuster `end_time` si nécessaire
-        if end_time <= start_time:
-            end_time = min(audio_duration, start_time + 5)  # Minimum 5s
-
-        seg_id = row[3] if row[3] else f"seg_{i+1:02d}"  # Générer ID si absent
-
-        # Convertir en millisecondes
-        start_ms = int(start_time * 1000)
-        end_ms = int(end_time * 1000)
-
-        # Découpe de l'audio
-        segment_filename = f"{Path(audio_path).stem}_{seg_id}.wav"
+        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")
 
-        # Mise à jour des timestamps
-        last_end_time = end_time
-
-        # Stocker la méta (pour metadata_state)
+        # Stocker les informations
+        segment_paths.append(segment_path)
         updated_metadata.append({
             "audio_file": segment_filename,
-            "text": segment_text,
+            "text": text,
             "start_time": start_time,
             "end_time": end_time,
-            "id": seg_id
+            "id": segment_id,
         })
 
-        segment_paths.append(segment_path)
-
-    # Remplir les 20 slots si moins de 20 segments
+    # Remplir les sorties audio (20 max)
     output_paths = segment_paths + [None] * (20 - len(segment_paths))
 
     return output_paths, updated_metadata
-# ------------------------
-# Étape 7 : Génération du ZIP (avec metadata.csv)
-# ------------------------
+
+# -------------------------------------------------
+# Étape 8 : Génération du ZIP
+# -------------------------------------------------
 def generate_zip(metadata_state):
     """
-    1) Crée le fichier 'metadata.csv'
-    2) Zip tous les extraits + metadata.csv
-    3) Renvoie le chemin du ZIP pour téléchargement
+    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")
-    # Supprimer le zip précédent si existe
     if os.path.exists(zip_path):
         os.remove(zip_path)
 
-    # Créer le CSV
+    # 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:
-            # Exemple de speaker_name et API
-            # A adapter selon tes besoins
             line = f"{seg['audio_file']}|{seg['text']}|projectname|/API_PHONETIC/\n"
             f.write(line)
 
-    # Créer le ZIP final
+    # Ajouter les fichiers au ZIP
     with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        # Ajouter les segments
-        for seg in metadata_state:
-            segment_file = os.path.join(TEMP_DIR, seg["audio_file"])
-            if os.path.exists(segment_file):
-                zf.write(segment_file, seg["audio_file"])
-        # Ajouter le CSV
         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
-# ------------------------
+# -------------------------------------------------
 with gr.Blocks(css="style.css") as demo:
-    gr.Markdown("# Application de découpe audio + Transcription Whisper")
+    gr.Markdown("# Application de Découpe Audio (jusqu'à 20 segments)")
 
-    # State pour conserver l'audio path + la liste de metadata
+    # State global
     metadata_state = gr.State(init_metadata_state())
 
-    # Étape 1 : Choix de l'audio
+    # Étape 1 : Téléversement audio
     with gr.Column():
-        gr.Markdown("### 1. Téléversez votre fichier audio (MP3/WAV)")
-        audio_input = gr.Audio(
-            type="filepath", label="Fichier audio"
-        )
+        gr.Markdown("### 1. Téléversez un fichier audio (MP3/WAV)")
+        audio_input = gr.Audio(source="upload", type="filepath", label="Fichier audio")
 
-    # Étape 3 : Affichage transcription brute
+    # Étape 2 : Transcription brute
     raw_transcription = gr.Textbox(
-        label="Transcription brute (générée par Whisper)",
-        placeholder="La transcription apparaîtra ici",
-        interactive=False
+        label="Transcription (Whisper)",
+        placeholder="Le texte apparaîtra ici après chargement.",
+        interactive=False,
     )
 
-    # Étape 4 : Tableau pour choisir les extraits
+    # Étape 3 : Table des segments
     gr.Markdown("### 2. Définissez vos segments")
-    gr.Markdown("**Colonne 1** : Le texte (copiez-coller depuis la transcription si besoin) **Colonne 2** : Temps de début (en secondes)  **Colonne 3** : Temps de fin (en secondes)  **Colonne 4** : ID de votre segment (optionnel).")
     table = gr.Dataframe(
         headers=["Texte", "Début (s)", "Fin (s)", "ID"],
         datatype=["str", "number", "number", "str"],
-        row_count=5,
-        col_count=4
+        row_count=20,
+        col_count=4,
     )
+
+    # Bouton de validation
     validate_button = gr.Button("Valider et générer les extraits")
 
-    # Étape 6 : Écoute des extraits
-    # On prévoit jusqu'à 5 extraits (correspondant à row_count=5)
-    # Si tu prévois plus, augmente simplement ce bloc
-    audio_player_1 = gr.Audio(label="Extrait 1", interactive=False)
-    audio_player_2 = gr.Audio(label="Extrait 2", interactive=False)
-    audio_player_3 = gr.Audio(label="Extrait 3", interactive=False)
-    audio_player_4 = gr.Audio(label="Extrait 4", interactive=False)
-    audio_player_5 = gr.Audio(label="Extrait 5", interactive=False)
-
-    # Pour la sortie 'Valider segments', on veut 2 retours :
-    # - la liste des chemins (jusqu'à 5)
-    # - la metadata mise à jour
-    # => On va mapper ces chemins sur les 5 players
-    def update_audio_players(segments):
-        """
-        Prend la liste des chemins d'extraits audio (taille variable)
-        et renvoie une liste de 5 valeurs (None si pas d'extrait)
-        """
-        max_slots = 5
-        audio_values = [None]*max_slots
-        for i, seg in enumerate(segments):
-            if i < max_slots:
-                audio_values[i] = seg
-        return tuple(audio_values)
-
-    # Étape 8 : Génération ZIP
+    # 20 lecteurs audio
+    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")
     zip_file = gr.File(label="Télécharger le ZIP")
 
-    # ------------------------
-    # Logique de callbacks
-    # ------------------------
+    # ----------------
+    # Callbacks
+    # ----------------
 
-    # 1) Callback quand on charge l'audio
+    # Étape 1 : Transcription audio
     audio_input.change(
         fn=transcribe_audio,
         inputs=audio_input,
-        outputs=[raw_transcription, table, audio_input],  # On renvoie le path en 3e
+        outputs=[raw_transcription, table, audio_input],
     )
 
+    # Étape 5 : Validation des segments
     validate_button.click(
-        fn=validate_segments_with_timestamps,
+        fn=validate_segments,
         inputs=[audio_input, table, metadata_state],
-        outputs=[
-            [audio_player_1, audio_player_2, audio_player_3, audio_player_4, audio_player_5],
-            metadata_state
-        ]
+        outputs=audio_players + [metadata_state],
     )
-    
-    # Étape 3 : Callback pour générer le ZIP
+
+    # Étape 8 : Génération du fichier ZIP
     generate_button.click(
         fn=generate_zip,
         inputs=metadata_state,
-        outputs=zip_file
+        outputs=zip_file,
     )
 
 demo.queue().launch()