erreurs de style again

const.py

@@ -1,7 +1,131 @@
 
-# from typing import List
-# from pydantic import BaseModel, Field
+from typing import List
+from pydantic import BaseModel, Field
+from pydantic import BaseModel, ValidationError, conint
+
+# Version 0.0.2
+class PhraseDetail(BaseModel):
+    texte: str
+    indice_debut: int
+    indice_fin: int
+
+class Erreur(BaseModel):
+    expression: str
+    indice_debut: int
+    indice_fin: int
+
+class Reformulation(BaseModel):
+    texte: str
+
+class DetectedPhrase(BaseModel):
+    phrase: PhraseDetail
+    erreurs: List[Erreur]
+    reformulations: List[Reformulation]
+    justification: str
+
+class Summary(BaseModel):
+    total_erreurs: conint(ge=0)
+    total_phrases: conint(ge=0)
+    total_reformulations: conint(ge=0)
+
 
+class DetectionResult(BaseModel):
+    phrases_detectees: List[DetectedPhrase] = Field(..., description="Liste des phrases contenant des erreurs avec leurs détails.")
+    summary: Summary = Field(..., description="Résumé des détections.")
+
+    def to_dict(self):
+        return {
+            "phrases_detectees": [phrase_detectee.model_dump() for phrase_detectee in self.phrases_detectees],
+            "summary": self.summary.model_dump()
+        }
+
+
+def academie_prompt_template():
+    return """
+    Tu es un rédacteur web expérimenté et pointilleux qui fait attention aux moindres détails. Je vais te donner un texte, et ta mission est de {mission}.
+   
+    Voici quelques exemples d'erreurs que tu dois détecter et corriger :
+    - {Exemple d'erreur 1}, mais on dit {Correction 1}
+    - {Exemple d'erreur 2}, mais on dit {Correction 2}
+    - {Exemple d'erreur 3}, mais on dit {Correction 3}
+   
+    Pour chaque occurrence trouvée, veille à :
+   
+    - Citer la phrase complète où l'expression apparaît, avec les **indices de début et de fin** de cette phrase dans le texte.
+    - Indiquer l'expression exacte utilisée dans le texte, avec ses **indices de début et de fin** pour chaque occurrence.
+    - Proposer 5 reformulations. Vous pouvez modifier toute la phrase si nécessaire pour améliorer le style tout en conservant le sens original et en prenant en compte le **contexte global** de la phrase dans le texte.
+    - Fournir **une justification unique** expliquant pourquoi les cinq reformulations proposées améliorent la phrase originale.
+
+    Les reformulations proposées doivent être fluides, naturelles, et respecter les règles suivantes :
+       - Évitez les anglicismes et les formulations informelles.
+       - Utilisez des termes et expressions appropriés pour un contexte formel ou professionnel.
+       - Les expressions comme "crucial", "essentiel", "important", "fondamental", etc., ne doivent pas être utilisées dans les phrases.
+       - Les expressions comme "Il existe", "il faut", "cependant", "de plus", "en revanche", "néanmoins", "toutefois" ne doivent pas être utilisées en début de phrase.
+       - Les expressions comme "joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des adjectifs comme "important", "essentiel", etc.
+       - "En plus" ne doit pas être utilisé seul en début de phrase.
+
+    Les reformulations doivent également éviter les erreurs de langue courantes, notamment celles répertoriées par l'Académie Française (site : https://www.academie-francaise.fr/dire-ne-pas-dire/).
+
+    Assurez-vous que chaque reformulation tient compte du **contexte sémantique** et logique de la phrase et du paragraphe dans lequel elle apparaît. Les reformulations doivent préserver le sens global de la phrase et son intention originale, même si la structure de la phrase change.
+    
+    Voici le texte à analyser :
+    {text}
+
+    Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+    ```json
+    {
+      "phrases_detectees": [
+        {
+          "phrase": {
+            "texte": "La phrase complète contenant les erreurs.",
+            "indice_debut": indice_debut_de_la_phrase,
+            "indice_fin": indice_fin_de_la_phrase
+          },
+          "erreurs": [
+            {
+              "expression": "L'expression erronée",
+              "indice_debut": indice_debut_de_l_expression,
+              "indice_fin": indice_fin_de_l_expression
+            }
+            // ... Autres erreurs éventuelles
+          ],
+          "reformulations": [
+            {
+              "texte": "Première reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            },
+            {
+              "texte": "Deuxième reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            },
+            {
+              "texte": "Troisième reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            },
+            {
+              "texte": "Quatrième reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            },
+            {
+              "texte": "Cinquième reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            }
+          ],
+          "justification": "Explication de pourquoi les cinq reformulations proposées sont plus correctes ou meilleures en tenant compte des erreurs détectées."
+        }
+        // ... Autres phrases détectées
+      ],
+      "summary": {
+        "total_erreurs": nombre_total_d_erreurs_detectées,
+        "total_phrases": nombre_total_de_phrases_contenant_des_erreurs,
+        "total_reformulations": nombre_total_de_reformulations_proposées
+      }
+    }
+    ```
+
+    - Assurez-vous que chaque indice correspond aux positions exactes dans le texte original.
+    - Le JSON doit être bien formé et respecter la structure indiquée.
+    - Les clés sont écrites en minuscules et suivent la structure spécifiée.
+"""
+
+
+# Version 0.0.1
 # class Phrase(BaseModel):
 #     texte: str = Field(..., description="La phrase complète contenant les erreurs.")
 #     indice_debut: int = Field(..., description="Indice de début de la phrase dans le texte.")
