Update app.py

app.py

@@ -3,125 +3,163 @@ import os
 import gradio as gr
 from TTS.api import TTS
 
-# Initialisation du modèle TTS avec GPU désactivé
-tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
-
-# Répertoire de sortie pour tous les fichiers audio
-output_folder = "output_audio"
-os.makedirs(output_folder, exist_ok=True)
-
-# Fonction pour générer un fichier audio à partir d'une section
-def generate_section_audio(project_name, section_name, text, speaker):
-    try:
-        # Création du sous-dossier pour le projet
-        project_path = os.path.join(output_folder, project_name)
-        os.makedirs(project_path, exist_ok=True)
-
-        # Définir le chemin de sortie pour cette section
-        file_name = f"{section_name}.wav"
-        output_path = os.path.join(project_path, file_name)
-
-        # Vérifier la disponibilité des fichiers audio pour le speaker
-        speaker_wav_paths = [os.path.join("examples", f) for f in os.listdir("examples") if f.startswith(speaker) and f.endswith(".wav")]
-        if not speaker_wav_paths:
-            raise ValueError(f"Aucun fichier audio trouvé pour le speaker : {speaker}")
-
-        # Génération de l'audio
-        tts.tts_to_file(
-            text=text,
-            file_path=output_path,
-            speaker_wav=speaker_wav_paths,
-            language="fr"
-        )
-
-        return output_path  # Retourne le chemin de l'audio généré
-    except Exception as e:
-        return str(e)  # Retourne l'erreur pour gestion dans l'interface
-
-# Fonction pour générer les audios de toutes les sections
-def generate_all_audios(project_name, sections, speaker):
-    results = []
-    for section in sections:
-        name = section["name"]
-        text = section["text"]
-        audio_path = generate_section_audio(project_name, name, text, speaker)
-        results.append(audio_path)
-    return results
-
-# Interface Gradio
-with gr.Blocks() as demo:
-    gr.Markdown("""
-    # 🎙️ Synthèse Vocale Margaux
-    ## 👋 Bienvenue sur Margaux
-    Créez des voix off naturelles à partir de textes. Divisez votre contenu en plusieurs sections pour une meilleure qualité audio.
-    """)
-
-    with gr.Box():
-        gr.Markdown("### 🛠️ Configuration du Projet")
-        project_name = gr.Textbox(label="Nom du Projet", placeholder="Exemple : Capsule_Video_PLU")
-        speaker = gr.Dropdown(label="Voix 🎙️", choices=["Margaux"], value="Margaux")  # Liste de voix
-        agree = gr.Checkbox(label="✅ J'accepte les conditions d'utilisation")
-
-    with gr.Box():
-        gr.Markdown("### ✍️ Gestion des Sections")
-        
-        sections = gr.State(value=[{"name": "Section_1", "text": ""}])  # Une section par défaut
-        
-        def update_section_list(sections):
-            return [gr.Textbox(label=f"Nom : {s['name']}", value=s["text"], lines=2) for s in sections]
-
-        sections_list = gr.Column()  # Conteneur pour afficher les sections ajoutées
-        
-        add_section_btn = gr.Button("+ Ajouter une Section ➕")
-        
-        def add_section(sections):
-            section_number = len(sections) + 1
-            section = {"name": f"Section_{section_number}", "text": ""}
-            sections.append(section)
-            return sections, update_section_list(sections)
-
-        add_section_btn.click(add_section, inputs=[sections], outputs=[sections])
-
-        remove_section_btn = gr.Button("- Supprimer la dernière Section ➖")
-
-        def remove_section(sections):
-            if len(sections) > 1:  # Ne pas supprimer si c'est la seule section
-                sections.pop()
-            return sections, update_section_list(sections)
-
-        remove_section_btn.click(remove_section, inputs=[sections], outputs=[sections])
-
-    with gr.Box():
-        gr.Markdown("### 🎧 Génération des Audios")
-        
-        generate_btn = gr.Button("Générer les Audios ▶️")
-        
-        results_output = gr.Column()  # Conteneur pour afficher les audios générés
-
-        def generate_audios_and_display(project_name, sections, speaker):
-            results = generate_all_audios(project_name, sections, speaker)
-            return [gr.Audio(label=f"Audio : {s['name']}", value=path) for s, path in zip(sections, results)]
-
-        generate_btn.click(
-            generate_audios_and_display,
-            inputs=[project_name, sections, speaker],
-            outputs=[results_output]
-        )
-
-    with gr.Box():
-        gr.Markdown("### 📁 Sauvegarde du Projet")
-        
-        save_project_btn = gr.Button("Sauvegarder le Projet ✅")
-        
-        save_message = gr.Markdown("")
-
-        def save_project(project_name):
-            project_path = os.path.join(output_folder, project_name)
-            if not os.path.exists(project_path):
-                return "⚠️ Aucun audio généré à sauvegarder."
-            return f"🎉 Projet '{project_name}' sauvegardé dans le dossier '{project_path}'."
-
-        save_project_btn.click(save_project, inputs=[project_name], outputs=[save_message])
-
-# Lancement de l'interface
-demo.launch(debug=True)
+class TTSInterface:
+    def __init__(self):
+        # Initialisation du modèle TTS
+        self.tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
+        self.output_folder = "output_audio"
+        os.makedirs(self.output_folder, exist_ok=True)
+
+    def create_interface(self):
+        with gr.Blocks(theme=gr.themes.Soft()) as demo:
+            # Variables d'état
+            state = gr.State({
+                "project_name": "",
+                "sections": []
+            })
+
+            # En-tête
+            gr.Markdown("""
+            # 🎙️ Synthèse Vocale Margaux
+            ## 👋 Bienvenue sur Margaux - Votre outil de synthèse vocale avancée
+            
+            Margaux vous permet de générer des voix off naturelles à partir de textes, structurées par sections pour une meilleure qualité audio.
+            
+            **Étapes principales :**
+            1. 🛠️ **Créer un projet** : Définissez le nom du projet et choisissez la voix.
+            2. ✍️ **Ajouter des sections** : Divisez votre texte en parties claires.
+            3. 🎧 **Générer les audios** : Chaque section est transformée en fichier audio.
+            4. 📁 **Sauvegardez le projet** : Finalisez et récupérez les fichiers.
+            """)
+
+            # Tabs pour les étapes
+            with gr.Tabs() as tabs:
+                # Étape 1: Configuration du projet
+                with gr.Tab("🛠️ Création du Projet"):
+                    with gr.Column():
+                        gr.Markdown("### Configuration initiale")
+                        project_name = gr.Textbox(
+                            label="Nom du Projet",
+                            placeholder="Exemple : Capsule_Video_PLU",
+                            scale=1
+                        )
+                        speaker = gr.Dropdown(
+                            choices=["Margaux"],
+                            value="Margaux",
+                            label="Voix 🎙️",
+                            scale=1
+                        )
+                        terms = gr.Checkbox(
+                            label="✅ J'accepte les conditions d'utilisation"
+                        )
+                        create_btn = gr.Button("Créer le Projet ➡️", variant="primary")
+
+                # Étape 2: Gestion des sections
+                with gr.Tab("✍️ Sections"):
+                    with gr.Column():
+                        gr.Markdown("### Gestion des sections")
+                        
+                        # Container pour les sections dynamiques
+                        sections_container = gr.Column()
+                        
+                        with gr.Row():
+                            add_section = gr.Button("+ Ajouter une Section ➕")
+                            remove_section = gr.Button("- Supprimer la dernière Section ➖")
+                        
+                        # Template pour une section
+                        def create_section_template(index):
+                            with gr.Group():
+                                with gr.Box():
+                                    gr.Markdown(f"#### Section {index}")
+                                    name = gr.Textbox(
+                                        label="Nom de la section",
+                                        value=f"Section_{index}"
+                                    )
+                                    text = gr.TextArea(
+                                        label="Texte à synthétiser",
+                                        placeholder="Entrez votre texte ici..."
+                                    )
+                            return [name, text]
+
+                # Étape 3: Génération des audios
+                with gr.Tab("🎧 Génération"):
+                    with gr.Column():
+                        gr.Markdown("### Génération des audios")
+                        generate_all = gr.Button("Générer tous les audios ▶️", variant="primary")
+                        audio_outputs = gr.Column()
+                        save_project = gr.Button("Sauvegarder le Projet ✅")
+
+            # Fonctions de callback
+            def update_project_info(name, terms):
+                if not terms:
+                    return gr.Error("Veuillez accepter les conditions d'utilisation")
+                if not name.strip():
+                    return gr.Error("Le nom du projet est requis")
+                return gr.Info(f"Projet '{name}' créé avec succès!")
+
+            def add_new_section(state):
+                current_sections = state["sections"]
+                new_section = {
+                    "name": f"Section_{len(current_sections) + 1}",
+                    "text": ""
+                }
+                current_sections.append(new_section)
+                return {"sections": current_sections}
+
+            def remove_last_section(state):
+                current_sections = state["sections"]
+                if current_sections:
+                    current_sections.pop()
+                return {"sections": current_sections}
+
+            def generate_audio(state, section_data):
+                try:
+                    # Logique de génération audio ici
+                    output_path = os.path.join(
+                        self.output_folder,
+                        state["project_name"],
+                        f"{section_data['name']}.wav"
+                    )
+                    
+                    # Simulation de génération (à remplacer par votre logique TTS)
+                    self.tts.tts_to_file(
+                        text=section_data["text"],
+                        file_path=output_path,
+                        language="fr"
+                    )
+                    
+                    return gr.Audio(output_path)
+                except Exception as e:
+                    return gr.Error(str(e))
+
+            # Événements
+            create_btn.click(
+                update_project_info,
+                inputs=[project_name, terms],
+                outputs=[gr.Info]
+            )
+            
+            add_section.click(
+                add_new_section,
+                inputs=[state],
+                outputs=[state]
+            )
+            
+            remove_section.click(
+                remove_last_section,
+                inputs=[state],
+                outputs=[state]
+            )
+
+            generate_all.click(
+                lambda x: [generate_audio(x, section) for section in x["sections"]],
+                inputs=[state],
+                outputs=[audio_outputs]
+            )
+
+        return demo
+
+if __name__ == "__main__":
+    interface = TTSInterface()
+    demo = interface.create_interface()
+    demo.launch(debug=True)