Upload 5 files

Appli for presentation like power point

ai_enhance.py

@@ -0,0 +1,171 @@
+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:
+        if self.summarizer and len(texte) > 200:
+            try:
+                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 activé : {e}")
+
+        return self._fallback_summary(texte)
+
+    def smart_summarize(self, texte: str, max_length: int = 150) -> str:
+        try:
+            summarizer = get_summarizer()
+        except Exception as e:
+            logger.warning(f"❌ Chargement summarizer échoué : {e}")
+            return self._fallback_summary(texte)
+
+        if summarizer and len(texte) > 200:
+            try:
+                input_length = len(texte.split())
+                summary_max = min(max_length, input_length // 2)
+                summary_min = max(50, summary_max // 3)
+
+                summary = 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:
+        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]:
+        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 []
+
+    def _analyze_complexity(self, texte: str) -> float:
+        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 _suggest_structure(self, paragraphs: List[str], sentences: List[str]) -> Dict[str, Any]:
+        slides = []
+        if sentences:
+            slides.append({
+                "title": "Introduction",
+                "content": sentences[0][:100] + "..." if len(sentences[0]) > 100 else sentences[0],
+                "type": "introduction"
+            })
+
+        for i, para in enumerate(paragraphs[:5]):
+            slides.append({
+                "title": f"Point {i+1}",
+                "content": para[:150] + "..." if len(para) > 150 else para,
+                "type": "content"
+            })
+
+        if len(sentences) > 1:
+            slides.append({
+                "title": "Conclusion",
+                "content": "Synthèse des points principaux et perspectives",
+                "type": "conclusion"
+            })
+
+        return {
+            "total_slides": len(slides),
+            "slides": slides,
+            "recommended_style": "professionnel",
+            "estimated_duration": len(slides) * 2
+        }
+
+    def _analyze_content_type(self, texte: str) -> str:
+        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"
+
+    def _basic_analysis(self, texte: str) -> Dict[str, Any]:
+        words = texte.split()
+        sentences = [s.strip() for s in texte.split('.') if s.strip()]
+
+        return {
+            "statistics": {
+                "word_count": len(words),
+                "sentence_count": len(sentences),
+                "paragraph_count": len([p for p in texte.split('\n') if p.strip()]),
+                "avg_sentence_length": len(words) / len(sentences) if sentences else 0,
+                "complexity_score": 0.5
+            },
+            "keywords": ["analyse", "texte", "présentation"],
+            "recommended_structure": {
+                "total_slides": 4,
+                "slides": [
+                    {"title": "Introduction", "content": "Présentation du sujet", "type": "introduction"},
+                    {"title": "Développement", "content": "Points principaux", "type": "content"},
+                    {"title": "Exemples", "content": "Illustrations concrètes", "type": "content"},
+                    {"title": "Conclusion", "content": "Synthèse et perspectives", "type": "conclusion"}
+                ],
+                "recommended_style": "professionnel",
+                "estimated_duration": 8
+            },
+            "content_analysis": "général"
+        }

app.py

@@ -0,0 +1,172 @@
+import gradio as gr
+import os
+import tempfile
+from datetime import datetime
+import logging
+import json
+
+from ai_enhance import AIEnhance
+from presentation_generator import PresentationGenerator
+
+# Configuration logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialisation des services
+ai_service = AIEnhance()
+presentation_generator = PresentationGenerator()
+
+def create_presentation_structure(texte):
+    """Crée la structure de présentation avec analyse IA"""
+    # CORRECTION : Utiliser _basic_analysis au lieu de analyze_text_advanced
+    analysis = ai_service._basic_analysis(texte)
+    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
+
+def generate_presentation_gradio(texte, style="professionnel"):
+    """Version Gradio de votre fonction generate()"""
+    try:
+        if not texte or len(texte.strip()) < 50:
+            return None, "❌ Veuillez entrer au moins 50 caractères."
+
+        logger.info(f"🚀 Génération IA pour {len(texte)} caractères")
+        
+        # VOTRE LOGIQUE EXISTANTE
+        structure, summary = create_presentation_structure(texte)
+        filename = presentation_generator.generate_presentation(structure, style)
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        download_filename = f"presentation_ia_{timestamp}.pptx"
+
+        logger.info("✅ Présentation générée avec succès!")
+        return filename, 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, f"❌ Erreur: {str(e)}"
+
+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."
+
+        # VOTRE LOGIQUE EXISTANTE
+        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)}"
+
+def summarize_text_gradio(texte):
+    """Version Gradio de votre api_summarize()"""
+    try:
+        if not texte.strip():
+            return "❌ Texte manquant"
+
+        # VOTRE LOGIQUE EXISTANTE
+        summary = ai_service.smart_summarize(texte)
+        return f"**📄 Résumé:**\n\n{summary}"
+
+    except Exception as e:
+        return f"❌ Erreur résumé: {str(e)}"
+
+# INTERFACE GRADIO (reste identique)
+with gr.Blocks(theme=gr.themes.Soft(), title="Générateur de Présentation IA") as demo:
+    gr.Markdown("# 🧠 Générateur de Présentation IA Intelligente")
+    gr.Markdown("Powered by Lab_Math_and Labhp & CIE Label_Bertoua")
+
+    with gr.Tab("🚀 Générer Présentation"):
+        with gr.Row():
+            with gr.Column():
+                text_input = gr.Textbox(
+                    label="📝 Collez votre texte ici",
+                    placeholder="Collez ou tapez votre texte, article, rapport...",
+                    lines=10,
+                    max_lines=20
+                )
+                style_dropdown = gr.Dropdown(
+                    choices=["professionnel", "moderne", "creatif"],
+                    label="🎨 Style de présentation",
+                    value="professionnel"
+                )
+                generate_btn = gr.Button("🚀 Générer la Présentation", variant="primary")
+            
+            with gr.Column():
+                output_file = gr.File(label="📥 Présentation Générée")
+                output_message = gr.Textbox(label="📋 Statut", interactive=False)
+        
+        generate_btn.click(
+            fn=generate_presentation_gradio,
+            inputs=[text_input, style_dropdown],
+            outputs=[output_file, output_message]
+        )
+
+    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]
+        )
+
+    with gr.Tab("📄 Résumer le Texte"):
+        with gr.Row():
+            with gr.Column():
+                summarize_text_input = gr.Textbox(
+                    label="📝 Texte à résumer",
+                    placeholder="Collez votre texte pour le résumé IA...",
+                    lines=8
+                )
+                summarize_btn = gr.Button("📊 Générer Résumé", variant="secondary")
+            
+            with gr.Column():
+                summary_output = gr.Markdown(label="📋 Résumé généré")
+        
+        summarize_btn.click(
+            fn=summarize_text_gradio,
+            inputs=[summarize_text_input],
+            outputs=[summary_output]
+        )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

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,151 @@
+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
+
+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...")
+            for i, slide_data in enumerate(structure.get('slides', [])):
+                logger.info(f"  ➕ Slide {i+1}: {slide_data.get('title', 'Sans titre')}")
+                self._add_content_slide(prs, slide_data, style_config)
+            
+            if structure.get('key_points'):
+                logger.info("🧠 Ajout des points clés...")
+                self._add_keypoints_slide(prs, structure, style_config)
+            
+            logger.info("🏁 Ajout de la conclusion...")
+            self._add_conclusion_slide(prs, 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"""
+        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}\nGénéré intelligemment par IA"
+
+    def _add_content_slide(self, prs, slide_data, style_config):
+        """Ajoute une slide de contenu"""
+        slide_layout = prs.slide_layouts[1]
+        slide = prs.slides.add_slide(slide_layout)
+
+        title_shape = slide.shapes.title
+        try:
+            content_shape = slide.placeholders[1]
+        except IndexError:
+            logger.warning("⚠️ Placeholder 1 non trouvé. Création d'une textbox manuelle.")
+            content_shape = slide.shapes.add_textbox(Inches(1), Inches(2), Inches(8), Inches(5))
+            content_shape.text_frame.text = ""
+
+        title_shape.text = slide_data.get('title', 'Slide')
+        content_shape.text = slide_data.get('content', '')
+
+        self._apply_style(title_shape, style_config, is_title=True)
+        self._apply_style(content_shape, style_config, is_title=False)
+
+    def _add_keypoints_slide(self, prs, structure, style_config):
+        """Ajoute la slide des points clés"""
+        slide_layout = prs.slide_layouts[1]
+        slide = prs.slides.add_slide(slide_layout)
+        
+        title_shape = slide.shapes.title
+        try:
+            content_shape = slide.placeholders[1]
+        except IndexError:
+            logger.warning("⚠️ Placeholder 1 non trouvé. Création d'une textbox manuelle.")
+            content_shape = slide.shapes.add_textbox(Inches(1), Inches(2), Inches(8), Inches(5))
+            content_shape.text_frame.text = ""
+        
+        title_shape.text = "Points Clés Identifiés par IA"
+        content_shape.text = "\n".join([f"• {point}" for point in structure['key_points']])
+        
+        self._apply_style(title_shape, style_config, is_title=True)
+        self._apply_style(content_shape, style_config, is_title=False)
+    
+    def _add_conclusion_slide(self, prs, style_config):
+        """Ajoute la slide de conclusion"""
+        slide_layout = prs.slide_layouts[1]
+        slide = prs.slides.add_slide(slide_layout)
+        
+        title_shape = slide.shapes.title
+        try:
+            content_shape = slide.placeholders[1]
+        except IndexError:
+            logger.warning("⚠️ Placeholder 1 non trouvé. Création d'une textbox manuelle.")
+            content_shape = slide.shapes.add_textbox(Inches(1), Inches(2), Inches(8), Inches(5))
+            content_shape.text_frame.text = ""
+        
+        title_shape.text = "Conclusion"
+        content_shape.text = "Présentation générée automatiquement avec IA\nAnalyse sémantique avancée\nMerci pour votre attention !"
+        
+        self._apply_style(title_shape, style_config, is_title=True)
+        self._apply_style(content_shape, style_config, is_title=False)
+    
+    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 18)
+                        run.font.bold = is_title
+        except Exception as e:
+            logger.warning(f"❌ Échec de l'application du style: {e}")
+            print("présentation générée")

requirements.txt

@@ -0,0 +1,11 @@
+gradio==4.19.1
+flask==2.3.3
+python-pptx==0.6.21
+transformers==4.30.2
+torch==2.0.1
+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