@@ -36,78 +160,76 @@
 #             "summary": self.summary.dict()
 #         }
 
-from typing import List
-from pydantic import BaseModel, Field
-
-class Phrase(BaseModel):
-    texte: str = Field(..., description="La phrase complète contenant les erreurs.")
-    indice_debut: int = Field(..., description="Indice de début de la phrase dans le texte.")
-    indice_fin: int = Field(..., description="Indice de fin de la phrase dans le texte.")
+# def academie_prompt_template():
+# class Phrase(BaseModel):
+#     texte: str = Field(..., description="La phrase complète contenant les erreurs.")
+#     indice_debut: int = Field(..., description="Indice de début de la phrase dans le texte.")
+#     indice_fin: int = Field(..., description="Indice de fin de la phrase dans le texte.")
 
-class Erreur(BaseModel):
-    expression: str = Field(..., description="L'expression erronée.")
-    indice_debut: int = Field(..., description="Indice de début de l'expression dans le texte.")
-    indice_fin: int = Field(..., description="Indice de fin de l'expression dans le texte.")
+# class Erreur(BaseModel):
+#     expression: str = Field(..., description="L'expression erronée.")
+#     indice_debut: int = Field(..., description="Indice de début de l'expression dans le texte.")
+#     indice_fin: int = Field(..., description="Indice de fin de l'expression dans le texte.")
 
-class Reformulation(BaseModel):
-    texte: str = Field(..., description="Reformulation proposée.")
+# class Reformulation(BaseModel):
+#     texte: str = Field(..., description="Reformulation proposée.")
 
-class PhraseDetection(BaseModel):
-    phrase: Phrase = Field(..., description="Informations sur la phrase contenant les erreurs.")
-    erreurs: List[Erreur] = Field(..., description="Liste des erreurs détectées dans la phrase.")
-    reformulations: List[Reformulation] = Field(..., description="Liste des cinq reformulations proposées.")
-    justification_unique: str = Field(..., description="Justification unique expliquant pourquoi ces reformulations améliorent la phrase.")
+# class PhraseDetection(BaseModel):
+#     phrase: Phrase = Field(..., description="Informations sur la phrase contenant les erreurs.")
+#     erreurs: List[Erreur] = Field(..., description="Liste des erreurs détectées dans la phrase.")
+#     reformulations: List[Reformulation] = Field(..., description="Liste des cinq reformulations proposées.")
+#     justification_unique: str = Field(..., description="Justification unique expliquant pourquoi ces reformulations améliorent la phrase.")
 
