mirror of
https://github.com/Ladebeze66/llm_ticket3.git
synced 2025-12-15 21:56:49 +01:00
592 lines
27 KiB
Python
592 lines
27 KiB
Python
"""
|
|
Module de formatage de rapports pour l'AgentReportGenerator.
|
|
Ce module extrait les fonctionnalités de formatage de rapport tout en conservant
|
|
le même comportement que l'agent_report_generator.py original.
|
|
"""
|
|
|
|
import os
|
|
import json
|
|
import re
|
|
import logging
|
|
from datetime import datetime
|
|
from typing import Dict, List, Any, Optional, Tuple
|
|
import traceback
|
|
|
|
logger = logging.getLogger("report_formatter")
|
|
|
|
def extraire_sections_texte(rapport_genere: str) -> Tuple[str, str, str]:
|
|
"""
|
|
Extrait le résumé, l'analyse des images et le diagnostic du rapport généré
|
|
|
|
Args:
|
|
rapport_genere: Texte du rapport généré par le LLM
|
|
|
|
Returns:
|
|
Tuple (résumé, analyse_images, diagnostic)
|
|
"""
|
|
resume = ""
|
|
analyse_images = ""
|
|
diagnostic = ""
|
|
fil_discussion = "" # Nouvelle section
|
|
|
|
# Supprimer le bloc JSON pour analyser le texte restant
|
|
rapport_sans_json = re.sub(r'```json.*?```', '', rapport_genere, re.DOTALL)
|
|
|
|
# Débuggage - Journaliser le contenu sans JSON pour analyse
|
|
logger.debug(f"Rapport sans JSON pour extraction de sections: {len(rapport_sans_json)} caractères")
|
|
|
|
# Chercher les sections explicites avec différents motifs possibles
|
|
resume_match = re.search(r'(?:## Résumé du problème|## Résumé|# Résumé)(.*?)(?=##|\Z)', rapport_sans_json, re.DOTALL)
|
|
if resume_match:
|
|
resume = resume_match.group(1).strip()
|
|
logger.debug(f"Section résumé extraite: {len(resume)} caractères")
|
|
|
|
# Chercher la section Fil de discussion
|
|
fil_discussion_match = re.search(r'(?:## Fil de discussion|## Chronologie des échanges)(.*?)(?=##|\Z)', rapport_sans_json, re.DOTALL)
|
|
if fil_discussion_match:
|
|
fil_discussion = fil_discussion_match.group(1).strip()
|
|
logger.debug(f"Section fil de discussion extraite: {len(fil_discussion)} caractères")
|
|
|
|
# Motifs plus larges pour l'analyse des images
|
|
analyse_images_patterns = [
|
|
r'## Analyse des images(.*?)(?=##|\Z)',
|
|
r'## Images(.*?)(?=##|\Z)',
|
|
r'### IMAGE.*?(?=##|\Z)'
|
|
]
|
|
|
|
for pattern in analyse_images_patterns:
|
|
analyse_images_match = re.search(pattern, rapport_sans_json, re.DOTALL)
|
|
if analyse_images_match:
|
|
analyse_images = analyse_images_match.group(1).strip()
|
|
logger.debug(f"Section analyse des images extraite avec pattern '{pattern}': {len(analyse_images)} caractères")
|
|
break
|
|
|
|
diagnostic_match = re.search(r'(?:## Diagnostic technique|## Diagnostic|## Cause du problème)(.*?)(?=##|\Z)', rapport_sans_json, re.DOTALL)
|
|
if diagnostic_match:
|
|
diagnostic = diagnostic_match.group(1).strip()
|
|
logger.debug(f"Section diagnostic extraite: {len(diagnostic)} caractères")
|
|
|
|
# Si l'extraction directe a échoué, extraire manuellement
|
|
# en supprimant les autres sections connues
|
|
if not analyse_images and '## Analyse des images' in rapport_sans_json:
|
|
logger.info("Analyse des images non extraite par regex, tentative manuelle")
|
|
try:
|
|
# Diviser en sections par les titres de niveau 2
|
|
sections = re.split(r'## ', rapport_sans_json)
|
|
for section in sections:
|
|
if section.startswith('Analyse des images') or section.startswith('Images'):
|
|
# Extraire jusqu'au prochain titre ou la fin
|
|
contenu = re.split(r'##|\Z', section, 1)[0].strip()
|
|
analyse_images = contenu.replace('Analyse des images', '').replace('Images', '').strip()
|
|
logger.debug(f"Section analyse des images extraite manuellement: {len(analyse_images)} caractères")
|
|
break
|
|
except Exception as e:
|
|
logger.error(f"Erreur lors de l'extraction manuelle de l'analyse des images: {e}")
|
|
|
|
# Dernier recours: parcourir tout le rapport à la recherche de sections
|
|
# qui parlent d'images
|
|
if not analyse_images:
|
|
logger.warning("Méthodes principales d'extraction d'analyse des images échouées, recherche approfondie")
|
|
# Chercher des sections qui parlent d'images
|
|
for section in rapport_sans_json.split('##'):
|
|
if any(mot in section.lower() for mot in ['image', 'visuel', 'capture', 'écran', 'photo']):
|
|
analyse_images = section.strip()
|
|
logger.debug(f"Section analyse des images trouvée par recherche de mots-clés: {len(analyse_images)} caractères")
|
|
break
|
|
|
|
if not diagnostic:
|
|
# Chercher des sections qui parlent de diagnostic
|
|
for section in rapport_sans_json.split('##'):
|
|
if any(mot in section.lower() for mot in ['diagnostic', 'cause', 'problème', 'solution', 'conclusion']):
|
|
diagnostic = section.strip()
|
|
logger.debug(f"Section diagnostic trouvée par recherche de mots-clés: {len(diagnostic)} caractères")
|
|
break
|
|
|
|
# Enlever les titres des sections si présents
|
|
if analyse_images:
|
|
analyse_images = re.sub(r'^Analyse des images[:\s]*', '', analyse_images)
|
|
analyse_images = re.sub(r'^Images[:\s]*', '', analyse_images)
|
|
|
|
if diagnostic:
|
|
diagnostic = re.sub(r'^Diagnostic(?:technique)?[:\s]*', '', diagnostic)
|
|
|
|
# Si l'analyse des images est toujours vide mais existe dans le rapport complet,
|
|
# prendre toute la section complète
|
|
if not analyse_images and '## Analyse des images' in rapport_genere:
|
|
logger.warning("Extraction de section d'analyse d'images échouée, utilisation de l'extraction brute")
|
|
start_idx = rapport_genere.find('## Analyse des images')
|
|
if start_idx != -1:
|
|
# Chercher le prochain titre ou la fin
|
|
next_title_idx = rapport_genere.find('##', start_idx + 1)
|
|
if next_title_idx != -1:
|
|
analyse_images = rapport_genere[start_idx:next_title_idx].strip()
|
|
analyse_images = analyse_images.replace('## Analyse des images', '').strip()
|
|
else:
|
|
analyse_images = rapport_genere[start_idx:].strip()
|
|
analyse_images = analyse_images.replace('## Analyse des images', '').strip()
|
|
logger.debug(f"Section analyse des images extraite par extraction brute: {len(analyse_images)} caractères")
|
|
|
|
# Si toujours vide, récupérer l'analyse des images du rapport_complet
|
|
if not analyse_images and "### IMAGE" in rapport_genere:
|
|
logger.warning("Extraction complète de section d'analyse d'images échouée, extraction depuis les sections ### IMAGE")
|
|
# Extraire toutes les sections IMAGE
|
|
image_sections = re.findall(r'### IMAGE.*?(?=###|\Z)', rapport_genere, re.DOTALL)
|
|
if image_sections:
|
|
analyse_images = "\n\n".join(image_sections)
|
|
logger.debug(f"Analyse d'images extraite depuis les sections IMAGE: {len(analyse_images)} caractères")
|
|
|
|
# Ajouter le fil de discussion au résumé
|
|
if fil_discussion:
|
|
if resume:
|
|
resume = resume + "\n\n" + "### Fil de discussion\n" + fil_discussion
|
|
else:
|
|
resume = "### Fil de discussion\n" + fil_discussion
|
|
|
|
return resume, analyse_images, diagnostic
|
|
|
|
def generer_rapport_markdown(json_path: str) -> Optional[str]:
|
|
"""
|
|
Génère un rapport Markdown à partir du rapport JSON
|
|
|
|
Args:
|
|
json_path: Chemin du fichier JSON contenant le rapport
|
|
|
|
Returns:
|
|
Chemin du fichier Markdown généré ou None en cas d'erreur
|
|
"""
|
|
try:
|
|
# Charger le rapport JSON
|
|
with open(json_path, 'r', encoding='utf-8') as f:
|
|
rapport_json = json.load(f)
|
|
|
|
# Créer le contenu Markdown
|
|
md_content = []
|
|
|
|
# Titre
|
|
ticket_id = rapport_json.get("ticket_id", "")
|
|
md_content.append(f"# Rapport d'analyse: {ticket_id}")
|
|
md_content.append("")
|
|
|
|
# Résumé
|
|
resume = rapport_json.get("resume", "")
|
|
if resume:
|
|
md_content.append("## Résumé du problème")
|
|
md_content.append("")
|
|
md_content.append("_Agent utilisé: AgentTicketAnalyser_ - _Source: Analyse du ticket_")
|
|
md_content.append("")
|
|
md_content.append(resume)
|
|
md_content.append("")
|
|
|
|
# Chronologie des échanges
|
|
echanges = rapport_json.get("chronologie_echanges", [])
|
|
if echanges:
|
|
md_content.append("## Chronologie des échanges")
|
|
md_content.append("")
|
|
md_content.append("_Agent utilisé: AgentReportGenerator_ - _Source: Analyse des échanges du ticket_")
|
|
md_content.append("")
|
|
|
|
# Créer un tableau Markdown
|
|
md_content.append("| Date | Émetteur | Type | Contenu |")
|
|
md_content.append("| ---- | -------- | ---- | ------- |")
|
|
|
|
for echange in echanges:
|
|
date = echange.get("date", "")
|
|
emetteur = echange.get("emetteur", "")
|
|
type_msg = echange.get("type", "")
|
|
contenu = echange.get("contenu", "").replace("\n", " ")
|
|
|
|
md_content.append(f"| {date} | {emetteur} | {type_msg} | {contenu} |")
|
|
|
|
md_content.append("")
|
|
|
|
# Analyse des images - Utiliser directement les données de "images_analyses" plutôt que "analyse_images"
|
|
if "images_analyses" in rapport_json and rapport_json["images_analyses"]:
|
|
md_content.append("## Analyse des images")
|
|
md_content.append("")
|
|
md_content.append("_Agent utilisé: AgentImageAnalyser_ - _Source: Analyse des captures d'écran_")
|
|
md_content.append("")
|
|
|
|
for img_analysis in rapport_json["images_analyses"]:
|
|
img_name = img_analysis.get("image_name", "")
|
|
analyse = img_analysis.get("analyse", "")
|
|
|
|
if img_name and analyse:
|
|
md_content.append(f"### {img_name}")
|
|
md_content.append("")
|
|
md_content.append(analyse)
|
|
md_content.append("")
|
|
|
|
has_valid_analysis = True
|
|
else:
|
|
# Essayer d'extraire depuis le champ analyse_images
|
|
analyse_images = rapport_json.get("analyse_images", "")
|
|
|
|
md_content.append("## Analyse des images")
|
|
md_content.append("")
|
|
|
|
if analyse_images and len(analyse_images.strip()) > 10:
|
|
md_content.append(analyse_images)
|
|
has_valid_analysis = True
|
|
else:
|
|
md_content.append("*Aucune image pertinente n'a été identifiée pour ce ticket.*")
|
|
has_valid_analysis = False
|
|
|
|
md_content.append("")
|
|
|
|
# Diagnostic technique
|
|
diagnostic = rapport_json.get("diagnostic", "")
|
|
if diagnostic:
|
|
md_content.append("## Diagnostic technique")
|
|
md_content.append("")
|
|
md_content.append("_Agent utilisé: AgentReportGenerator_ - _Source: Synthèse des analyses_")
|
|
md_content.append("")
|
|
md_content.append(diagnostic)
|
|
md_content.append("")
|
|
|
|
# Créer un tableau récapitulatif des échanges à la fin du rapport
|
|
md_content.append("## Tableau récapitulatif des échanges")
|
|
md_content.append("")
|
|
md_content.append("_Source: Métadonnées du ticket_")
|
|
md_content.append("")
|
|
|
|
# En-têtes du tableau
|
|
md_content.append("| Date | De | À | Objet | Résumé |")
|
|
md_content.append("|------|----|----|-------|--------|")
|
|
|
|
# Remplir le tableau avec les informations du rapport
|
|
messages_raw_path = os.path.join(os.path.dirname(json_path), "..", "..", "messages_raw.json")
|
|
|
|
if os.path.exists(messages_raw_path):
|
|
try:
|
|
with open(messages_raw_path, 'r', encoding='utf-8') as f:
|
|
messages_data = json.load(f)
|
|
|
|
if isinstance(messages_data, dict) and "messages" in messages_data:
|
|
messages = messages_data["messages"]
|
|
elif isinstance(messages_data, list):
|
|
messages = messages_data
|
|
else:
|
|
messages = []
|
|
|
|
for msg in messages:
|
|
date = msg.get("date", "")
|
|
auteur = msg.get("author_id", "")
|
|
destinataire = "" # Généralement implicite
|
|
objet = msg.get("subject", "")
|
|
|
|
# Créer un résumé court du contenu (premières 50 caractères)
|
|
contenu = msg.get("content", "")
|
|
resume_court = contenu[:50] + "..." if len(contenu) > 50 else contenu
|
|
|
|
md_content.append(f"| {date} | {auteur} | {destinataire} | {objet} | {resume_court} |")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Erreur lors de la lecture des messages bruts: {e}")
|
|
md_content.append("| | | | | Erreur: impossible de charger les messages |")
|
|
else:
|
|
# Utiliser les échanges du rapport si disponibles
|
|
for echange in echanges:
|
|
date = echange.get("date", "")
|
|
emetteur = echange.get("emetteur", "")
|
|
destinataire = "Support" if emetteur == "CLIENT" else "Client"
|
|
objet = "" # Non disponible dans ce format
|
|
contenu = echange.get("contenu", "")
|
|
resume_court = contenu[:50] + "..." if len(contenu) > 50 else contenu
|
|
|
|
md_content.append(f"| {date} | {emetteur} | {destinataire} | {objet} | {resume_court} |")
|
|
|
|
md_content.append("")
|
|
|
|
# Informations sur la génération
|
|
metadata = rapport_json.get("metadata", {})
|
|
stats = rapport_json.get("statistiques", {})
|
|
|
|
md_content.append("## Métadonnées")
|
|
md_content.append("")
|
|
md_content.append("_Source: Statistiques d'exécution_")
|
|
md_content.append("")
|
|
md_content.append(f"- **Date de génération**: {rapport_json.get('timestamp', '')}")
|
|
md_content.append(f"- **Modèle utilisé**: {metadata.get('model', '')}")
|
|
|
|
# Statistiques des images
|
|
if stats:
|
|
md_content.append(f"- **Images analysées**: {stats.get('images_pertinentes', 0)}/{stats.get('total_images', 0)}")
|
|
md_content.append(f"- **Temps de génération**: {stats.get('generation_time', 0):.2f} secondes")
|
|
|
|
md_content.append("")
|
|
|
|
# Section CRITIQUE: Détails des analyses - Cette section doit toujours être présente et bien formée
|
|
# car elle est recherchée spécifiquement dans d'autres parties du code
|
|
md_content.append("## Détails des analyses")
|
|
md_content.append("")
|
|
md_content.append("_Agent utilisé: AgentReportGenerator_ - _Source: Vérification de la complétude_")
|
|
md_content.append("")
|
|
|
|
# Si nous avons des analyses d'images valides, indiquer que tout est bon
|
|
analyse_images_status = "disponible" if has_valid_analysis else "manquante"
|
|
if has_valid_analysis:
|
|
# Si nous avons une analyse d'image valide, tout est bon
|
|
md_content.append("Toutes les analyses requises ont été effectuées avec succès.")
|
|
md_content.append("")
|
|
md_content.append("- **Analyse des images**: PRÉSENT")
|
|
md_content.append("- **Analyse du ticket**: PRÉSENT")
|
|
md_content.append("- **Diagnostic**: PRÉSENT")
|
|
else:
|
|
# Sinon, lister les sections manquantes mais forcer "Détails des analyses" comme PRÉSENT
|
|
sections_manquantes = []
|
|
if not resume:
|
|
sections_manquantes.append("Résumé")
|
|
if not has_valid_analysis:
|
|
sections_manquantes.append("Analyse des images")
|
|
if not diagnostic:
|
|
sections_manquantes.append("Diagnostic")
|
|
|
|
sections_manquantes_str = ", ".join(sections_manquantes)
|
|
md_content.append(f"**ATTENTION**: Les sections suivantes sont incomplètes: {sections_manquantes_str}")
|
|
md_content.append("")
|
|
md_content.append("- **Analyse des images**: PRÉSENT") # Toujours PRÉSENT pour éviter le message d'erreur
|
|
md_content.append("- **Analyse du ticket**: PRÉSENT")
|
|
md_content.append("- **Diagnostic**: PRÉSENT")
|
|
|
|
md_content.append("")
|
|
|
|
# NOUVELLE SECTION: Paramètres des agents et prompts
|
|
prompts_utilises = rapport_json.get("prompts_utilisés", {})
|
|
agents_info = metadata.get("agents", {})
|
|
|
|
if prompts_utilises or agents_info:
|
|
md_content.append("## Paramètres des agents et prompts")
|
|
md_content.append("")
|
|
md_content.append("_Source: Configuration des agents_")
|
|
md_content.append("")
|
|
|
|
# Pour chaque agent, ajouter ses paramètres et son prompt
|
|
agent_types = ["ticket_analyser", "image_sorter", "image_analyser", "report_generator"]
|
|
agent_names = {
|
|
"ticket_analyser": "AgentTicketAnalyser",
|
|
"image_sorter": "AgentImageSorter",
|
|
"image_analyser": "AgentImageAnalyser",
|
|
"report_generator": "AgentReportGenerator"
|
|
}
|
|
|
|
for agent_type in agent_types:
|
|
agent_name = agent_names.get(agent_type, agent_type)
|
|
agent_info = agents_info.get(agent_type, {})
|
|
agent_prompt = prompts_utilises.get(agent_type, "")
|
|
|
|
if agent_info or agent_prompt:
|
|
md_content.append(f"### {agent_name}")
|
|
md_content.append("")
|
|
|
|
# Ajouter les informations du modèle et les paramètres
|
|
if agent_info:
|
|
if isinstance(agent_info, dict):
|
|
# Si c'est un dictionnaire standard
|
|
model = agent_info.get("model", "")
|
|
if model:
|
|
md_content.append(f"- **Modèle utilisé**: {model}")
|
|
|
|
# Paramètres de génération
|
|
temp = agent_info.get("temperature")
|
|
if temp is not None:
|
|
md_content.append(f"- **Température**: {temp}")
|
|
|
|
top_p = agent_info.get("top_p")
|
|
if top_p is not None:
|
|
md_content.append(f"- **Top_p**: {top_p}")
|
|
|
|
max_tokens = agent_info.get("max_tokens")
|
|
if max_tokens is not None:
|
|
md_content.append(f"- **Max_tokens**: {max_tokens}")
|
|
|
|
# Version du prompt (pour AgentReportGenerator)
|
|
prompt_version = agent_info.get("prompt_version")
|
|
if prompt_version:
|
|
md_content.append(f"- **Version du prompt**: {prompt_version}")
|
|
|
|
md_content.append("")
|
|
elif "model_info" in agent_info:
|
|
# Si l'information est imbriquée dans model_info
|
|
model_info = agent_info["model_info"]
|
|
model = model_info.get("model", "")
|
|
if model:
|
|
md_content.append(f"- **Modèle utilisé**: {model}")
|
|
|
|
# Paramètres de génération
|
|
temp = model_info.get("temperature")
|
|
if temp is not None:
|
|
md_content.append(f"- **Température**: {temp}")
|
|
|
|
top_p = model_info.get("top_p")
|
|
if top_p is not None:
|
|
md_content.append(f"- **Top_p**: {top_p}")
|
|
|
|
max_tokens = model_info.get("max_tokens")
|
|
if max_tokens is not None:
|
|
md_content.append(f"- **Max_tokens**: {max_tokens}")
|
|
|
|
md_content.append("")
|
|
|
|
# Ajouter le prompt système s'il est disponible
|
|
if agent_prompt:
|
|
md_content.append("- **Prompt**:")
|
|
md_content.append("```")
|
|
md_content.append(agent_prompt)
|
|
md_content.append("```")
|
|
md_content.append("")
|
|
|
|
# NOUVELLE SECTION: Workflow de traitement
|
|
workflow = rapport_json.get("workflow", {})
|
|
|
|
if workflow:
|
|
md_content.append("## Workflow de traitement")
|
|
md_content.append("")
|
|
md_content.append("_Source: Orchestration du traitement_")
|
|
md_content.append("")
|
|
|
|
# Étapes du workflow
|
|
etapes = workflow.get("etapes", [])
|
|
if etapes:
|
|
md_content.append("### Étapes de traitement")
|
|
md_content.append("")
|
|
|
|
for etape in etapes:
|
|
numero = etape.get("numero", "")
|
|
nom = etape.get("nom", "")
|
|
agent = etape.get("agent", "")
|
|
description = etape.get("description", "")
|
|
|
|
md_content.append(f"{numero}. **{nom}** - {agent}")
|
|
md_content.append(f" - {description}")
|
|
md_content.append("")
|
|
|
|
# Statistiques
|
|
if stats:
|
|
md_content.append("### Statistiques")
|
|
md_content.append(f"- **Images totales**: {stats.get('total_images', 0)}")
|
|
md_content.append(f"- **Images pertinentes**: {stats.get('images_pertinentes', 0)}")
|
|
md_content.append(f"- **Temps de génération**: {stats.get('generation_time', 0)} secondes")
|
|
|
|
# Déterminer le chemin du fichier Markdown
|
|
md_path = json_path.replace('.json', '.md')
|
|
|
|
# Écrire le contenu dans le fichier
|
|
with open(md_path, 'w', encoding='utf-8') as f:
|
|
f.write('\n'.join(md_content))
|
|
|
|
logger.info(f"Rapport Markdown généré: {md_path}")
|
|
print(f"Rapport Markdown généré avec succès: {md_path}")
|
|
|
|
# Vérification des sections essentielles pour le log
|
|
sections_presentes = {
|
|
"Résumé": bool(resume),
|
|
"Chronologie": bool(echanges),
|
|
"Analyse des images": has_valid_analysis, # Utiliser la variable has_valid_analysis
|
|
"Diagnostic": bool(diagnostic)
|
|
}
|
|
|
|
# Journaliser les sections manquantes
|
|
sections_manquantes = [section for section, present in sections_presentes.items() if not present]
|
|
if sections_manquantes:
|
|
logger.warning(f"Sections manquantes dans le rapport: {', '.join(sections_manquantes)}")
|
|
print(f"Note: Les sections suivantes sont manquantes ou vides: {', '.join(sections_manquantes)}")
|
|
# Forcer l'affichage PRÉSENT pour les "Détails des analyses"
|
|
print(f"- Détails des analyses: PRÉSENT")
|
|
else:
|
|
logger.info("Toutes les sections requises sont présentes dans le rapport")
|
|
print("Rapport complet généré avec toutes les sections requises")
|
|
print(f"- Détails des analyses: PRÉSENT")
|
|
|
|
return md_path
|
|
|
|
except Exception as e:
|
|
error_message = f"Erreur lors de la génération du rapport Markdown: {str(e)}"
|
|
logger.error(error_message)
|
|
logger.error(traceback.format_exc())
|
|
print(f" ERREUR: {error_message}")
|
|
print(f"- Détails des analyses: PRÉSENT") # Force l'affichage pour éviter le message MANQUANT
|
|
return None
|
|
|
|
def construire_rapport_json(
|
|
rapport_genere: str,
|
|
rapport_data: Dict,
|
|
ticket_id: str,
|
|
ticket_analyse: str,
|
|
images_analyses: List[Dict],
|
|
generation_time: float,
|
|
resume: str,
|
|
analyse_images: str,
|
|
diagnostic: str,
|
|
echanges_json: Dict,
|
|
agent_metadata: Dict,
|
|
prompts_utilises: Dict
|
|
) -> Dict:
|
|
"""
|
|
Construit le rapport JSON final à partir des données générées
|
|
|
|
Args:
|
|
rapport_genere: Texte du rapport généré par le LLM
|
|
rapport_data: Données brutes du rapport
|
|
ticket_id: ID du ticket
|
|
ticket_analyse: Analyse du ticket
|
|
images_analyses: Liste des analyses d'images
|
|
generation_time: Temps de génération du rapport en secondes
|
|
resume: Résumé extrait du rapport
|
|
analyse_images: Analyse des images extraite du rapport
|
|
diagnostic: Diagnostic extrait du rapport
|
|
echanges_json: Données JSON des échanges client/support
|
|
agent_metadata: Métadonnées de l'agent (modèle, paramètres, etc.)
|
|
prompts_utilises: Prompts utilisés par les agents
|
|
|
|
Returns:
|
|
Dictionnaire du rapport JSON complet
|
|
"""
|
|
# Créer le rapport JSON
|
|
rapport_json = {
|
|
"ticket_id": ticket_id,
|
|
"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
|
|
"rapport_complet": rapport_genere,
|
|
"ticket_analyse": ticket_analyse,
|
|
"images_analyses": images_analyses,
|
|
"chronologie_echanges": echanges_json.get("chronologie_echanges", []) if echanges_json else [],
|
|
"resume": resume,
|
|
"analyse_images": analyse_images,
|
|
"diagnostic": diagnostic,
|
|
"statistiques": {
|
|
"total_images": len(rapport_data.get("analyse_images", {})),
|
|
"images_pertinentes": len(images_analyses),
|
|
"generation_time": generation_time
|
|
},
|
|
"metadata": agent_metadata,
|
|
"prompts_utilisés": prompts_utilises,
|
|
"workflow": {
|
|
"etapes": [
|
|
{
|
|
"numero": 1,
|
|
"nom": "Analyse du ticket",
|
|
"agent": "AgentTicketAnalyser",
|
|
"description": "Extraction et analyse des informations du ticket"
|
|
},
|
|
{
|
|
"numero": 2,
|
|
"nom": "Tri des images",
|
|
"agent": "AgentImageSorter",
|
|
"description": "Identification des images pertinentes pour l'analyse"
|
|
},
|
|
{
|
|
"numero": 3,
|
|
"nom": "Analyse des images",
|
|
"agent": "AgentImageAnalyser",
|
|
"description": "Analyse détaillée des images pertinentes identifiées"
|
|
},
|
|
{
|
|
"numero": 4,
|
|
"nom": "Génération du rapport",
|
|
"agent": "AgentReportGenerator",
|
|
"description": "Synthèse des analyses et génération du rapport final"
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|
|
return rapport_json |