llm_ticket3/.specstory/history/2025-04-07_07-17-analyse-de-code-et-ajout-de-logs.md

Analyse de code et ajout de logs (2025-04-07 09:17:58)

User

il faudrait que tu analyses mon code et que tu m'aides avec précision pour ajouter des logs ainsi que des print statement dans les endroits indispensables dans mon code car le fichier de test s'execute sans problème mais je ne retrouve aucun résultat il doit y avoir un soucis quelque part. Allons-y méthodiquement pour vérifier l'execution du programme

---

Assistant

Je vais analyser votre code pour trouver où ajouter des logs et des instructions d'affichage afin de comprendre pourquoi votre test s'exécute sans produire de résultats. Commençons par explorer la structure du projet.

---

Listed current directory • **22** results

Name
📄 orchestrator.py
📁 __pycache__
📄 test_orchestrator.py
📁 .git
📁 agents
📁 llm_classes
📄 .gitignore
📁 .specstory
📄 orchestrator.py.backup
📄 orchestrator.py.new
📄 test_agents_with_models.py
📁 utils
📁 output
📁 prompt
📄 retrieve_ticket.log
📄 retrieve_ticket.py
📄 config.json
📄 README.md
📄 config.template.json
📄 requirements.txt
📁 venv
📁 data

---

Maintenant, examinons le fichier de test pour comprendre ce que vous essayez d'exécuter.

---

Read file: test_orchestrator.py

---

Examinons maintenant le fichier orchestrator.py pour comprendre son fonctionnement:

---

Read file: orchestrator.py

---

Vérifions si le dossier de sortie contient des données:

---

Listed directory output • **12** results

Name
📁 ticket_T0150
📁 ticket_T0131
📁 ticket_T0129
📁 ticket_T0128
📁 ticket_T0124
📁 ticket_T0167
📁 ticket_T0101
📁 ticket_T0201
📁 ticket_T0182
📁 ticket_T0125
📁 ticket_T11067
📁 ticket_T0282

---

Examinons maintenant l'implémentation des agents pour comprendre leur fonctionnement:

---

Listed directory agents • **8** results

Name
📄 agent_report_generator.py
📄 agent_image_analyser.py
📄 agent_image_sorter.py
📄 agent_json_analyser.py
📄 base_agent.py
📁 __pycache__
📁 utils
📄 agent_report_generator.py.backup

---

Examinons la classe de base des agents:

---

Read file: agents/base_agent.py

---

Examinons l'implémentation d'un des agents (JSON Analyser) pour comprendre le fonctionnement:

---

Read file: agents/agent_json_analyser.py

---

Examinons l'implémentation d'une classe LLM pour comprendre comment elle gère les réponses:

---

Listed directory llm_classes • **10** results

Name
📁 __pycache__
📄 ollama.py
📄 base_llm.py
📄 mistral_large.py
📄 mistral_large_pixtral2411.py
📄 mistral_medium.py
📄 pixtral_12b.py
📄 pixtral_large.py
📄 pixtral_medium.py
📁 utils

---

Read file: llm_classes/base_llm.py

---

Read file: llm_classes/mistral_large.py

---

Après avoir analysé votre code, j'ai identifié plusieurs endroits où l'ajout de logs pourrait aider à comprendre le problème. Voici les modifications à apporter:

1. D'abord, modifions l'orchestrator.py pour ajouter plus de logs:

import os
import json
import logging
from typing import List, Dict, Any, Optional
from agents.base_agent import BaseAgent

# Configuration du logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', 
                    filename='orchestrator.log', filemode='w')
logger = logging.getLogger("Orchestrator")

