Update app.py

app.py

@@ -2,15 +2,16 @@ 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
 
-# ------------------------
-# CONFIG
-# ------------------------
+# -------------------------------------------------
+# Configuration
+# -------------------------------------------------
 
 MODEL_NAME = "openai/whisper-large-v3"
 device = 0 if torch.cuda.is_available() else "cpu"
@@ -25,221 +26,221 @@ pipe = pipeline(
 TEMP_DIR = "./temp_audio"
 os.makedirs(TEMP_DIR, exist_ok=True)
 
-# On stocke la liste des métadonnées (segments) dans un State
-# pour la conserver entre les étapes (transcription, découpe, zip).
+# -------------------------------------------------
+# Gestion de l'état
+# -------------------------------------------------
 def init_metadata_state():
+    """
+    Stockera la liste des segments validés : 
+    [
+        { "audio_file":..., "text":..., "start_time":..., "end_time":..., "id":... }, ...
+    ]
+    """
     return []
 
-# ------------------------
-# FONCTIONS
-# ------------------------
-
+# -------------------------------------------------
+# Étape 2 : Transcription avec Whisper
+# -------------------------------------------------
 def transcribe_audio(audio_path):
     """
-    Étape 2 : Transcription du fichier audio via Whisper
-              + récupération de la transcription brute.
+    Retourne :
+      - Transcription brute (concaténation des mots)
+      - Un tableau de 20 lignes vides (4 colonnes)
+      - Le chemin du fichier audio pour la suite
     """
     if not audio_path:
-        return "Aucun fichier audio fourni.", [], None
+        return "Aucun fichier audio fourni", [], None
 
-    # Transcription Whisper
+    # Transcrire
     result = pipe(audio_path, return_timestamps="word")
     text = result["text"]
-    chunks = result["chunks"]  # liste de { 'timestamp': (start, end), 'text': ... }
+    chunks = result["chunks"]  # [{'timestamp': (start, end), 'text': ... }, ...]
 
+    # Concaténer le texte brut
     raw_transcription = " ".join([c["text"] for c in chunks])
 
-    # Le 3e retour = chemin du fichier audio, qu'on renverra tel quel pour la découpe
-    return raw_transcription, [], audio_path
+    # Générer un tableau de 20 lignes vides (utilisateur remplit manuellement)
+    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):
     """
-    Étape 5 : Découpe de l'audio en fonction des segments
-              et mise à jour du State `metadata_state`.
-    - `table_data` doit contenir : [ [Texte, Début(s), Fin(s), ID], ... ]
-    - Retourne :
-        1) Une liste de chemins (extraits audio) pour les players
-        2) La liste des nouvelles métadonnées (mise à jour).
+    - Parcourt chaque ligne du tableau (jusqu'à 20).
+    - Découpe l'audio via pydub si la ligne est valide.
+    - Met à jour la "State" (metadata_state).
+    - Retourne la liste des chemins générés (segment_paths).
     """
     if not audio_path:
-        return ["Aucun fichier audio..."], metadata_state
+        return [], metadata_state
 
-    # Nettoyage du dossier temporaire avant recréation des extraits
+    # 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 = []
 
     for i, row in enumerate(table_data):
-        # row = [ segment_text, start_time, end_time, seg_id ]
+        # row = [ texte, start, end, seg_id ]
         if len(row) < 4:
-            continue
+            continue  # ligne incomplète
+        segment_text, start_time, end_time, seg_id = row
 
-        seg_text, start_time, end_time, seg_id = row
-        if not seg_text or start_time is None or end_time is None:
+        if not segment_text or start_time is None or end_time is None:
+            # Ligne vide ou incomplète => on ignore
             continue
-
-        # Si l'utilisateur n'a pas mis d'ID, en créer un
         if not seg_id:
             seg_id = f"seg_{i+1:02d}"
 
-        # Découpe
         start_ms = int(float(start_time) * 1000)
         end_ms = int(float(end_time) * 1000)
