llm_lab/examples/analyse_image_workflow.py

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

"""
Script d'exemple pour montrer l'utilisation des agents d'analyse d'image et JSON
"""

import os
import sys
import json
import argparse
from datetime import datetime
from pathlib import Path

# Ajouter le répertoire parent au sys.path pour importer les modules
sys.path.append(str(Path(__file__).parent.parent))

from agents.analyse_image import AgentAnalyseImage
from agents.analyse_json import AgentAnalyseJSON

def create_output_dir():
    """Crée un répertoire pour les sorties basé sur la date/heure"""
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    output_dir = f"outputs/vision_{timestamp}"
    os.makedirs(output_dir, exist_ok=True)
    return output_dir

def analyse_directe(image_path, output_dir):
    """Analyse directe avec l'agent d'analyse d'image"""
    print(f"\n=== Analyse directe de l'image {os.path.basename(image_path)} ===")
    
    # Création d'une instance AgentAnalyseImage
    agent = AgentAnalyseImage("AgentVision")
    
    # Analyse de l'image avec une question spécifique
    question = "Décris en détail cette image. Qu'est-ce que tu y vois? Y a-t-il du texte visible?"
    print(f"Question: {question}")
    
    resultats = agent.executer(image_path, question=question)
    
    if "erreur" in resultats:
        print(f"Erreur: {resultats['erreur']}")
        return
    
    # Affichage du résultat
    print("\nRéponse:")
    for analyse in resultats["analyses"]:
        print(f"\n{analyse['reponse']}")
    
    # Sauvegarde du résultat
    output_file = os.path.join(output_dir, "resultat_direct.json")
    agent.sauvegarder_resultats(output_file, resultats)
    print(f"\nRésultat sauvegardé dans: {output_file}")

def workflow_complet(image_path, json_path=None, output_dir=None):
    """Workflow complet: analyse image puis analyse JSON"""
    print(f"\n=== Workflow complet pour l'image {os.path.basename(image_path)} ===")
    
    if output_dir is None:
        output_dir = create_output_dir()
    
    # Étape 1: Analyse de l'image
    print("\nÉtape 1: Analyse de l'image")
    agent_image = AgentAnalyseImage("AgentVision")
    
    # Chargement des données JSON si spécifiées
    json_data = None
    if json_path:
        try:
            with open(json_path, 'r', encoding='utf-8') as f:
                json_data = json.load(f)
            print(f"Données JSON chargées depuis {json_path}")
        except Exception as e:
            print(f"Erreur lors du chargement du JSON: {e}")
    
    # Exécution de l'analyse d'image
    resultats_image = agent_image.executer(image_path, json_data)
    
    # Sauvegarde des résultats intermédiaires
    image_output_file = os.path.join(output_dir, "analyse_image.json")
    agent_image.sauvegarder_resultats(image_output_file, resultats_image)
    print(f"Analyse d'image sauvegardée dans: {image_output_file}")
    
    # Étape 2: Analyse des résultats JSON
    print("\nÉtape 2: Analyse approfondie des résultats")
    agent_json = AgentAnalyseJSON("AgentAnalyseJSON")
    
    # Analyse des résultats de l'image
    question_json = "Analyse les résultats de l'analyse d'image et extrait les éléments clés."
    resultats_analyse = agent_json.executer(resultats_image, question_json)
    
    # Sauvegarde des résultats d'analyse
    json_output_file = os.path.join(output_dir, "analyse_complete.json")
    with open(json_output_file, 'w', encoding='utf-8') as f:
        json.dump(resultats_analyse, f, ensure_ascii=False, indent=2)
    print(f"Analyse complète sauvegardée dans: {json_output_file}")
    
    # Fusion des résultats
    resultats_finaux = {
        "image": image_path,
        "timestamp": datetime.now().isoformat(),
        "analyse_image": resultats_image,
        "analyse_json": resultats_analyse
    }
    
    # Sauvegarde des résultats finaux
    final_output_file = os.path.join(output_dir, "resultats_finaux.json")
    with open(final_output_file, 'w', encoding='utf-8') as f:
        json.dump(resultats_finaux, f, ensure_ascii=False, indent=2)
    print(f"Résultats finaux sauvegardés dans: {final_output_file}")
    
    return resultats_finaux

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Analyse d'images avec les agents")
    parser.add_argument("--image", required=True, help="Chemin vers l'image à analyser")
    parser.add_argument("--json", help="Chemin vers un fichier JSON complémentaire (optionnel)")
    parser.add_argument("--mode", choices=["direct", "complet"], default="complet", 
                        help="Mode d'analyse: direct (simple) ou complet (workflow)")
    
    args = parser.parse_args()
    
    # Vérification de l'existence de l'image
    if not os.path.exists(args.image):
        print(f"Erreur: L'image {args.image} n'existe pas")
        sys.exit(1)
    
    # Création du répertoire de sortie
    output_dir = create_output_dir()
    
    # Exécution du mode choisi
    if args.mode == "direct":
        analyse_directe(args.image, output_dir)
    else:
        workflow_complet(args.image, args.json, output_dir)
    
    print("\nAnalyse terminée !")