class Orchestrator:
    def __init__(self, 
                 output_dir: str = "output/", 
                 json_agent: Optional[BaseAgent] = None,
                 image_sorter: Optional[BaseAgent] = None,
                 image_analyser: Optional[BaseAgent] = None,
                 report_generator: Optional[BaseAgent] = None):
        
        self.output_dir = output_dir
        
        # Assignation directe des agents (qui peuvent être injectés lors des tests)
        self.json_agent = json_agent
        self.image_sorter = image_sorter
        self.image_analyser = image_analyser
        self.report_generator = report_generator
        
        logger.info(f"Orchestrator initialisé avec output_dir: {output_dir}")
        logger.info(f"JSON Agent: {json_agent}")
        logger.info(f"Image Sorter: {image_sorter}")
        logger.info(f"Image Analyser: {image_analyser}")
        logger.info(f"Report Generator: {report_generator}")

    def detecter_tickets(self) -> List[str]:
        logger.info(f"Recherche de tickets dans: {self.output_dir}")
        tickets = []
        for ticket_dir in os.listdir(self.output_dir):
            ticket_path = os.path.join(self.output_dir, ticket_dir)
            if os.path.isdir(ticket_path) and ticket_dir.startswith("ticket_"):
                tickets.append(ticket_path)
        
        logger.info(f"Tickets trouvés: {tickets}")
        print(f"Tickets détectés: {len(tickets)}")
        return tickets

    def traiter_ticket(self, ticket_path: str):
        logger.info(f"Début du traitement du ticket: {ticket_path}")
        print(f"Traitement du ticket: {ticket_path}")
        
        extractions_trouvees = False
        for extraction in os.listdir(ticket_path):
            extraction_path = os.path.join(ticket_path, extraction)
            if os.path.isdir(extraction_path):
                extractions_trouvees = True
                logger.info(f"Traitement de l'extraction: {extraction_path}")
                print(f"  Traitement de l'extraction: {extraction}")
                
                attachments_dir = os.path.join(extraction_path, "attachments")
                rapport_json_path = os.path.join(extraction_path, f"{extraction.split('_')[0]}_rapport.json")
                rapports_dir = os.path.join(extraction_path, f"{extraction.split('_')[0]}_rapports")
                
                logger.info(f"Vérification des chemins: rapport_json_path={rapport_json_path}, existe={os.path.exists(rapport_json_path)}")
                print(f"  Vérification du rapport JSON: {os.path.exists(rapport_json_path)}")
                
                os.makedirs(rapports_dir, exist_ok=True)

                if os.path.exists(rapport_json_path):
                    with open(rapport_json_path, 'r', encoding='utf-8') as file:
                        ticket_json = json.load(file)
                    
                    logger.info(f"Rapport JSON chargé: {rapport_json_path}")
                    
                    if self.json_agent:
                        logger.info("Exécution de l'agent JSON")
                        print("  Analyse du JSON en cours...")
                        json_analysis = self.json_agent.executer(ticket_json)
                        logger.info(f"Résultat de l'analyse JSON: {json_analysis[:100]}...")
                    else:
                        logger.warning("Agent JSON non disponible")
                        json_analysis = None

                    relevant_images = []
                    if os.path.exists(attachments_dir):
                        logger.info(f"Vérification des pièces jointes dans: {attachments_dir}")
                        print(f"  Vérification des pièces jointes: {attachments_dir}")
                        
                        images_count = 0
                        for attachment in os.listdir(attachments_dir):
                            attachment_path = os.path.join(attachments_dir, attachment)
                            if attachment.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
                                images_count += 1
                                logger.info(f"Image trouvée: {attachment_path}")
                                
                                if self.image_sorter:
                                    logger.info(f"Analyse de la pertinence de l'image: {attachment_path}")
                                    print(f"    Analyse de la pertinence de l'image: {attachment}")
                                    is_relevant = self.image_sorter.executer(attachment_path)
                                    logger.info(f"Image pertinente: {is_relevant}")
                                    if is_relevant:
                                        relevant_images.append(attachment_path)
                                else:
                                    logger.warning("Image Sorter non disponible")
                        
                        logger.info(f"Images analysées: {images_count}, Images pertinentes: {len(relevant_images)}")
                        print(f"  Images analysées: {images_count}, Images pertinentes: {len(relevant_images)}")
                    else:
                        logger.warning(f"Répertoire des pièces jointes non trouvé: {attachments_dir}")
                        print(f"  Répertoire des pièces jointes non trouvé: {attachments_dir}")

                    image_analysis_results = {}
                    for image_path in relevant_images:
                        if self.image_analyser and json_analysis:
                            logger.info(f"Analyse de l'image: {image_path}")
                            print(f"  Analyse de l'image: {os.path.basename(image_path)}")
                            image_analysis_results[image_path] = self.image_analyser.executer(
                                image_path, 
                                contexte=json_analysis
                            )
                            logger.info(f"Résultat de l'analyse d'image: {image_analysis_results[image_path][:100]}...")
                    
                    rapport_data = {
                        "analyse_json": json_analysis,
                        "analyse_images": image_analysis_results
                    }
                    
                    if self.report_generator:
                        logger.info("Génération du rapport final")
                        print("  Génération du rapport final")
                        rapport_path = os.path.join(rapports_dir, extraction.split('_')[0])
                        self.report_generator.executer(rapport_data, rapport_path)
                        logger.info(f"Rapport généré à: {rapport_path}")
                        print(f"  Rapport généré à: {rapport_path}")
                    else:
                        logger.warning("Report Generator non disponible")

                    print(f"Traitement du ticket {ticket_path} terminé.\n")
                    logger.info(f"Traitement du ticket {ticket_path} terminé.")
                else:
                    logger.warning(f"Fichier rapport JSON non trouvé: {rapport_json_path}")
                    print(f"  ERREUR: Fichier rapport JSON non trouvé: {rapport_json_path}")
        
        if not extractions_trouvees:
            logger.warning(f"Aucune extraction trouvée dans le ticket: {ticket_path}")
            print(f"  ERREUR: Aucune extraction trouvée dans le ticket: {ticket_path}")

    def executer(self):
        logger.info("Début de l'exécution de l'orchestrateur")
        print("Début de l'exécution de l'orchestrateur")
        
        tickets = self.detecter_tickets()
        if not tickets:
            logger.warning("Aucun ticket détecté dans le répertoire de sortie")
            print("ATTENTION: Aucun ticket détecté dans le répertoire de sortie")
        
        for ticket in tickets:
            self.traiter_ticket(ticket)
        
        logger.info("Fin de l'exécution de l'orchestrateur")
        print("Fin de l'exécution de l'orchestrateur")