-class Summary(BaseModel):
-    total_erreurs: int = Field(..., description="Nombre total d'erreurs détectées.")
-    total_phrases: int = Field(..., description="Nombre total de phrases contenant des erreurs.")
-    total_reformulations: int = Field(..., description="Nombre total de reformulations proposées.")
+# class Summary(BaseModel):
+#     total_erreurs: int = Field(..., description="Nombre total d'erreurs détectées.")
+#     total_phrases: int = Field(..., description="Nombre total de phrases contenant des erreurs.")
+#     total_reformulations: int = Field(..., description="Nombre total de reformulations proposées.")
 
-class DetectionResult(BaseModel):
-    phrases_detectees: List[PhraseDetection] = Field(..., description="Liste des phrases contenant des erreurs avec leurs détails.")
-    summary: Summary = Field(..., description="Résumé des détections.")
+# class DetectionResult(BaseModel):
+#     phrases_detectees: List[PhraseDetection] = Field(..., description="Liste des phrases contenant des erreurs avec leurs détails.")
+#     summary: Summary = Field(..., description="Résumé des détections.")
 
-    def to_dict(self):
-        return {
-            "phrases_detectees": [phrase_detection.dict() for phrase_detection in self.phrases_detectees],
-            "summary": self.summary.model_dump()
-        }
+#     def to_dict(self):
+#         return {
+#             "phrases_detectees": [phrase_detection.dict() for phrase_detection in self.phrases_detectees],
+#             "summary": self.summary.model_dump()
+#         }
 
 
-"""Tu es un rédacteur web expérimenté et pointilleux qui fait attention aux moindres détails. Je vais te donner un texte, et ta mission est de {mission}.
+# """Tu es un rédacteur web expérimenté et pointilleux qui fait attention aux moindres détails. Je vais te donner un texte, et ta mission est de {mission}.
    
