Update app.py

app.py

@@ -3,22 +3,18 @@
 # === Imports ===
 import gradio as gr
 import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer, pipeline
 from datetime import datetime
 import os
 import json
 import logging
 from huggingface_hub import login
-
-# --- Imports spécifiques pour l'AgentResearcher ---
 import requests
 from bs4 import BeautifulSoup
-import logging
 from concurrent.futures import ThreadPoolExecutor
+import re
 
-login(token=os.environ["HF_TOKEN"])
-
-# === Configuration du logger ===
+# --- Configuration du logger ---
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(levelname)s - %(message)s",
@@ -28,8 +24,14 @@ logging.basicConfig(
     ]
 )
 
+# --- Authentification Hugging Face ---
+# Assurez-vous que la variable d'environnement HF_TOKEN est définie avec votre token Hugging Face
+# Sinon, vous pouvez la définir directement ici
+# os.environ["HF_TOKEN"] = "votre_token_huggingface"
+login(token=os.environ["HF_TOKEN"])
+
 # === Chargement des modèles ===
-# Chargement du modèle pour l'AgentManager
+# AgentManager
 manager_model_name = "meta-llama/Llama-3.1-8B-Instruct"
 manager_model = AutoModelForCausalLM.from_pretrained(
     manager_model_name,
@@ -56,7 +58,6 @@ analyzer_model = AutoModelForCausalLM.from_pretrained(
 )
 analyzer_tokenizer = AutoTokenizer.from_pretrained(analyzer_model_name)
 
-# AgentCoder
 # AgentCoder
 coder_model_name = "Qwen/Qwen2.5-Coder-14B-Instruct"
 coder_model = AutoModelForCausalLM.from_pretrained(
@@ -113,18 +114,7 @@ Vous êtes un assistant d'analyse. Vos tâches sont :
 5. Votre réponse doit commencer par 'Validité: Oui' ou 'Validité: Non', suivi du rapport d'analyse.
 """
 
-coder_prompt_template = """
-System: Vous êtes un assistant de codage. Votre tâche est de :
-1. Générer du code basé sur le résumé structuré validé suivant :
-{structured_summary}
-2. Incorporer les résultats de recherche suivants :
-{search_results}
-"""
-
-# === Définition des fonctions pour chaque agent ===
-
-
-# === Fonctions Utilitaires de l'agentManager ===
+# === Fonctions Utilitaires de l'AgentManager ===
 def get_variables_context():
     variables = {}
     for agent, data in project_state.items():
@@ -143,10 +133,8 @@ def update_project_state(modifications):
         target[keys[-1]] = value
 
 def extract_modifications(user_input):
-    # Extraction simplifiée pour l'exemple
     modifications = {}
     if "modifie" in user_input.lower():
-        import re
         matches = re.findall(r"modifie la variable (\w+(?:\.\w+)*) à (.+)", user_input, re.IGNORECASE)
         for match in matches:
             var_name, var_value = match
@@ -189,17 +177,15 @@ def agent_manager(chat_history, user_input):
         return response, chat_history, False
 
     # Générer la réponse
-    prompt = ""
-    for msg in conversation:
-        prompt += f"{msg['role']}: {msg['content']}\n"
+    prompt = manager_tokenizer.apply_chat_template(conversation, add_generation_prompt=True, tokenize=False)
 
-    input_ids = manager_tokenizer.encode(prompt, return_tensors="pt").to(manager_model.device)
+    input_ids = manager_tokenizer(prompt, return_tensors="pt").to(manager_model.device)
     output_ids = manager_model.generate(
-        input_ids,
+        input_ids["input_ids"],
         max_new_tokens=256,
         eos_token_id=manager_tokenizer.eos_token_id,
         pad_token_id=manager_tokenizer.pad_token_id,
-        attention_mask=input_ids.new_ones(input_ids.shape)
+        attention_mask=input_ids["attention_mask"]
     )
     response = manager_tokenizer.decode(output_ids[0], skip_special_tokens=True)
 
@@ -214,12 +200,7 @@ def agent_manager(chat_history, user_input):
         return response, chat_history, False
 
 # --- AgentResearcher ---
-# Fonctions spécifiques pour les recherches dynamiques
-
 def fetch_webpage(url: str) -> str:
-    """
-    Télécharge le contenu HTML d'une URL donnée.
-    """
     try:
         response = requests.get(url, timeout=10)
         response.raise_for_status()
@@ -230,9 +211,6 @@ def fetch_webpage(url: str) -> str:
         return ""
 
 def extract_information_from_html(html: str, keyword: str) -> list:
-    """
-    Extrait des informations pertinentes depuis le HTML en fonction d'un mot-clé.
-    """
     try:
         soup = BeautifulSoup(html, "html.parser")
         results = []
@@ -246,9 +224,6 @@ def extract_information_from_html(html: str, keyword: str) -> list:
         return []
 
 def search_gradio_docs(query: str) -> dict:
-    """
-    Recherche dans la documentation Gradio les sections pertinentes pour une requête donnée.
-    """
     url = "https://gradio.app/docs/"
     logging.info(f"Lancement de la recherche pour la requête : {query}")
     html_content = fetch_webpage(url)
@@ -282,14 +257,14 @@ def agent_researcher():
     ]
 
     output_ids = researcher_model.generate(
-        input_ids,
+        input_ids["input_ids"],
         max_new_tokens=512,
         eos_token_id=terminators,
         do_sample=True,
         temperature=0.6,
         top_p=0.9,
     )
-    response_ids = output_ids[0][input_ids.shape[-1]:]
+    response_ids = output_ids[0][input_ids["input_ids"].shape[-1]:]
     response = researcher_tokenizer.decode(response_ids, skip_special_tokens=True)
 
     # Parser la réponse JSON
@@ -331,7 +306,7 @@ def agent_analyzer():
     prompt = analyzer_tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
 
     # Création du pipeline
-    analyzer_pipeline = transformers.pipeline(
+    analyzer_pipeline = pipeline(
         "text-generation",
         model=analyzer_model,
         tokenizer=analyzer_tokenizer,
@@ -435,20 +410,128 @@ def user_interaction(message, chat_history):
 
 # === Interface Gradio ===
 with gr.Blocks() as interface:
-    chatbot = gr.Chatbot()
-    state = gr.State([])
-    msg = gr.Textbox(placeholder="Entrez votre message ici...")
-    send_btn = gr.Button("Envoyer")
+    with gr.Tabs():
+        # Onglet "Chat"
+        with gr.Tab("Chat"):
+            with gr.Row():
+                # Colonne gauche : Chat principal
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(label="Chat Principal")
+                    state = gr.State([])  # Historique des messages
+                    msg = gr.Textbox(placeholder="Entrez votre message ici...")
+                    send_btn = gr.Button("Envoyer")
+
+                # Colonne droite : Statut des agents et logs
+                with gr.Column(scale=2):
+                    agent_status_chat = gr.Chatbot(label="Suivi des Agents")
+                    logs_box = gr.Textbox(
+                        value="",
+                        lines=10,
+                        interactive=False,
+                        placeholder="Logs d'exécution",
+                        label="Logs",
+                    )
+
+        # Onglet "Output"
+        with gr.Tab("Output"):
+            output_code = gr.Code(
+                value="# Le code généré sera affiché ici.\n",
+                language="python",
+                label="Code Final",
+            )
+
+    # === Fonctions de mise à jour des statuts et logs ===
+    def update_agent_status_and_logs(chat_history):
+        """
+        Met à jour les messages des agents et les logs d'exécution.
+        """
+        # Initialisation des messages
+        agent_status_messages = []
+
+        # AgentManager
+        structured_summary = project_state["AgentManager"]["structured_summary"]
+        if structured_summary:
+            manager_message = f"AgentManager : Résumé structuré disponible.\n{structured_summary}"
+        else:
+            manager_message = "AgentManager : En attente d'informations de l'utilisateur."
+        agent_status_messages.append(("AgentManager", manager_message))
+
+        # AgentResearcher
+        researcher_result = project_state["AgentResearcher"]["search_results"]
+        if researcher_result:
+            researcher_message = (
+                f"AgentResearcher : Résultats obtenus\n"
+                f"Documentation : {researcher_result.get('documentation', 'N/A')}\n"
+                f"Extraits de code : {researcher_result.get('extraits_code', 'N/A')}"
+            )
+        else:
+            researcher_message = "AgentResearcher : Recherche en cours..."
+        agent_status_messages.append(("AgentResearcher", researcher_message))
+
+        # AgentAnalyzer
+        analysis_report = project_state["AgentAnalyzer"]["analysis_report"]
+        if analysis_report:
+            analyzer_message = (
+                f"AgentAnalyzer : Analyse terminée\n"
+                f"{analysis_report}"
+            )
+        else:
+            analyzer_message = "AgentAnalyzer : Analyse en cours..."
+        agent_status_messages.append(("AgentAnalyzer", analyzer_message))
 
-    def respond(message, chat_history):
+        # AgentCoder
+        final_code = project_state["AgentCoder"]["final_code"]
+        if final_code:
+            coder_message = "AgentCoder : Code généré avec succès ✔️"
+        else:
+            coder_message = "AgentCoder : En attente des instructions."
+        agent_status_messages.append(("AgentCoder", coder_message))
+
+        # Logs
+        logs = ""
+        with open("project.log", "r") as log_file:
+            logs = log_file.read()
+
+        return agent_status_messages, logs
+
+    # === Fonction principale de réponse ===
+    def respond(message, chat_history, agent_chat):
+        """
+        Gestion des interactions principales et mise à jour des statuts/logs.
+        """
+        # Mettre à jour le chat principal
         updated_chat_history, _ = user_interaction(message, chat_history)
-        bot_message = updated_chat_history[-1]['assistant']
-        chatbot.append((message, bot_message))
-        return chatbot, updated_chat_history
+        bot_message = updated_chat_history[-1]["assistant"]
+
+        # Mettre à jour le statut des agents et les logs
+        agent_status, logs = update_agent_status_and_logs(updated_chat_history)
 
-    send_btn.click(respond, inputs=[msg, state], outputs=[chatbot, state])
-    msg.submit(respond, inputs=[msg, state], outputs=[chatbot, state])
+        # Mettre à jour le chatbot des agents
+        agent_chat.clear()
+        for agent_name, msg_content in agent_status:
+            agent_chat.append((agent_name, msg_content))
+
+        # Générer le code final si disponible
+        generated_code = project_state["AgentCoder"].get("final_code", "")
+        if not generated_code:
+            generated_code = "# Aucun code n'a encore été généré."
+        else:
+            generated_code = f"{generated_code}"
+
+        return chatbot.update([(message, bot_message)]), updated_chat_history, agent_chat.update(), logs, generated_code
+
+    # === Actions des boutons et soumission ===
+    send_btn.click(
+        respond,
+        inputs=[msg, state, agent_status_chat],
+        outputs=[chatbot, state, agent_status_chat, logs_box, output_code],
+    )
+    msg.submit(
+        respond,
+        inputs=[msg, state, agent_status_chat],
+        outputs=[chatbot, state, agent_status_chat, logs_box, output_code],
+    )
 
+# Lancer l'interface
 if __name__ == "__main__":
-    interface.launch()
-    
+    interface.launch()