Update app.py

app.py

@@ -2,8 +2,10 @@ import os
 import shutil
 import zipfile
 import torch
-import gradio as gr
+import numpy as np
+import pandas as pd
 from pathlib import Path
+import gradio as gr
 from pydub import AudioSegment
 from transformers import pipeline
 
@@ -34,7 +36,7 @@ def init_metadata_state():
 def transcribe_audio(audio_path):
     if not audio_path:
         print("[LOG] Aucun fichier audio fourni.")
-        return "Aucun fichier audio fourni", [], None, []
+        return "Aucun fichier audio fourni", None, [], ""
     
     print(f"[LOG] Début de la transcription de {audio_path}...")
     result = pipe(audio_path, return_timestamps="word")
@@ -42,16 +44,14 @@ def transcribe_audio(audio_path):
     
     if not words:
         print("[LOG ERROR] Erreur : Aucun timestamp détecté.")
-        return "Erreur : Aucun timestamp détecté.", [], None, []
+        return "Erreur : Aucun timestamp détecté.", None, [], ""
     
     raw_transcription = " ".join([w["text"] for w in words])
     word_timestamps = [(w["text"], w["timestamp"][0]) for w in words]
-    
     transcription_with_timestamps = " ".join([f"{w[0]}[{w[1]:.2f}]" for w in word_timestamps])
     
     print(f"[LOG] Transcription brute : {raw_transcription}")
-    print(f"[LOG DETAIL] Timestamps associés : {word_timestamps}")
-    return raw_transcription, [], audio_path, word_timestamps, transcription_with_timestamps
+    return raw_transcription, word_timestamps, transcription_with_timestamps, audio_path
 
 # -------------------------------------------------
 # 3. Enregistrement des segments définis par l'utilisateur
@@ -59,71 +59,38 @@ def transcribe_audio(audio_path):
 def save_segments(table_data):
     print("[LOG] Enregistrement des segments définis par l'utilisateur...")
     formatted_data = []
-    for i, row in enumerate(table_data):
-        if len(row) < 3 or not row[0].strip():
-            print(f"[LOG WARNING] Ligne vide ignorée à l'index {i}.")
-            continue
-
-        text, start_time, end_time = row[0].strip(), row[1], row[2]
+    
+    for i, row in table_data.iterrows():
+        text, start_time, end_time = row["Texte"], row["Début (s)"], row["Fin (s)"]
         segment_id = f"seg_{i+1:02d}"
-
+        
         try:
+            start_time = str(start_time).replace(",", ".")
+            end_time = str(end_time).replace(",", ".")
+            
+            if not start_time.replace(".", "").isdigit() or not end_time.replace(".", "").isdigit():
+                raise ValueError("Valeurs de timestamps invalides")
+            
             start_time = float(start_time)
             end_time = float(end_time)
+            
+            if start_time < 0 or end_time <= start_time:
+                raise ValueError("Valeurs incohérentes")
+            
             formatted_data.append([text, start_time, end_time, segment_id])
-            print(f"[LOG] Segment ajouté : {text} | Début: {start_time}, Fin: {end_time}, ID: {segment_id}")
+            print(f"[LOG] Segment ajouté : {text} | Début: {start_time:.2f}s, Fin: {end_time:.2f}s, ID: {segment_id}")
+        
         except ValueError as e:
-            print(f"[LOG ERROR] Erreur de conversion de timestamps : {e}")
-            return [], "Erreur : Vérifiez que les valeurs de début et de fin sont bien des nombres."
+            print(f"[LOG ERROR] Erreur de conversion des timestamps : {e}")
+            return pd.DataFrame(), "Erreur : Vérifiez que les valeurs sont bien des nombres valides."
     
-    return formatted_data
+    return pd.DataFrame(formatted_data, columns=["Texte", "Début (s)", "Fin (s)", "ID"]), ""
 
 # -------------------------------------------------
-# 4. Validation et découpage des extraits audio
+# 4. Génération du fichier ZIP
 # -------------------------------------------------
