llm_ticket3/test_orchestrator_llama_vision_new.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Script de test pour exécuter l'orchestrateur sur un ticket spécifique
avec le modèle LlamaVision pour tous les agents.
Utilisation: python test_orchestrator_llama_vision.py [code_ticket]
Exemple: python test_orchestrator_llama_vision.py T0101
"""

import os
import sys
import time
import logging
import traceback
from datetime import datetime

# Import des agents
from agents.llama_vision.agent_ticket_analyser import AgentTicketAnalyser
from agents.llama_vision.agent_image_sorter import AgentImageSorter
from agents.llama_vision.agent_image_analyser import AgentImageAnalyser
from agents.llama_vision.agent_report_generator import AgentReportGenerator

# Import du modèle LLM LlamaVision
from llm_classes.llama_vision import LlamaVision

# Import de l'orchestrateur
from orchestrator import Orchestrator

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

def test_orchestrator_llama_vision(ticket_id=None):
    """
    Exécute l'orchestrateur avec les agents définis utilisant tous LlamaVision
    
    Args:
        ticket_id: Identifiant du ticket à traiter (optionnel)
    """
    # 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/: {len(tickets)}")
    print(f"Tickets existants dans output/: {len(tickets)}")
    
    if len(tickets) == 0:
        logger.error("Aucun ticket trouvé dans le dossier output/")
        print("ERREUR: Aucun ticket trouvé dans le dossier output/")
        return
    
    # Initialisation des LLM
    print("Initialisation du modèle LlamaVision...")
    
    start_time = time.time()
    
    # Valeurs de timeout pour chaque étape
    request_timeout = 400  # 6,5 minutes
    
    # Utilisation de LlamaVision pour tous les agents avec paramètres adaptés
    json_llm = LlamaVision()
    json_llm.configurer(
        temperature=0.1,
        top_p=0.7,
        num_ctx=2048,
        num_predict=2048,
        request_timeout=request_timeout
    )
    logger.info("LLM LlamaVision initialisé pour l'analyse JSON")
    
    image_sorter_llm = LlamaVision()
    image_sorter_llm.configurer(
        temperature=0.1,
        top_p=0.8,
        top_k=30,
        num_ctx=1024,
        request_timeout=request_timeout
    )
    logger.info("LLM LlamaVision initialisé pour le tri d'images")
    
    image_analyser_llm = LlamaVision()
    image_analyser_llm.configurer(
        temperature=0.2,
        top_p=0.8,
        num_ctx=2048,
        request_timeout=request_timeout
    )
    logger.info("LLM LlamaVision initialisé pour l'analyse d'images")
    
    report_generator_llm = LlamaVision()
    report_generator_llm.configurer(
        temperature=0.3,
        top_p=0.8,
        num_ctx=4096,
        num_predict=3000,
        request_timeout=request_timeout
    )
    logger.info("LLM LlamaVision initialisé pour la génération de rapports")
    
    llm_init_time = time.time() - start_time
    print(f"Tous les modèles LlamaVision ont été initialisés en {llm_init_time:.2f} secondes")
    
    # Création des agents
    print("Création des agents...")
    ticket_agent = AgentTicketAnalyser(json_llm)
    image_sorter = AgentImageSorter(image_sorter_llm)
    image_analyser = AgentImageAnalyser(image_analyser_llm)
    
    # Utiliser AgentReportGeneratorQwen pour le rapport (plus stable)
    report_generator = AgentReportGenerator(report_generator_llm)
    
    print("Tous les agents ont été créés")
    
    # Initialisation de l'orchestrateur avec les agents
    logger.info("Initialisation de l'orchestrateur")
    print("Initialisation de l'orchestrateur")
    
    orchestrator = Orchestrator(
        output_dir="output/",
        ticket_agent=ticket_agent,
        image_sorter=image_sorter,
        image_analyser=image_analyser,
        report_generator=report_generator
    )
    
    # Vérification du ticket spécifique si fourni
    specific_ticket_path = None
    if ticket_id:
        target_ticket = f"ticket_{ticket_id}"
        specific_ticket_path = os.path.join("output", target_ticket)
        
        if not os.path.exists(specific_ticket_path):
            logger.error(f"Le ticket {target_ticket} n'existe pas")
            print(f"ERREUR: Le ticket {target_ticket} n'existe pas")
            return
            
        logger.info(f"Ticket spécifique à traiter: {specific_ticket_path}")
        print(f"Ticket spécifique à traiter: {target_ticket}")
    
    # Exécution de l'orchestrateur
    total_start_time = time.time()
    logger.info("Début de l'exécution de l'orchestrateur avec LlamaVision")
    print("Début de l'exécution de l'orchestrateur avec LlamaVision")
    
    try:
        orchestrator.executer(ticket_id)
        
        # Vérifier le rapport généré et afficher un résumé
        if ticket_id:
            # Chercher le rapport Markdown le plus récent
            ticket_dir = os.path.join("output", f"ticket_{ticket_id}")
            latest_md = None
            
            for extraction in os.listdir(ticket_dir):
                extraction_path = os.path.join(ticket_dir, extraction)
                if os.path.isdir(extraction_path):
                    rapports_dir = os.path.join(extraction_path, f"{ticket_id}_rapports", f"{ticket_id}")
                    if os.path.exists(rapports_dir):
                        md_files = [f for f in os.listdir(rapports_dir) if f.endswith('.md')]
                        if md_files:
                            md_files.sort(reverse=True)  # Le plus récent en premier
                            latest_md = os.path.join(rapports_dir, md_files[0])
                            break
            
            if latest_md:
                print(f"\nVérification du rapport: {latest_md}")
                try:
                    with open(latest_md, 'r', encoding='utf-8') as f:
                        content = f.read()
                    
                    # Vérifier si le tableau des échanges est présent
                    has_table = "| Date | " in content
                    has_details = "## Détails des analyses" in content
                    
                    print(f"- Tableau des échanges: {'Présent' if has_table else 'MANQUANT'}")
                    print(f"- Détails des analyses: {'Présent' if has_details else 'MANQUANT'}")
                    
                    if not has_table:
                        print("\nATTENTION: Le tableau des échanges client/support est manquant!")
                        print("Vérifiez le system prompt de l'agent de rapport et la transmission des données.")
                    
                except Exception as e:
                    print(f"Erreur lors de la vérification du rapport: {e}")
    
    except Exception as e:
        logger.error(f"Erreur lors de l'exécution de l'orchestrateur: {str(e)}")
        print(f"ERREUR: {str(e)}")
        traceback.print_exc()
    
    total_time = time.time() - total_start_time
    logger.info(f"Fin de l'exécution de l'orchestrateur (durée: {total_time:.2f} secondes)")
    print(f"Fin de l'exécution de l'orchestrateur (durée: {total_time:.2f} secondes)")


if __name__ == "__main__":
    print("Démarrage du test de l'orchestrateur avec LlamaVision")
    
    # Vérifier si un ID de ticket est passé en argument
    ticket_id = None
    if len(sys.argv) > 1:
        ticket_id = sys.argv[1]
        print(f"ID de ticket fourni en argument: {ticket_id}")
    
    test_orchestrator_llama_vision(ticket_id)
    print("Test terminé")