llm_ticket3/main_llama.py

"""Point d'entrée principal pour l'analyse d'un ticket de support en utilisant exclusivement LlamaVision."""

import os
import sys
import argparse
import logging
import json
import traceback

from agent_factory_llama import AgentFactoryLlamaVision
from orchestrator_llama import OrchestratorLlamaVision
from agents.utils.report_csv_exporter import traiter_rapports_ticket
from llm_classes.llama_vision import LlamaVision

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

logger = logging.getLogger("MainLlamaVision")

def parse_arguments():
    parser = argparse.ArgumentParser(description="Analyse complète d'un ticket avec LlamaVision.")
    
    parser.add_argument("ticket_id", help="ID du ticket à analyser (ex: T1234)")
    parser.add_argument("--output_dir", default="output", help="Répertoire de sortie (par défaut: output)")
    
    # Paramètre pour définir le modèle LlamaVision à utiliser
    parser.add_argument("--model", default=AgentFactoryLlamaVision.DEFAULT_MODEL_NAME, 
                        help=f"Modèle LlamaVision à utiliser (par défaut: {AgentFactoryLlamaVision.DEFAULT_MODEL_NAME})")
    
    # 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 la déduplication (0-10)")
    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")
    parser.add_argument("--reports-dir", default="reports", help="Répertoire de sauvegarde des rapports")
    
    # Options OCR et traduction
    parser.add_argument("--no-ocr", action="store_true", help="Désactiver l'OCR sur les images")
    parser.add_argument("--no-ocr-llm", action="store_true", help="Désactiver l'OCR avancé via LLM")
    parser.add_argument("--no-english", action="store_true", help="Utiliser la langue originale au lieu de l'anglais")
    
    # Etapes facultatives
    parser.add_argument("--skip-ticket-analysis", action="store_true", help="Sauter l'analyse du ticket")
    parser.add_argument("--skip-image-sorting", action="store_true", help="Sauter le tri d'images")
    parser.add_argument("--skip-image-analysis", action="store_true", help="Sauter l'analyse des images")
    parser.add_argument("--skip-vision-ocr", action="store_true", help="Sauter l'OCR avancé via LLM")
    parser.add_argument("--skip-report", action="store_true", help="Sauter la génération du rapport")
                        
    return parser.parse_args()

def main(ticket_id=None):
    """
    Fonction principale pour l'analyse d'un ticket avec le modèle LlamaVision
    """
    args = parse_arguments()
    
    # Utiliser l'argument passé en ligne de commande s'il existe
    if args.ticket_id:
        ticket_id = args.ticket_id
    
    # Vérifier que le ticket_id est fourni
    if not ticket_id:
        print(f"Erreur: ID de ticket requis. Utilisation: python {os.path.basename(__file__)} TICKET_ID")
        sys.exit(1)
    
    # Configuration du niveau de log
    if args.debug:
        logging.getLogger().setLevel(logging.DEBUG)
        logger.debug("Mode debug activé")
    
    # Modèle LlamaVision
    try:
        model_name = args.model
        # Initialiser le modèle LlamaVision
        logger.info(f"Initialisation du modèle LlamaVision: {model_name}")
        modele_llama = LlamaVision(model_name)
        modele_llama.configurer(temperature=0.2, top_p=0.9, max_tokens=4000)

        # Récupérer le nom normalisé du modèle
        #normalized_model_name = modele_llama.pipeline_normalized_name
        #logger.info(f"Nom normalisé du modèle: {normalized_model_name}")

        # Initialiser les agents avec LlamaVision
        logger.info("Création des agents avec LlamaVision")
        factory = AgentFactoryLlamaVision()
        agents = factory.create_all_agents(model_name=model_name)
        
        # Récupérer les agents individuels
        ticket_agent = agents.get("ticket_analyser")
        image_sorter = agents.get("image_sorter")
        image_analyser = agents.get("image_analyser")
        report_generator = agents.get("report_generator")
        vision_ocr = agents.get("vision_ocr")
        
        # Configuration de 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,
            "ocr_enabled": not args.no_ocr,
            "ocr_llm_enabled": not args.no_ocr_llm,  # Désactiver si l'option est fournie
            "english_only": True,
            "model_name": model_name  # Utiliser le nom normalisé du modèle
        }
        
        logger.info(f"Configuration: {json.dumps(config, indent=2)}")
        
        # Application des skips
        if args.skip_ticket_analysis:
            logger.info("Étape d'analyse du ticket désactivée")
            ticket_agent = None
        if args.skip_image_sorting:
            logger.info("Étape de tri d'images désactivée")
            image_sorter = None
        if args.skip_image_analysis:
            logger.info("Étape d'analyse d'images désactivée")
            image_analyser = None
        if args.skip_vision_ocr:
            logger.info("Étape d'OCR avancé via LLM désactivée")
            vision_ocr = None
        if args.skip_report:
            logger.info("Étape de génération de rapport désactivée")
            report_generator = None
        
        # Créer l'orchestrateur
        logger.info(f"Création de l'orchestrateur pour le ticket {ticket_id}")
        orchestrator = OrchestratorLlamaVision(
            output_dir=args.output_dir,
            ticket_agent=ticket_agent,
            image_sorter=image_sorter,
            image_analyser=image_analyser,
            report_generator=report_generator,
            vision_ocr=vision_ocr,
            config=config
        )
        
        # Exécuter l'analyse
        logger.info(f"Démarrage de l'analyse du ticket {ticket_id}")
        orchestrator.executer(ticket_id)
        logger.info(f"Analyse du ticket {ticket_id} terminée")
        
        # Génération des fichiers CSV si un rapport a été généré
        if report_generator and not args.skip_report:
            try:
                logger.info(f"Génération des fichiers CSV pour le ticket {ticket_id}")
                traiter_rapports_ticket(ticket_id)
                logger.info("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}")
        
    except Exception as e:
        logger.error(f"Erreur: {e}")
        if args.debug:
            traceback.print_exc()
        sys.exit(1)
    
    return 0

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