2. Modifions également la classe AgentJsonAnalyser pour ajouter des logs:

from .base_agent import BaseAgent
from typing import Dict, Any
import logging

logger = logging.getLogger("AgentJsonAnalyser")

class AgentJsonAnalyser(BaseAgent):
    """
    Agent pour analyser les fichiers JSON et extraire les informations pertinentes.
    """
    def __init__(self, llm):
        super().__init__("AgentJsonAnalyser", llm, "json_analyser")
        logger.info("AgentJsonAnalyser initialisé")
        
    def executer(self, ticket_json: Dict) -> str:
        logger.info(f"Analyse du JSON: {str(ticket_json)[:100]}...")
        prompt = f"Analyse ce ticket JSON et identifie les éléments importants : {ticket_json}"
        
        logger.info("Envoi de la requête au LLM")
        print(f"  AgentJsonAnalyser: Envoi de la requête au LLM {self.llm.modele}")
        response = self.llm.interroger(prompt)
        
        logger.info(f"Réponse reçue: {response[:100]}...")
        self.ajouter_historique("analyse_json", ticket_json, response)
        return response

3. Assurez-vous que les agents image_sorter et image_analyser ont également des logs:

from .base_agent import BaseAgent
import logging

logger = logging.getLogger("AgentImageSorter")

class AgentImageSorter(BaseAgent):
    """
    Agent pour trier les images et identifier celles qui sont pertinentes.
    """
    def __init__(self, llm):
        super().__init__("AgentImageSorter", llm, "image_sorter")
        logger.info("AgentImageSorter initialisé")
        
    def executer(self, image_path: str) -> bool:
        logger.info(f"Évaluation de la pertinence de l'image: {image_path}")
        print(f"    AgentImageSorter: Évaluation de {image_path}")
        
        prompt = f"Détermine si cette image est pertinente pour un ticket technique: {image_path}"
        response = self.llm.interroger(prompt)
        
        # Simple heuristique: si la réponse contient "oui", "pertinent" ou "important"
        is_relevant = any(mot in response.lower() for mot in ["oui", "pertinent", "important", "utile", "yes", "relevant"])
        
        logger.info(f"Image {image_path} considérée comme {'pertinente' if is_relevant else 'non pertinente'}")
        self.ajouter_historique("tri_image", image_path, response)
        return is_relevant

4. Pour confirmer que les tests s'exécutent correctement, modifiez le fichier test_orchestrator.py pour ajouter plus de vérifications:

from orchestrator import Orchestrator
from agents.agent_json_analyser import AgentJsonAnalyser
from agents.agent_image_sorter import AgentImageSorter
from agents.agent_image_analyser import AgentImageAnalyser
from agents.agent_report_generator import AgentReportGenerator

from llm_classes.mistral_large import MistralLarge
from llm_classes.pixtral_12b import Pixtral12b
from llm_classes.ollama import Ollama

import os
import logging

# Configuration du logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', 
                    filename='test_orchestrator.log', filemode='w')
logger = logging.getLogger("TestOrchestrator")