-Voici quelques exemples d'erreurs que tu dois détecter et corriger :
-- {Exemple d'erreur 1}, mais on dit {Correction 1}
-- {Exemple d'erreur 2}, mais on dit {Correction 2}
-- {Exemple d'erreur 3}, mais on dit {Correction 3}
+# Voici quelques exemples d'erreurs que tu dois détecter et corriger :
+# - {Exemple d'erreur 1}, mais on dit {Correction 1}
+# - {Exemple d'erreur 2}, mais on dit {Correction 2}
+# - {Exemple d'erreur 3}, mais on dit {Correction 3}
 
-Pour chaque occurrence trouvée, veille à :
+# Pour chaque occurrence trouvée, veille à :
    
-- Citer la phrase complète où l'expression apparaît, avec les **indices de début et de fin** de cette phrase dans le texte.
-- Indiquer l'expression exacte utilisée dans le texte, avec ses **indices de début et de fin** pour chaque occurrence.
-- Proposer 5 reformulations. Vous pouvez modifier toute la phrase si nécessaire pour améliorer le style tout en conservant le sens original et en prenant en compte le **contexte global** de la phrase dans le texte.
-- Fournir **une justification unique** expliquant pourquoi les cinq reformulations proposées améliorent la phrase originale.
+# - Citer la phrase complète où l'expression apparaît, avec les **indices de début et de fin** de cette phrase dans le texte.
+# - Indiquer l'expression exacte utilisée dans le texte, avec ses **indices de début et de fin** pour chaque occurrence.
+# - Proposer 5 reformulations. Vous pouvez modifier toute la phrase si nécessaire pour améliorer le style tout en conservant le sens original et en prenant en compte le **contexte global** de la phrase dans le texte.
+# - Fournir **une justification unique** expliquant pourquoi les cinq reformulations proposées améliorent la phrase originale.
 
-Les reformulations proposées doivent être fluides, naturelles, et respecter les règles suivantes :
-   - Évitez les anglicismes et les formulations informelles.
-   - Utilisez des termes et expressions appropriés pour un contexte formel ou professionnel.
-   - Les expressions comme "crucial", "essentiel", "important", "fondamental", etc., ne doivent pas être utilisées dans les phrases.
-   - Les expressions comme "Il existe", "il faut", "cependant", "de plus", "en revanche", "néanmoins", "toutefois" ne doivent pas être utilisées en début de phrase.
-   - Les expressions comme "joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des adjectifs comme "important", "essentiel", etc.
-   - "En plus" ne doit pas être utilisé seul en début de phrase.
+# Les reformulations proposées doivent être fluides, naturelles, et respecter les règles suivantes :
+#    - Évitez les anglicismes et les formulations informelles.
+#    - Utilisez des termes et expressions appropriés pour un contexte formel ou professionnel.
+#    - Les expressions comme "crucial", "essentiel", "important", "fondamental", etc., ne doivent pas être utilisées dans les phrases.
+#    - Les expressions comme "Il existe", "il faut", "cependant", "de plus", "en revanche", "néanmoins", "toutefois" ne doivent pas être utilisées en début de phrase.
+#    - Les expressions comme "joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des adjectifs comme "important", "essentiel", etc.
+#    - "En plus" ne doit pas être utilisé seul en début de phrase.
 
-Les reformulations doivent également éviter les erreurs de langue courantes, notamment celles répertoriées par l'Académie Française (site : https://www.academie-francaise.fr/dire-ne-pas-dire/).
+# Les reformulations doivent également éviter les erreurs de langue courantes, notamment celles répertoriées par l'Académie Française (site : https://www.academie-francaise.fr/dire-ne-pas-dire/).
 
-Assurez-vous que chaque reformulation tient compte du **contexte sémantique** et logique de la phrase et du paragraphe dans lequel elle apparaît. Les reformulations doivent préserver le sens global de la phrase et son intention originale, même si la structure de la phrase change.
+# Assurez-vous que chaque reformulation tient compte du **contexte sémantique** et logique de la phrase et du paragraphe dans lequel elle apparaît. Les reformulations doivent préserver le sens global de la phrase et son intention originale, même si la structure de la phrase change.
 
-Voici le texte à analyser :
-{text}
+# Voici le texte à analyser :
+# {text}
 
 
-Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+# Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
 
-\n{format_instruction}
-"""
+# \n{format_instruction}
+# """
 
 # """Tu es un rédacteur web expérimenté et pointilleux qui fait attention aux moindres détails. Je vais te donner un texte, et ta mission est de {mission}.
    

faute_style.py

@@ -1,53 +1,57 @@
 import json
 from langchain.prompts import PromptTemplate
 from langchain.chains import LLMChain
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 from typing import List, Tuple
 from langchain.chat_models import ChatOpenAI
 from langchain.output_parsers import PydanticOutputParser
 
+# Last version Yet
 
-from typing import List
-from pydantic import BaseModel, Field
-
-class Phrase(BaseModel):
-    texte: str = Field(..., description="La phrase complète contenant les erreurs.")
-    indice_debut: int = Field(..., description="Indice de début de la phrase dans le texte.")
-    indice_fin: int = Field(..., description="Indice de fin de la phrase dans le texte.")
+class PhraseDetail(BaseModel):
+    texte: str
+    indice_debut: int
+    indice_fin: int
 
 class Erreur(BaseModel):
-    expression: str = Field(..., description="L'expression erronée.")
-    indice_debut: int = Field(..., description="Indice de début de l'expression dans le texte.")
-    indice_fin: int = Field(..., description="Indice de fin de l'expression dans le texte.")
+    expression: str
+    indice_debut: int
+    indice_fin: int
 
 class Reformulation(BaseModel):
-    texte: str = Field(..., description="Reformulation prenant en compte toutes les erreurs.")
-    justification: str = Field(..., description="Explication de pourquoi cette reformulation est meilleure en tenant compte des erreurs détectées.")
+    texte: str
 
-class PhraseDetection(BaseModel):
-    phrase: Phrase = Field(..., description="Informations sur la phrase contenant les erreurs.")
-    erreurs: List[Erreur] = Field(..., description="Liste des erreurs détectées dans la phrase.")
-    reformulations: List[Reformulation] = Field(..., description="Liste des cinq reformulations proposées.")
+class DetectedPhrase(BaseModel):
+    phrase: PhraseDetail
+    erreurs: List[Erreur]
+    reformulations: List[Reformulation]
+    justification: str
 
 class Summary(BaseModel):
-    total_erreurs: int = Field(..., description="Nombre total d'erreurs détectées.")
-    total_phrases: int = Field(..., description="Nombre total de phrases contenant des erreurs.")
-    total_reformulations: int = Field(..., description="Nombre total de reformulations proposées.")
+    total_erreurs: int
+    total_phrases: int
+    total_reformulations: int
+
+    @field_validator('total_erreurs', 'total_phrases', 'total_reformulations')
+    def non_negative(cls, v, field):
+        if v < 0:
+            raise ValueError(f"{field.name} doit être non négatif")
+        return v
+
 
 class DetectionResult(BaseModel):
-    phrases_detectees: List[PhraseDetection] = Field(..., description="Liste des phrases contenant des erreurs avec leurs détails.")
+    phrases_detectees: List[DetectedPhrase] = Field(..., description="Liste des phrases contenant des erreurs avec leurs détails.")
     summary: Summary = Field(..., description="Résumé des détections.")
 
     def to_dict(self):
         return {
-            "phrases_detectees": [phrase_detection.model_dump() for phrase_detection in self.phrases_detectees],
+            "phrases_detectees": [phrase_detectee.model_dump() for phrase_detectee in self.phrases_detectees],
             "summary": self.summary.model_dump()
         }
 
 
 def academie_prompt_template():
-    return """
-    Tu es un rédacteur web expérimenté et pointilleux qui fait attention aux moindres détails. Je vais te donner un texte, et ta mission est de repérer des erreurs de langue courantes, notamment celles répertoriées par l'Académie Française (site : https://www.academie-francaise.fr/dire-ne-pas-dire/).
+    return """Tu es un rédacteur web expérimenté et pointilleux qui fait attention aux moindres détails. Je vais te donner un texte, et ta mission est de repérer des erreurs de langue courantes, notamment celles répertoriées par l'Académie Française (site : https://www.academie-francaise.fr/dire-ne-pas-dire/).
    
     Voici quelques exemples d'erreurs que tu dois détecter et corriger :
     - On ne dit pas "Faire recours", mais on dit "Avoir recours" ou "Recourir"
@@ -81,6 +85,51 @@ def academie_prompt_template():
     ```{text}```
 
     Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+    ```json
+    {
+      "phrases_detectees": [
+        {
+          "phrase": {
+            "texte": "La phrase complète contenant les erreurs.",
+            "indice_debut": indice_debut_de_la_phrase,
+            "indice_fin": indice_fin_de_la_phrase
+          },
+          "erreurs": [
+            {
+              "expression": "L'expression erronée",
+              "indice_debut": indice_debut_de_l_expression,
+              "indice_fin": indice_fin_de_l_expression
+            }
+            // ... Autres erreurs éventuelles
+          ],
+          "reformulations": [
+            {
+              "texte": "Première reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            },
+            {
+              "texte": "Deuxième reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            },
+            {
+              "texte": "Troisième reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            },
+            {
+              "texte": "Quatrième reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            },
+            {
+              "texte": "Cinquième reformulation de la phrase en tenant compte de toutes les erreurs détectées."
+            }
+          ],
+          "justification": "Explication de pourquoi les cinq reformulations proposées sont plus correctes ou meilleures en tenant compte des erreurs détectées."
+        }
+        // ... Autres phrases détectées
+      ],
+      "summary": {
+        "total_erreurs": nombre_total_d_erreurs_detectées,
+        "total_phrases": nombre_total_de_phrases_contenant_des_erreurs,
+        "total_reformulations": nombre_total_de_reformulations_proposées
+      }
+    }
+    ```
     \n{format_instruction}
     """
 
@@ -118,6 +167,135 @@ def detect_errors(text):
         "prompt": final_prompt
     }
 
+
+# Version 0.0.1
+# class Phrase(BaseModel):
+#     texte: str = Field(..., description="La phrase complète contenant les erreurs.")
+#     indice_debut: int = Field(..., description="Indice de début de la phrase dans le texte.")
+#     indice_fin: int = Field(..., description="Indice de fin de la phrase dans le texte.")
+
+# class Erreur(BaseModel):
+#     expression: str = Field(..., description="L'expression erronée.")
+#     indice_debut: int = Field(..., description="Indice de début de l'expression dans le texte.")
+#     indice_fin: int = Field(..., description="Indice de fin de l'expression dans le texte.")
+
+# class Reformulation(BaseModel):
+#     texte: str = Field(..., description="Reformulation prenant en compte toutes les erreurs.")
+#     justification: str = Field(..., description="Explication de pourquoi cette reformulation est meilleure en tenant compte des erreurs détectées.")
+
+# class PhraseDetection(BaseModel):
+#     phrase: Phrase = Field(..., description="Informations sur la phrase contenant les erreurs.")
+#     erreurs: List[Erreur] = Field(..., description="Liste des erreurs détectées dans la phrase.")
+#     reformulations: List[Reformulation] = Field(..., description="Liste des cinq reformulations proposées.")
+
+# class Summary(BaseModel):
+#     total_erreurs: int = Field(..., description="Nombre total d'erreurs détectées.")
+#     total_phrases: int = Field(..., description="Nombre total de phrases contenant des erreurs.")
+#     total_reformulations: int = Field(..., description="Nombre total de reformulations proposées.")
+
+# class DetectionResult(BaseModel):
+#     phrases_detectees: List[PhraseDetection] = Field(..., description="Liste des phrases contenant des erreurs avec leurs détails.")
+#     summary: Summary = Field(..., description="Résumé des détections.")
+
+#     def to_dict(self):
+#         return {
+#             "phrases_detectees": [phrase_detection.model_dump() for phrase_detection in self.phrases_detectees],
+#             "summary": self.summary.model_dump()
+#         }
+
+
+# def academie_prompt_template():
+#     return """
+#     Tu es un rédacteur web expérimenté et pointilleux qui fait attention aux moindres détails. Je vais te donner un texte, et ta mission est de repérer des erreurs de langue courantes, notamment celles répertoriées par l'Académie Française (site : https://www.academie-francaise.fr/dire-ne-pas-dire/).
+   
+#     Voici quelques exemples d'erreurs que tu dois détecter et corriger :
+#     - On ne dit pas "Faire recours", mais on dit "Avoir recours" ou "Recourir"
+#     - On ne dit pas "Souscrire à un contrat", mais on dit "Souscrire un contrat"
+#     - On ne dit pas "Dans ce sens" (pour parler d'un raisonnement), mais on dit "En ce sens"
+#     - On ne dit pas "En termes de" pour parler de "En matière de"
+#     - On ne dit pas "Palier à", mais on dit "Palier" tout court
+#     - On ne dit pas "code de la route", mais "Code de la route"
+
+#     Pour chaque occurrence trouvée, veille à :
+   
+#     - Citer la phrase complète où l'expression apparaît, avec les **indices de début et de fin** de cette phrase dans le texte.
+#     - Indiquer l'expression exacte utilisée dans le texte, avec ses **indices de début et de fin** pour chaque occurrence.
+#     - Proposer 5 reformulations. Vous pouvez modifier toute la phrase si nécessaire pour améliorer le style tout en conservant le sens original et en prenant en compte le **contexte global** de la phrase dans le texte.
+#     - Fournir **une justification unique** expliquant pourquoi les cinq reformulations proposées améliorent la phrase originale.
+    
+#     Les reformulations proposées doivent être fluides, naturelles, et respecter les règles suivantes :
+#        - Évitez les anglicismes et les formulations informelles.
+#        - Utilisez des termes et expressions appropriés pour un contexte formel ou professionnel.
+#        - Les expressions comme "crucial", "essentiel", "important", "fondamental", etc., ne doivent pas être utilisées dans les phrases.
+#        - Les expressions comme "Il existe", "il faut", "cependant", "de plus", "en revanche", "néanmoins", "toutefois" ne doivent pas être utilisées en début de phrase.
+#        - Les expressions comme "joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des adjectifs comme "important", "essentiel", etc.
+#        - "En plus" ne doit pas être utilisé seul en début de phrase.
+    
+#     Les reformulations doivent également éviter les erreurs de langue courantes, notamment celles répertoriées par l'Académie Française (site : https://www.academie-francaise.fr/dire-ne-pas-dire/).
+   
+#     Assurez-vous que chaque reformulation tient compte du **contexte sémantique** et logique de la phrase et du paragraphe dans lequel elle apparaît. Les reformulations doivent préserver le sens global de la phrase et son intention originale, même si la structure de la phrase change.
+    
+#     Voici le texte à analyser :
+    
+#     ```{text}```
+
+#     Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+#     - "phrase_avec_erreur": {
+#           "contenu": "<contenu_de_la_phrase>",
+#           "indices_phrase": "<indices_debut_fin_phrase>"
+#       },
+#     - "erreurs": [
+#           {
+#               "expression_erreur": "<expression_erronee>",
+#               "indices_expression": "<indices_debut_fin_expression>",
+#               "reformulations": [
+#                   "<reformulation_1>",
+#                   "<reformulation_2>",
+#                   "<reformulation_3>",
+#                   "<reformulation_4>",
+#                   "<reformulation_5>"
+#               ],
+#               "justification": "<justification_pour_les_reformulations>"
+#           }
+#       ]
+#     \n{format_instruction}
+#     """
+
+# def detect_errors(text):
+#     # Créer le template avec la variable text intégrée directement
+#     prompt_template = academie_prompt_template()
+
+#     output_parser = PydanticOutputParser(pydantic_object=DetectionResult)
+
+#     # Créer le prompt avec le texte intégré
+#     gen_prompt_template = PromptTemplate(
+#         input_variables=["text"],
+#         template=prompt_template,
+#         partial_variables={'format_instruction': output_parser.get_format_instructions()}
+#     )
+
+#     # Créer une instance du modèle de langage
+#     llm = ChatOpenAI(model='gpt-4', temperature=0.5, api_key="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")
+
+#     # Exécuter la chaîne avec le LLM
+#     llm_chain = gen_prompt_template | llm | output_parser
+
+#     # Appel du modèle avec le texte fourni
+#     result_dict = llm_chain.invoke({"text": text}).to_dict()
+
+#     # Parsing de la réponse JSON
+#     json_result = json.dumps(result_dict, indent=8, ensure_ascii=False)
+
+#     # Générer le prompt final
+#     final_prompt = gen_prompt_template.format(text=text)
+
+#     # Retourne les suggestions ou les erreurs de parsing
+#     return {
+#         "result": json_result,
+#         "prompt": final_prompt
+#     }
+
 # # Modèles Pydantic pour structurer la réponse
 # class AlternativeSuggestion(BaseModel):
 #     suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
@@ -322,59 +500,59 @@ def detect_errors(text):
     
 #     Le format de sortie doit être un JSON structuré avec les éléments suivants :
     
-#     ```json
-#     {
-#       "phrases_detectees": [
-#         {
-#           "phrase": {
-#             "texte": "La phrase complète contenant les erreurs.",
-#             "indice_debut": indice_debut_de_la_phrase,
-#             "indice_fin": indice_fin_de_la_phrase
-#           },
-#           "erreurs": [
-#             {
-#               "expression": "L'expression erronée",
-#               "indice_debut": indice_debut_de_l_expression,
-#               "indice_fin": indice_fin_de_l_expression
-#             }
-#             // ... Autres erreurs éventuelles
-#           ],
-#           "reformulations": [
-#             {
-#               "texte": "Première reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
-#               "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
-#             },
-#             {
-#               "texte": "Deuxième reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
-#               "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
-#             },
-#             {
-#               "texte": "Troisième reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
-#               "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
-#             },
-#             {
-#               "texte": "Quatrième reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
-#               "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
-#             },
-#             {
-#               "texte": "Cinquième reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
-#               "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
-#             }
-#           ]
-#         }
-#         // ... Autres phrases détectées
-#       ],
-#       "summary": {
-#         "total_erreurs": nombre_total_d_erreurs_detectées,
-#         "total_phrases": nombre_total_de_phrases_contenant_des_erreurs,
-#         "total_reformulations": nombre_total_de_reformulations_proposées
-#       }
-#     }
-#     ```
+    # ```json
+    # {
+    #   "phrases_detectees": [
+    #     {
+    #       "phrase": {
+    #         "texte": "La phrase complète contenant les erreurs.",
+    #         "indice_debut": indice_debut_de_la_phrase,
+    #         "indice_fin": indice_fin_de_la_phrase
+    #       },
+    #       "erreurs": [
+    #         {
+    #           "expression": "L'expression erronée",
+    #           "indice_debut": indice_debut_de_l_expression,
+    #           "indice_fin": indice_fin_de_l_expression
+    #         }
+    #         // ... Autres erreurs éventuelles
+    #       ],
+    #       "reformulations": [
+    #         {
+    #           "texte": "Première reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
+    #           "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
+    #         },
+    #         {
+    #           "texte": "Deuxième reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
+    #           "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
+    #         },
+    #         {
+    #           "texte": "Troisième reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
+    #           "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
+    #         },
+    #         {
+    #           "texte": "Quatrième reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
+    #           "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
+    #         },
+    #         {
+    #           "texte": "Cinquième reformulation de la phrase en tenant compte de toutes les erreurs détectées.",
+    #           "justification": "Explication de pourquoi cette reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées."
+    #         }
+    #       ]
+    #     }
+    #     // ... Autres phrases détectées
+    #   ],
+    #   "summary": {
+    #     "total_erreurs": nombre_total_d_erreurs_detectées,
+    #     "total_phrases": nombre_total_de_phrases_contenant_des_erreurs,
+    #     "total_reformulations": nombre_total_de_reformulations_proposées
+    #   }
+    # }
+    # ```
     
-#     Assurez-vous que :
+    # Assurez-vous que :
     
-#     - Chaque indice correspond aux positions exactes dans le texte original.
-#     - Le JSON est bien formé et respecte la structure indiquée.
-#     - Les clés sont écrites en minuscules et suivent la structure spécifiée.
+    # - Chaque indice correspond aux positions exactes dans le texte original.
+    # - Le JSON est bien formé et respecte la structure indiquée.
+    # - Les clés sont écrites en minuscules et suivent la structure spécifiée.
 #     """