update analyse globale

app.py

@@ -231,24 +231,54 @@ async def generate_text(
     return {"summary_text_2": generated_text}
 @app.post("/analyse_globale/")
 async def generate_global_analysis(file: UploadFile = File(...)):
-    # Check file size
+    # Lire le fichier téléchargé
     contents = await file.read()
+
+    # Vérification de la taille du fichier
     file_size = len(contents)
-    if file_size > 5_000_000:  # 5MB limit
-        return {"error": "File size exceeds the 5MB limit. The file will be sampled."}
+    if file_size > 5_000_000:  # Limite de 5 Mo
+        return {"error": "La taille du fichier dépasse la limite de 5 Mo. Le fichier sera échantillonné."}
 
-    # Read the uploaded CSV file
+    # Lire le fichier CSV téléchargé
     try:
         df = pd.read_csv(io.StringIO(contents.decode('utf-8')))
     except Exception as e:
-        return {"error": f"Error reading CSV file: {str(e)}"}
+        return {"error": f"Erreur lors de la lecture du fichier CSV : {str(e)}"}
 
-    if len(df) > 1000:  # Adjust this number based on your needs
-        df = df.sample(n=1000, random_state=42)
+    # Échantillonner les données si elles sont trop grandes
+    if len(df) > 1000:  # Ajustez ce nombre selon vos besoins
+        df = df.sample(n=500, random_state=42)
 
-    total_plaintes = len(df)
+    # Convertir le DataFrame en chaîne de caractères
+    try:
+        text_to_generate = df.to_string(index=False)
+    except Exception as e:
+        return {"error": f"Erreur lors de la conversion du DataFrame en chaîne : {str(e)}"}
+
+    # S'assurer que le texte généré est dans les limites de taille
+    if len(text_to_generate.encode('utf-8')) > 5_000_000:
+        return {"error": "Le texte généré dépasse la limite de taille même après échantillonnage. Veuillez réduire davantage les données."}
 
-    # Analyse par domaine (code existant)
+    # Définir le prompt de l'analyse globale
+    prompt_global = """
+    Analyse globale des plaintes pour tous les domaines :
+    Résumé général :
+    - Total des plaintes : {len(df)}
+    Répartition des plaintes par domaine :
+    {domain_analyses}
+    Problèmes récurrents observés dans tous les domaines :
+    - lister 1 à 2 problèmes les plus fréquents
+    Actions entreprises :
+    - Action 1 : Description de l'action
+    Recommandations pour améliorer la gestion des plaintes :
+    1. [Recommandation 1] : Détails
+
+    En résumé, voici les principales tendances et recommandations pour améliorer la gestion des plaintes et résoudre les problèmes identifiés à travers tous les domaines.
+    ---
+    Utilisez ces informations pour améliorer la qualité du service et optimiser la gestion des plaintes.
+    """
+
+    # Groupement des données par domaine
     domain_analyses = ""
     for domain, group in df.groupby('DOMAINE'):
         domain_summary = group.groupby('STATUT').size().to_dict()
@@ -264,62 +294,24 @@ async def generate_global_analysis(file: UploadFile = File(...)):
         """
         domain_analyses += domain_analysis
 
-    # Analyse des blocages
-    blocages_analysis = df[df['STATUT'] == 'EN COURS'].groupby('DOMAINE').size().sort_values(ascending=False)
-    blocages_text = "\n".join([f"  - {domain}: {count} plaintes en cours" for domain, count in blocages_analysis.items()])
-
-    # Analyse de la réactivité (basée sur le nombre de plaintes non traitées)
-    reactivite_analysis = df[df['STATUT'].isin(['EN COURS', 'NON PRIS EN CHARGE'])].groupby('DOMAINE').size().sort_values(ascending=False)
-    reactivite_text = "\n".join([f"  - {domain}: {count} plaintes non résolues" for domain, count in reactivite_analysis.items()])
-
-    # Mise à jour du prompt global
-    prompt_global = f"""
-    Analyse globale des plaintes pour tous les domaines :
-    Résumé général :
-    - Total des plaintes analysées : {total_plaintes}
-    Répartition des plaintes par domaine : 
-    {domain_analyses}
-    Analyse des blocages :
-    Les domaines suivants présentent le plus grand nombre de plaintes en cours, ce qui peut indiquer des blocages dans le travail :
-    {blocages_text}
-    Analyse de la réactivité :
-    Les domaines suivants ont le plus grand nombre de plaintes non résolues (en cours ou non prises en charge), ce qui peut indiquer une moindre réactivité :
-    {reactivite_text}
-    Basé sur ces données :
-    1. Identifiez les 2-3 principaux facteurs qui semblent bloquer le travail le plus, en vous basant sur les domaines avec le plus de plaintes en cours.
-    2. Analysez pourquoi certains domaines semblent moins réactifs que d'autres, en vous basant sur le nombre de plaintes non résolues.
-    3. Proposez 3-4 actions concrètes qui pourraient être mises en place pour :
-       a) Débloquer le travail dans les domaines les plus affectés
-       b) Améliorer la réactivité dans les domaines moins performants
-    4. Expliquez comment ces actions pourraient améliorer globalement la gestion des plaintes et réduire les temps de résolution.
-    5. Recommandez des mesures spécifiques pour suivre et améliorer la performance dans les domaines identifiés comme problématiques.
-    En résumé, présentez une analyse focalisée sur les blocages du travail et la réactivité des différents domaines, avec des recommandations concrètes pour améliorer la situation.
-    """
-    # Format the prompt with the analyzed data
-    # formatted_prompt = prompt_global.format(
-    #     total_plaintes=len(df),
-    #     month_most_domains=month_with_most_domains,
-    #     dominant_domain=dominant_domain,
-    #     domain_analyses=domain_analyses
-    # )
-
-    # Create the request for the API
+    # Création de la requête pour l'API (exemple avec un modèle fictif)
     try:
+        # Remplacez cette partie par la logique spécifique à votre API
         completion = client.chat.completions.create(
             model="meta/llama-3.1-8b-instruct",
-            messages=[{"role": "user", "content": prompt_global }],
-            temperature=0.2,
-            top_p=0.9,
-            stream=True
+            messages=[{"role": "user", "content": prompt_global.format(domain_analyses=domain_analyses) + text_to_generate}],
+            temperature=0.2, top_p=0.9, stream=True
         )
     except Exception as e:
-        return {"error": f"Error generating text: {str(e)}"}
+        return {"error": f"Erreur lors de la génération du texte : {str(e)}"}
 
+    # Récupération du texte généré
     generated_text = ""
     for chunk in completion:
         if chunk.choices[0].delta.content is not None:
             generated_text += chunk.choices[0].delta.content
 
+    # Retour du texte généré
     return {"global_analysis_text": generated_text}
 if __name__ == "__main__":
     uvicorn.run("app:app",reload=True)