llm_ticket3/main.py

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

"""
Script principal pour exécuter l'analyse complète d'un ticket avec les agents LLM.
Utilise l'orchestrateur et la factory d'agents pour configurer et exécuter l'analyse.
"""

import os
import sys
import argparse
import logging
import json
from typing import Dict, Any, Optional

from agent_factory import AgentFactory, TEXT_MODELS, VISION_MODELS
from orchestrator import Orchestrator
from agents.utils.report_csv_exporter import traiter_rapports_ticket

# Configuration du logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(),
        logging.FileHandler('main.log')
    ]
)

logger = logging.getLogger("main")

def parse_arguments():
    """
    Parse les arguments de ligne de commande.
    
    Returns:
        ArgumentParser: Les arguments parsés
    """
    parser = argparse.ArgumentParser(description="Analyse complète d'un ticket avec les agents LLM.")
    
    # Arguments principaux
    parser.add_argument("ticket_id", help="ID du ticket à analyser (ex: T1234)")
    parser.add_argument("--output_dir", default="output", 
                        help="Répertoire de sortie contenant les tickets (par défaut: output)")
    
    # Configuration des modèles LLM
    parser.add_argument("--text-model", choices=TEXT_MODELS, 
                        help="Modèle LLM à utiliser pour l'analyse de texte")
    parser.add_argument("--vision-model", choices=VISION_MODELS, 
                        help="Modèle LLM à utiliser pour l'analyse d'images")
    
    # Options de configuration
    parser.add_argument("--no-dedup", action="store_true", 
                        help="Désactiver le préfiltrage des doublons d'images")
    parser.add_argument("--seuil", type=int, default=5, 
                        help="Seuil de similarité pour détecter les doublons (0-10, défaut=5)")
    parser.add_argument("--save-results", action="store_true", 
                        help="Sauvegarder les résultats intermédiaires")
    parser.add_argument("--debug", action="store_true", 
                        help="Activer le mode debug avec plus d'informations")
    parser.add_argument("--reports-dir", default="reports", 
                        help="Répertoire pour sauvegarder les rapports générés")
    
    # Options d'exécution
    parser.add_argument("--skip-ticket-analysis", action="store_true", 
                        help="Sauter l'étape d'analyse du ticket")
    parser.add_argument("--skip-image-sorting", action="store_true", 
                        help="Sauter l'étape de tri des images")
    parser.add_argument("--skip-image-analysis", action="store_true", 
                        help="Sauter l'étape d'analyse des images")
    parser.add_argument("--skip-report", action="store_true", 
                        help="Sauter l'étape de génération du rapport")
    
    return parser.parse_args()

def main():
    # Récupérer les arguments
    args = parse_arguments()
    
    # Configurer le mode debug
    if args.debug:
        logging.getLogger().setLevel(logging.DEBUG)
        logger.debug("Mode debug activé")
    
    # Préparer la configuration pour l'orchestrateur
    config = {
        "dedup_enabled": not args.no_dedup,
        "dedup_threshold": args.seuil,
        "save_results": args.save_results,
        "debug_mode": args.debug,
        "reports_dir": args.reports_dir
    }
    
    logger.info(f"Configuration: {json.dumps(config, indent=2)}")
    
    try:
        # Initialiser les agents nécessaires
        agents_to_create = {}
        
        if not args.skip_ticket_analysis:
            agents_to_create["ticket_analyser"] = True
        
        if not args.skip_image_sorting:
            agents_to_create["image_sorter"] = True
            
        if not args.skip_image_analysis:
            agents_to_create["image_analyser"] = True
            
        if not args.skip_report:
            agents_to_create["report_generator"] = True
        
        # Créer les agents nécessaires
        logger.info("Initialisation des agents...")
        
        # Créer les modèles LLM
        text_llm = None
        if args.text_model and ("ticket_analyser" in agents_to_create or "report_generator" in agents_to_create):
            logger.info(f"Utilisation du modèle texte spécifié: {args.text_model}")
            text_llm = AgentFactory.create_llm(args.text_model)
        
        vision_llm = None
        if args.vision_model and ("image_sorter" in agents_to_create or "image_analyser" in agents_to_create):
            logger.info(f"Utilisation du modèle vision spécifié: {args.vision_model}")
            vision_llm = AgentFactory.create_llm(args.vision_model)
        
        # Créer seulement les agents nécessaires
        agents = {}
        
        if "ticket_analyser" in agents_to_create:
            agents["ticket_analyser"] = AgentFactory.create_ticket_analyser(text_llm)
            
        if "image_sorter" in agents_to_create:
            agents["image_sorter"] = AgentFactory.create_image_sorter(vision_llm)
            
        if "image_analyser" in agents_to_create:
            agents["image_analyser"] = AgentFactory.create_image_analyser(vision_llm)
            
        if "report_generator" in agents_to_create:
            agents["report_generator"] = AgentFactory.create_report_generator(text_llm)
        
        # Initialiser l'orchestrateur avec les agents créés
        orchestrator = Orchestrator(
            output_dir=args.output_dir,
            ticket_agent=agents.get("ticket_analyser"),
            image_sorter=agents.get("image_sorter"),
            image_analyser=agents.get("image_analyser"),
            report_generator=agents.get("report_generator"),
            config=config
        )
        
        # Exécuter l'analyse du ticket
        logger.info(f"Début de l'analyse du ticket {args.ticket_id}")
        orchestrator.executer(args.ticket_id)
        logger.info(f"Analyse du ticket {args.ticket_id} terminée")
        
        # Générer automatiquement les fichiers CSV si le rapport a été créé
        if "report_generator" in agents and not args.skip_report:
            try:
                logger.info(f"Génération des fichiers CSV pour le ticket {args.ticket_id}")
                traiter_rapports_ticket(args.ticket_id)
                logger.info(f"Fichiers CSV générés avec succès")
            except Exception as e:
                logger.error(f"Erreur lors de la génération des fichiers CSV: {e}", exc_info=True)
        
    except Exception as e:
        logger.error(f"Erreur lors de l'exécution: {e}", exc_info=True)
        return 1
    
    return 0

if __name__ == "__main__":
    sys.exit(main())