appfr.py

import concurrent.futures as cf
import glob
import io
import os
import time
import asyncio
import re
import json
from pathlib import Path
from tempfile import NamedTemporaryFile
from typing import List, Literal

import gradio as gr
from edge_tts import Communicate
from loguru import logger
from openai import OpenAI
from promptic import llm
from pydantic import BaseModel, ValidationError
from pypdf import PdfReader
from tenacity import retry, retry_if_exception_type

# Define standard values
STANDARD_TEXT_MODELS = [
    "gpt-4-turbo",
    "gpt-3.5-turbo",
    "gpt-4o-2024-08-06",
    "gpt-4o",
    "gpt-4o-mini-2024-07-18",
    "gpt-4o-mini",
    "ollama/llama3.1:latest",
]

STANDARD_VOICES = [
    "fr-FR-DeniseNeural",
    "fr-FR-HenriNeural",
    "fr-FR-AlainNeural",
    "fr-FR-JacquelineNeural",
    "fr-FR-JeromeNeural",
    "fr-FR-YvesNeural",
]

class DialogueItem(BaseModel):
    text: str
    speaker: Literal["speaker-1", "speaker-2"]

class Dialogue(BaseModel):
    scratchpad: str
    dialogue: List[DialogueItem]

async def get_audio_async(text: str, voice: str) -> bytes:
    communicate = Communicate(text, voice)
    audio_data = b""
    async for chunk in communicate.stream():
        if chunk["type"] == "audio":
            audio_data += chunk["data"]
    return audio_data

def clean_and_parse_output(text):
    # Essayez de trouver un JSON valide dans le texte
    json_match = re.search(r'\{.*\}', text, re.DOTALL)
    if json_match:
        try:
            return json.loads(json_match.group())
        except json.JSONDecodeError:
            pass
    
    # Si aucun JSON valide n'est trouvé, essayez de construire un dictionnaire à partir du texte
    dialogue = []
    scratchpad = ""
    current_speaker = None
    for line in text.split('\n'):
        if line.startswith("speaker-1:") or line.startswith("speaker-2:"):
            current_speaker = line.split(':')[0]
            dialogue.append({"speaker": current_speaker, "text": line.split(':', 1)[1].strip()})
        elif current_speaker and line.strip():
            dialogue[-1]["text"] += " " + line.strip()
        elif not dialogue:
            scratchpad += line + "\n"
    
    return {"scratchpad": scratchpad.strip(), "dialogue": dialogue}

def get_audio(text: str, voice: str) -> bytes:
    return asyncio.run(get_audio_async(text, voice))

def conditional_llm(model, api_base=None, api_key=None):
    def decorator(func):
        if api_base:
            return llm(model=model, api_base=api_base)(func)
        else:
            return llm(model=model, api_key=api_key)(func)
    return decorator

