app.py

#https://huggingface.co/spaces/MisterAI/GenDoc_05
#app.py_144
#Uniquement Granite 3b instruct


import os
import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer
from pptx import Presentation
from pptx.util import Inches, Pt
import torch
import time

#TEXT_MODELS = {
#    "Utter-Project_EuroLLM-1.7B": "utter-project/EuroLLM-1.7B",
#    "Mistral Nemo 2407 (GGUF)": "MisterAI/Bartowski_MistralAI_Mistral-Nemo-Instruct-2407-IQ4_XS.gguf",
##    "Mixtral 8x7B": "mistralai/Mixtral-8x7B-v0.1",
#    "Lucie 7B": "OpenLLM-France/Lucie-7B"
#}


# Configuration du modèle unique
MODEL_PATH = "ibm-granite/granite-3.1-3b-a800m-Instruct"

PREPROMPT = """Vous êtes un assistant IA expert en création de présentations PowerPoint professionnelles.
Générez une présentation structurée et détaillée au format Markdown en suivant ce format EXACT:

TITRE: [Titre principal de la présentation]

DIAPO 1:
Titre: [Titre de la diapo]
Points:
- Point 1
- Point 2
- Point 3

DIAPO 2:
Titre: [Titre de la diapo]
Points:
- Point 1
- Point 2
- Point 3

[Continuez avec ce format pour chaque diapositive]

Analysez le texte suivant et créez une présentation professionnelle :"""

class ExecutionTimer:
    def __init__(self):
        self.start_time = None
        self.last_duration = None

    def start(self):
        self.start_time = time.time()

    def get_elapsed(self):
        if self.start_time is None:
            return 0
        return time.time() - self.start_time

    def stop(self):
        if self.start_time is not None:
            self.last_duration = self.get_elapsed()
            self.start_time = None
        return self.last_duration

    def get_status(self):
        if self.start_time is not None:
            current = self.get_elapsed()
            last = f" (précédent: {self.last_duration:.2f}s)" if self.last_duration else ""
            return f"En cours... {current:.2f}s{last}"
        elif self.last_duration:
            return f"Terminé en {self.last_duration:.2f}s"
        return "En attente..."

class PresentationGenerator:
    def __init__(self):
        print("Initialisation du modèle Granite...")
        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
        self.model = AutoModelForCausalLM.from_pretrained(
            MODEL_PATH,
            torch_dtype=torch.float32,  # Utilisation de float32 pour plus de stabilité
            device_map="auto"  # Laisse le modèle choisir le meilleur device
        )
        self.model.eval()  # Mode évaluation
        print("Modèle initialisé avec succès!")

    def generate_text(self, prompt, temperature=0.7, max_tokens=2048):
        """Génère le texte de la présentation selon le format Granite"""
        try:
            # Formatage du chat selon les instructions Granite
            chat = [{"role": "user", "content": prompt}]
            formatted_prompt = self.tokenizer.apply_chat_template(
                chat,
                tokenize=False,
                add_generation_prompt=True
            )

            # Tokenisation et génération
            inputs = self.tokenizer(
                formatted_prompt,
                return_tensors="pt",
                truncation=True,
                max_length=4096
            ).to(self.model.device)

            with torch.no_grad():
                outputs = self.model.generate(
                    **inputs,
                    max_new_tokens=max_tokens,
                    temperature=temperature,
                    do_sample=True,
                    pad_token_id=self.tokenizer.eos_token_id
                )

            return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

        except Exception as e:
            print(f"Erreur lors de la génération: {str(e)}")
            raise

    def parse_presentation_content(self, content):
        """Parse le contenu généré en sections pour les diapositives"""
        slides = []
        current_slide = None
        
        for line in content.split('\n'):
            line = line.strip()
            if line.startswith('TITRE:'):
                slides.append({'type': 'title', 'title': line[6:].strip()})
            elif line.startswith('DIAPO'):
                if current_slide:
                    slides.append(current_slide)
                current_slide = {'type': 'content', 'title': '', 'points': []}
            elif line.startswith('Titre:') and current_slide:
                current_slide['title'] = line[6:].strip()
            elif line.startswith('- ') and current_slide:
                current_slide['points'].append(line[2:].strip())
        
        if current_slide:
            slides.append(current_slide)
        
        return slides

    def create_presentation(self, slides):
        """Crée la présentation PowerPoint"""
        prs = Presentation()
        
        # Première diapo (titre)
        title_slide = prs.slides.add_slide(prs.slide_layouts[0])
        title_slide.shapes.title.text = slides[0]['title']
        
        # Autres diapos
        for slide in slides[1:]:
            content_slide = prs.slides.add_slide(prs.slide_layouts[1])
            content_slide.shapes.title.text = slide['title']
            
            if slide['points']:
                body = content_slide.shapes.placeholders[1].text_frame
                body.clear()
                for point in slide['points']:
                    p = body.add_paragraph()
                    p.text = point
                    p.level = 0
        
        return prs