-        extract = original_audio[start_ms:end_ms]
+        # Vérifier que la sélection est valide
+        if start_ms < 0 or end_ms <= start_ms:
+            continue
 
-        # Nom de fichier
-        stem_name = Path(audio_path).stem
-        segment_filename = f"{stem_name}_{seg_id}.wav"
-        segment_filepath = os.path.join(TEMP_DIR, segment_filename)
-        extract.export(segment_filepath, format="wav")
+        segment_filename = f"{Path(audio_path).stem}_{seg_id}.wav"
+        segment_path = os.path.join(TEMP_DIR, segment_filename)
 
-        segment_paths.append(segment_filepath)
+        # Découpe + export
+        extract = original_audio[start_ms:end_ms]
+        extract.export(segment_path, format="wav")
 
-        # Stocker la métadonnée
+        # Stocker chemin + info
+        segment_paths.append(segment_path)
         updated_metadata.append({
             "audio_file": segment_filename,
-            "text": seg_text,
+            "text": segment_text,
             "start_time": start_time,
             "end_time": end_time,
-            "id": seg_id,
+            "id": seg_id
         })
 
+    # On renvoie la liste + on met à jour la state
     return segment_paths, updated_metadata
 
-
+# -------------------------------------------------
+# Étape 8 : Génération du ZIP
+# -------------------------------------------------
 def generate_zip(metadata_state):
     """
-    Étape 8 : Générer un ZIP contenant tous les extraits + un metadata.csv
-    Retourne le chemin vers le ZIP final.
+    Crée metadata.csv + zip tous les extraits + le CSV
+    Retourne le chemin du zip pour téléchargement
     """
     if not metadata_state:
         return None
 
-    # Supprimer un ancien zip si présent
     zip_path = os.path.join(TEMP_DIR, "dataset.zip")
     if os.path.exists(zip_path):
         os.remove(zip_path)
 
-    # Créer metadata.csv
+    # Créer le 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:
-            # Ajuste speaker_name ou API selon ton besoin
             line = f"{seg['audio_file']}|{seg['text']}|projectname|/API_PHONETIC/\n"
             f.write(line)
 
-    # Créer le ZIP
+    # Zipper
     with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
         # Ajouter chaque extrait
         for seg in metadata_state:
-            seg_file = os.path.join(TEMP_DIR, seg["audio_file"])
-            if os.path.exists(seg_file):
-                zf.write(seg_file, seg["audio_file"])
-
-        # Ajouter le metadata.csv
+            file_path = os.path.join(TEMP_DIR, seg["audio_file"])
+            if os.path.exists(file_path):
+                zf.write(file_path, seg["audio_file"])
+        # Ajouter le CSV
         zf.write(metadata_csv_path, "metadata.csv")
 
     return zip_path
 
-
-def distribute_segments_to_players(segments):
+# -------------------------------------------------
+# Mise à jour des players (jusqu'à 20)
+# -------------------------------------------------
+def spread_segments_to_players(segment_paths):
     """
-    Transforme la liste de segments en un tuple de 20 valeurs max
-    (pour 20 players).
-    Si moins de 20 segments, on complète avec None.
+    Reçoit la liste de chemins (X <= 20).
+    Retourne un tuple de 20 valeurs pour remplir 
+    chaque gr.Audio individuellement, ou None si inexistant.
     """
-    max_players = 20
-    result = []
-    for i in range(max_players):
-        if i < len(segments):
-            result.append(segments[i])
-        else:
-            result.append(None)
-    return tuple(result)
-
-
-# ------------------------
-# CONSTRUCTION UI GRADIO
-# ------------------------
+    max_slots = 20
+    out = [None] * max_slots
+    for i, p in enumerate(segment_paths):
+        if i < max_slots:
+            out[i] = p
+    return tuple(out)
+
+# -------------------------------------------------
+# Construction de l'interface Gradio
+# -------------------------------------------------
 with gr.Blocks(css="style.css") as demo:
+    gr.Markdown("# Application de Découpe Audio (jusqu'à 20 segments)")
 
-    gr.Markdown("# Application de Découpage Audio + Transcription (jusqu'à 20 extraits)")
+    # State global pour stocker la metadata (liste de dict)
     metadata_state = gr.State(init_metadata_state())
 
-    # Étape 1 : Chargement de l'audio
+    # Étape 1 : Upload audio
     with gr.Box():
-        gr.Markdown("### 1. Téléversez votre 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 : Transcription brute
+    # Transcription brute
     raw_transcription = gr.Textbox(
-        label="Transcription brute (Whisper)",
-        placeholder="Le texte s'affichera ici après la transcription...",
+        label="Transcription (Whisper)",
+        placeholder="Le texte apparaîtra ici après chargement.",
         interactive=False
     )
 
-    # Étape 4 : Tableau pour 20 segments max
-    gr.Markdown("### 2. Définissez jusqu'à 20 segments")
-    gr.Markdown("""**Colonnes :**  
-1) Texte (phrase ou portion copiée depuis la transcription)  
-2) Début (en secondes)  
-3) Fin (en secondes)  
-4) ID segment (optionnel)""")
-
+    # Tableau de 20 lignes
+    gr.Markdown("### 2. Définissez vos segments (vous pouvez en remplir moins, ça fonctionnera !)")
+    gr.Markdown("**Colonne 1** : Texte, **Colonne 2** : D��but (s), **Colonne 3** : Fin (s), **Colonne 4** : ID (optionnel)")
     table = gr.Dataframe(
         headers=["Texte", "Début (s)", "Fin (s)", "ID"],
         datatype=["str", "number", "number", "str"],
-        row_count=20,  # <-- 20 lignes
+        row_count=20,
         col_count=4
     )
-
     validate_button = gr.Button("Valider et générer les extraits")
 
-    # Étape 6 : 20 players audio pour l'écoute
-    # On les organise en 5 rangées de 4 players
-    players = []
+    # 20 lecteurs audio
+    audio_players = []
     for i in range(20):
-        players.append(gr.Audio(label=f"Extrait {i+1}", interactive=False))
+        ap = gr.Audio(label=f"Extrait {i+1}", interactive=False)
+        audio_players.append(ap)
 
-    # Groupons-les en blocs de 4
-    for i in range(0, 20, 4):
-        with gr.Row():
-            for j in range(i, i+4):
-                players[j]
-
-    # Étape 8 : Génération ZIP
+    # Générer ZIP
     generate_button = gr.Button("Générer le fichier ZIP")
-    zip_file = gr.File(label="Télécharger le ZIP (audios + metadata.csv)")
+    zip_file = gr.File(label="Télécharger le ZIP")
+
+    # ----------------
+    # Callbacks
+    # ----------------
 
-    # 1) Callback quand on charge l'audio => Transcription
+    # Au changement d'audio => transcription
     audio_input.change(
         fn=transcribe_audio,
         inputs=audio_input,
         outputs=[raw_transcription, table, audio_input]
     )
 
-    # 2) Callback quand on valide => Découpe audio + maj metadata
+    # Validation => découpe => mise à jour players
     validate_button.click(
         fn=validate_segments,
         inputs=[audio_input, table, metadata_state],
-        outputs=[  # 1) chemins extraits (list) 2) metadata (list)
-            players,  # Les 20 players
-            metadata_state
-        ],
-        # On va mapper la liste de segments sur 20 players
+        outputs=["temp_paths", metadata_state],
     ).then(
-        fn=distribute_segments_to_players,
-        inputs=None,  # la sortie "players" (chemins) est déjà captée
-        outputs=players
+        fn=spread_segments_to_players,
+        inputs="temp_paths",
+        outputs=audio_players
     )
 
-    # 3) Génération ZIP
+    # Génération ZIP
     generate_button.click(
         fn=generate_zip,
         inputs=metadata_state,