def generate_audio(
    files: list,
    openai_api_key: str = None,
    text_model: str = "gpt-4-turbo",
    speaker_1_voice: str = "fr-FR-DeniseNeural",
    speaker_2_voice: str = "fr-FR-HenriNeural",
    api_base: str = None,
    intro_instructions: str = '',
    text_instructions: str = '',
    scratch_pad_instructions: str = '',
    prelude_dialog: str = '',
    podcast_dialog_instructions: str = '',
    edited_transcript: str = None,
    user_feedback: str = None,
    original_text: str = None,
) -> tuple:
    # Validate API Key
    if not os.getenv("OPENAI_API_KEY") and not openai_api_key:
        raise gr.Error("OpenAI API key is required")

    combined_text = original_text or ""

    if not combined_text:
        for file in files:
            with Path(file).open("rb") as f:
                reader = PdfReader(f)
                text = "\n\n".join([page.extract_text() for page in reader.pages if page.extract_text()])
                combined_text += text + "\n\n"

    # import logging
    # logging.basicConfig(level=logging.DEBUG)

    @retry(retry=retry_if_exception_type(ValidationError))
    @conditional_llm(model=text_model, api_base=api_base, api_key=openai_api_key)
    def generate_dialogue(text: str, intro_instructions: str, text_instructions: str, scratch_pad_instructions: str, 
                        prelude_dialog: str, podcast_dialog_instructions: str,
                        edited_transcript: str = None, user_feedback: str = None, ) -> Dialogue:
        """
        {intro_instructions}
        
        Voici le texte d'entrée original :
        
        <input_text>
        {text}
        </input_text>

        {text_instructions}
        
        <scratchpad>
        {scratch_pad_instructions}
        </scratchpad>
        
        {prelude_dialog}
        
        <podcast_dialogue>
        {podcast_dialog_instructions}
        </podcast_dialogue>
        {edited_transcript}{user_feedback}
        """
        # Le texte généré est nettoyé et analysé ici
        # logging.debug(f"Raw output from model: {text}")
        cleaned_output = clean_and_parse_output(text)
        return Dialogue(**cleaned_output)

    instruction_improve='En vous basant sur le texte original, veuillez générer une version améliorée du dialogue en incorporant les modifications, commentaires et retours.'
    edited_transcript_processed="\nTranscription éditée précédemment générée, avec des modifications et commentaires spécifiques que je veux que vous abordiez soigneusement :\n"+"<edited_transcript>\n"+edited_transcript+"</edited_transcript>" if edited_transcript !="" else ""
    user_feedback_processed="\nRetour global de l'utilisateur :\n\n"+user_feedback if user_feedback !="" else ""

    if edited_transcript_processed.strip()!='' or user_feedback_processed.strip()!='':
        user_feedback_processed="<requested_improvements>"+user_feedback_processed+"\n\n"+instruction_improve+"</requested_improvements>" 

    llm_output = generate_dialogue(
        combined_text,
        intro_instructions=intro_instructions,
        text_instructions=text_instructions,
        scratch_pad_instructions=scratch_pad_instructions,
        prelude_dialog=prelude_dialog,
        podcast_dialog_instructions=podcast_dialog_instructions,
        edited_transcript=edited_transcript_processed,
        user_feedback=user_feedback_processed
    )

    audio = b""
    transcript = ""
    characters = 0

    with cf.ThreadPoolExecutor() as executor:
        futures = []
        for line in llm_output.dialogue:
            transcript_line = f"{line.speaker}: {line.text}"
            voice = speaker_1_voice if line.speaker == "speaker-1" else speaker_2_voice
            future = executor.submit(get_audio, line.text, voice)
            futures.append((future, transcript_line))
            characters += len(line.text)

        for future, transcript_line in futures:
            audio_chunk = future.result()
            audio += audio_chunk
            transcript += transcript_line + "\n\n"

    logger.info(f"Generated {characters} characters of audio")

    temporary_directory = "./gradio_cached_examples/tmp/"
    os.makedirs(temporary_directory, exist_ok=True)

    temporary_file = NamedTemporaryFile(
        dir=temporary_directory,
        delete=False,
        suffix=".wav",
    )
    temporary_file.write(audio)
    temporary_file.close()

    for file in glob.glob(f"{temporary_directory}*.wav"):
        if os.path.isfile(file) and time.time() - os.path.getmtime(file) > 24 * 60 * 60:
            os.remove(file)

    return temporary_file.name, transcript, combined_text

def validate_and_generate_audio(*args):
    files = args[0]
    if not files:
        return None, None, None, "Veuillez télécharger au moins un fichier PDF avant de générer l'audio."
    try:
        audio_file, transcript, original_text = generate_audio(*args)
        return audio_file, transcript, original_text, None
    except Exception as e:
        return None, None, None, str(e)

def edit_and_regenerate(edited_transcript, user_feedback, *args):
    return validate_and_generate_audio(*args)

def process_feedback_and_regenerate(feedback, *args):
    new_args = list(args)
    new_args.append(feedback)
    return validate_and_generate_audio(*new_args)

def read_readme():
    readme_path = Path("README.md")
    if readme_path.exists():
        with open(readme_path, "r") as file:
            content = file.read()
            content = re.sub(r'--.*?--', '', content, flags=re.DOTALL)
            return content
    else:
        return "README.md non trouvé. Veuillez vérifier le dépôt pour plus d'informations."