# Timer global pour le suivi du temps
timer = ExecutionTimer()

def update_status():
    return timer.get_status()

def generate_skeleton(text, temperature, max_tokens, status_output):
    """Génère le squelette de la présentation"""
    try:
        timer.start()
        generator = PresentationGenerator()
        
        # Génération du contenu
        full_prompt = PREPROMPT + "\n\n" + text
        generated_content = generator.generate_text(full_prompt, temperature, max_tokens)
        
        timer.stop()
        return timer.get_status(), generated_content, gr.update(visible=True)
        
    except Exception as e:
        timer.stop()
        error_msg = f"Erreur: {str(e)}"
        print(error_msg)
        return error_msg, None, gr.update(visible=False)

def create_presentation_file(generated_content):
    """Crée le fichier PowerPoint à partir du contenu généré"""
    try:
        timer.start()
        generator = PresentationGenerator()
        
        # Création et sauvegarde de la présentation
        slides = generator.parse_presentation_content(generated_content)
        prs = generator.create_presentation(slides)
        
        output_path = os.path.join(os.getcwd(), "presentation.pptx")
        prs.save(output_path)
        
        timer.stop()
        return output_path
        
    except Exception as e:
        timer.stop()
        print(f"Erreur lors de la création du fichier: {str(e)}")
        return None

# Interface Gradio
with gr.Blocks(theme=gr.themes.Glass()) as demo:
    gr.Markdown(
        """
        # Générateur de Présentations PowerPoint IA
        
        Créez des présentations professionnelles automatiquement avec l'aide de l'IA.
        """
    )
    
    with gr.Row():
        with gr.Column(scale=1):
            temperature = gr.Slider(
                minimum=0.1,
                maximum=1.0,
                value=0.7,
                step=0.1,
                label="Température"
            )
            max_tokens = gr.Slider(
                minimum=1000,
                maximum=4096,
                value=2048,
                step=256,
                label="Tokens maximum"
            )
    
    with gr.Row():
        with gr.Column(scale=2):
            input_text = gr.Textbox(
                lines=10,
                label="Votre texte",
                placeholder="Décrivez le contenu que vous souhaitez pour votre présentation..."
            )
    
    with gr.Row():
        generate_skeleton_btn = gr.Button("Générer le Squelette de la Présentation", variant="primary")
    
    with gr.Row():
        with gr.Column():
            status_output = gr.Textbox(
                label="Statut",
                lines=2,
                every=1  # Met à jour toutes les secondes
            )
            generated_content = gr.Textbox(
                label="Contenu généré",
                lines=10,
                show_copy_button=True
            )
            create_presentation_btn = gr.Button("Créer La Présentation", visible=False)
            output_file = gr.File(
                label="Présentation PowerPoint",
                type="filepath"  # Utilise filepath au lieu de binary
            )
    
    # Mise à jour du statut en temps réel
    status_output.change(
        fn=update_status,
        inputs=[],
        outputs=[status_output],
        every=1
    )
    
    generate_skeleton_btn.click(
        fn=generate_skeleton,
        inputs=[
            input_text,
            temperature,
            max_tokens,
            status_output
        ],
        outputs=[
            status_output,
            generated_content,
            create_presentation_btn
        ]
    )
    
    create_presentation_btn.click(
        fn=create_presentation_file,
        inputs=[generated_content],
        outputs=[output_file]
    )

if __name__ == "__main__":
    demo.launch()