-def validate_segments(audio_path, table_data, metadata_state):
-    print("[LOG] Début de la validation des segments...")
-    if not audio_path:
-        print("[LOG ERROR] Erreur : Aucun fichier audio fourni !")
-        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 text, start_time, end_time, segment_id in table_data:
-        start_ms, end_ms = int(start_time * 1000), int(end_time * 1000)
-        if start_ms < 0 or end_ms <= start_ms:
-            print(f"[LOG ERROR] Problème de découpage : {text} | {start_time}s - {end_time}s")
-            continue
-
-        segment_filename = f"{Path(audio_path).stem}_{segment_id}.wav"
-        segment_path = os.path.join(TEMP_DIR, segment_filename)
-
-        extract = original_audio[start_ms:end_ms]
-        extract.export(segment_path, format="wav")
-
-        segment_paths.append(segment_path)
-        updated_metadata.append({
-            "audio_file": segment_filename,
-            "text": text,
-            "start_time": start_time,
-            "end_time": end_time,
-            "id": segment_id,
-        })
-        print(f"[LOG] Extrait généré : {segment_filename}")
-    
-    return segment_paths, updated_metadata
-
-# -------------------------------------------------
-# 5. Génération du fichier ZIP
-# -------------------------------------------------
-def generate_zip(metadata_state):
-    if not metadata_state:
+def generate_zip(metadata_state, audio_path):
+    if metadata_state.empty:
         print("[LOG ERROR] Aucun segment valide trouvé pour la génération du ZIP.")
         return None
     
@@ -132,42 +99,41 @@ def generate_zip(metadata_state):
         os.remove(zip_path)
     
     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:
-            f.write(f"{seg['audio_file']}|{seg['text']}|projectname|/API_PHONETIC/\n")
+    metadata_state.to_csv(metadata_csv_path, sep="|", index=False)
     
     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"])
+        original_audio = AudioSegment.from_file(audio_path)
+        
+        for _, row in metadata_state.iterrows():
+            start_ms, end_ms = int(row["Début (s)"] * 1000), int(row["Fin (s)"] * 1000)
+            segment_audio = original_audio[start_ms:end_ms]
+            segment_filename = f"{Path(audio_path).stem}_{row['ID']}.wav"
+            segment_path = os.path.join(TEMP_DIR, segment_filename)
+            segment_audio.export(segment_path, format="wav")
+            zf.write(segment_path, segment_filename)
     
     print("[LOG] Fichier ZIP généré avec succès.")
     return zip_path
 
 # -------------------------------------------------
-# 6. Interface utilisateur Gradio
+# 5. Interface utilisateur Gradio
 # -------------------------------------------------
 with gr.Blocks() as demo:
     gr.Markdown("# Application de Découpe Audio")
     metadata_state = gr.State(init_metadata_state())
-    extracted_segments = gr.State([])
-
+    
     audio_input = gr.Audio(type="filepath", label="Fichier audio")
     raw_transcription = gr.Textbox(label="Transcription", interactive=False)
     transcription_timestamps = gr.Textbox(label="Transcription avec Timestamps", interactive=False)
-    table = gr.Dataframe(headers=["Texte", "Début (s)", "Fin (s)"], datatype=["str", "number", "number"], row_count=(1, "dynamic"), col_count=3)
-    save_segments_button = gr.Button("Enregistrer les valeurs")
-    validate_button = gr.Button("Valider")
+    table = gr.Dataframe(headers=["Texte", "Début (s)", "Fin (s)"], datatype=["str", "str", "str"], row_count=(1, "dynamic"))
+    save_button = gr.Button("Enregistrer les segments")
     generate_button = gr.Button("Générer ZIP")
     zip_file = gr.File(label="Télécharger le ZIP")
     word_timestamps = gr.State()
+    
+    audio_input.change(transcribe_audio, inputs=audio_input, outputs=[raw_transcription, word_timestamps, transcription_timestamps, audio_input])
+    save_button.click(save_segments, inputs=table, outputs=[metadata_state])
+    generate_button.click(generate_zip, inputs=[metadata_state, audio_input], outputs=zip_file)
 
-    audio_input.change(transcribe_audio, inputs=audio_input, outputs=[raw_transcription, table, audio_input, word_timestamps, transcription_timestamps])
-    save_segments_button.click(save_segments, inputs=table, outputs=table)
-    validate_button.click(validate_segments, inputs=[audio_input, table, metadata_state], outputs=[extracted_segments, metadata_state])
-    generate_button.click(generate_zip, inputs=metadata_state, outputs=zip_file)
-
-demo.queue().launch()
+demo.queue().launch()