INSTRUCTION_TEMPLATES = {
    "podcast (French)": {
        "intro": """Votre tâche consiste à transformer le texte d'entrée fourni en un dialogue de podcast vivant, engageant et informatif, dans le style d'une émission de radio française populaire. Le texte d'entrée peut être désordonné ou non structuré, car il peut provenir de diverses sources telles que des fichiers PDF ou des pages web.

Ne vous inquiétez pas des problèmes de formatage ou des informations non pertinentes ; votre objectif est d'extraire les points clés, d'identifier les définitions et les faits intéressants qui pourraient être discutés dans un podcast.

Définissez soigneusement tous les termes utilisés pour un large public francophone.
""",
        "text_instructions": "Tout d'abord, lisez attentivement le texte d'entrée et identifiez les principaux sujets, points clés et faits ou anecdotes intéressants. Réfléchissez à la manière dont vous pourriez présenter ces informations de manière amusante et engageante, adaptée à une présentation de haute qualité pour un public francophone.",
        "scratch_pad": """Réfléchissez à des moyens créatifs de discuter des principaux sujets et points clés que vous avez identifiés dans le texte d'entrée. Envisagez d'utiliser des analogies, des exemples, des techniques de narration ou des scénarios hypothétiques pour rendre le contenu plus accessible et attrayant pour les auditeurs francophones.

Gardez à l'esprit que votre podcast doit être accessible à un large public francophone, donc évitez d'utiliser trop de jargon ou de supposer une connaissance préalable du sujet. Si nécessaire, trouvez des moyens d'expliquer brièvement les concepts complexes en termes simples.

Utilisez votre imagination pour combler les lacunes du texte d'entrée ou pour poser des questions stimulantes qui pourraient être explorées dans le podcast. L'objectif est de créer un dialogue informatif et divertissant, donc n'hésitez pas à faire preuve de créativité dans votre approche.

Définissez clairement tous les termes utilisés et prenez le temps d'expliquer le contexte.

Écrivez ici vos idées de brainstorming et une esquisse générale pour le dialogue du podcast. Assurez-vous de noter les principaux points et enseignements que vous souhaitez réitérer à la fin.

Faites en sorte que ce soit amusant et captivant pour un public francophone.
""",
        "prelude": """Maintenant que vous avez réfléchi à des idées et créé une esquisse générale, il est temps d'écrire le dialogue réel du podcast. Visez un flux naturel et conversationnel entre l'animateur et tout invité. Intégrez les meilleures idées de votre session de brainstorming et assurez-vous d'expliquer tous les sujets complexes de manière compréhensible pour un public francophone.
""",
        "dialog": """Écrivez ici un dialogue de podcast très long, captivant et informatif en français, basé sur les points clés et les idées créatives que vous avez développés lors de la session de brainstorming. Utilisez un ton conversationnel et incluez tout contexte ou explication nécessaire pour rendre le contenu accessible à un public francophone général.

Ne créez jamais de noms fictifs pour les animateurs et les invités, mais rendez cela engageant et immersif pour les auditeurs francophones. N'incluez pas de marqueurs entre crochets comme [Animateur] ou [Invité]. Concevez votre sortie pour être lue à haute voix – elle sera directement convertie en audio.

Faites en sorte que le dialogue soit aussi long et détaillé que possible, tout en restant sur le sujet et en maintenant un flux engageant. Utilisez toute votre capacité de production pour créer l'épisode de podcast le plus long possible, tout en communiquant les informations clés du texte d'entrée de manière divertissante.

À la fin du dialogue, l'animateur et les invités doivent naturellement résumer les principales idées et enseignements de leur discussion. Cela doit découler naturellement de la conversation, en réitérant les points clés de manière informelle et conversationnelle. Évitez de donner l'impression qu'il s'agit d'un récapitulatif évident – l'objectif est de renforcer les idées centrales une dernière fois avant de conclure.

Le podcast doit comporter environ 20 000 mots.
""",
    },
}

def update_instructions(template):
    return (
        INSTRUCTION_TEMPLATES[template]["intro"],
        INSTRUCTION_TEMPLATES[template]["text_instructions"],
        INSTRUCTION_TEMPLATES[template]["scratch_pad"],
        INSTRUCTION_TEMPLATES[template]["prelude"],
        INSTRUCTION_TEMPLATES[template]["dialog"]
    )