def test_orchestrator():
    # Vérifier que le dossier output existe
    if not os.path.exists("output/"):
        os.makedirs("output/")
        logger.warning("Le dossier output/ n'existait pas et a été créé")
        print("ATTENTION: Le dossier output/ n'existait pas et a été créé")
    
    # Vérifier le contenu du dossier output
    tickets = [d for d in os.listdir("output/") if d.startswith("ticket_") and os.path.isdir(os.path.join("output/", d))]
    logger.info(f"Tickets trouvés dans output/: {tickets}")
    print(f"Tickets existants dans output/: {tickets}")
    
    # Initialisation des LLM
    json_llm = MistralLarge()
    logger.info("LLM MistralLarge initialisé")
    print("LLM MistralLarge initialisé")
    
    image_sorter_llm = Pixtral12b()
    logger.info("LLM Pixtral12b initialisé")
    print("LLM Pixtral12b initialisé")
    
    image_analyser_llm = Ollama()
    logger.info("LLM Ollama initialisé")
    print("LLM Ollama initialisé")
    
    report_generator_llm = MistralLarge()
    logger.info("Deuxième LLM MistralLarge initialisé")
    print("Deuxième LLM MistralLarge initialisé")
    
    # Création des agents
    json_agent = AgentJsonAnalyser(json_llm)
    logger.info("Agent JSON analyser initialisé")
    print("Agent JSON analyser initialisé")
    
    image_sorter = AgentImageSorter(image_sorter_llm)
    logger.info("Agent Image sorter initialisé")
    print("Agent Image sorter initialisé")
    
    image_analyser = AgentImageAnalyser(image_analyser_llm)
    logger.info("Agent Image analyser initialisé")
    print("Agent Image analyser initialisé")
    
    report_generator = AgentReportGenerator(report_generator_llm)
    logger.info("Agent Rapport générateur initialisé")
    print("Agent Rapport générateur initialisé")
    
    # Initialisation de l'orchestrateur avec les agents
    logger.info("Initialisation de l'orchestrateur")
    print("Initialisation de l'orchestrateur")
    
    orchestrator = Orchestrator(
        output_dir="output/",
        json_agent=json_agent,
        image_sorter=image_sorter,
        image_analyser=image_analyser,
        report_generator=report_generator
    )
    
    # Exécution complète de l'orchestrateur
    logger.info("Début de l'exécution de l'orchestrateur")
    print("Début de l'exécution de l'orchestrateur")
    
    orchestrator.executer()
    
    logger.info("Fin de l'exécution de l'orchestrateur")
    print("Fin de l'exécution de l'orchestrateur")

if __name__ == "__main__":
    print("Démarrage du test de l'orchestrateur")
    test_orchestrator()
    print("Test terminé")

Avec ces modifications, vous aurez:

1. Des logs détaillés dans les fichiers orchestrator.log et test_orchestrator.log
2. Des affichages console plus explicites pour suivre le flux d'exécution
3. Des vérifications supplémentaires dans la fonction de test pour s'assurer que les conditions préalables sont remplies
4. Des messages explicites à chaque étape critique de l'exécution

Ces modifications vous aideront à identifier où le processus s'arrête ou échoue. Exécutez le test et examinez les fichiers de log pour comprendre pourquoi aucun résultat n'est produit.

---

User

il faut surement mettre a jour cette gestion des logs et print dans les autres agents de mon programme@agent_image_analyser.py @agent_report_generator.py

---

Assistant

Pour améliorer la gestion des logs et des instructions d'affichage dans les fichiers agent_image_analyser.py et agent_report_generator.py, voici les modifications à apporter :

1. Mise à jour de agent_image_analyser.py

Ajoutons des logs pour suivre l'exécution de l'agent d'analyse d'images :

from .base_agent import BaseAgent
from typing import Any
import logging

logger = logging.getLogger("AgentImageAnalyser")

class AgentImageAnalyser(BaseAgent):
    """
    Agent pour analyser les images et extraire les informations pertinentes.
    """
    def __init__(self, llm):
        super().__init__("AgentImageAnalyser", llm, "image_analyser")
        logger.info("AgentImageAnalyser initialisé")
        
    def executer(self, image_description: str, contexte: str) -> str:
        logger.info(f"Analyse de l'image: {image_description} avec le contexte: {contexte}")
        prompt = f"Analyse cette image en tenant compte du contexte suivant : {contexte}. Description de l'image : {image_description}"
        
        logger.info("Envoi de la requête au LLM")
        response = self.llm.interroger(prompt)
        
        logger.info(f"Réponse reçue pour l'image {image_description}: {response[:100]}...")
        self.ajouter_historique("analyse_image", {"image": image_description, "contexte": contexte}, response)
        return response

