Upload 2 files

app.py

@@ -0,0 +1,895 @@
+"""
+LAB_MATH & LABHP - GÉNÉRATEUR DE PRÉSENTATIONS INTELLIGENT V3.0
+All-in-one avec analyse automatique du type de document
+"""
+
+import gradio as gr
+import os
+import re
+import time
+import nltk
+from pptx import Presentation
+from pptx.util import Inches, Pt
+from pptx.dml.color import RGBColor
+from pptx.enum.text import PP_ALIGN
+from pptx.enum.shapes import MSO_SHAPE
+import PyPDF2
+from docx import Document
+from collections import Counter
+from datetime import datetime
+import random
+
+# ==========================================
+# CONFIGURATION ET CONSTANTES
+# ==========================================
+CODE_SECRET = "32015"
+VERSION = "3.0"
+
+# Palettes de couleurs par type de document
+THEMES = {
+    "scientifique": {
+        "primary": RGBColor(0, 84, 159),      # Bleu profond
+        "secondary": RGBColor(142, 186, 229),  # Bleu clair
+        "accent": RGBColor(255, 199, 44),      # Or
+        "bg_title": RGBColor(0, 32, 96),       # Bleu nuit
+        "title_text": RGBColor(255, 255, 255), # Blanc
+        "body_text": RGBColor(35, 35, 35),     # Gris foncé
+        "icon": "🔬"
+    },
+    "pedagogique": {
+        "primary": RGBColor(39, 174, 96),      # Vert
+        "secondary": RGBColor(46, 204, 113),    # Vert clair
+        "accent": RGBColor(241, 196, 15),       # Jaune
+        "bg_title": RGBColor(27, 79, 114),      # Bleu-vert
+        "title_text": RGBColor(255, 255, 255),  # Blanc
+        "body_text": RGBColor(35, 35, 35),      # Gris foncé
+        "icon": "📚"
+    },
+    "professionnel": {
+        "primary": RGBColor(52, 73, 94),        # Gris anthracite
+        "secondary": RGBColor(127, 140, 141),   # Gris moyen
+        "accent": RGBColor(230, 126, 34),       # Orange
+        "bg_title": RGBColor(44, 62, 80),       # Bleu-gris
+        "title_text": RGBColor(255, 255, 255),  # Blanc
+        "body_text": RGBColor(52, 73, 94),      # Gris anthracite
+        "icon": "💼"
+    },
+    "rapport": {
+        "primary": RGBColor(155, 89, 182),      # Violet
+        "secondary": RGBColor(142, 68, 173),    # Violet foncé
+        "accent": RGBColor(52, 152, 219),       # Bleu
+        "bg_title": RGBColor(91, 44, 111),      # Violet profond
+        "title_text": RGBColor(255, 255, 255),  # Blanc
+        "body_text": RGBColor(35, 35, 35),      # Gris foncé
+        "icon": "📊"
+    },
+    "reunion": {
+        "primary": RGBColor(231, 76, 60),       # Rouge
+        "secondary": RGBColor(192, 57, 43),     # Rouge foncé
+        "accent": RGBColor(243, 156, 18),       # Orange
+        "bg_title": RGBColor(169, 50, 38),      # Bordeaux
+        "title_text": RGBColor(255, 255, 255),  # Blanc
+        "body_text": RGBColor(35, 35, 35),      # Gris foncé
+        "icon": "📋"
+    }
+}
+
+# ==========================================
+# PARTIE 1 : ANALYSEUR INTELLIGENT DE DOCUMENTS
+# ==========================================
+class DocumentAnalyzer:
+    def __init__(self):
+        try:
+            nltk.download('punkt', quiet=True)
+            nltk.download('punkt_tab', quiet=True)
+            nltk.download('averaged_perceptron_tagger', quiet=True)
+            nltk.download('stopwords', quiet=True)
+            from nltk.corpus import stopwords
+            self.stopwords = set(stopwords.words('french'))
+        except:
+            self.stopwords = set(['le', 'la', 'les', 'de', 'du', 'des', 'un', 'une', 'et', 'est', 'sont'])
+    
+    def extract_text(self, file_obj):
+        """Extrait le texte du fichier"""
+        try:
+            if file_obj.name.endswith('.pdf'):
+                reader = PyPDF2.PdfReader(file_obj.name)
+                text = " ".join([p.extract_text() for p in reader.pages if p.extract_text()])
+            elif file_obj.name.endswith('.docx'):
+                doc = Document(file_obj.name)
+                text = " ".join([p.text for p in doc.paragraphs])
+            else:
+                with open(file_obj.name, 'r', encoding='utf-8', errors='ignore') as f:
+                    text = f.read()
+            return text
+        except Exception as e:
+            return f"Erreur d'extraction: {e}"
+    
+    def detect_document_type(self, text):
+        """
+        Analyse le texte pour déterminer automatiquement le type de document
+        Retourne: (type_document, confiance, caractéristiques)
+        """
+        text_lower = text.lower()
+        
+        # Mots-clés par catégorie
+        keywords = {
+            "Article Scientifique": {
+                "mots": [
+                    "étude", "recherche", "méthodologie", "résultats", "analyse", 
+                    "données", "statistiques", "hypothèse", "expérience", "corrélation",
+                    "significatif", "variable", "échantillon", "protocole", "publication",
+                    "revue", "littérature", "bibliographie", "références", "abstract"
+                ],
+                "poids": 0
+            },
+            "Cours / Pédagogique": {
+                "mots": [
+                    "cours", "leçon", "chapitre", "exercice", "apprentissage", 
+                    "étudiant", "professeur", "comprendre", "définition", "exemple",
+                    "objectifs", "compétences", "évaluation", "notion", "principe",
+                    "illustration", "démonstration", "pratique", "théorique", "savoir"
+                ],
+                "poids": 0
+            },
+            "Rapport d'Étude": {
+                "mots": [
+                    "rapport", "étude", "analyse", "données", "collecte", 
+                    "terrain", "enquête", "observation", "constat", "recommandation",
+                    "conclusion", "objectifs", "méthodologie", "échantillon", "résultats",
+                    "indicateurs", "graphique", "tableau", "synthèse", "préconisation"
+                ],
+                "poids": 0
+            },
+            "Rapport de Réunion": {
+                "mots": [
+                    "réunion", "compte-rendu", "participants", "ordre du jour", "discussion",
+                    "décision", "action", "point", "échange", "prochain", "date",
+                    "présents", "excusés", "délibération", "vote", "validation",
+                    "proposition", "adoption", "calendrier", "responsable", "échéance"
+                ],
+                "poids": 0
+            },
+            "Communication / Présentation": {
+                "mots": [
+                    "présentation", "communication", "conférence", "intervention", "public",
+                    "message", "impact", "perspectives", "enjeux", "défis",
+                    "opportunités", "vision", "stratégie", "innovation", "projet",
+                    "partenaires", "collaboration", "développement", "avenir", "objectif"
+                ],
+                "poids": 0
+            },
+            "Thèse / Mémoire": {
+                "mots": [
+                    "thèse", "mémoire", "doctorat", "master", "recherche",
+                    "problématique", "hypothèse", "cadre théorique", "état de l'art",
+                    "contribution", "originalité", "discussion", "limites", "perspectives",
+                    "soutenance", "directeur", "jury", "travaux", "publications"
+                ],
+                "poids": 0
+            }
+        }
+        
+        # Calcul des scores
+        sentences = text.split('.')
+        total_words = len(text.split())
+        
+        for doc_type, data in keywords.items():
+            score = 0
+            for mot in data["mots"]:
+                occurrences = text_lower.count(mot)
+                if occurrences > 0:
+                    score += occurrences * (1 + (len(mot) / 10))
+            data["poids"] = score
+        
+        # Sélection du type avec le score le plus élevé
+        best_type = max(keywords.items(), key=lambda x: x[1]["poids"])
+        confidence = (best_type[1]["poids"] / max(1, total_words)) * 100
+        
+        # Analyse complémentaire
+        features = self.extract_features(text)
+        
+        return best_type[0], min(confidence, 100), features
+    
+    def extract_features(self, text):
+        """Extrait des caractéristiques du document"""
+        features = {}
+        
+        # Nombre de mots
+        words = text.split()
+        features["word_count"] = len(words)
+        
+        # Nombre de phrases
+        sentences = text.split('.')
+        features["sentence_count"] = len([s for s in sentences if len(s.strip()) > 10])
+        
+        # Présence de chiffres/nombres
+        numbers = re.findall(r'\d+', text)
+        features["number_count"] = len(numbers)
+        
+        # Pourcentage de chiffres
+        if features["word_count"] > 0:
+            features["numeric_density"] = (features["number_count"] / features["word_count"]) * 100
+        
+        # Longueur moyenne des phrases
+        if features["sentence_count"] > 0:
+            features["avg_sentence_length"] = features["word_count"] / features["sentence_count"]
+        
+        return features
+    
+    def extract_key_points(self, text, num_points=10):
+        """Extrait les points clés du document"""
+        sentences = nltk.sent_tokenize(text) if 'nltk' in dir() else text.split('.')
+        
+        # Filtrer les phrases trop courtes
+        sentences = [s.strip() for s in sentences if len(s.strip()) > 30]
+        
+        if not sentences:
+            return ["Document trop court pour l'analyse"]
+        
+        # Score basé sur la position et les mots-clés
+        scored_sentences = []
+        for i, sent in enumerate(sentences):
+            score = 0
+            # Bonus pour les débuts de paragraphes
+            if i % 5 == 0:
+                score += 3
+            # Bonus pour les phrases contenant des mots importants
+            important_words = ['important', 'conclusion', 'résultat', 'objectif', 'but']
+            for word in important_words:
+                if word in sent.lower():
+                    score += 2
+            # Malus pour les phrases trop longues
+            if len(sent.split()) > 30:
+                score -= 1
+            
+            scored_sentences.append((score, sent))
+        
+        # Trier et prendre les meilleures phrases
+        scored_sentences.sort(reverse=True)
+        key_points = [sent for score, sent in scored_sentences[:num_points]]
+        
+        return key_points
+
+# ==========================================
+# PARTIE 2 : GÉNÉRATEUR DE PLANS ADAPTATIFS
+# ==========================================
+class AdaptiveOutlineGenerator:
+    def __init__(self):
+        self.templates = {
+            "Article Scientifique": {
+                "structure": [
+                    ("title", "TITRE DE L'ARTICLE"),
+                    ("authors", "AUTEURS & AFFILIATIONS"),
+                    ("abstract", "RÉSUMÉ"),
+                    ("intro", "INTRODUCTION & CONTEXTE"),
+                    ("problem", "PROBLÉMATIQUE"),
+                    ("methodology", "MÉTHODOLOGIE"),
+                    ("results", "RÉSULTATS"),
+                    ("discussion", "DISCUSSION"),
+                    ("conclusion", "CONCLUSION"),
+                    ("references", "RÉFÉRENCES CLÉS")
+                ],
+                "type": "scientifique",
+                "icon": "📄"
+            },
+            "Cours / Pédagogique": {
+                "structure": [
+                    ("title", "TITRE DU COURS"),
+                    ("objectives", "OBJECTIFS PÉDAGOGIQUES"),
+                    ("prerequis", "PRÉ-REQUIS"),
+                    ("introduction", "INTRODUCTION"),
+                    ("part1", "PARTIE 1 : CONCEPTS FONDAMENTAUX"),
+                    ("part2", "PARTIE 2 : APPLICATIONS"),
+                    ("part3", "PARTIE 3 : EXERCICES TYPES"),
+                    ("summary", "SYNTHÈSE"),
+                    ("evaluation", "ÉVALUATION"),
+                    ("resources", "RESSOURCES COMPLÉMENTAIRES")
+                ],
+                "type": "pedagogique",
+                "icon": "📖"
+            },
+            "Rapport d'Étude": {
+                "structure": [
+                    ("title", "TITRE DU RAPPORT"),
+                    ("exec_summary", "RÉSUMÉ EXÉCUTIF"),
+                    ("context", "CONTEXTE DE L'ÉTUDE"),
+                    ("objectives", "OBJECTIFS"),
+                    ("methodology", "MÉTHODOLOGIE"),
+                    ("results", "RÉSULTATS PRINCIPAUX"),
+                    ("analysis", "ANALYSE DÉTAILLÉE"),
+                    ("conclusions", "CONCLUSIONS"),
+                    ("recommendations", "RECOMMANDATIONS"),
+                    ("annexes", "ANNEXES")
+                ],
+                "type": "rapport",
+                "icon": "📊"
+            },
+            "Rapport de Réunion": {
+                "structure": [
+                    ("title", "COMPTE-RENDU DE RÉUNION"),
+                    ("info", "INFORMATIONS GÉNÉRALES"),
+                    ("participants", "PARTICIPANTS"),
+                    ("agenda", "ORDRE DU JOUR"),
+                    ("discussions", "POINTS DISCUTÉS"),
+                    ("decisions", "DÉCISIONS PRISES"),
+                    ("actions", "PLAN D'ACTIONS"),
+                    ("next", "PROCHAINE RÉUNION"),
+                    ("annexes", "ANNEXES"),
+                    ("signatures", "VALIDATION")
+                ],
+                "type": "reunion",
+                "icon": "📋"
+            },
+            "Communication / Présentation": {
+                "structure": [
+                    ("title", "TITRE DE LA COMMUNICATION"),
+                    ("context", "CONTEXTE"),
+                    ("enjeux", "ENJEUX"),
+                    ("message", "MESSAGE CLÉ"),
+                    ("developpement", "DÉVELOPPEMENT"),
+                    ("illustrations", "ILLUSTRATIONS"),
+                    ("impacts", "IMPACTS"),
+                    ("perspectives", "PERSPECTIVES"),
+                    ("conclusion", "CONCLUSION"),
+                    ("discussion", "DISCUSSION")
+                ],
+                "type": "professionnel",
+                "icon": "🎤"
+            },
+            "Thèse / Mémoire": {
+                "structure": [
+                    ("title", "TITRE DE LA THÈSE"),
+                    ("dedicace", "DÉDICACES"),
+                    ("remerciements", "REMERCIEMENTS"),
+                    ("resume", "RÉSUMÉ"),
+                    ("abstract", "ABSTRACT"),
+                    ("intro", "INTRODUCTION GÉNÉRALE"),
+                    ("chap1", "CHAPITRE 1 : REVUE DE LITTÉRATURE"),
+                    ("chap2", "CHAPITRE 2 : CADRE THÉORIQUE"),
+                    ("chap3", "CHAPITRE 3 : MÉTHODOLOGIE"),
+                    ("chap4", "CHAPITRE 4 : RÉSULTATS"),
+                    ("chap5", "CHAPITRE 5 : DISCUSSION"),
+                    ("conclusion", "CONCLUSION GÉNÉRALE"),
+                    ("bibliographie", "BIBLIOGRAPHIE"),
+                    ("annexes", "ANNEXES")
+                ],
+                "type": "scientifique",
+                "icon": "🎓"
+            }
+        }
+    
+    def generate_outline(self, text, detected_type, features, key_points):
+        """Génère un plan adapté au type de document"""
+        template = self.templates.get(detected_type, self.templates["Rapport d'Étude"])
+        
+        # Création du titre principal
+        sentences = text.split('.')
+        title = sentences[0][:100] if sentences else f"DOCUMENT: {detected_type}"
+        title = re.sub(r'[^\w\s-]', '', title).strip()
+        
+        outline = {
+            "title": title,
+            "type": detected_type,
+            "theme": template["type"],
+            "icon": template["icon"],
+            "slides": []
+        }
+        
+        # Slide de titre
+        outline["slides"].append({
+            "type": "title",
+            "title": title.upper(),
+            "subtitle": f"{detected_type} | LAB_MATH & LABHP\nGénéré le {datetime.now().strftime('%d/%m/%Y')}",
+            "icon": template["icon"]
+        })
+        
+        # Génération des slides selon le template
+        for i, (slide_type, slide_title) in enumerate(template["structure"]):
+            slide_content = self.generate_slide_content(
+                slide_type, slide_title, text, key_points, features, i, len(template["structure"])
+            )
+            
+            outline["slides"].append({
+                "type": "content",
+                "title": slide_title,
+                "content": slide_content,
+                "icon": self.get_slide_icon(slide_type)
+            })
+        
+        # Slide de remerciements
+        outline["slides"].append({
+            "type": "thanks",
+            "title": "MERCI DE VOTRE ATTENTION",
+            "content": [
+                "N'hésitez pas à poser vos questions",
+                "📧 Contact: labmath@cie-label-bertoua.cm",
+                f"📊 Document de type: {detected_type}",
+                "✨ Généré par l'IA de LAB_MATH"
+            ],
+            "icon": "🙏"
+        })
+        
+        return outline
+    
+    def generate_slide_content(self, slide_type, slide_title, text, key_points, features, index, total):
+        """Génère le contenu spécifique pour chaque type de slide"""
+        
+        # Adapter le contenu selon le type de slide
+        if "intro" in slide_type or "context" in slide_type:
+            return self._generate_intro_content(text, key_points[:2])
+        
+        elif "method" in slide_type:
+            return self._generate_methodology_content(text)
+        
+        elif "result" in slide_type or "analysis" in slide_type:
+            return self._generate_results_content(text, features)
+        
+        elif "conclu" in slide_type or "summary" in slide_type:
+            return self._generate_conclusion_content(text, key_points[-3:])
+        
+        elif "action" in slide_type or "recommend" in slide_type:
+            return self._generate_recommendations_content(text)
+        
+        elif "objectives" in slide_type:
+            return self._generate_objectives_content(text)
+        
+        else:
+            # Contenu générique
+            return self._generate_generic_content(text, key_points, index, total)
+    
+    def get_slide_icon(self, slide_type):
+        """Retourne une icône adaptée au type de slide"""
+        icons = {
+            "intro": "🔍",
+            "method": "⚙️",
+            "result": "📈",
+            "conclu": "✅",
+            "action": "🚀",
+            "objectives": "🎯",
+            "context": "🌍",
+            "analysis": "📊",
+            "discussion": "💭",
+            "references": "📚",
+            "annexes": "📎"
+        }
+        
+        for key, icon in icons.items():
+            if key in slide_type:
+                return icon
+        return "•"
+    
+    def _generate_intro_content(self, text, key_points):
+        content = ["Contexte et introduction :"]
+        if key_points:
+            content.extend([f"• {kp[:100]}..." for kp in key_points])
+        else:
+            content.append("• Présentation du sujet et de son importance")
+            content.append("• Objectifs généraux du document")
+        return content
+    
+    def _generate_methodology_content(self, text):
+        # Chercher des sections de méthodologie dans le texte
+        method_section = re.search(r'(méthodologie|méthode|approche|protocole).*?(?=\n\n|\Z)', 
+                                   text, re.IGNORECASE | re.DOTALL)
+        
+        if method_section:
+            sentences = method_section.group().split('.')
+            return [f"• {s.strip()}" for s in sentences[:4] if len(s.strip()) > 20]
+        
+        return [
+            "• Approche méthodologique adoptée",
+            "• Outils et techniques utilisés",
+            "• Collecte et analyse des données",
+            "• Validation des résultats"
+        ]
+    
+    def _generate_results_content(self, text, features):
+        content = ["Résultats principaux :"]
+        
+        # Chercher des chiffres dans le texte
+        numbers = re.findall(r'\d+%|\d+[.,]?\d*\s*(?:participants|personnes|échantillons)', text)
+        
+        if numbers:
+            content.append(f"• {numbers[0] if numbers else 'Données quantitatives disponibles'}")
+        
+        if features.get("numeric_density", 0) > 5:
+            content.append("• Analyse statistique significative")
+        
+        content.append("• Interprétation des données")
+        content.append("• Implications des résultats")
+        
+        return content
+    
+    def _generate_conclusion_content(self, text, key_points):
+        content = ["Synthèse et conclusions :"]
+        if key_points:
+            content.extend([f"• {kp[:100]}..." for kp in key_points])
+        else:
+            content.append("• Récapitulatif des points clés")
+            content.append("• Contributions principales")
+            content.append("• Limites et perspectives")
+        return content
+    
+    def _generate_recommendations_content(self, text):
+        # Chercher des recommandations
+        rec_section = re.search(r'(recommandation|préconisation|proposition|suggestion).*?(?=\n\n|\Z)', 
+                                text, re.IGNORECASE | re.DOTALL)
+        
+        if rec_section:
+            sentences = rec_section.group().split('.')
+            return [f"✓ {s.strip()}" for s in sentences[:4] if len(s.strip()) > 15]
+        
+        return [
+            "✓ Action prioritaire 1",
+            "✓ Action prioritaire 2",
+            "✓ Action prioritaire 3",
+            "✓ Calendrier de mise en œuvre"
+        ]
+    
+    def _generate_objectives_content(self, text):
+        content = ["Objectifs :"]
+        objectives = re.findall(r'(?:objectif|but|finalité)\s*(?:de|du|des)?\s*([^\.]+)', 
+                               text, re.IGNORECASE)
+        
+        if objectives:
+            content.extend([f"🎯 {obj.strip()}" for obj in objectives[:4]])
+        else:
+            content.extend([
+                "🎯 Objectif général 1",
+                "🎯 Objectif spécifique 1",
+                "🎯 Objectif spécifique 2",
+                "🎯 Résultats attendus"
+            ])
+        
+        return content
+    
+    def _generate_generic_content(self, text, key_points, index, total):
+        """Génère du contenu générique"""
+        if key_points and index < len(key_points):
+            main_point = key_points[index]
+            return [f"• {main_point[:150]}...", "• Développement du point", "• Illustrations et exemples"]
+        
+        return [f"• Point clé {index+1}", "• Développement", "• Conclusion partielle"]
+
+# ==========================================
+# PARTIE 3 : GÉNÉRATEUR DE PRÉSENTATION PROFESSIONNELLE
+# ==========================================
+class ProfessionalPresentationGenerator:
+    def __init__(self):
+        self.themes = THEMES
+    
+    def generate(self, outline):
+        """Génère la présentation PowerPoint"""
+        prs = Presentation()
+        prs.slide_width = Inches(13.33)
+        prs.slide_height = Inches(7.5)
+        
+        # Récupérer le thème approprié
+        theme = self.themes.get(outline["theme"], self.themes["professionnel"])
+        
+        for slide_data in outline["slides"]:
+            if slide_data["type"] == "title":
+                self._create_title_slide(prs, slide_data, theme)
+            elif slide_data["type"] == "thanks":
+                self._create_thanks_slide(prs, slide_data, theme)
+            else:
+                self._create_content_slide(prs, slide_data, theme, outline)
+        
+        # Sauvegarde
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"Presentation_LabMath_{timestamp}.pptx"
+        prs.save(filename)
+        return filename
+    
+    def _create_title_slide(self, prs, data, theme):
+        """Crée la slide de titre"""
+        slide = prs.slides.add_slide(prs.slide_layouts[6])
+        
+        # Fond
+        bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, 0, 0, prs.slide_width, prs.slide_height)
+        bg.fill.solid()
+        bg.fill.fore_color.rgb = theme["bg_title"]
+        bg.line.fill.background()
+        
+        # Bandeau décoratif
+        band = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, 0, prs.slide_height - Inches(1), 
+                                      prs.slide_width, Inches(1))
+        band.fill.solid()
+        band.fill.fore_color.rgb = theme["accent"]
+        band.fill.transparency = 0.3
+        band.line.fill.background()
+        
+        # Titre principal
+        title_box = slide.shapes.add_textbox(Inches(1), Inches(2), prs.slide_width - Inches(2), Inches(2))
+        title_frame = title_box.text_frame
+        title_frame.word_wrap = True
+        
+        # Icône
+        icon_para = title_frame.add_paragraph()
+        icon_para.text = data.get("icon", "📊")
+        icon_para.font.size = Pt(60)
+        icon_para.font.color.rgb = theme["accent"]
+        icon_para.alignment = PP_ALIGN.CENTER
+        
+        # Titre
+        title_para = title_frame.add_paragraph()
+        title_para.text = data["title"]
+        title_para.font.size = Pt(44)
+        title_para.font.bold = True
+        title_para.font.color.rgb = theme["title_text"]
+        title_para.alignment = PP_ALIGN.CENTER
+        title_para.space_before = Pt(20)
+        
+        # Sous-titre
+        if "subtitle" in data:
+            sub_box = slide.shapes.add_textbox(Inches(1), Inches(5), prs.slide_width - Inches(2), Inches(1))
+            sub_frame = sub_box.text_frame
+            sub_para = sub_frame.add_paragraph()
+            sub_para.text = data["subtitle"]
+            sub_para.font.size = Pt(18)
+            sub_para.font.color.rgb = theme["title_text"]
+            sub_para.alignment = PP_ALIGN.CENTER
+    
+    def _create_content_slide(self, prs, data, theme, outline):
+        """Crée une slide de contenu"""
+        slide = prs.slides.add_slide(prs.slide_layouts[6])
+        
+        # Bandeau supérieur
+        header = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, 0, 0, prs.slide_width, Inches(0.12))
+        header.fill.solid()
+        header.fill.fore_color.rgb = theme["primary"]
+        header.line.fill.background()
+        
+        # Bande latérale décorative
+        side = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, 0, 0, Inches(0.08), prs.slide_height)
+        side.fill.solid()
+        side.fill.fore_color.rgb = theme["accent"]
+        side.line.fill.background()
+        
+        # Titre de la slide
+        title_box = slide.shapes.add_textbox(Inches(0.5), Inches(0.2), prs.slide_width - Inches(1), Inches(0.8))
+        title_frame = title_box.text_frame
+        title_para = title_frame.add_paragraph()
+        
+        # Icône + titre
+        title_para.text = f"{data.get('icon', '•')} {data['title']}"
+        title_para.font.size = Pt(28)
+        title_para.font.bold = True
+        title_para.font.color.rgb = theme["primary"]
+        
+        # Contenu
+        content_box = slide.shapes.add_textbox(Inches(0.8), Inches(1.2), 
+                                               prs.slide_width - Inches(1.5), 
+                                               prs.slide_height - Inches(2.5))
+        content_frame = content_box.text_frame
+        content_frame.word_wrap = True
+        
+        for item in data.get("content", []):
+            para = content_frame.add_paragraph()
+            para.text = item
+            para.font.size = Pt(18)
+            para.font.color.rgb = theme["body_text"]
+            para.space_after = Pt(12)
+            para.space_before = Pt(6)
+            
+            # Mettre en évidence les éléments importants
+            if item.startswith("✓") or item.startswith("🎯"):
+                para.font.bold = True
+                para.font.color.rgb = theme["primary"]
+        
+        # Pied de page
+        footer = slide.shapes.add_textbox(Inches(0.5), prs.slide_height - Inches(0.4), 
+                                          prs.slide_width - Inches(1), Inches(0.3))
+        footer_frame = footer.text_frame
+        footer_para = footer_frame.add_paragraph()
+        footer_para.text = f"LAB_MATH & LABHP | {outline['type']} | Slide {len(prs.slides)}"
+        footer_para.font.size = Pt(10)
+        footer_para.font.color.rgb = RGBColor(150, 150, 150)
+        footer_para.alignment = PP_ALIGN.RIGHT
+    
+    def _create_thanks_slide(self, prs, data, theme):
+        """Crée la slide de remerciements"""
+        slide = prs.slides.add_slide(prs.slide_layouts[6])
+        
+        # Fond
+        bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, 0, 0, prs.slide_width, prs.slide_height)
+        bg.fill.solid()
+        bg.fill.fore_color.rgb = RGBColor(245, 245, 245)
+        bg.line.fill.background()
+        
+        # Message principal
+        title_box = slide.shapes.add_textbox(Inches(1), Inches(2), prs.slide_width - Inches(2), Inches(1.5))
+        title_frame = title_box.text_frame
+        title_para = title_frame.add_paragraph()
+        title_para.text = data["title"]
+        title_para.font.size = Pt(48)
+        title_para.font.bold = True
+        title_para.font.color.rgb = theme["primary"]
+        title_para.alignment = PP_ALIGN.CENTER
+        
+        # Contenu
+        content_box = slide.shapes.add_textbox(Inches(2), Inches(4), prs.slide_width - Inches(4), Inches(2))
+        content_frame = content_box.text_frame
+        content_frame.word_wrap = True
+        
+        for item in data.get("content", []):
+            para = content_frame.add_paragraph()
+            para.text = item
+            para.font.size = Pt(20)
+            para.font.color.rgb = theme["body_text"]
+            para.alignment = PP_ALIGN.CENTER
+            para.space_after = Pt(10)
+
+# ==========================================
+# PARTIE 4 : INTERFACE PRINCIPALE
+# ==========================================
+class PresentationApp:
+    def __init__(self):
+        self.analyzer = DocumentAnalyzer()
+        self.outline_generator = AdaptiveOutlineGenerator()
+        self.presentation_generator = ProfessionalPresentationGenerator()
+        self.code_secret = CODE_SECRET
+    
+    def authenticate(self, code):
+        """Vérifie le code d'accès"""
+        if code == self.code_secret:
+            return gr.update(visible=False), gr.update(visible=True), "✅ Accès autorisé !"
+        return gr.update(visible=True), gr.update(visible=False), "❌ Code incorrect"
+    
+    def process_document(self, file, code):
+        """Traite le document et génère la présentation"""
+        # Vérification du code
+        if code != self.code_secret:
+            return None, "❌ Code d'accès invalide", "", "", ""
+        
+        if not file:
+            return None, "❌ Veuillez sélectionner un fichier", "", "", ""
+        
+        try:
+            # Étape 1: Extraction du texte
+            status = "📖 Extraction du texte..."
+            text = self.analyzer.extract_text(file)
+            
+            if not text or len(text) < 100:
+                return None, "❌ Document trop court ou illisible", "", "", ""
+            
+            # Étape 2: Analyse du type de document
+            status = "🔍 Analyse du type de document..."
+            doc_type, confidence, features = self.analyzer.detect_document_type(text)
+            
+            # Étape 3: Extraction des points clés
+            status = "🎯 Extraction des points clés..."
+            key_points = self.analyzer.extract_key_points(text)
+            
+            # Étape 4: Génération du plan adaptatif
+            status = "📝 Génération du plan adaptatif..."
+            outline = self.outline_generator.generate_outline(text, doc_type, features, key_points)
+            
+            # Étape 5: Génération de la présentation
+            status = "🎨 Création de la présentation..."
+            pptx_file = self.presentation_generator.generate(outline)
+            
+            # Informations pour l'affichage
+            doc_info = f"📊 Type détecté: {doc_type}\n📈 Confiance: {confidence:.1f}%\n📄 Mots: {features['word_count']}"
+            
+            plan_info = "Plan généré:\n" + "\n".join([f"• {s['title']}" for s in outline['slides'][:5]])
+            
+            preview = f"Points clés extraits:\n" + "\n".join([f"• {kp[:80]}..." for kp in key_points[:3]])
+            
+            return pptx_file, f"✅ Succès! Présentation générée", doc_info, plan_info, preview
+            
+        except Exception as e:
+            return None, f"❌ Erreur: {str(e)}", "", "", ""
+
+# ==========================================
+# LANCEMENT DE L'APPLICATION
+# ==========================================
+app = PresentationApp()
+
+with gr.Blocks(title="LAB_MATH - Générateur Intelligent de Présentations", 
+               theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("""
+    # 🎯 LAB_MATH & LABHP - Générateur Intelligent de Présentations V3.0
+    ### Analyse automatique du type de document et génération adaptative
+    """)
+    
+    # Écran de connexion
+    with gr.Column(visible=True) as auth_screen:
+        gr.Markdown("""
+        <div style='text-align: center; padding: 50px;'>
+            <h1 style='color: #2E86AB;'>🔐 ACCÈS SÉCURISÉ</h1>
+            <p>Veuillez entrer votre code d'accès pour utiliser l'application</p>
+        </div>
+        """)
+        
+        code_input = gr.Textbox(label="Code d'accès", type="password", 
+                                placeholder="Entrez votre code")
+        auth_btn = gr.Button("Se connecter", variant="primary")
+        auth_status = gr.Textbox(label="Statut", interactive=False)
+    
+    # Application principale
+    with gr.Column(visible=False) as main_screen:
+        gr.Markdown("""
+        <div style='background: linear-gradient(135deg, #2E86AB, #3498DB); padding: 20px; border-radius: 10px; color: white; text-align: center;'>
+            <h2 style='margin:0;'>🤖 Générateur Intelligent de Présentations</h2>
+            <p style='margin:5px 0 0 0; opacity:0.9;'>Analyse automatique | Plans adaptatifs | Design professionnel</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_input = gr.File(label="📁 1. Sélectionnez votre document", 
+                                    file_types=[".pdf", ".docx", ".txt"])
+                
+                code_verify = gr.Textbox(label="🔑 Code de vérification", 
+                                         type="password", 
+                                         placeholder="Confirmez votre code")
+                
+                generate_btn = gr.Button("🚀 GÉNÉRER LA PRÉSENTATION", 
+                                        variant="primary", size="lg")
+                
+                status_output = gr.Textbox(label="Statut", interactive=False)
+            
+            with gr.Column(scale=2):
+                with gr.Tabs():
+                    with gr.TabItem("📊 Analyse du document"):
+                        doc_info = gr.Textbox(label="Type de document détecté", 
+                                             lines=4, interactive=False)
+                        key_points_preview = gr.Textbox(label="Points clés extraits", 
+                                                        lines=6, interactive=False)
+                    
+                    with gr.TabItem("📝 Plan généré"):
+                        plan_info = gr.Textbox(label="Structure adaptative", 
+                                              lines=8, interactive=False)
+                    
+                    with gr.TabItem("🎨 Aperçu"):
+                        preview_area = gr.HTML("""
+                        <div style='padding: 20px; text-align: center; color: #666;'>
+                            <h3>Aperçu de la présentation</h3>
+                            <p>Générez une présentation pour voir l'aperçu</p>
+                        </div>
+                        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                output_file = gr.File(label="📥 Télécharger la présentation")
+            
+            with gr.Column(scale=2):
+                gr.Markdown("""
+                ### 📋 Types de documents supportés:
+                - Articles scientifiques
+                - Cours et supports pédagogiques
+                - Rapports d'étude
+                - Comptes-rendus de réunion
+                - Communications et présentations
+                - Thèses et mémoires
+                """)
+    
+    # Gestion des événements
+    auth_btn.click(
+        fn=app.authenticate,
+        inputs=[code_input],
+        outputs=[auth_screen, main_screen, auth_status]
+    )
+    
+    generate_btn.click(
+        fn=app.process_document,
+        inputs=[file_input, code_verify],
+        outputs=[output_file, status_output, doc_info, plan_info, key_points_preview]
+    )
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("🚀 LAB_MATH - Générateur Intelligent de Présentations V3.0")
+    print("=" * 60)
+    print("📊 Analyse automatique des documents")
+    print("🎯 Plans adaptatifs par type de document")
+    print("✨ Design professionnel adapté")
+    print("=" * 60)
+    print(f"🔐 Code d'accès: {CODE_SECRET}")
+    print("🌐 Interface: http://localhost:7860")
+    print("=" * 60)
+    
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+python-pptx
+python-docx
+PyPDF2
+nltk