with gr.Blocks(title="PDF to Audio (French)", css="""
    #header {
        display: flex;
        align-items: center;
        justify-content: space-between;
        padding: 20px;
        background-color: transparent;
        border-bottom: 1px solid #ddd;
    }
    #title {
        font-size: 24px;
        margin: 0;
    }
    #logo_container {
        width: 200px;
        height: 200px;
        display: flex;
        justify-content: center;
        align-items: center;
    }
    #logo_image {
        max-width: 100%;
        max-height: 100%;
        object-fit: contain;
    }
    #main_container {
        margin-top: 20px;
    }
""") as demo:
    
    with gr.Row(elem_id="header"):
        with gr.Column(scale=4):
            gr.Markdown("# Convertir des PDFs en podcast audio en français\n\nD'abord, téléchargez un ou plusieurs PDFs, sélectionnez les options, puis cliquez sur Générer l'Audio.\n\nVous pouvez également sélectionner diverses options personnalisées et diriger la façon dont le résultat est généré.", elem_id="title")
        with gr.Column(scale=1):
            gr.HTML('''
                <div id="logo_container">
                    <img src="https://huggingface.co/spaces/lamm-mit/PDF2Audio/resolve/main/logo.png" id="logo_image" alt="Logo">
                </div>
            ''')
    
    submit_btn = gr.Button("Générer l'Audio", elem_id="submit_btn")

    with gr.Row(elem_id="main_container"):
        with gr.Column(scale=2):
            files = gr.Files(label="PDFs", file_types=["pdf"], )
            
            openai_api_key = gr.Textbox(
                label="Clé API OpenAI",
                visible=True,
                placeholder="Entrez votre clé API OpenAI ici...",
                type="password"
            )
            text_model = gr.Dropdown(
                label="Modèle de génération de texte",
                choices=STANDARD_TEXT_MODELS,
                value="gpt-4-turbo",
                info="Sélectionnez le modèle pour générer le texte du dialogue.",
            )
            speaker_1_voice = gr.Dropdown(
                label="Voix du Speaker 1",
                choices=STANDARD_VOICES,
                value="fr-FR-DeniseNeural",
                info="Sélectionnez la voix pour le Speaker 1.",
            )
            speaker_2_voice = gr.Dropdown(
                label="Voix du Speaker 2",
                choices=STANDARD_VOICES,
                value="fr-FR-HenriNeural",
                info="Sélectionnez la voix pour le Speaker 2.",
            )
            api_base = gr.Textbox(
                label="Base API personnalisée",
                placeholder="Entrez l'URL de base de l'API personnalisée si vous utilisez un modèle personnalisé/local...",
                info="Si vous utilisez un modèle personnalisé ou local, fournissez l'URL de base de l'API ici, par exemple : http://localhost:8080/v1 pour le serveur REST llama.cpp.",
            )

        with gr.Column(scale=3):
            template_dropdown = gr.Dropdown(
                label="Modèle d'instructions",
                choices=list(INSTRUCTION_TEMPLATES.keys()),
                value="podcast (French)",
                info="Sélectionnez le modèle d'instructions à utiliser. Vous pouvez également modifier n'importe quel champ pour des résultats plus personnalisés.",
            )
            intro_instructions = gr.Textbox(
                label="Instructions d'introduction",
                lines=10,
                value=INSTRUCTION_TEMPLATES["podcast (French)"]["intro"],
                info="Fournissez les instructions d'introduction pour générer le dialogue.",
            )
            text_instructions = gr.Textbox(
                label="Instructions d'analyse de texte standard",
                lines=10,
                placeholder="Entrez les instructions d'analyse de texte...",
                value=INSTRUCTION_TEMPLATES["podcast (French)"]["text_instructions"],
                info="Fournissez les instructions pour analyser les données brutes et le texte.",
            )
            scratch_pad_instructions = gr.Textbox(
                label="Instructions de brouillon",
                lines=15,
                value=INSTRUCTION_TEMPLATES["podcast (French)"]["scratch_pad"],
                info="Fournissez les instructions de brouillon pour réfléchir au contenu de la présentation/du dialogue.",
            )
            prelude_dialog = gr.Textbox(
                label="Prélude du dialogue",
                lines=5,
                value=INSTRUCTION_TEMPLATES["podcast (French)"]["prelude"],
                info="Fournissez les instructions de prélude avant que la présentation/le dialogue ne soit développé.",
            )
            podcast_dialog_instructions = gr.Textbox(
                label="Instructions du dialogue du podcast",
                lines=20,
                value=INSTRUCTION_TEMPLATES["podcast (French)"]["dialog"],
                info="Fournissez les instructions pour générer la présentation ou le dialogue du podcast.",
            )

    audio_output = gr.Audio(label="Audio", format="wav", interactive=False, autoplay=False)
    transcript_output = gr.Textbox(label="Transcription", lines=20, show_copy_button=True)
    original_text_output = gr.Textbox(label="Texte original", lines=10, visible=False)
    error_output = gr.Textbox(visible=False)  # Textbox caché pour stocker le message d'erreur

    use_edited_transcript = gr.Checkbox(label="Utiliser la transcription éditée (cochez si vous voulez apporter des modifications à la transcription générée initialement)", value=False)
    edited_transcript = gr.Textbox(label="Éditez la transcription ici. Par exemple, marquez les modifications dans le texte avec des instructions claires. Ex: '[AJOUTER LA DÉFINITION DE MATERIOMIQUE]'.", lines=20, visible=False,
                                   show_copy_button=True, interactive=False)

    user_feedback = gr.Textbox(label="Fournir des commentaires ou des notes", lines=10)
    regenerate_btn = gr.Button("Régénérer l'audio avec les modifications et les commentaires")

    def update_edit_box(checkbox_value):
        return gr.update(interactive=checkbox_value, lines=20 if checkbox_value else 20, visible=True if checkbox_value else False)

    use_edited_transcript.change(
        fn=update_edit_box,
        inputs=[use_edited_transcript],
        outputs=[edited_transcript]
    )

    template_dropdown.change(
        fn=update_instructions,
        inputs=[template_dropdown],
        outputs=[intro_instructions, text_instructions, scratch_pad_instructions, prelude_dialog, podcast_dialog_instructions]
    )
    
    submit_btn.click(
        fn=validate_and_generate_audio,
        inputs=[
            files, openai_api_key, text_model, 
            speaker_1_voice, speaker_2_voice, api_base,
            intro_instructions, text_instructions, scratch_pad_instructions, 
            prelude_dialog, podcast_dialog_instructions, 
            edited_transcript,
            user_feedback,
        ],
        outputs=[audio_output, transcript_output, original_text_output, error_output]
    ).then(
        fn=lambda audio, transcript, original_text, error: (
            transcript if transcript else "",
            error if error else None
        ),
        inputs=[audio_output, transcript_output, original_text_output, error_output],
        outputs=[edited_transcript, error_output]
    ).then(
        fn=lambda error: gr.Warning(error) if error else None,
        inputs=[error_output],
        outputs=[]
    )

    regenerate_btn.click(
        fn=lambda use_edit, edit, *args: validate_and_generate_audio(
            *args[:12],  # Tous les inputs jusqu'à podcast_dialog_instructions
            edit if use_edit else "",  # Utiliser la transcription éditée si la case est cochée, sinon chaîne vide
            *args[12:]  # user_feedback et original_text_output
        ),
        inputs=[
            use_edited_transcript, edited_transcript,
            files, openai_api_key, text_model, 
            speaker_1_voice, speaker_2_voice, api_base,
            intro_instructions, text_instructions, scratch_pad_instructions, 
            prelude_dialog, podcast_dialog_instructions,
            user_feedback, original_text_output
        ],
        outputs=[audio_output, transcript_output, original_text_output, error_output]
    ).then(
        fn=lambda audio, transcript, original_text, error: (
            transcript if transcript else "",
            error if error else None
        ),
        inputs=[audio_output, transcript_output, original_text_output, error_output],
        outputs=[edited_transcript, error_output]
    ).then(
        fn=lambda error: gr.Warning(error) if error else None,
        inputs=[error_output],
        outputs=[]
    )

    # Ajouter le contenu README en bas
    gr.Markdown("---")  # Ligne horizontale pour séparer l'interface du README
    gr.Markdown(read_readme())
    
# Activer la mise en file d'attente pour de meilleures performances
demo.queue(max_size=20, default_concurrency_limit=32)

# Lancer l'application Gradio
if __name__ == "__main__":
    demo.launch()