Upload 5 files

Application de présentation intelligente des rapport d'études, des communications scientifiques, des comptes rendus, etc.

ai_enhance.py

@@ -0,0 +1,152 @@
+import logging
+import string
+from typing import Dict, List, Any
+from collections import Counter
+from model_loader import get_summarizer
+
+logger = logging.getLogger(__name__)
+
+class AIEnhance:
+    def __init__(self):
+        self.sentence_model = None
+        self.llm_service = None
+
+        try:
+            logger.info("📦 Chargement du modèle de résumé IA (summarizer)...")
+            self.summarizer = get_summarizer()
+            logger.info("✅ Modèle summarizer chargé avec succès.")
+        except Exception as e:
+            logger.warning(f"❌ Échec du chargement du summarizer : {e}")
+            self.summarizer = None
+
+        logger.info("✅ AIEnhance initialisé.")
+
+    def smart_summarize(self, texte: str, max_length: int = 150) -> str:
+        """Résumé intelligent du texte"""
+        try:
+            if self.summarizer and len(texte) > 200:
+                input_length = len(texte.split())
+                summary_max = min(max_length, input_length // 2)
+                summary_min = max(50, summary_max // 3)
+
+                summary = self.summarizer(
+                    texte,
+                    max_length=summary_max,
+                    min_length=summary_min,
+                    do_sample=False
+                )
+                return summary[0]['summary_text']
+        except Exception as e:
+            logger.warning(f"Résumé IA échoué, fallback: {e}")
+
+        return self._fallback_summary(texte)
+
+    def _fallback_summary(self, texte: str) -> str:
+        """Résumé de fallback"""
+        sentences = [s.strip() for s in texte.split('.') if s.strip()]
+        if len(sentences) <= 2:
+            return texte
+
+        important_sentences = [sentences[0]]
+        keywords = self._extract_keywords(texte, 5)
+        for sentence in sentences[1:4]:
+            if any(keyword in sentence.lower() for keyword in keywords):
+                important_sentences.append(sentence)
+
+        return '. '.join(important_sentences[:3]) + '.'
+
+    def _extract_keywords(self, texte: str, top_n: int = 10) -> List[str]:
+        """Extraction des mots-clés"""
+        try:
+            words = texte.translate(str.maketrans('', '', string.punctuation)).lower().split()
+            stop_words = {'le', 'la', 'les', 'de', 'des', 'du', 'et', 'est', 'son', 'ses', 'dans', 'pour', 'par'}
+            meaningful_words = [word for word in words if len(word) > 3 and word not in stop_words]
+            word_freq = Counter(meaningful_words)
+            return [word for word, count in word_freq.most_common(top_n)]
+        except Exception as e:
+            logger.warning(f"Erreur extraction keywords: {e}")
+            return ["analyse", "texte", "présentation", "contenu", "sujet"]
+
+    def _analyze_complexity(self, texte: str) -> float:
+        """Analyse la complexité du texte"""
+        words = texte.split()
+        if not words:
+            return 0.0
+        avg_word_length = sum(len(word) for word in words) / len(words)
+        unique_words = len(set(words))
+        lexical_diversity = unique_words / len(words)
+        return min(1.0, (avg_word_length * 0.1 + lexical_diversity) / 2)
+
+    def _analyze_content_type(self, texte: str) -> str:
+        """Analyse le type de contenu"""
+        texte_lower = texte.lower()
+        keywords_technique = {'technique', 'technologie', 'code', 'programmation', 'algorithme', 'données'}
+        keywords_commercial = {'vente', 'marketing', 'client', 'business', 'profit', 'stratégie'}
+        keywords_educatif = {'apprentissage', 'éducation', 'enseignement', 'cours', 'étudiant'}
+
+        if any(keyword in texte_lower for keyword in keywords_technique):
+            return "technique"
+        elif any(keyword in texte_lower for keyword in keywords_commercial):
+            return "commercial"
+        elif any(keyword in texte_lower for keyword in keywords_educatif):
+            return "éducatif"
+        else:
+            return "général"
+
+    # MÉTHODE CORRIGÉE - celle que vous appelez dans app.py
+    def _basic_analysis(self, texte: str) -> Dict[str, Any]:
+        """Analyse de base du texte - MÉTHODE MANQUANTE AJOUTÉE"""
+        words = texte.split()
+        sentences = [s.strip() for s in texte.split('.') if s.strip()]
+        paragraphs = [p.strip() for p in texte.split('\n') if p.strip()]
+        
+        # Créer des slides avec du contenu réel
+        slides = []
+        
+        # Slide introduction
+        if sentences:
+            slides.append({
+                "title": "Introduction",
+                "content": sentences[0][:100] + "..." if len(sentences[0]) > 100 else sentences[0],
+                "type": "introduction"
+            })
+        
+        # Slides de contenu (basées sur les paragraphes)
+        for i, para in enumerate(paragraphs[:4]):
+            if para and len(para) > 20:
+                slides.append({
+                    "title": f"Point Clé {i+1}",
+                    "content": para[:150] + "..." if len(para) > 150 else para,
+                    "type": "content"
+                })
+        
+        # Slide conclusion
+        if len(sentences) > 1:
+            slides.append({
+                "title": "Conclusion",
+                "content": "Synthèse des points principaux et perspectives futures",
+                "type": "conclusion"
+            })
+
+        return {
+            "statistics": {
+                "word_count": len(words),
+                "sentence_count": len(sentences),
+                "paragraph_count": len(paragraphs),
+                "avg_sentence_length": len(words) / len(sentences) if sentences else 0,
+                "complexity_score": self._analyze_complexity(texte)
+            },
+            "keywords": self._extract_keywords(texte, 8),
+            "recommended_structure": {
+                "total_slides": len(slides),
+                "slides": slides,
+                "recommended_style": "professionnel",
+                "estimated_duration": len(slides) * 2
+            },
+            "content_analysis": self._analyze_content_type(texte)
+        }
+
+    # Alias pour compatibilité
+    def analyze_text_advanced(self, texte: str) -> Dict[str, Any]:
+        """Alias pour _basic_analysis pour la compatibilité"""
+        return self._basic_analysis(texte)

app.py

@@ -0,0 +1,444 @@
+import gradio as gr
+import os
+import tempfile
+from datetime import datetime
+import logging
+import json
+import PyPDF2
+from docx import Document
+
+# Configuration logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialisation des services
+from ai_enhance import AIEnhance
+from presentation_generator import PresentationGenerator
+
+ai_service = AIEnhance()
+presentation_generator = PresentationGenerator()
+
+# Code secret
+CODE_SECRET = "32015"  # code à cinq chiffres
+
+def verifier_code(code):
+    """Vérifie si le code entré est correct"""
+    if code == CODE_SECRET:
+        return True, "🔓 Accès autorisé !"
+    else:
+        return False, "❌ Code incorrect. Veuillez réessayer."
+
+# FONCTIONS D'EXTRACTION DE TEXTE
+def extract_text_from_pdf(file_path):
+    """Extrait le texte d'un fichier PDF"""
+    try:
+        with open(file_path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text() + "\n"
+            return text.strip()
+    except Exception as e:
+        logger.error(f"Erreur extraction PDF: {e}")
+        raise Exception(f"Erreur lors de l'extraction du PDF: {str(e)}")
+
+def extract_text_from_docx(file_path):
+    """Extrait le texte d'un fichier Word"""
+    try:
+        doc = Document(file_path)
+        text = ""
+        for paragraph in doc.paragraphs:
+            text += paragraph.text + "\n"
+        return text.strip()
+    except Exception as e:
+        logger.error(f"Erreur extraction DOCX: {e}")
+        raise Exception(f"Erreur lors de l'extraction du document Word: {str(e)}")
+
+def extract_text_from_txt(file_path):
+    """Extrait le texte d'un fichier texte"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            return file.read().strip()
+    except Exception as e:
+        logger.error(f"Erreur extraction TXT: {e}")
+        raise Exception(f"Erreur lors de l'extraction du fichier texte: {str(e)}")
+
+def extract_text_from_file(file_obj):
+    """Extrait le texte selon le format du fichier"""
+    try:
+        file_path = file_obj.name
+        file_extension = os.path.splitext(file_path)[1].lower()
+        
+        logger.info(f"📁 Extraction du fichier: {file_path}")
+        
+        if file_extension == '.pdf':
+            return extract_text_from_pdf(file_path)
+        elif file_extension in ['.doc', '.docx']:
+            return extract_text_from_docx(file_path)
+        elif file_extension == '.txt':
+            return extract_text_from_txt(file_path)
+        else:
+            raise Exception(f"Format non supporté: {file_extension}")
+            
+    except Exception as e:
+        logger.error(f"❌ Erreur extraction: {e}")
+        raise
+
+def create_presentation_structure(texte):
+    """Crée la structure de présentation avec analyse IA"""
+    try:
+        # ESSAYER DIFFÉRENTES MÉTHODES POUR TROUVER CELLE QUI FONCTIONNE
+        if hasattr(ai_service, '_basic_analysis'):
+            analysis = ai_service._basic_analysis(texte)
+        elif hasattr(ai_service, 'analyze_text_advanced'):
+            analysis = ai_service.analyze_text_advanced(texte)
+        else:
+            # Créer une analyse de base manuellement
+            analysis = {
+                "statistics": {
+                    "word_count": len(texte.split()), 
+                    "sentence_count": texte.count('.'),
+                    "paragraph_count": len([p for p in texte.split('\n\n') if p.strip()])
+                },
+                "keywords": ["texte", "analyse", "présentation"],
+                "recommended_structure": {
+                    "slides": [
+                        {"title": "Introduction", "content": "Présentation du sujet"},
+                        {"title": "Développement", "content": "Points principaux"},
+                        {"title": "Conclusion", "content": "Synthèse"}
+                    ],
+                    "recommended_style": "professionnel"
+                },
+                "content_analysis": "général"
+            }
+        
+        summary = ai_service.smart_summarize(texte)
+        structure = {
+            "title": f"Présentation: {analysis['content_analysis'].capitalize()}",
+            "slides": analysis["recommended_structure"]["slides"],
+            "key_points": analysis["keywords"][:8],
+            "style_recommendation": analysis["recommended_structure"]["recommended_style"],
+            "analysis_metadata": analysis
+        }
+        return structure, summary
+        
+    except Exception as e:
+        logger.error(f"Erreur dans create_presentation_structure: {e}")
+        # Retourner une structure par défaut en cas d'erreur
+        default_structure = {
+            "title": "Présentation Générée par IA",
+            "slides": [
+                {"title": "Introduction", "content": "Votre texte a été analysé avec succès"},
+                {"title": "Points Principaux", "content": "Les insights clés ont été extraits"},
+                {"title": "Conclusion", "content": "Synthèse des éléments importants"}
+            ],
+            "key_points": ["analyse", "texte", "présentation"],
+            "analysis_metadata": {"statistics": {"word_count": len(texte.split())}}
+        }
+        return default_structure, texte[:200] + "..."
+
+def generate_presentation_gradio(texte, style="professionnel"):
+    """Version Gradio améliorée avec prévisualisation"""
+    try:
+        if not texte or len(texte.strip()) < 50:
+            return None, None, "❌ Veuillez entrer au moins 50 caractères."
+
+        logger.info(f"🚀 Génération IA pour {len(texte)} caractères")
+        
+        # Générer la structure
+        structure, summary = create_presentation_structure(texte)
+        filename = presentation_generator.generate_presentation(structure, style)
+
+        # Créer une belle prévisualisation
+        preview_html = create_preview_html(structure, summary)
+        
+        logger.info("✅ Présentation générée avec succès!")
+        return filename, preview_html, f"🎉 Présentation générée! ({len(structure['slides'])} slides)"
+
+    except Exception as e:
+        logger.error(f"❌ Erreur lors de la génération: {e}")
+        return None, None, f"❌ Erreur: {str(e)}"
+
+def create_preview_html(structure, summary):
+    """Crée une belle prévisualisation HTML des slides"""
+    html_content = f"""
+    <div style="font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto;">
+        <h2 style="color: #2E86AB; border-bottom: 2px solid #2E86AB; padding-bottom: 10px;">
+            📊 Aperçu de votre Présentation
+        </h2>
+        
+        <div style="background: #f8f9fa; padding: 15px; border-radius: 10px; margin-bottom: 20px;">
+            <h3 style="color: #2E86AB;">🎯 Titre Principal</h3>
+            <p style="font-size: 18px; font-weight: bold;">{structure['title']}</p>
+        </div>
+        
+        <div style="background: #e8f4f8; padding: 15px; border-radius: 10px; margin-bottom: 20px;">
+            <h3 style="color: #2E86AB;">📝 Résumé IA</h3>
+            <p>{summary}</p>
+        </div>
+        
+        <h3 style="color: #2E86AB;">🔄 Structure des Slides</h3>
+    """
+    
+    # Ajouter chaque slide
+    for i, slide in enumerate(structure['slides']):
+        html_content += f"""
+        <div style="background: white; border: 2px solid #2E86AB; border-radius: 10px; padding: 15px; margin: 10px 0;">
+            <div style="display: flex; align-items: center; margin-bottom: 10px;">
+                <span style="background: #2E86AB; color: white; width: 30px; height: 30px; border-radius: 50%; display: flex; align-items: center; justify-content: center; font-weight: bold;">
+                    {i+1}
+                </span>
+                <h4 style="margin: 0 0 0 10px; color: #2E86AB;">{slide['title']}</h4>
+            </div>
+            <p style="margin: 0; color: #555;">{slide['content']}</p>
+        </div>
+        """
+    
+    # Ajouter les points clés
+    html_content += f"""
+        <div style="background: #fff3cd; padding: 15px; border-radius: 10px; margin-top: 20px;">
+            <h3 style="color: #856404;">🎯 Points Clés Identifiés</h3>
+            <div style="display: flex; flex-wrap: wrap; gap: 8px;">
+    """
+    
+    for point in structure['key_points']:
+        html_content += f'<span style="background: #856404; color: white; padding: 5px 10px; border-radius: 15px; font-size: 12px;">{point}</span>'
+    
+    html_content += """
+            </div>
+        </div>
+    </div>
+    """
+    
+    return html_content
+
+##### FONCTIONS UPLOAD AMÉLIORÉES #####
+def handle_file_upload(files):
+    """Gère l'upload de fichiers et extrait le texte"""
+    if not files:
+        return None, None, "❌ Aucun fichier sélectionné."
+    
+    try:
+        file_obj = files[0]  # Premier fichier
+        extracted_text = extract_text_from_file(file_obj)
+        
+        if not extracted_text or len(extracted_text.strip()) < 10:
+            return None, None, "❌ Le fichier semble vide ou ne contient pas de texte extractible."
+        
+        # Statistiques
+        word_count = len(extracted_text.split())
+        char_count = len(extracted_text)
+        
+        message = f"✅ Fichier traité avec succès! 📊 {word_count} mots, {char_count} caractères"
+        
+        return extracted_text, extracted_text, message
+        
+    except Exception as e:
+        logger.error(f"Erreur upload: {e}")
+        return None, None, f"❌ Erreur: {str(e)}"
+
+def generate_from_uploaded_text(analyzed_text, style="professionnel"):
+    """Génère la présentation à partir du texte uploadé"""
+    return generate_presentation_gradio(analyzed_text, style)
+
+def analyze_text_gradio(texte):
+    """Version Gradio de votre api_analyze()"""
+    try:
+        if not texte or len(texte.strip()) < 10:
+            return "❌ Texte trop court. Minimum 10 caractères."
+
+        structure, summary = create_presentation_structure(texte)
+        
+        # Formatage pour l'interface Gradio
+        result = f"""
+## 📊 Analyse IA du Texte
+
+**Statistiques:**
+- {structure['analysis_metadata']['statistics']['word_count']} mots
+- {structure['analysis_metadata']['statistics']['sentence_count']} phrases  
+- {structure['analysis_metadata']['statistics']['paragraph_count']} paragraphes
+
+**🎯 Thèmes identifiés:**
+{', '.join(structure['key_points'][:8])}
+
+**📝 Résumé:**
+{summary}
+
+**🏗️ Structure proposée:**
+"""
+        for i, slide in enumerate(structure['slides']):
+            result += f"\n{i+1}. **{slide['title']}** - {slide['content'][:100]}..."
+
+        return result
+
+    except Exception as e:
+        return f"❌ Erreur d'analyse: {str(e)}"
+
+# INTERFACE PRINCIPALE AVEC AUTHENTIFICATION
+with gr.Blocks(theme=gr.themes.Soft(), title="Générateur de Présentation IA") as demo:
+    
+    # Écran d'authentification
+    with gr.Column(visible=True) as auth_screen:
+        gr.Markdown("# 🔒 Accès Sécurisé")
+        gr.Markdown("Veuillez entrer le code d'accès à 5 chiffres")
+        
+        with gr.Row():
+            code_input = gr.Textbox(
+                label="Code d'accès",
+                type="text",
+                max_lines=1,
+                placeholder="Entrez les 5 chiffres...",
+                elem_id="code_input"
+            )
+            verifier_btn = gr.Button("Vérifier", variant="primary")
+        
+        message_sortie = gr.Textbox(label="Statut", interactive=False)
+    
+    # Application principale (cachée au début)
+    with gr.Column(visible=False) as app_screen:
+        gr.Markdown("""
+        # 🧠 Générateur de Présentation IA Intelligente
+        **Powered by Lab_Math_and Labhp & CIE Label_Bertoua**
+        
+        Transformez votre texte en présentation PowerPoint professionnelle en quelques secondes !
+        """)
+        
+        with gr.Tab("🚀 Générer à partir de Texte"):
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="📝 Collez votre texte ici",
+                        placeholder="Collez ou tapez votre texte, article, rapport... (minimum 50 caractères)",
+                        lines=12,
+                        max_lines=20
+                    )
+                    style_dropdown = gr.Dropdown(
+                        choices=["professionnel", "moderne", "creatif"],
+                        label="🎨 Style de présentation",
+                        value="professionnel",
+                        info="Choisissez le style visuel de votre présentation"
+                    )
+                    generate_btn = gr.Button("🚀 Générer la Présentation", variant="primary", size="lg")
+                
+                with gr.Column():
+                    output_file = gr.File(label="📥 Télécharger la Présentation", file_types=[".pptx"])
+                    preview_output = gr.HTML(label="👁️ Aperçu de la Structure")
+                    output_message = gr.Textbox(label="📋 Statut", interactive=False)
+            
+            generate_btn.click(
+                fn=generate_presentation_gradio,
+                inputs=[text_input, style_dropdown],
+                outputs=[output_file, preview_output, output_message]
+            )
+        
+        with gr.Tab("📁 Générer à partir de Fichier"):
+            gr.Markdown("### 📤 Uploader votre document")
+            gr.Markdown("""
+            **Formats supportés:**
+            - 📄 PDF (rapports, articles)
+            - 📝 DOC/DOCX (documents Word)  
+            - 📋 TXT (fichiers texte)
+            """)
+            
+            with gr.Row():
+                with gr.Column():
+                    upload_button = gr.UploadButton(
+                        "📁 Choisir un fichier",
+                        file_types=[".pdf", ".doc", ".docx", ".txt"],
+                        file_count="single",
+                        size="lg"
+                    )
+                    uploaded_file_info = gr.Textbox(label="📋 Fichier sélectionné", interactive=False)
+                    extract_btn = gr.Button("🔍 Extraire et Analyser", variant="primary")
+                
+                with gr.Column():
+                    extracted_text = gr.Textbox(
+                        label="📝 Texte extrait",
+                        interactive=False, 
+                        lines=8,
+                        max_lines=12
+                    )
+                    upload_status = gr.Textbox(label="📊 Statut extraction", interactive=False)
+            
+            with gr.Row():
+                file_style_dropdown = gr.Dropdown(
+                    choices=["professionnel", "moderne", "creatif"],
+                    label="🎨 Style de présentation",
+                    value="professionnel"
+                )
+                generate_from_file_btn = gr.Button("🚀 Générer la Présentation", variant="primary")
+            
+            with gr.Row():
+                file_output = gr.File(label="📥 Présentation Générée", file_types=[".pptx"])
+                file_preview = gr.HTML(label="👁️ Aperçu")
+                file_message = gr.Textbox(label="📋 Statut génération", interactive=False)
+        
+        with gr.Tab("🔍 Analyser le Texte"):
+            with gr.Row():
+                with gr.Column():
+                    analyze_text_input = gr.Textbox(
+                        label="📝 Texte à analyser",
+                        placeholder="Collez votre texte pour l'analyse IA...",
+                        lines=8
+                    )
+                    analyze_btn = gr.Button("🔍 Analyser avec IA", variant="secondary")
+                
+                with gr.Column():
+                    analysis_output = gr.Markdown(label="📊 Résultats de l'analyse")
+            
+            analyze_btn.click(
+                fn=analyze_text_gradio,
+                inputs=[analyze_text_input],
+                outputs=[analysis_output]
+            )
+
+    # GESTION DES INTERACTIONS UPLOAD
+    def update_file_info(files):
+        """Met à jour les informations du fichier uploadé"""
+        if files:
+            file_obj = files[0]
+            file_size = os.path.getsize(file_obj.name) / 1024  # KB
+            return f"📄 {os.path.basename(file_obj.name)} ({file_size:.1f} KB)"
+        return "Aucun fichier sélectionné"
+    
+    # Lier les événements upload
+    upload_button.upload(
+        fn=update_file_info,
+        inputs=[upload_button],
+        outputs=[uploaded_file_info]
+    )
+    
+    extract_btn.click(
+        fn=handle_file_upload,
+        inputs=[upload_button],
+        outputs=[extracted_text, extracted_text, upload_status]
+    )
+    
+    generate_from_file_btn.click(
+        fn=generate_from_uploaded_text,
+        inputs=[extracted_text, file_style_dropdown],
+        outputs=[file_output, file_preview, file_message]
+    )
+
+    def gerer_acces(code):
+        """Gère l'authentification et affiche l'application si le code est correct"""
+        est_valide, message = verifier_code(code)
+        return (
+            message, 
+            gr.update(visible=not est_valide),  # Cacher l'écran d'auth
+            gr.update(visible=est_valide)       # Afficher l'application
+        )
+    
+    # Lier le bouton de vérification
+    verifier_btn.click(
+        fn=gerer_acces,
+        inputs=[code_input],
+        outputs=[message_sortie, auth_screen, app_screen]
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860,
+        share=False
+    )

model_loader.py

@@ -0,0 +1,29 @@
+from transformers import pipeline
+
+# Liste des modèles de summarization plus légers
+MODEL_OPTIONS = [
+    "Falconsai/text_summarization",  # Original
+    "facebook/bart-large-cnn",       # Alternative 1
+    "t5-small",                      # Alternative 2 (léger)
+    "mrm8488/bert-mini-finetuned-cnn_daily_mail-summarization"  # Alternative 3
+]
+
+summarizer = None  # Global
+
+def load_model_with_fallback():
+    for model_name in MODEL_OPTIONS:
+        try:
+            print(f"Tentative de chargement: {model_name}")
+            model = pipeline("summarization", model=model_name)
+            print(f"Succès avec: {model_name}")
+            return model
+        except Exception as e:
+            print(f"Échec avec {model_name}: {e}")
+            continue
+    raise Exception("Aucun modèle n'a pu être chargé")
+
+def get_summarizer():
+    global summarizer
+    if summarizer is None:
+        summarizer = load_model_with_fallback()
+    return summarizer

presentation_generator.py

@@ -0,0 +1,246 @@
+from pptx import Presentation
+from pptx.util import Inches, Pt
+from pptx.enum.text import PP_ALIGN
+from pptx.dml.color import RGBColor
+import tempfile
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+class PresentationGenerator:
+    def __init__(self):
+        self.styles = {
+            "professionnel": {
+                "title_color": RGBColor(0, 0, 128),
+                "text_color": RGBColor(0, 0, 0),
+                "background_color": RGBColor(255, 255, 255),
+                "font_name": "Calibri"
+            },
+            "moderne": {
+                "title_color": RGBColor(220, 20, 60),
+                "text_color": RGBColor(50, 50, 50),
+                "background_color": RGBColor(240, 240, 240),
+                "font_name": "Segoe UI"
+            },
+            "creatif": {
+                "title_color": RGBColor(75, 0, 130),
+                "text_color": RGBColor(0, 0, 0),
+                "background_color": RGBColor(255, 250, 240),
+                "font_name": "Arial"
+            }
+        }
+    
+    def generate_presentation(self, structure, style="professionnel"):
+        """Génère une présentation PowerPoint à partir de la structure IA"""
+        try:
+            logger.info("📄 Initialisation de la présentation...")
+            prs = Presentation()
+            style_config = self.styles.get(style, self.styles["professionnel"])
+            
+            logger.info("🎯 Ajout de la slide de titre...")
+            self._add_title_slide(prs, structure, style_config)
+            
+            logger.info("📄 Ajout des slides de contenu enrichies...")
+            for i, slide_data in enumerate(structure.get('slides', [])):
+                logger.info(f"  ➕ Slide {i+1}: {slide_data.get('title', 'Sans titre')}")
+                self._add_enhanced_content_slide(prs, slide_data, style_config, i)
+            
+            if structure.get('key_points'):
+                logger.info("🧠 Ajout des points clés enrichis...")
+                self._add_enhanced_keypoints_slide(prs, structure, style_config)
+            
+            logger.info("📈 Ajout de la slide statistiques...")
+            self._add_statistics_slide(prs, structure, style_config)
+            
+            logger.info("🏁 Ajout de la conclusion enrichie...")
+            self._add_enhanced_conclusion_slide(prs, structure, style_config)
+            
+            logger.info("💾 Sauvegarde de la présentation...")
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pptx')
+            prs.save(temp_file.name)
+            
+            logger.info(f"✅ Présentation enregistrée dans : {temp_file.name}")
+            return temp_file.name
+
+        except Exception as e:
+            logger.error(f"❌ Erreur génération présentation: {e}")
+            raise
+
+    def _add_title_slide(self, prs, structure, style_config):
+        """Ajoute la slide de titre améliorée"""
+        slide_layout = prs.slide_layouts[0]
+        slide = prs.slides.add_slide(slide_layout)
+        title = slide.shapes.title
+        subtitle = slide.placeholders[1]
+        
+        title.text = structure.get('title', 'Présentation Générée par IA')
+        subtitle.text = f"Style: {style_config['font_name']}\nGénéré intelligemment par IA\n{len(structure.get('slides', []))} slides"
+
+    def _add_enhanced_content_slide(self, prs, slide_data, style_config, slide_index):
+        """Ajoute une slide de contenu enrichie"""
+        slide_layout = prs.slide_layouts[1]
+        slide = prs.slides.add_slide(slide_layout)
+
+        title_shape = slide.shapes.title
+        content_shape = slide.placeholders[1] if len(slide.placeholders) > 1 else self._create_textbox(slide)
+        
+        # Titre amélioré
+        title_shape.text = self._enhance_slide_title(slide_data.get('title', f'Slide {slide_index + 1}'), slide_index)
+        
+        # Contenu enrichi
+        enhanced_content = self._enhance_slide_content(slide_data.get('content', ''), slide_index)
+        content_shape.text = enhanced_content
+
+        self._apply_style(title_shape, style_config, is_title=True)
+        self._apply_style(content_shape, style_config, is_title=False)
+
+    def _enhance_slide_title(self, title, slide_index):
+        """Améliore les titres des slides"""
+        title_enhancements = {
+            0: ["🚀 Introduction", "📋 Aperçu Général", "🎯 Présentation du Sujet"],
+            1: ["🔍 Analyse Détaillée", "📊 Points Clés", "💡 Insights Principaux"],
+            2: ["🏗️ Développement", "📈 Données et Faits", "🔬 Analyse Approfondie"],
+            3: ["💎 Synthèse", "🎖️ Points Forts", "📝 Résumé Exécutif"]
+        }
+        
+        base_title = title_enhancements.get(slide_index, ["📄 Slide", "💼 Contenu", "📖 Section"])
+        return f"{base_title[0]} : {title}"
+
+    def _enhance_slide_content(self, content, slide_index):
+        """Enrichit le contenu des slides"""
+        if not content or len(content.strip()) < 10:
+            default_contents = [
+                "Présentation du contexte et des objectifs\n• Introduction au sujet principal\n• Définition des enjeux clés\n• Présentation de la structure",
+                "Analyse des points essentiels\n• Données chiffrées et statistiques\n• Tendances observées\n• Perspectives d'évolution",
+                "Développement des concepts clés\n• Études de cas concrètes\n• Recommandations pratiques\n• Implications stratégiques",
+                "Synthèse des éléments majeurs\n• Points à retenir\n• Actions recommandées\n• Prochaines étapes"
+            ]
+            return default_contents[slide_index % len(default_contents)]
+        
+        # Enrichir le contenu existant
+        enhancements = [
+            "\n\n🎯 Points clés à retenir :\n• Information principale\n• Donnée significative\n• Insight important",
+            "\n\n📊 Éléments marquants :\n• Chiffre clé\n• Tendance observée\n• Recommandation",
+            "\n\n💡 Actions recommandées :\n• Mesure concrète\n• Stratégie à adopter\n• Perspective future",
+            "\n\n🌟 Impact et valeur :\n• Bénéfice attendu\n• Résultat potentiel\n• Contribution majeure"
+        ]
+        
+        enhanced_content = content
+        if len(content) > 100:
+            # Ajouter des puces si le contenu est long
+            sentences = [s.strip() for s in content.split('.') if s.strip()]
+            if len(sentences) > 2:
+                enhanced_content = "• " + "\n• ".join(sentences[:4])
+        
+        return enhanced_content + enhancements[slide_index % len(enhancements)]
+
+    def _add_enhanced_keypoints_slide(self, prs, structure, style_config):
+        """Ajoute la slide des points clés enrichie"""
+        slide_layout = prs.slide_layouts[1]
+        slide = prs.slides.add_slide(slide_layout)
+        
+        title_shape = slide.shapes.title
+        content_shape = slide.placeholders[1] if len(slide.placeholders) > 1 else self._create_textbox(slide)
+        
+        title_shape.text = "🎯 Points Clés Identifiés par IA"
+        
+        # Points clés enrichis
+        key_points = structure.get('key_points', [])
+        enhanced_points = []
+        
+        for i, point in enumerate(key_points[:10]):  # Limiter à 10 points max
+            icons = ["🔸", "🌟", "💡", "📌", "🎯", "⚡", "✅", "📊", "🔍", "🏆"]
+            enhanced_points.append(f"{icons[i % len(icons)]} {point}")
+        
+        content_text = "Principaux insights extraits de l'analyse :\n\n" + "\n".join(enhanced_points)
+        
+        # Ajouter une conclusion sur les points clés
+        content_text += f"\n\n📈 Synthèse :\n• {len(key_points)} thèmes majeurs identifiés\n• Analyse sémantique avancée\n• Priorisation intelligente"
+        
+        content_shape.text = content_text
+        
+        self._apply_style(title_shape, style_config, is_title=True)
+        self._apply_style(content_shape, style_config, is_title=False)
+
+    def _add_statistics_slide(self, prs, structure, style_config):
+        """Ajoute une slide avec les statistiques d'analyse"""
+        slide_layout = prs.slide_layouts[1]
+        slide = prs.slides.add_slide(slide_layout)
+        
+        title_shape = slide.shapes.title
+        content_shape = slide.placeholders[1] if len(slide.placeholders) > 1 else self._create_textbox(slide)
+        
+        title_shape.text = "📊 Métriques d'Analyse"
+        
+        stats = structure.get('analysis_metadata', {}).get('statistics', {})
+        content_text = "Analyse quantitative du contenu :\n\n"
+        
+        metrics = [
+            f"📝 {stats.get('word_count', 0)} mots analysés",
+            f"💬 {stats.get('sentence_count', 0)} phrases traitées",
+            f"📄 {stats.get('paragraph_count', 0)} paragraphes examinés",
+            f"🎯 {len(structure.get('key_points', []))} thèmes clés identifiés",
+            f"🔄 {len(structure.get('slides', []))} slides générées",
+            f"⚡ Complexité : {stats.get('complexity_score', 0.5):.1f}/1.0"
+        ]
+        
+        content_text += "\n".join(metrics)
+        content_text += "\n\n🔍 Méthodologie :\n• Analyse sémantique IA\n• Extraction de concepts clés\n• Structuration intelligente"
+        
+        content_shape.text = content_text
+        
+        self._apply_style(title_shape, style_config, is_title=True)
+        self._apply_style(content_shape, style_config, is_title=False)
+
+    def _add_enhanced_conclusion_slide(self, prs, structure, style_config):
+        """Ajoute la slide de conclusion enrichie"""
+        slide_layout = prs.slide_layouts[1]
+        slide = prs.slides.add_slide(slide_layout)
+        
+        title_shape = slide.shapes.title
+        content_shape = slide.placeholders[1] if len(slide.placeholders) > 1 else self._create_textbox(slide)
+        
+        title_shape.text = "🏁 Conclusion & Perspectives"
+        
+        conclusion_text = "Synthèse de la présentation :\n\n"
+        conclusion_text += "✅ Analyse complète réalisée avec succès\n"
+        conclusion_text += "🎯 Points essentiels mis en lumière\n"
+        conclusion_text += "💡 Insights actionnables identifiés\n\n"
+        
+        conclusion_text += "Prochaines étapes recommandées :\n"
+        conclusion_text += "• Approfondir les points clés\n"
+        conclusion_text += "• Mettre en œuvre les recommandations\n"
+        conclusion_text += "• Mesurer l'impact des actions\n\n"
+        
+        conclusion_text += "🧠 Présentation générée automatiquement\n"
+        conclusion_text += "avec technologie IA avancée\n"
+        conclusion_text += "Lab_Math & Labhp - CIE Label_Bertoua"
+        
+        content_shape.text = conclusion_text
+        
+        self._apply_style(title_shape, style_config, is_title=True)
+        self._apply_style(content_shape, style_config, is_title=False)
+
+    def _create_textbox(self, slide):
+        """Crée une textbox manuelle si le placeholder n'existe pas"""
+        return slide.shapes.add_textbox(Inches(1), Inches(1.5), Inches(8), Inches(5))
+
+    def _apply_style(self, shape, style_config, is_title=True):
+        """Applique le style aux éléments textuels"""
+        if not hasattr(shape, "text_frame") or shape.text_frame is None:
+            logger.warning("⚠️ Shape sans text_frame, style non appliqué.")
+            return
+
+        try:
+            for paragraph in shape.text_frame.paragraphs:
+                for run in paragraph.runs:
+                    if run.font:
+                        run.font.name = style_config["font_name"]
+                        run.font.color.rgb = (
+                            style_config["title_color"] if is_title else style_config["text_color"]
+                        )
+                        run.font.size = Pt(32 if is_title else 16)
+                        run.font.bold = is_title
+        except Exception as e:
+            logger.warning(f"❌ Échec de l'application du style: {e}")

requirements.txt

@@ -0,0 +1,13 @@
+gradio>=4.0.0
+python-pptx>=1.0.0
+PyPDF2>=3.0.0
+python-docx>=1.1.0
+transformers>=4.30.0
+torch>=2.0.0
+flask>=2.3.0
+numpy==1.24.3
+scikit-learn==1.2.2
+sentence-transformers==2.2.2
+nltk==3.8.1
+requests==2.28.2
+python-dotenv==1.0.0