Update app.py

app.py

@@ -1,21 +1,270 @@
-# main.py
+# app.py
 import streamlit as st
 import asyncio
+from typing import Any, List, Type
+from pydantic import BaseModel, Field
 
-from crew_utils import (
-    ExposeCrew,
-    project_manager,
-    planner,
-    researcher_intro,
-    researcher_dev,
-    researcher_conclusion,
-    assembler,
-    create_plan_task,
-    compile_report_task,
-    llm,
-)
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib import colors
 
 from crewai import Agent, Crew, Process, Task
+from crewai_tools import SerperDevTool
+from crewai import LLM
+
+# --- PDF Tool from pdf_tool.py ---
+class PDFToolInput(BaseModel):
+    content: str = Field(..., description="Contenu de l'exposé en format Markdown")
+    output_path: str = Field(..., description="Chemin de sortie du fichier PDF")
+
+class PDFTool(BaseTool):
+    name: str = "Generate PDF"
+    description: str = "Outil pour générer un document PDF à partir de texte en format Markdown."
+    args_schema: Type[BaseModel] = PDFToolInput
+
+    def _run(
+        self,
+        content: str,
+        output_path: str = "expose.pdf",
+        **kwargs,
+    ) -> str:
+        try:
+            doc = SimpleDocTemplate(output_path, pagesize=letter)
+            styles = getSampleStyleSheet()
+
+            # Ajout d'un style personnalisé pour le texte normal
+            styles.add(ParagraphStyle(name='CustomBodyText',
+                                      parent=styles['Normal'],
+                                      fontSize=12,
+                                      leading=14,
+                                      spaceAfter=10))
+
+            # Ajout d'un style personnalisé pour les titres de section
+            styles.add(ParagraphStyle(name='CustomHeading1',
+                                      parent=styles['Heading1'],
+                                      fontSize=18,
+                                      leading=22,
+                                      spaceBefore=20,
+                                      spaceAfter=6,
+                                      textColor=colors.HexColor("#2c3e50"))) # Couleur bleu foncé
+
+            # Ajout d'un style personnalisé pour les titres de sous-section
+            styles.add(ParagraphStyle(name='CustomHeading2',
+                                      parent=styles['Heading2'],
+                                      fontSize=14,
+                                      leading=18,
+                                      spaceBefore=10,
+                                      spaceAfter=4,
+                                      textColor=colors.HexColor("#34495e"))) # Couleur bleu-gris
+
+            # Séparer le contenu en sections en utilisant les sauts de ligne comme délimiteurs
+            sections = content.split("\n\n")
+
+            Story = []
+            for section in sections:
+                # Déterminer si la section est un titre de section, un titre de sous-section ou du texte normal
+                if section.startswith("# "):
+                    # Titre de section
+                    title = section[2:].strip()
+                    Story.append(Paragraph(title, styles["CustomHeading1"]))
+                elif section.startswith("## "):
+                    # Titre de sous-section
+                    subtitle = section[3:].strip()
+                    Story.append(Paragraph(subtitle, styles["CustomHeading2"]))
+                else:
+                    # Texte normal
+                    Story.append(Paragraph(section, styles["CustomBodyText"]))
+
+            doc.build(Story)
+            return f"Fichier PDF généré avec succès : {output_path}"
+        except Exception as e:
+            return f"Erreur lors de la génération du PDF : {e}"
+
+
+# --- Crew utilities from crew_utils.py ---
+
+# --- Définition des outils ---
+search_tool = SerperDevTool()
+pdf_tool = PDFTool()
+
+# --- Définition du LLM (Gemini) ---
+# Remplace par ta clé API
+GEMINI_API_KEY = "AIzaSyD6yZxfVOnh63GXBJjakAupk9aP4CZrgrQ"
+llm = LLM(
+    model="gemini/gemini-1.5-flash",
+    temperature=0.7,
+    timeout=120,           # Seconds to wait for response
+    max_tokens=8000,
+)
+
+
+# --- Définition des agents ---
+# Chef de Projet
+project_manager = Agent(
+    role="Chef de Projet",
+    goal="Coordonner la création d'un exposé complet et de haute qualité sur le thème donné.",
+    backstory="Expert en gestion de projet et en coordination d'équipes, capable de diriger des projets complexes jusqu'à leur aboutissement.",
+    verbose=True,
+    llm=llm,
+    allow_delegation=True,
+)
+
+# Planificateur
+planner = Agent(
+    role="Planificateur d'Exposé",
+    goal="Créer un plan détaillé et pertinent pour l'exposé.",
+    backstory="Spécialiste de la structuration de contenu, capable de générer des plans clairs et logiques pour des exposés complexes.",
+    verbose=True,
+    llm=llm,
+)
+
+# Rédacteurs (3 instances pour gérer l'introduction, le développement et la conclusion)
+researcher_intro = Agent(
+    role="Rédacteur Spécialisé en Introduction",
+    goal="Rédiger une introduction captivante pour l'exposé.",
+    backstory="Expert en recherche et en rédaction, capable de produire du contenu informatif et bien écrit sur des sujets variés.",
+    verbose=True,
+    llm=llm,
+    tools=[search_tool],
+)
+
+researcher_dev = Agent(
+    role="Rédacteur Spécialisé en Développement",
+    goal="Rédiger les sections de développement de l'exposé.",
+    backstory="Expert en recherche et en rédaction, capable de produire du contenu informatif et bien écrit sur des sujets variés.",
+    verbose=True,
+    llm=llm,
+    tools=[search_tool],
+)
+
+researcher_conclusion = Agent(
+    role="Rédacteur Spécialisé en Conclusion",
+    goal="Rédiger une conclusion percutante pour l'exposé.",
+    backstory="Expert en recherche et en rédaction, capable de produire du contenu informatif et bien écrit sur des sujets variés.",
+    verbose=True,
+    llm=llm,
+    tools=[search_tool],
+)
+
+# Assembleur
+assembler = Agent(
+    role="Assembleur d'Exposé",
+    goal="Compiler toutes les sections rédigées de l'exposé dans un seul document et générer un document PDF final de qualité professionnelle.",
+    backstory="Expert en mise en forme et en compilation de documents, capable de transformer des contenus distincts en un document final harmonieux et esthétique.",
+    verbose=True,
+    llm=llm,
+    tools=[pdf_tool],
+)
+
+# --- Définition des tâches ---
+# Tâche pour le Planificateur
+create_plan_task = Task(
+    description="""
+        Créez un plan détaillé pour un exposé sur le thème suivant : {topic}.
+        Le plan doit inclure une introduction, plusieurs sections principales (au moins 3), et une conclusion.
+        Assurez-vous que le plan est logique et couvre tous les aspects importants du sujet.
+        Divisez les sections principales en sous-sections si nécessaire pour une meilleure organisation.
+    """,
+    expected_output="Un plan d'exposé structuré avec des titres de sections et sous-sections, en format Markdown.",
+    agent=planner,
+)
+
+class SectionContent(BaseModel):
+    title: str = Field(..., description="Titre de la section")
+    content: str = Field(..., description="Contenu de la section")
+
+# Tâches pour les Rédacteurs (exemple pour 3 sections, à adapter)
+async def write_section_task(
+        researcher: Agent, section_title: str, context: List[Task]
+    ) -> Task:
+    return Task(
+        description=f"""
+            Rédigez la section '{section_title}' de l'exposé en vous basant sur le plan fourni.
+            Effectuez des recherches approfondies en utilisant l'outil de recherche pour enrichir le contenu.
+            La section doit être informative, bien écrite et doit respecter le ton académique d'un exposé.
+            Voici le contexte: {context}
+        """,
+        expected_output=f"Texte complet et bien rédigé pour la section '{section_title}' de l'exposé, au format Markdown.",
+        agent=researcher,
+        tools=[search_tool],
+        output_pydantic=SectionContent,  # Utilisez le modèle Pydantic ici
+        context=context,
+    )
+
+# Tâche pour l'Assembleur
+compile_report_task = Task(
+    description="""
+        Compilez toutes les sections rédigées de l'exposé dans un seul document.
+        Organisez les sections selon le plan fourni par le planificateur.
+        Générez un document PDF final prêt pour la présentation.
+        Assurez-vous que le document est bien structuré, facile à lire et qu'il respecte les conventions d'un exposé académique.
+        Voici le contexte: {context}
+    """,
+    expected_output="Un document PDF complet de l'exposé, prêt à être présenté.",
+    agent=assembler,
+    tools=[pdf_tool],
+)
+
+# --- Orchestration des tâches avec un processus hiérarchique ---
+async def process_section_tasks(
+    manager: Agent,
+    plan: Any, # Remplace Any par le type de retour attendu de la tâche create_plan_task
+    researchers: List[Agent],
+):
+    # Assume que plan est une liste de titres de sections
+    sections = plan.split("\n") # Adapter selon le format réel du plan
+    section_tasks: List[Task] = []
+
+    for i, section in enumerate(sections):
+        if section != "":
+            researcher = researchers[i % len(researchers)]
+            section_task = await write_section_task(
+                researcher=researcher,
+                section_title=section.strip(),
+                context=[create_plan_task],
+            )
+            section_tasks.append(section_task)
+
+    return section_tasks
+
+class ExposeCrew(Crew):
+    def __init__(self, agents, tasks, process, manager_llm, verbose):
+        super().__init__(agents=agents, tasks=tasks, process=process, manager_llm=manager_llm, verbose=verbose)
+
+    async def kickoff(self, inputs: dict = {}) -> str:
+        # Exécuter la tâche de création du plan
+        plan = await create_plan_task.execute(context=inputs)
+        self.log.info(f"Plan de l'exposé : {plan}")
+
+        # Créer et exécuter les tâches de rédaction de section en parallèle
+        section_tasks = await process_section_tasks(
+            manager=self.manager_llm,
+            plan=plan,
+            researchers=[researcher_intro, researcher_dev, researcher_conclusion],
+        )
+        
+        sections_results = await asyncio.gather(*[task.execute(context=[create_plan_task]) for task in section_tasks])
+        section_outputs = [result.content for result in sections_results]
+
+        self.log.info(f"Sections rédigées : {section_outputs}")
+
+        # Mettre à jour la description de la tâche de compilation avec les sections rédigées
+        compile_report_task.description = f"""
+            Compilez toutes les sections rédigées de l'exposé dans un seul document.
+            Organisez les sections selon le plan fourni par le planificateur :
+            {plan}
+            Sections rédigées :
+            {section_outputs}
+            Générez un document PDF final prêt pour la présentation.
+        """
+        compile_report_task.context = section_tasks
+
+        # Exécuter la tâche de compilation
+        result = await compile_report_task.execute()
+        return result
+
+# --- Streamlit App from app.py ---
 
 async def run_crew(topic):
     """Exécute le crew pour générer l'exposé."""
@@ -41,7 +290,7 @@ if st.button("Générer l'exposé"):
         with st.spinner("Création de l'exposé en cours..."):
             try:
                 # Exécuter le crew de manière asynchrone
-                result = asyncio.run(run_crew(topic))
+                result = await asyncio.run(run_crew(topic))
                 st.success("Exposé généré avec succès!")
 
                 # Téléchargement du fichier PDF