2. Mise à jour de agent_report_generator.py

Ajoutons également des logs pour suivre la génération des rapports :

import json
import os
from .base_agent import BaseAgent
from datetime import datetime
from typing import Dict, Any, Tuple
import logging

logger = logging.getLogger("AgentReportGenerator")

class AgentReportGenerator(BaseAgent):
    """
    Agent pour générer un rapport à partir des informations collectées.
    """
    def __init__(self, llm):
        super().__init__("AgentReportGenerator", llm, "report_generator")
        logger.info("AgentReportGenerator initialisé")
        
    def executer(self, rapport_data: Dict, filename: str) -> Tuple[str, str]:
        logger.info(f"Génération du rapport pour le fichier: {filename}")
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        
        # Ajouter les métadonnées des LLM utilisés
        if "metadata" not in rapport_data:
            rapport_data["metadata"] = {}
        
        rapport_data["metadata"]["report_generator"] = {
            "model": getattr(self.llm, "modele", str(type(self.llm))),
            "configuration": self.config.to_dict()
        }
        
        # Créer les dossiers si nécessaire
        reports_dir = "../reports"
        json_dir = os.path.join(reports_dir, "json_reports")
        md_dir = os.path.join(reports_dir, "markdown_reports")
        os.makedirs(json_dir, exist_ok=True)
        os.makedirs(md_dir, exist_ok=True)
        
        # Sauvegarde JSON
        json_path = f"{json_dir}/{filename}_{timestamp}.json"
        with open(json_path, "w", encoding="utf-8") as f_json:
            json.dump(rapport_data, f_json, ensure_ascii=False, indent=4)
        
        logger.info(f"Rapport JSON sauvegardé à: {json_path}")
        
        # Sauvegarde Markdown
        md_path = f"{md_dir}/{filename}_{timestamp}.md"
        with open(md_path, "w", encoding="utf-8") as f_md:
            # En-tête du rapport
            ticket_id = rapport_data.get("ticket_id", filename)
            f_md.write(f"# Rapport d'Analyse du Ticket {ticket_id}\n\n")
            f_md.write(f"*Généré le: {datetime.now().strftime('%d/%m/%Y à %H:%M:%S')}*\n\n")
            
            # Résumé
            metadata = rapport_data.get("metadata", {})
            etapes = metadata.get("etapes", [])
            f_md.write("## Résumé\n\n")
            f_md.write(f"- **ID Ticket**: {ticket_id}\n")
            f_md.write(f"- **Date d'analyse**: {metadata.get('timestamp_debut', timestamp)}\n")
            f_md.write(f"- **Nombre d'étapes**: {len(etapes)}\n\n")
            
            # Vue d'ensemble des agents et modèles utilisés
            f_md.write("## Modèles et Paramètres Utilisés\n\n")
            f_md.write("### Vue d'ensemble\n\n")
            f_md.write("| Agent | Modèle | Température | Top-P | Max Tokens |\n")
            f_md.write("|-------|--------|-------------|-------|------------|\n")
            
            for agent_name in ["json_agent", "image_sorter", "image_analyser", "report_generator"]:
                agent_info = metadata.get(agent_name, {})
                if agent_info.get("status") == "non configuré":
                    continue
                    
                model = agent_info.get("model", "N/A")
                config = agent_info.get("configuration", {}).get("config", {})
                temp = config.get("temperature", "N/A")
                top_p = config.get("top_p", "N/A")
                max_tokens = config.get("max_tokens", "N/A")
                
                f_md.write(f"| {agent_name} | {model} | {temp} | {top_p} | {max_tokens} |\n")
                
            f_md.write("\n")
            
            # Détails des paramètres par agent
            f_md.write("### Détails des Paramètres\n\n")
            f_md.write("```json\n")
            agents_config = {}
            for agent_name in ["json_agent", "image_sorter", "image_analyser", "report_generator"]:
                if agent_name in metadata and "configuration" in metadata[agent_name]:
                    agents_config[agent_name] = metadata[agent_name]["configuration"]
            f_md.write(json.dumps(agents_config, indent=2))
            f_md.write("\n```\n\n")
            
            # Détails des prompts système
            f_md.write("### Prompts Système\n\n")
            for agent_name in ["json_agent", "image_sorter", "image_analyser

---



---