first commit

.gitignore

@@ -0,0 +1 @@
+venv/

app.py

@@ -0,0 +1,375 @@
+import streamlit as st
+
+import logging
+from langchain.chat_models import ChatOpenAI
+
+# Import the function for detecting the "est une étape" pattern
+from pattern_ce_qui_explique import explication, explication_prompt_template
+from pattern_epoque import epoque, epoque_prompt_template
+from pattern_est_une_etape import une_etape, est_une_etape_prompt_template
+from pattern_adverbe_ment import adverbement, adverbement_prompt_template
+from pattern_connecteur_cependant import connecteur, connecteur_prompt_template
+from pattern_decision import decision, decision_prompt_template
+from pattern_look import look, look_prompt_template
+from pattern_il_existe import il_existe, il_existe_prompt_template
+from pattern_il_faut import il_faut, il_faut_prompt_template
+from pattern_vous_pouvez import vous_pouvez, vous_pouvez_prompt_template
+from pattern_imaginez import imaginez, imaginez_prompt_template
+from pattern_en_plus import en_plus_prompt_template, detect_en_plus
+from pattern_outre import detect_outre, outre_prompt_template
+from pattern_il_suffit_de import detect_il_suffit_de, il_suffit_de_prompt_template
+from pattern_important_crucial import importance_prompt_template, importance_detection
+from pattern_permettre import permettre_detection, permettre_prompt_template
+from pattern_voici_decouvrez import detect_voici_decouvrez, voici_decouvrez_prompt_template
+from faute_style import detect_errors, academie_prompt_template
+
+# Interface Streamlit
+st.title("Analyse du texte")
+
+# Liste des templates de prompt
+List_prompt = {
+    "< Détection du pattern 'est une étape' >": est_une_etape_prompt_template(),
+    "< Détection du pattern 'epoque de, à l'ère de' >": epoque_prompt_template(),
+    "< Détection du pattern 'ce qui explique' >": explication_prompt_template(),
+    "< Détection des adverbes en -ment >": adverbement_prompt_template(),
+    "< Détection des connecteurs 'cependant' >": connecteur_prompt_template(),
+    "< Détection des decision 'éclairée...' >": decision_prompt_template(),
+    "< Détection du pattern 'look' >": look_prompt_template(),
+    "< Détection du pattern 'il existe' >": il_existe_prompt_template(),
+    "< Détection du pattern 'il faut' >": il_faut_prompt_template(),
+    "< Détection du pattern 'vous pouvez' >": vous_pouvez_prompt_template(),
+    "< Détection du pattern 'imaginez' >": imaginez_prompt_template(),
+    "< Détection du pattern 'en plus' >": en_plus_prompt_template(),
+    "< Détection du pattern 'outre' >": outre_prompt_template(),
+    "< Détection du pattern 'il suffit de' >": il_suffit_de_prompt_template(),
+    "< Détection du pattern 'important crucial' >": importance_prompt_template(),
+    "< Détection du pattern 'permettre' >": permettre_prompt_template(),
+    "< Détection du pattern 'voici découvrez' >": voici_decouvrez_prompt_template(),
+    "< Détection des erreurs de style" : academie_prompt_template()
+}
+
+# Menu déroulant pour sélectionner l'analyse
+option = st.selectbox(
+    "Choisissez l'analyse à effectuer :",
+    List_prompt.keys()
+)
+
+# Afficher le prompt correspondant à l'option sélectionnée
+selected_prompt = List_prompt.get(option, "")
+st.subheader(f"Prompt : {option}")
+st.text_area("Voici le prompt utilisé pour cette analyse :", value=selected_prompt, height=300, disabled=True)
+
+# Champ de saisie du texte
+input_text = st.text_area("Entrez votre texte ici :", height=200)
+
+# Bouton d'analyse
+if st.button("Lancer l'analyse"):
+    if input_text:
+        if option == "< Détection du pattern 'est une étape' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = une_etape(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'est une étape'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+
+        elif option == "< Détection du pattern 'epoque de, à l'ère de' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = epoque(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'epoque de, à l'ère de'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'ce qui explique' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = explication(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'ce qui explique'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection des adverbes en -ment >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = adverbement(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse des adverbes en -ment")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection des connecteurs 'cependant' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = connecteur(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse des connecteurs 'cependant'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection des decision 'éclairée...' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = decision(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse des decision 'éclairée...'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'look' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = look(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'look'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'il existe' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = il_existe(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'il existe'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'il faut' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = il_faut(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'il faut'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'vous pouvez' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = vous_pouvez(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'vous pouvez'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'imaginez' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = imaginez(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'imaginez'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'en plus' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = detect_en_plus(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'en plus'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'outre' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = detect_outre(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'outre'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'il suffit de' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = detect_il_suffit_de(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'il suffit de'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+
+        elif option == "< Détection du pattern 'important crucial' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = importance_detection(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'important crucial'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'permettre' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = permettre_detection(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'permettre'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection du pattern 'voici découvrez' >":
+            try:
+                # Analyser le texte pour les fautes de style
+                result = detect_voici_decouvrez(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse du pattern 'voici découvrez'")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                # st.subheader("Prompt final envoyé au modèle")
+                # st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+        elif option == "< Détection des erreurs de style" :
+            try:
+                # Analyser le texte pour les fautes de style
+                result = detect_errors(input_text)
+
+                # Afficher les résultats en JSON formaté
+                st.subheader("Résultats de l'analyse des erreurs de style")
+                st.json(result['result'], expanded=True)
+
+                # Afficher le prompt final
+                st.subheader("Prompt final envoyé au modèle")
+                st.write(result['prompt'])
+
+            except Exception as e:
+                logging.error(f"Error during analysis: {e}")
+                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
+        
+    else:
+        st.error("Veuillez entrer du texte pour lancer l'analyse.")

const.py

@@ -0,0 +1,265 @@
+
+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.")
+#     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.dict() for phrase_detection in self.phrases_detectees],
+#             "summary": self.summary.dict()
+#         }
+
+# 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 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 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.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}.
+   
+# 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é :
+
+# \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}.
+   
+# 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 pour expliquer pourquoi la reformulation est plus correcte ou meilleure.
+
+# 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é :
+# \n{format_instruction}>>"""

faute_style.py

@@ -0,0 +1,558 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+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
+
+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: 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[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 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é :
+    ```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
+            }}
+            
+          ],
+          "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."
+        }}
+        
+      ],
+      "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}
+    """
+
+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
+    }
+
+
+# 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.")
+#     suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+#     suggestion_3: str = Field(..., description="Troisième suggestion de reformulation.")
+#     suggestion_4: str = Field(..., description="Quatrième suggestion de reformulation.")
+#     suggestion_5: str = Field(..., description="Cinquième suggestion de reformulation.")
+#     justification: str = Field(..., description="Justification de la suggestion.")
+
+
+# class PatternDetail(BaseModel):
+#     pattern: str = Field(..., description="Mot ou expression détectée.")
+#     indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence de l'expression dans le texte.")
+#     sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+#     sentence_indices: Tuple[int, int] = Field(..., description="Indices de début et de fin de la phrase complète dans le texte.")
+#     alternative_suggestions: AlternativeSuggestion = Field(..., description="Cinq suggestions de reformulation avec justification. La phrase complète peut être modifiée.")
+
+#     def to_dict(self):
+#         return {
+#             "pattern": self.pattern,
+#             "indices": self.indices,
+#             "sentence": self.sentence,
+#             "sentence_indices": self.sentence_indices,
+#             "alternative_suggestions": {
+#                 "suggestion_1": self.alternative_suggestions.suggestion_1,
+#                 "suggestion_2": self.alternative_suggestions.suggestion_2,
+#                 "suggestion_3": self.alternative_suggestions.suggestion_3,
+#                 "suggestion_4": self.alternative_suggestions.suggestion_4,
+#                 "suggestion_5": self.alternative_suggestions.suggestion_5,
+#                 "justification": self.alternative_suggestions.justification
+#             }
+#         }
+
+
+# class Summary(BaseModel):
+#     total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+#     alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+#     occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+#     def to_dict(self):
+#         return {
+#             "total_patterns_detected": self.total_patterns_detected,
+#             "alternative_suggestions_provided": self.alternative_suggestions_provided,
+#             "occurrences": self.occurrences
+#         }
+
+
+# class DetectionResult(BaseModel):
+#     patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+#     summary: Summary = Field(..., description="Résumé de la détection.")
+
+#     def to_dict(self):
+#         return {
+#             "patterns": [pattern.to_dict() for pattern in self.patterns],
+#             "summary": self.summary.to_dict()
+#         }
+
+
+# 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 pour expliquer pourquoi la reformulation est plus correcte ou meilleure.
+    
+#     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é :
+#     \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}.
+   
+# 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 pour expliquer pourquoi la reformulation est plus correcte ou meilleure.
+
+# 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é :
+# \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}.
+
+# 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 phrase contenant une ou plusieurs erreurs, veille à :
+
+# - Citer la phrase complète où les erreurs apparaissent, avec les **indices de début et de fin** de cette phrase dans le texte.
+# - Indiquer pour chaque erreur dans la phrase :
+#   - L'expression exacte utilisée dans le texte, avec ses **indices de début et de fin** pour chaque occurrence.
+# - Proposer 5 reformulations de la phrase en prenant en compte toutes les erreurs détectées. 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 pour expliquer pourquoi chaque reformulation est plus correcte ou meilleure.
+
+# 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 phrase contenant des erreurs :
+# \n{format_instruction}>>"""
+
+
+
+# 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 phrase contenant une ou plusieurs erreurs, veille à :
+   
+#     - Citer la phrase complète où les erreurs apparaissent, avec les **indices de début et de fin** de cette phrase dans le texte.
+#     - Indiquer pour chaque erreur dans la phrase :
+#       - L'expression exacte utilisée dans le texte, avec ses **indices de début et de fin** pour chaque occurrence.
+#     - Proposer 5 reformulations de la phrase en prenant en compte toutes les erreurs détectées. 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 pour expliquer pourquoi chaque reformulation est plus correcte ou meilleure en tenant compte des erreurs détectées.
+    
+#     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 :
+    
+    # ```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 :
+    
+    # - 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.
+#     """

pattern_adverbe_ment.py

@@ -0,0 +1,134 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+    justification: str = Field(..., description="Justification de la suggestion.")
+
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation avec justification.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+                "justification": self.alternative_suggestions.justification
+            }
+        }
+
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+
+def adverbement_prompt_template():
+    return """
+   Veuillez analyser le texte suivant et identifier tous les adverbes se terminant par "-ment". 
+   Regroupe ces patterns par phrase afin de les reformuler ensemble dans la seule phrase.
+
+    Pour chaque occurrence trouvée, veuillez :
+    
+    - Citer la phrase complète où l'expression apparaît.
+    - Indiquer l'expression exacte utilisée dans le texte.
+    - Proposer deux reformulations de la phrase en supprimant les adverbes redondants ou superflus, ou en les remplaçant par des verbes plus précis pour améliorer le style, tout en conservant le sens original.
+    - Fournir une justification de la suggestion, expliquant en quoi elle améliore la clarté ou le style.
+    
+    Assurez-vous de respecter les règles suivantes :
+    1. Les expressions comme "crucial", "essentiel", "important", "fondamental", etc., ne doivent pas être utilisées dans les phrases.
+    2. 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.
+    3. 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.
+    4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+    Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+    - "pattern": "mot ou expression détectée",
+    - "indices": [[index de début, index de fin pour chaque occurrence]],
+    - "sentence": "phrase où l'expression est utilisée",
+    - "alternative_suggestions": ["suggestion 1", "suggestion 2"],
+    - "justification": "justification de la suggestion"
+
+    Si aucun pattern n'est trouvé, retournez un JSON avec :
+    - "pattern0": "",
+    - "occurrences": 0,
+
+    À la fin, ajoutez un résumé avec :
+    - "total_patterns_detected": nombre total de patterns détectés,
+    - "alternative_suggestions_provided": nombre de suggestions données,
+    - "occurrences": nombre d'occurrences.
+
+    Voici le texte à analyser :
+    ```{text}```
+
+    \n{format_instruction}
+    """
+
+
+def adverbement(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = adverbement_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-4o', 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
+    }

pattern_ce_qui_explique.py

@@ -0,0 +1,133 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+            }
+        }
+
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+
+def explication_prompt_template():
+    return """
+    Analyse le texte suivant et identifie toutes les occurrences de l'expression "Ce qui" et ses variantes, telles que :
+    "Ce qui signifie que", "Ce qui implique que", "Ce qui veut dire que", "Ce qui fait que", "Ce qui entraîne", 
+    "Ce qui conduit à", "Ce qui permet de", "Ce qui résulte en", "Ce qui cause", "Ce qui représente".
+
+    Incluez également toute autre expression similaire commençant par "Ce qui" et introduisant une conséquence, une explication ou une clarification.
+
+    Pour chaque occurrence trouvée, veuillez :
+
+    - Citer la phrase complète où l'expression apparaît.
+    - Indiquer l'expression exacte utilisée dans le texte.
+    - Proposer deux reformulations de la phrase pour changer l'expression détectée, en évitant les répétitions, et rendre la phrase plus précise et claire.
+    - Assurez-vous de respecter les règles suivantes :
+      1. Ne pas utiliser plus d'une fois dans l'introduction des expressions comme "crucial", "essentiel", "important", "fondamental", etc.
+      2. Ne pas utiliser "il existe", "il faut", "cependant", "de plus", etc., en début de phrase.
+      3. Les expressions comme "Joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des mots comme "important", "essentiel", etc.
+      4. "En plus" ne doit pas être seul en début de phrase.
+
+    Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+    - "pattern": "mot ou expression détectée",
+    - "indices": [[index de début, index de fin pour chaque occurrence]],
+    - "sentence": "phrase où l'expression est utilisée",
+    - "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+    Si aucun pattern n'est trouvé, retournez un JSON avec :
+
+    - "pattern0": "",
+    - "occurrences": 0,
+
+    À la fin, ajoutez un résumé avec :
+    - "total_patterns_detected": nombre total de patterns détectés,
+    - "alternative_suggestions_provided": nombre de suggestions fournies,
+    - "occurrences": nombre d'occurrences.
+
+    Voici le texte à analyser :
+    ```{text}```
+
+    \n{format_instruction}
+    """
+
+
+def explication(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = explication_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-4o', 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
+    }

pattern_connecteur_cependant.py

@@ -0,0 +1,135 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+    justification: str = Field(..., description="Justification de la suggestion.")
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation avec justification.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+                "justification": self.alternative_suggestions.justification
+            }
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+def connecteur_prompt_template():
+    return """
+    Veuillez analyser le texte suivant et identifier toutes les phrases qui commencent par des connecteurs ou des adverbes tels que :
+
+    Opposition/Concession : "Cependant", "Toutefois", "Néanmoins", "Pourtant", "En revanche", "Or", "Mais", "Malgré tout", "En dépit de cela", "Au demeurant", "Bien que", "Quoique"
+    Addition : "De plus", "En outre", "Par ailleurs", "D'ailleurs", "De surcroît", "En addition", "Par-dessus le marché", "En plus de cela"
+    Conséquence : "Ainsi", "Donc", "Alors", "Par conséquent", "En effet", "C'est pourquoi", "Par suite", "En conséquence", "Il en résulte que", "D'où"
+    Chronologie : "Ensuite", "Puis", "D'abord", "Premièrement", "Deuxièmement", "Enfin", "Par la suite"
+    Exemple : "Par exemple", "Notamment", "En particulier", "Comme"
+    Conclusion/Synthèse : "Finalement", "Au final", "En conclusion", "Pour finir", "En résumé", "Somme toute"
+
+    Pour chaque occurrence trouvée, veuillez :
+
+    - Citer la phrase complète où l'expression apparaît.
+    - Indiquer l'expression exacte utilisée dans le texte.
+    - Proposer deux reformulations de la phrase, en déplaçant le connecteur vers le milieu ou la fin de la phrase si approprié, ou en intégrant le connecteur dans une phrase précédente ou suivante pour améliorer la fluidité.
+    - Fournir une justification de la suggestion, expliquant en quoi elle améliore la clarté ou le style.
+
+    Assurez-vous de respecter les règles suivantes :
+    1. Les expressions comme "crucial", "essentiel", "important", "fondamental", etc., ne doivent pas être utilisées plus d'une fois dans l'introduction.
+    2. 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.
+    3. 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.
+    4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+    Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+    - "pattern": "mot ou expression détectée",
+    - "indices": [[index de début, index de fin pour chaque occurrence]],
+    - "sentence": "phrase où l'expression est utilisée",
+    - "alternative_suggestions": ["suggestion 1", "suggestion 2"],
+    - "justification": "justification de la suggestion"
+
+    Si aucun pattern n'est trouvé, retournez un JSON avec :
+    - "pattern0": "",
+    - "occurrences": 0,
+
+    À la fin, ajoutez un résumé avec :
+    - "total_patterns_detected": nombre total de patterns détectés,
+    - "alternative_suggestions_provided": nombre de suggestions données,
+    - "occurrences": nombre d'occurrences.
+
+    Voici le texte à analyser :
+    ```{text}```
+
+    \n{format_instruction}
+    """
+
+def connecteur(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = connecteur_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-4o', 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
+    }

pattern_decision.py

@@ -0,0 +1,128 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+    justification: str = Field(..., description="Justification de la suggestion.")
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation avec justification.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+                "justification": self.alternative_suggestions.justification
+            }
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+def decision_prompt_template():
+    return """
+  Veuillez analyser le texte suivant et identifier toutes les occurrences des expressions liées à la prise de décision comportant des adjectifs tels que "éclairée", "avisée", "judicieuse", "réfléchie", "sage", "pertinente", "optimale", "sensée", etc.
+
+  Pour chaque occurrence trouvée, veuillez :
+
+    - Citer la phrase complète où l'expression apparaît.
+    - Indiquer l'expression exacte utilisée dans le texte.
+    - Proposer deux reformulations de la phrase, en supprimant l'expression ou en la reformulant pour améliorer le style, tout en conservant le sens général.
+    - Assurez-vous que la phrase reformulée est grammaticalement correcte, naturelle et adaptée au contexte.
+
+  Assurez-vous également de respecter les règles suivantes :
+  1. Les expressions comme "crucial", "essentiel", "important", "fondamental", etc., ne doivent pas être utilisées plus d'une fois dans l'introduction.
+  2. 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.
+  3. 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.
+  4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+  Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+  - "pattern": "mot ou expression détectée",
+  - "indices": [[index de début, index de fin pour chaque occurrence]],
+  - "sentence": "phrase où l'expression est utilisée",
+  - "alternative_suggestions": ["suggestion 1", "suggestion 2"],
+  - "justification": "justification de la suggestion"
+
+  Si aucun pattern n'est trouvé, retournez un JSON avec :
+  - "pattern0": "",
+  - "occurrences": 0,
+
+  À la fin, ajoutez un résumé avec :
+  - "total_patterns_detected": nombre total de patterns détectés,
+  - "alternative_suggestions_provided": nombre de suggestions données,
+  - "occurrences": nombre d'occurrences.
+
+  Voici le texte à analyser :
+  ```{text}```
+
+  \n{format_instruction}
+  """
+
+def decision(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = decision_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-4o', 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
+    }

pattern_detection_permettre.py

@@ -0,0 +1,51 @@
+import spacy
+
+# Charger le modèle de langue française
+nlp = spacy.load('fr_core_news_md')  # Utilisez 'fr_core_news_sm' si 'md' n'est pas disponible
+
+def est_auxiliaire(token):
+    return token.pos_ == "AUX" or (token.pos_ == "VERB" and token.tag_ and "Aux" in token.tag_)
+
+def est_infinitif(token):
+    return token.pos_ == "VERB" and "Inf" in token.tag_
+
+def trouver_formes_permettre(texte):
+    doc = nlp(texte)
+    resultats = []
+    for i, token in enumerate(doc):
+        # Vérifier si le lemme est "permettre" et que le mot est un verbe (autre que "permis")
+        if token.lemma_ == "permettre" and token.pos_ == "VERB" and token.text.lower() != "permis":
+            resultats.append((token.text, token.idx))
+        # Traiter spécifiquement le mot "permis"
+        elif token.text.lower() == "permis":
+            est_verbe = False
+            # Vérifier si le mot précédent est un auxiliaire
+            if i > 0 and est_auxiliaire(doc[i - 1]):
+                est_verbe = True
+            # Vérifier si le mot suivant est "de" suivi d'un verbe à l'infinitif
+            elif i + 2 < len(doc) and doc[i + 1].text.lower() == "de" and est_infinitif(doc[i + 2]):
+                est_verbe = True
+            # Vérifier si le mot précédent est un déterminant (le, la, un, une, etc.)
+            elif i > 0 and doc[i - 1].pos_ == "DET":
+                est_verbe = False
+            else:
+                # Autres vérifications possibles si nécessaire
+                est_verbe = False
+
+            if est_verbe:
+                resultats.append((token.text, token.idx))
+            else:
+                continue  # C'est un nom, on l'exclut
+    return resultats
+
+# Exemple d'utilisation
+texte = """
+Il m'a permis de partir. J'ai besoin d'un permis de conduire.
+Cela permet de comprendre. La loi permettra des changements.
+Le permis de construire a été accordé. Nous avons permis cette action.
+"""
+
+formes_permettre = trouver_formes_permettre(texte)
+print("Les formes du verbe 'permettre' trouvées dans le texte avec leurs index sont :")
+for mot, index in formes_permettre:
+    print(f"Mot : '{mot}' à l'index {index}")

pattern_en_plus.py

@@ -0,0 +1,108 @@
+from langchain.prompts import PromptTemplate
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field
+from typing import List
+import json
+from langchain.chat_models import ChatOpenAI
+
+
+# Modèle de sortie pour la détection de l'expression "en plus" en début de phrase
+class ReformulationDetail(BaseModel):
+    original: str = Field(..., description="Phrase originale contenant 'en plus' en début de phrase.")
+    explanation: str = Field(..., description="Explication sur pourquoi l'expression 'en plus' est mal placée en début de phrase.")
+    reformulation_1: str = Field(..., description="Reformulation de la phrase avec 'en plus' déplacé.")
+    reformulation_2: str = Field(..., description="Seconde reformulation de la phrase.")
+    reformulation_3: str = Field(..., description="Troisième reformulation de la phrase.")
+
+    def to_dict(self):
+        return {
+            "original": self.original,
+            "explanation": self.explanation,
+            "reformulation_1": self.reformulation_1,
+            "reformulation_2": self.reformulation_2,
+            "reformulation_3": self.reformulation_3
+        }
+
+class Summary(BaseModel):
+    total_occurrences: int = Field(..., description="Nombre total d'occurrences de 'en plus' détectées.")
+    reformulations_provided: int = Field(..., description="Nombre de reformulations fournies.")
+
+    def to_dict(self):
+        return {
+            "total_occurrences": self.total_occurrences,
+            "reformulations_provided": self.reformulations_provided
+        }
+
+class DetectionResult(BaseModel):
+    reformulations: List[ReformulationDetail] = Field(..., description="Liste des reformulations proposées.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "reformulations": [reformulation.to_dict() for reformulation in self.reformulations],
+            "summary": self.summary.to_dict()
+        }
+
+# Création du template pour la détection de l'utilisation de "en plus" en début de phrase
+def en_plus_prompt_template():
+    return """
+Vous êtes un éditeur de texte IA extrêmement rigoureux. Votre tâche est d'analyser **précisément** le texte fourni pour détecter **toutes les occurrences** de l'expression **"en plus"** utilisée **en début de phrase**, sans "de".
+
+Pour chaque phrase trouvée, vous devez impérativement :
+
+1. **Citer exactement** la phrase originale contenant "en plus".
+2. **Expliquer brièvement et clairement** pourquoi "en plus" est mal placé en début de phrase et préciser qu'il doit être reformulé au cœur de la phrase.
+3. **Proposer trois alternatives plus correctes**, telles que "de plus", "en outre", "par ailleurs", "aussi", mais **placées au milieu de la phrase**.
+4. **Assurer** que chaque reformulation est **fluide**, **naturelle** et que l'alternative n'est pas placée au début ou à la fin de la phrase.
+
+**Consignes supplémentaires :**
+
+- **Ne pas ajouter** d'informations ou de commentaires non demandés.
+- Présenter les résultats de manière **claire**, **structurée** et en respectant le format indiqué.
+- **Ne pas analyser** ou modifier d'autres parties du texte que les phrases contenant "en plus" en début de phrase.
+
+### Format attendu pour chaque occurrence :
+
+- **Original** : "[Phrase originale]"
+    - **Explication** : "[Explication concise]"
+    - **Reformulation 1** : "[Reformulation ici]"
+    - **Reformulation 2** : "[Reformulation ici]"
+    - **Reformulation 3** : "[Reformulation ici]"
+
+Le texte à analyser est le suivant :
+```{text}```
+
+{format_instruction}
+"""
+
+def detect_en_plus(text):
+    # Création du modèle de sortie avec Pydantic
+    output_parser = PydanticOutputParser(pydantic_object=DetectionResult)
+
+    # Génération du prompt à partir du modèle
+    gen_prompt_template = PromptTemplate(
+        input_variables=["text"],
+        template=en_plus_prompt_template(),
+        partial_variables={'format_instruction': output_parser.get_format_instructions()}
+    )
+
+    # Création du modèle de langage (avec LLM)
+    llm = ChatOpenAI(model='gpt-4', temperature=0.5, api_key="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")
+
+    # Chaîne de traitement du prompt avec le modèle et le parseur
+    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()
+
+    # Conversion du résultat en JSON
+    json_result = json.dumps(result_dict, indent=8, ensure_ascii=False)
+
+    # Génération du prompt final
+    final_prompt = gen_prompt_template.format(text=text)
+
+    # Retour des résultats
+    return {
+        "result": json_result,
+        "prompt": final_prompt
+    }

pattern_epoque.py

@@ -0,0 +1,135 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+            }
+        }
+
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+
+def epoque_prompt_template():
+    return """
+    Analyse le texte suivant et identifie toutes les occurrences des expressions suivantes et de leurs variantes :
+    "Le monde de", "L’univers de", "À l’ère de", "Le domaine de", "À l'époque de", "Au temps de", "À l'aube de",
+    "Dans le cadre de", "Au cœur de", "En matière de", "Dans l'univers de".
+
+    Incluez également toute autre expression similaire qui introduit un contexte général ou un cadre temporel ou spatial.
+
+    Pour chaque occurrence trouvée, veuillez :
+    
+    - Citer la phrase complète où l'expression apparaît.
+    - Indiquer l'expression exacte utilisée dans le texte.
+    - Proposer deux reformulations de la phrase, de sorte à remplacer l'expression détectée par une formulation plus précise ou stylistiquement améliorée, sans utiliser d'expressions équivalentes.
+    - Justifiez brièvement chaque reformulation en expliquant comment elle améliore le style ou la clarté.
+
+    Assurez-vous de respecter également les règles suivantes :
+    1. Les expressions comme "crucial", "essentiel", "important", "fondamental", et d'autres ne doivent être utilisées qu'une fois dans l'introduction (premier paragraphe).
+    2. Les expressions comme "Il existe", "Il faut", "cependant", "De plus", "en revanche", "Néanmoins", "toutefois", "imaginez" ne doivent pas être utilisées en début de phrase.
+    3. "Joue un rôle", "il est", ou "est une étape" ne doivent pas être associés à des mots tels que "important", "essentiel", etc.
+    4. "En plus" (et ses variantes) ne doit pas être seul en début de phrase.
+
+    Votre analyse doit être retournée en JSON avec les éléments suivants :
+    
+    Pour chaque pattern détecté :
+    - "pattern": "mot ou expression détectée",
+    - "indices": [[index de début, index de fin pour chaque occurrence]],
+    - "sentence": "phrase où l'expression est utilisée",
+    - "alternative_suggestions": ["suggestion 1", "suggestion 2"] (si applicable)
+    
+    Si aucun pattern n'est trouvé, renvoyez :
+    - "pattern0": "",
+    - "occurrences": 0,
+
+    À la fin, ajoutez un résumé avec :
+    - "total_patterns_detected": nombre total de patterns détectés,
+    - "alternative_suggestions_provided": nombre de suggestions fournies,
+    - "occurrences": nombre d'occurrences.
+
+    Voici le texte à analyser :
+    ```{text}```
+    
+    \n{format_instruction}
+    """
+
+
+def epoque(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = epoque_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-4o', 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  # LLMChain(prompt=prompt, llm=llm, verbose=True)
+    
+    # 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
+    }

pattern_est_une_etape.py

@@ -0,0 +1,141 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    adjectif: str = Field(..., description="Adjectif associé à l'expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "adjectif": self.adjectif,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+            }
+        }
+
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+def est_une_etape_prompt_template() :
+
+    return """
+    Analyser le texte suivant et identifier toutes les phrases où une expression similaire à "est une étape" est utilisée,
+    y compris des variantes comme "est une étape", "constitue une étape", "représente une étape", "marque une étape",
+    "signifie une étape", "symbolise une étape", etc.
+
+    Recherche particulièrement ces expressions lorsqu'elles sont associées à des adjectifs exprimant l'importance
+    (par exemple, "important", "essentiel", "crucial", "primordial", "fondamental", "indispensable", "déterminant",
+    "vital", "majeur", "clé", "nécessaire", "stratégique", "significatif", etc.), que l'adjectif se trouve avant ou après le mot "étape".
+
+    Pour chaque occurrence trouvée, veuillez :
+
+    - Citer la phrase complète où l'expression apparaît.
+    - Indiquer l'expression exacte utilisée dans le texte.
+    - Mentionner l'adjectif d'importance associé.
+    - Proposer deux reformulations de la phrase pour changer l'expression détectée et l'adjectif associé,
+      sans employer d'expression équivalente.
+    - Assurez-vous de respecter les règles suivantes :
+      1. Les expressions comme "crucial", "essentiel", "important", "fondamental" doivent être utilisées une seule fois
+         dans l'introduction (premier paragraphe).
+      2. Évitez l'usage de mots comme "il existe", "il faut", "cependant", "de plus", "en revanche", "toutefois" en début de phrase.
+      3. N'utilisez pas "joue un rôle", "il est", ou "est une étape" avec des adjectifs tels qu'"important", "essentiel", etc.
+
+    Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+    - "pattern": "mot ou expression détectée",
+    - "adjectif": "adjectif associé",
+    - "indices": [[index de début, index de fin pour chaque occurrence]],
+    - "sentence": "phrase où l'expression est utilisée",
+    - "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+    Si aucun pattern n'est trouvé, retournez un JSON avec :
+
+    - "pattern0": "",
+    - "occurrences": 0,
+
+    Ajoutez également un résumé à la fin :
+
+    - "total_patterns_detected": nombre total de patterns détectés,
+    - "alternative_suggestions_provided": nombre de suggestions données
+    - "occurrences": nombre d'occurrences.
+
+    Voici le texte à analyser :
+    ```{text}```
+
+    \n{format_instruction}
+    """
+
+def une_etape(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = est_une_etape_prompt_template()
+
+    output_parser = PydanticOutputParser(pydantic_object=DetectionResult)
+
+    # Créer le prompt avec le texte intégré
+    # prompt = PromptTemplate(template=template, input_variables=["text"])
+
+    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-4o',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 # LLMChain(prompt=prompt, llm=llm, verbose=True)
+    
+    # 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)
+
+    final_prompt = gen_prompt_template.format(text=text)
+    # Retourne les suggestions ou les erreurs de parsing
+
+    return {
+        "result": json_result,
+        "prompt": final_prompt
+    }

pattern_il_existe.py

@@ -0,0 +1,133 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+            }
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+# Fonction pour générer le prompt template
+def il_existe_prompt_template():
+    return """
+   Analyser le texte suivant et détecter toutes les occurrences de l'expression "il existe" et ses variantes, telles que :
+
+    "il existe"
+    "il y a"
+    "on trouve"
+    "on peut trouver"
+    "il est possible de trouver"
+    "on découvre"
+    "il est possible de découvrir"
+
+Pour chaque occurrence trouvée, veuillez :
+
+   - Citer la phrase complète où l'expression apparaît.
+   - Indiquer l'expression exacte utilisée dans le texte.
+   - Expliquer pourquoi l'expression "il existe" peut être lourde, formelle ou inutilement descriptive dans certains contextes.
+   - Proposer deux reformulations plus simples, fluides et naturelles pour rendre la phrase plus concise ou directe, en évitant d'utiliser "il existe" ou ses variantes.
+
+Assurez-vous également de respecter les règles suivantes :
+1. Les expressions comme "crucial", "essentiel", "important", "fondamental" ne doivent pas être utilisées plus d'une fois dans l'introduction.
+2. 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.
+3. Les expressions comme "joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des adjectifs tels qu'"important", "essentiel", etc.
+4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+- "pattern": "mot ou expression détectée",
+- "indices": [[index de début, index de fin pour chaque occurrence]],
+- "sentence": "phrase où l'expression est utilisée",
+- "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+Si aucun pattern n'est trouvé, retournez un JSON avec :
+- "pattern0": "",
+- "occurrences": 0,
+
+À la fin, ajoutez un résumé avec :
+- "total_patterns_detected": nombre total de patterns détectés,
+- "alternative_suggestions_provided": nombre de suggestions données,
+- "occurrences": nombre d'occurrences.
+
+Voici le texte à analyser :
+```{text}```
+
+\n{format_instruction}
+    """
+
+def il_existe(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = il_existe_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-4o', 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
+    }

pattern_il_faut.py

@@ -0,0 +1,129 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+    justification: str = Field(..., description="Justification de la suggestion.")
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation avec justification.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+                "justification": self.alternative_suggestions.justification
+            }
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+def il_faut_prompt_template():
+    return """
+   Analyse le texte suivant et détecte toutes les occurrences de l'expression "il faut".
+
+   Pour chaque occurrence trouvée, veuillez :
+
+   - Citer la phrase complète où l'expression apparaît.
+   - Indiquer l'expression exacte utilisée dans le texte.
+   - Expliquer pourquoi l'expression "il faut" peut paraître trop directive ou informelle dans un contexte formel ou professionnel.
+   - Proposer deux reformulations de la phrase sans utiliser d'expressions ou de mots qui soulignent l'importance, comme "il est nécessaire de", "il est important de", ou "il convient de".
+   - Utilisez des formulations à l'impératif pour rendre la phrase plus directe et fluide.
+   - Assurez-vous que la phrase reformulée est fluide, naturelle, et préserve le sens original.
+
+   Assurez-vous également de respecter les règles suivantes :
+   1. Les expressions comme "crucial", "essentiel", "important", "fondamental", etc., ne doivent pas être utilisées plus d'une fois dans l'introduction.
+   2. 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.
+   3. 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.
+   4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+   Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+   - "pattern": "mot ou expression détectée",
+   - "indices": [[index de début, index de fin pour chaque occurrence]],
+   - "sentence": "phrase où l'expression est utilisée",
+   - "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+   Si aucun pattern n'est trouvé, retournez un JSON avec :
+   - "pattern0": "",
+   - "occurrences": 0,
+
+   À la fin, ajoutez un résumé avec :
+   - "total_patterns_detected": nombre total de patterns détectés,
+   - "alternative_suggestions_provided": nombre de suggestions données,
+   - "occurrences": nombre d'occurrences.
+
+   Voici le texte à analyser :
+   ```{text}```
+
+   \n{format_instruction}
+    """
+
+def il_faut(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = il_faut_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-4o', 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
+    }

pattern_il_suffit_de.py

@@ -0,0 +1,102 @@
+from langchain.prompts import PromptTemplate
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field
+from typing import List
+import json
+from langchain.chat_models import ChatOpenAI
+
+
+# Modèle de sortie pour la détection de l'expression "il suffit de"
+class ReformulationDetail(BaseModel):
+    original: str = Field(..., description="Phrase originale contenant 'il suffit de'.")
+    explanation: str = Field(..., description="Explication sur pourquoi l'expression 'il suffit de' est inadaptée.")
+    reformulation_1: str = Field(..., description="Première reformulation de la phrase.")
+    reformulation_2: str = Field(..., description="Seconde reformulation de la phrase.")
+    reformulation_3: str = Field(..., description="Troisième reformulation de la phrase.")
+
+    def to_dict(self):
+        return {
+            "original": self.original,
+            "explanation": self.explanation,
+            "reformulation_1": self.reformulation_1,
+            "reformulation_2": self.reformulation_2,
+            "reformulation_3": self.reformulation_3
+        }
+
+class Summary(BaseModel):
+    total_occurrences: int = Field(..., description="Nombre total d'occurrences de 'il suffit de' détectées.")
+    reformulations_provided: int = Field(..., description="Nombre de reformulations fournies.")
+
+    def to_dict(self):
+        return {
+            "total_occurrences": self.total_occurrences,
+            "reformulations_provided": self.reformulations_provided
+        }
+
+class DetectionResult(BaseModel):
+    reformulations: List[ReformulationDetail] = Field(..., description="Liste des reformulations proposées.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "reformulations": [reformulation.to_dict() for reformulation in self.reformulations],
+            "summary": self.summary.to_dict()
+        }
+
+# Génération du prompt pour la détection de "il suffit de"
+def il_suffit_de_prompt_template():
+    return """
+Veuillez analyser le texte ci-dessous pour détecter toutes les occurrences de l'expression "il suffit de".
+
+Pour chaque phrase trouvée :
+
+1. **Citez exactement** la phrase originale contenant "il suffit de".
+2. **Expliquez** pourquoi l'expression "il suffit de" est inadaptée dans un contexte professionnel ou formel, et pourquoi elle simplifie à l'excès ou n'indique pas assez d'importance.
+3. **Proposez trois reformulations** de la phrase, sans utiliser des expressions qui soulignent l'importance (comme "il est nécessaire de", "il est important de", etc.). Utilisez des formulations à l'impératif pour rendre les instructions plus directes, précises, et professionnelles.
+4. **Assurez-vous** que chaque reformulation est naturelle, fluide et conserve le sens original sans insister sur l'importance de l'action.
+
+**Format attendu pour chaque occurrence** :
+
+- **Original** : "[Phrase originale]"
+    - **Explication** : "[Explication concise sur l'inadéquation de 'il suffit de']"
+    - **Reformulation 1** : "[Première reformulation]"
+    - **Reformulation 2** : "[Seconde reformulation]"
+    - **Reformulation 3** : "[Troisième reformulation]"
+
+Le texte à analyser est le suivant :
+```{text}```
+
+{format_instruction}
+"""
+
+def detect_il_suffit_de(text):
+    # Création du modèle de sortie avec Pydantic
+    output_parser = PydanticOutputParser(pydantic_object=DetectionResult)
+
+    # Génération du prompt à partir du modèle
+    gen_prompt_template = PromptTemplate(
+        input_variables=["text"],
+        template=il_suffit_de_prompt_template(),
+        partial_variables={'format_instruction': output_parser.get_format_instructions()}
+    )
+
+    # Création du modèle de langage (avec LLM)
+    llm = ChatOpenAI(model='gpt-4', temperature=0.5, api_key="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")
+
+    # Chaîne de traitement du prompt avec le modèle et le parseur
+    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()
+
+    # Conversion du résultat en JSON
+    json_result = json.dumps(result_dict, indent=8, ensure_ascii=False)
+
+    # Génération du prompt final
+    final_prompt = gen_prompt_template.format(text=text)
+
+    # Retour des résultats
+    return {
+        "result": json_result,
+        "prompt": final_prompt
+    }

pattern_imaginez.py

@@ -0,0 +1,129 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+            }
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+# Fonction pour générer le prompt template
+def imaginez_prompt_template():
+    return """
+   Analyser le texte suivant et détecter toutes les occurrences de l'expression "Imaginez" et ses variantes telles que :
+
+    "Visualisez", "Envisagez", "Concevez", "Supposez", "Pensez à", "Représentez-vous", "Imaginez-vous"
+
+Pour chaque occurrence trouvée, veuillez :
+
+   - Citer la phrase complète où l'expression apparaît.
+   - Indiquer l'expression exacte utilisée dans le texte.
+   - Expliquer pourquoi ces expressions peuvent alourdir ou rendre l'introduction trop familière, directe ou directive.
+   - Proposer deux reformulations plus simples, fluides et naturelles pour rendre la phrase plus concise ou directe,
+     en évitant d'utiliser l'expression "Imaginez" ou ses variantes. Assurez-vous que la reformulation conserve le sens original
+     tout en étant plus formelle et professionnelle.
+
+Assurez-vous également de respecter les règles suivantes :
+1. Les expressions comme "crucial", "essentiel", "important", "fondamental" ne doivent pas être utilisées plus d'une fois dans l'introduction.
+2. 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.
+3. Les expressions comme "joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des adjectifs tels qu'"important", "essentiel", etc.
+4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+- "pattern": "mot ou expression détectée",
+- "indices": [[index de début, index de fin pour chaque occurrence]],
+- "sentence": "phrase où l'expression est utilisée",
+- "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+Si aucun pattern n'est trouvé, retournez un JSON avec :
+- "pattern0": "",
+- "occurrences": 0,
+
+À la fin, ajoutez un résumé avec :
+- "total_patterns_detected": nombre total de patterns détectés,
+- "alternative_suggestions_provided": nombre de suggestions données,
+- "occurrences": nombre d'occurrences.
+
+Voici le texte à analyser :
+```{text}```
+
+\n{format_instruction}
+    """
+
+def imaginez(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = imaginez_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-4o', 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
+    }

pattern_important_crucial.py

@@ -0,0 +1,128 @@
+from langchain.prompts import PromptTemplate
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+import json
+from langchain.chat_models import ChatOpenAI
+
+# Modèle de sortie pour la détection des expressions exprimant l'importance, la nécessité, ou l'urgence
+class ImportanceDetection(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée exprimant l'importance, la nécessité ou l'urgence.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    meaning: str = Field(..., description="Sens exprimé par l'expression.")
+    alternative_suggestions: List[str] = Field(..., description="Suggestions alternatives pour reformuler la phrase.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "meaning": self.meaning,
+            "alternative_suggestions": self.alternative_suggestions
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[ImportanceDetection] = Field(..., description="Liste des mots ou expressions détectés.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+# Création du template pour la détection des expressions d'importance, de nécessité ou d'urgence
+def importance_prompt_template():
+    return """
+Vous êtes un détecteur de texte IA extrêmement rigoureux. Votre tâche consiste à analyser le texte suivant et à identifier **toutes** les occurrences de mots, expressions, ou locutions exprimant **l'importance**, **la nécessité**, **l'urgence**, ou **le caractère indispensable** d'un élément.
+
+Vous devez inclure :
+
+1. **Adjectifs** (tels que) : "crucial", "essentiel", "important", "fondamental", "primordial", "indispensable", "nécessaire", "vital", "pivotal", "majeur", "clé", "significatif", "déterminant", "incontournable", "impératif", "obligatoire", "capital", "prépondérant", "stratégique", "marquant", "décisif", "inévitable", "urgent", etc.
+
+2. **Adverbes** (tels que) : "essentiellement", "crucialement", "fondamentalement", "nécessairement", "impérativement", "urgemment", etc.
+
+3. **Locutions et expressions** (telles que) : "de la plus haute importance", "d'une importance capitale", "de première nécessité", "il est urgent de", "il est vital que", "à ne pas négliger", "absolument nécessaire", "infiniment précieux", etc.
+
+4. **Variations grammaticales** : toutes les formes grammaticales, incluant le féminin, masculin, singulier, pluriel, et les variations de temps, doivent être prises en compte.
+
+Pour chaque occurrence trouvée, veuillez :
+   - Citer la phrase complète où l'expression apparaît.
+   - Indiquer l'expression exacte utilisée dans le texte.
+   - Expliquer pourquoi ces expressions peuvent alourdir ou rendre l'introduction trop familière, directe ou directive.
+   - Proposer deux reformulations plus simples, fluides et naturelles pour rendre la phrase plus concise ou directe,
+     en évitant d'utiliser l'expression ou ses variantes. Assurez-vous que la reformulation conserve le sens original
+     tout en étant plus formelle et professionnelle.
+
+Assurez-vous également de respecter les règles suivantes :
+1. Les expressions comme "crucial", "essentiel", "important", "fondamental" ne doivent pas être utilisées plus d'une fois dans l'introduction.
+2. 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.
+3. Les expressions comme "joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des adjectifs tels qu'"important", "essentiel", etc.
+4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+**Format de sortie requis :**
+- "pattern": "mot ou expression détectée",
+- "indices": [[index de début, index de fin pour chaque occurrence]],
+- "sentence": "phrase où l'expression est utilisée",
+- "meaning": "Sens exprimé",
+- "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+Si aucun pattern n'est trouvé, retournez un JSON avec :
+- "pattern0": "",
+- "occurrences": 0,
+
+À la fin, ajoutez un résumé avec :
+- "total_patterns_detected": nombre total de patterns détectés,
+- "alternative_suggestions_provided": nombre de suggestions données,
+- "occurrences": nombre d'occurrences.
+
+Le texte à analyser est :
+```{text}```
+
+{format_instruction}
+"""
+
+def importance_detection(text):
+    # Création du modèle de sortie avec Pydantic
+    output_parser = PydanticOutputParser(pydantic_object=DetectionResult)
+
+    # Génération du prompt à partir du modèle
+    gen_prompt_template = PromptTemplate(
+        input_variables=["text"],
+        template=importance_prompt_template(),
+        partial_variables={'format_instruction': output_parser.get_format_instructions()}
+    )
+
+    # Création du modèle de langage (avec LLM)
+    llm = ChatOpenAI(model='gpt-4o', temperature=0.5, api_key="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")
+
+    # Chaîne de traitement du prompt avec le modèle et le parseur
+    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()
+
+    # Conversion du résultat en JSON
+    json_result = json.dumps(result_dict, indent=8, ensure_ascii=False)
+
+    # Génération du prompt final
+    final_prompt = gen_prompt_template.format(text=text)
+
+    # Retour des résultats
+    return {
+        "result": json_result,
+        "prompt": final_prompt
+    }

pattern_look.py

@@ -0,0 +1,128 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+    justification: str = Field(..., description="Justification de la suggestion.")
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation avec justification.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+                "justification": self.alternative_suggestions.justification
+            }
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+def look_prompt_template():
+    return """
+   Analyse le texte suivant et détecte strictement toutes les occurrences du mot "look" utilisées dans le contexte de la décoration et de l'aménagement des espaces de vie ou de travail.
+
+   Pour chaque occurrence trouvée, veuillez :
+
+   - Citer la phrase complète où l'expression apparaît.
+   - Indiquer l'expression exacte utilisée dans le texte.
+   - Expliquer pourquoi l'utilisation de "look" est inappropriée dans ce contexte décoratif en français, en précisant qu'il s'agit d'un anglicisme.
+   - Proposer deux reformulations de la phrase en utilisant un terme ou une expression plus correcte en français, comme "style", "allure", "ambiance", "aspect", ou "touche", en tenant compte du contexte de la décoration.
+   - Assurez-vous que la phrase reformulée soit fluide, naturelle et préserve le sens original.
+
+   Assurez-vous également de respecter les règles suivantes :
+   1. Les expressions comme "crucial", "essentiel", "important", "fondamental", etc., ne doivent pas être utilisées plus d'une fois dans l'introduction.
+   2. 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.
+   3. 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.
+   4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+   Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+   - "pattern": "mot ou expression détectée",
+   - "indices": [[index de début, index de fin pour chaque occurrence]],
+   - "sentence": "phrase où l'expression est utilisée",
+   - "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+   Si aucun pattern n'est trouvé, retournez un JSON avec :
+   - "pattern0": "",
+   - "occurrences": 0,
+
+   À la fin, ajoutez un résumé avec :
+   - "total_patterns_detected": nombre total de patterns détectés,
+   - "alternative_suggestions_provided": nombre de suggestions données,
+   - "occurrences": nombre d'occurrences.
+
+   Voici le texte à analyser :
+   ```{text}```
+
+   \n{format_instruction}
+    """
+
+def look(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = look_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-4o', 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
+    }

pattern_outre.py

@@ -0,0 +1,133 @@
+from langchain.prompts import PromptTemplate
+from langchain.output_parsers import PydanticOutputParser
+from langchain.chat_models import ChatOpenAI
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+import json
+
+# Modèle de sortie pour la détection de l'utilisation incorrecte de "Outre"
+class OutreDetection(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée, ici 'Outre'.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où 'Outre' est utilisé.")
+    explanation: str = Field(..., description="Explication de pourquoi l'utilisation de 'Outre' est incorrecte.")
+    alternative_suggestions: List[str] = Field(..., description="Suggestions alternatives pour reformuler la phrase.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "explanation": self.explanation,
+            "alternative_suggestions": self.alternative_suggestions
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[OutreDetection] = Field(..., description="Liste des occurrences incorrectes de 'Outre'.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+# Création du template pour la détection de l'utilisation incorrecte de "Outre"
+def outre_prompt_template():
+    return """
+Veuillez analyser le texte suivant pour détecter les phrases où "Outre" est utilisé en début de phrase, sans être suivi d'un complément approprié.
+
+Pour chaque phrase trouvée :
+
+   - Citez la phrase originale contenant "Outre" en début de phrase.
+   - Expliquez pourquoi l'utilisation de "Outre" est incorrecte et précisez qu'il s'agit d'une préposition qui doit être suivie d'un complément.
+   - Proposez une correction en remplaçant "Outre" par "En outre" ou en réécrivant la phrase de manière correcte.
+   - Assurez-vous que la phrase reformulée soit naturelle, fluide et correcte.
+
+Voici l'explication à afficher : "Outre" est une préposition en français qui signifie "en plus de" ou "en dehors de", et doit être suivie d'un complément. Par exemple :
+
+    - Correct : "Outre ses compétences en gestion, il est également un excellent communicateur."
+    - Incorrect : "Outre, il est également un excellent communicateur."
+
+Par contre, "En outre" est une locution adverbiale qui signifie "de plus" ou "en plus", et elle est correctement utilisée pour introduire une nouvelle idée ou information, souvent au début d'une phrase. Exemple :
+
+    - Correct : "En outre, il a une grande expérience dans ce domaine."
+
+En résumé :
+   - "Outre" est une préposition et doit être suivi d'un complément.
+   - "En outre" est une locution adverbiale et peut être utilisée seule au début d'une phrase pour introduire une nouvelle idée.
+
+Analysez le texte ci-dessous et détectez toutes les occurrences de "cela signifie que".
+
+Pour chaque phrase :
+
+   - Citez la phrase originale.
+   - Supprimez "cela signifie que" et proposez une reformulation concise et élégante qui maintient le sens de la phrase.
+   - Assurez-vous que la phrase reformulée soit naturelle, fluide et correcte.
+
+Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+   - "pattern": "mot ou expression détectée",
+   - "indices": [[index de début, index de fin pour chaque occurrence]],
+   - "sentence": "phrase où l'expression est utilisée",
+   - "explanation": "explication de pourquoi l'expression est incorrecte",
+   - "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+Si aucun pattern n'est trouvé, retournez un JSON avec :
+   - "pattern0": "",
+   - "occurrences": 0,
+
+À la fin, ajoutez un résumé avec :
+   - "total_patterns_detected": nombre total de patterns détectés,
+   - "alternative_suggestions_provided": nombre de suggestions données,
+   - "occurrences": nombre d'occurrences.
+
+Le texte à analyser est :
+```{text}```
+
+{format_instruction}
+"""
+
+def detect_outre(text):
+    # Création du modèle de sortie avec Pydantic
+    output_parser = PydanticOutputParser(pydantic_object=DetectionResult)
+
+    # Génération du prompt à partir du modèle
+    gen_prompt_template = PromptTemplate(
+        input_variables=["text"],
+        template=outre_prompt_template(),
+        partial_variables={'format_instruction': output_parser.get_format_instructions()}
+    )
+
+    # Création du modèle de langage (avec LLM)
+    llm = ChatOpenAI(model='gpt-4o', temperature=0.5, api_key="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")
+
+    # Chaîne de traitement du prompt avec le modèle et le parseur
+    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()
+
+    # Conversion du résultat en JSON
+    json_result = json.dumps(result_dict, indent=8, ensure_ascii=False)
+
+    # Génération du prompt final
+    final_prompt = gen_prompt_template.format(text=text)
+
+    # Retour des résultats
+    return {
+        "result": json_result,
+        "prompt": final_prompt
+    }

pattern_permettre.py

@@ -0,0 +1,125 @@
+from langchain.prompts import PromptTemplate
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+import json
+
+# Modèle de sortie (adapté pour la détection des formes du verbe "permettre" avec reformulations)
+class PermettreDetection(BaseModel):
+    pattern: str = Field(..., description="Forme verbale du verbe 'permettre' détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: List[str] = Field(..., description="Suggestions alternatives pour la reformulation de la phrase.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": self.alternative_suggestions
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de formes du verbe 'permettre' détectées.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[PermettreDetection] = Field(..., description="Liste des formes verbales détectées.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+# Création du template pour la détection avec reformulations
+def permettre_prompt_template():
+    return """
+Tu es un détecteur de texte AI très performant et précis. Ta mission est la suivante :
+
+- **Objectif :** Identifier toutes les formes conjuguées du verbe **"permettre"** dans le texte ci-dessous (ex : **"permet"**, **"permettra"**, **"permis"** en tant que verbe, etc.).
+
+- **Exclusions :** Ignore les cas où **"permis"** est utilisé comme **nom commun** (ex : **"permis de conduire"**, **"permis de construire"**, etc.).
+
+**Instructions supplémentaires :**
+   - Analyse grammaticale : identifie les mots dont le **lemme** est **"permettre"**.
+   - Ne pas considérer **"permis"** comme nom commun, mais bien comme verbe uniquement.
+   - Couvre toutes les formes verbales, y compris les participes passés, infinitifs, et les temps futurs, présents, etc.
+   - Ne pas dupliquer les détections des mêmes formes verbales.
+
+Pour chaque occurrence trouvée, veuillez :
+   - Citer la phrase complète où l'expression apparaît.
+   - Indiquer l'expression exacte utilisée dans le texte.
+   - Expliquer pourquoi ces expressions peuvent alourdir ou rendre l'introduction trop familière, directe ou directive.
+   - Proposer deux reformulations plus simples, fluides et naturelles pour rendre la phrase plus concise ou directe,
+     en évitant d'utiliser l'expression "permettre" ou ses variantes. Assurez-vous que la reformulation conserve le sens original
+     tout en étant plus formelle et professionnelle.
+
+Assurez-vous également de respecter les règles suivantes :
+1. Les expressions comme "crucial", "essentiel", "important", "fondamental" ne doivent pas être utilisées plus d'une fois dans l'introduction.
+2. 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.
+3. Les expressions comme "joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des adjectifs tels qu'"important", "essentiel", etc.
+4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+**Format de sortie requis :**
+- "pattern": "mot ou expression détectée",
+- "indices": [[index de début, index de fin pour chaque occurrence]],
+- "sentence": "phrase où l'expression est utilisée",
+- "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+Si aucun pattern n'est trouvé, retournez un JSON avec :
+- "pattern0": "",
+- "occurrences": 0,
+
+À la fin, ajoutez un résumé avec :
+- "total_patterns_detected": nombre total de patterns détectés,
+- "alternative_suggestions_provided": nombre de suggestions données,
+- "occurrences": nombre d'occurrences.
+
+Le texte à analyser est le suivant :
+```{text}```
+
+\n{format_instruction}
+"""
+
+def permettre_detection(text):
+    # Création du modèle de sortie avec Pydantic
+    output_parser = PydanticOutputParser(pydantic_object=DetectionResult)
+
+    # Génération du prompt à partir du modèle
+    gen_prompt_template = PromptTemplate(
+        input_variables=["text"],
+        template=permettre_prompt_template(),
+        partial_variables={'format_instruction': output_parser.get_format_instructions()}
+    )
+
+    # Création du modèle de langage (avec LLM)
+    llm = ChatOpenAI(model='gpt-4o', temperature=0.5, api_key="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")
+
+    # Chaîne de traitement du prompt avec le modèle et le parseur
+    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()
+
+    # Conversion du résultat en JSON
+    json_result = json.dumps(result_dict, indent=8, ensure_ascii=False)
+
+    # Génération du prompt final
+    final_prompt = gen_prompt_template.format(text=text)
+
+    # Retour des résultats
+    return {
+        "result": json_result,
+        "prompt": final_prompt
+    }

pattern_voici_decouvrez.py

@@ -0,0 +1,104 @@
+from langchain.prompts import PromptTemplate
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+import json
+from langchain.chat_models import ChatOpenAI
+
+
+# Modèle de sortie pour la détection des expressions "VOICI" et "DÉCOUVREZ"
+class ReformulationDetail(BaseModel):
+    original: str = Field(..., description="Phrase originale contenant 'VOICI' ou 'DÉCOUVREZ'.")
+    explanation: str = Field(..., description="Explication sur pourquoi l'expression alourdit la phrase.")
+    reformulation_1: str = Field(..., description="Reformulation basée sur l'approche Anticipation/Intrigue.")
+    reformulation_2: str = Field(..., description="Reformulation basée sur l'approche Conversationnel.")
+    reformulation_3: str = Field(..., description="Reformulation basée sur l'approche Accompagnement doux.")
+
+    def to_dict(self):
+        return {
+            "original": self.original,
+            "explanation": self.explanation,
+            "reformulation_1": self.reformulation_1,
+            "reformulation_2": self.reformulation_2,
+            "reformulation_3": self.reformulation_3,
+        }
+
+class Summary(BaseModel):
+    total_occurrences: int = Field(..., description="Nombre total d'occurrences de 'VOICI' et 'DÉCOUVREZ'.")
+    reformulations_provided: int = Field(..., description="Nombre de reformulations proposées.")
+
+    def to_dict(self):
+        return {
+            "total_occurrences": self.total_occurrences,
+            "reformulations_provided": self.reformulations_provided,
+        }
+
+class DetectionResult(BaseModel):
+    reformulations: List[ReformulationDetail] = Field(..., description="Liste des reformulations proposées pour chaque occurrence.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "reformulations": [reformulation.to_dict() for reformulation in self.reformulations],
+            "summary": self.summary.to_dict()
+        }
+
+# Création du template pour la détection de l'utilisation de "VOICI" et "DÉCOUVREZ" à la fin d'une introduction
+def voici_decouvrez_prompt_template():
+    return """
+Tu es un éditeur de texte IA extrêmement performant et rigoureux. Ta tâche est d'analyser **précisément** le texte fourni pour détecter **toutes les occurrences** des expressions **"VOICI"** et **"DÉCOUVREZ"** situées **à la fin d'une introduction**.
+L'introduction , c'est le premier paragraphe.
+Pour chaque occurrence identifiée, tu dois obligatoirement :
+
+1. **Citer exactement** la phrase originale contenant "VOICI" ou "DÉCOUVREZ".
+2. **Expliquer brièvement et clairement** pourquoi l'utilisation de ce terme peut alourdir ou rendre la transition vers le contenu moins fluide.
+3. **Proposer trois reformulations distinctes**, selon les approches suivantes :
+    - **Anticipation/Intrigue** : Créer de l'attente ou de l'intrigue pour susciter l'intérêt du lecteur.
+    - **Conversationnel** : Formuler la phrase de manière plus engageante et naturelle.
+    - **Accompagnement doux** : Offrir une transition progressive et moins directive vers le contenu.
+
+### Format attendu pour chaque occurrence :
+
+- **Original** : "[Phrase originale]"
+    - **Explication** : "[Explication concise]"
+    - **Reformulation 1 (Anticipation/Intrigue)** : "[Reformulation ici]"
+    - **Reformulation 2 (Conversationnel)** : "[Reformulation ici]"
+    - **Reformulation 3 (Accompagnement doux)** : "[Reformulation ici]"
+
+Le texte à analyser est le suivant :
+```{text}```
+Le format de la sortie doit être en JSON.
+```{format_instruction}```
+"""
+
+def detect_voici_decouvrez(text):
+    # Création du modèle de sortie avec Pydantic
+    output_parser = PydanticOutputParser(pydantic_object=DetectionResult)
+
+    # Génération du prompt à partir du modèle
+    gen_prompt_template = PromptTemplate(
+        input_variables=["text"],
+        template=voici_decouvrez_prompt_template(),
+        partial_variables={'format_instruction': output_parser.get_format_instructions()}
+    )
+
+    # Création du modèle de langage (avec LLM)
+    llm = ChatOpenAI(model='gpt-4', temperature=0.5, api_key="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")
+
+    # Chaîne de traitement du prompt avec le modèle et le parseur
+    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()
+
+    # Conversion du résultat en JSON
+    json_result = json.dumps(result_dict, indent=8, ensure_ascii=False)
+
+    # Génération du prompt final
+    final_prompt = gen_prompt_template.format(text=text)
+
+    # Retour des résultats
+    return {
+        "result": json_result,
+        "prompt": final_prompt
+    }

pattern_vous_pouvez.py

@@ -0,0 +1,129 @@
+import json
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from typing import List, Tuple
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import PydanticOutputParser
+
+
+# Modèles Pydantic pour structurer la réponse
+class AlternativeSuggestion(BaseModel):
+    suggestion_1: str = Field(..., description="Première suggestion de reformulation.")
+    suggestion_2: str = Field(..., description="Deuxième suggestion de reformulation.")
+    justification: str = Field(..., description="Justification de la suggestion.")
+
+class PatternDetail(BaseModel):
+    pattern: str = Field(..., description="Mot ou expression détectée.")
+    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
+    sentence: str = Field(..., description="Phrase complète où l'expression apparaît.")
+    alternative_suggestions: AlternativeSuggestion = Field(..., description="Deux suggestions de reformulation avec justification.")
+
+    def to_dict(self):
+        return {
+            "pattern": self.pattern,
+            "indices": self.indices,
+            "sentence": self.sentence,
+            "alternative_suggestions": {
+                "suggestion_1": self.alternative_suggestions.suggestion_1,
+                "suggestion_2": self.alternative_suggestions.suggestion_2,
+                "justification": self.alternative_suggestions.justification
+            }
+        }
+
+class Summary(BaseModel):
+    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
+    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
+    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")
+
+    def to_dict(self):
+        return {
+            "total_patterns_detected": self.total_patterns_detected,
+            "alternative_suggestions_provided": self.alternative_suggestions_provided,
+            "occurrences": self.occurrences
+        }
+
+class DetectionResult(BaseModel):
+    patterns: List[PatternDetail] = Field(..., description="Liste des patterns détectés avec détails.")
+    summary: Summary = Field(..., description="Résumé de la détection.")
+
+    def to_dict(self):
+        return {
+            "patterns": [pattern.to_dict() for pattern in self.patterns],
+            "summary": self.summary.to_dict()
+        }
+
+def vous_pouvez_prompt_template():
+    return """
+   Analyser le texte ci-dessous pour détecter les expressions "vous pouvez", "vous devez", "il vous faut",
+   "vous avez à", "il est nécessaire que vous", "vous avez la possibilité de", "vous êtes prié de" et autres formules similaires.
+
+   Pour chaque occurrence trouvée, veuillez :
+
+   - Citer la phrase complète où l'expression apparaît.
+   - Indiquer l'expression exacte utilisée dans le texte.
+   - Expliquer pourquoi ces expressions peuvent alourdir le texte ou donner un ton trop directif ou permissif.
+   - Proposer deux reformulations de la phrase plus fluides, en évitant d'insister sur la permission ou l'autorité, en privilégiant des tournures neutres ou à l'impératif.
+   - Assurez-vous que la phrase reformulée est fluide, naturelle, et conserve le sens original sans insister sur l'importance de l'action.
+
+   Assurez-vous également de respecter les règles suivantes :
+   1. Les expressions comme "crucial", "essentiel", "important", "fondamental" ne doivent pas être utilisées plus d'une fois dans l'introduction.
+   2. 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.
+   3. Les expressions comme "joue un rôle", "il est", ou "est une étape" ne doivent pas être associées à des adjectifs tels qu'"important", "essentiel", etc.
+   4. "En plus" ne doit pas être utilisé seul en début de phrase.
+
+   Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :
+
+   - "pattern": "mot ou expression détectée",
+   - "indices": [[index de début, index de fin pour chaque occurrence]],
+   - "sentence": "phrase où l'expression est utilisée",
+   - "alternative_suggestions": ["suggestion 1", "suggestion 2"]
+
+   Si aucun pattern n'est trouvé, retournez un JSON avec :
+   - "pattern0": "",
+   - "occurrences": 0,
+
+   À la fin, ajoutez un résumé avec :
+   - "total_patterns_detected": nombre total de patterns détectés,
+   - "alternative_suggestions_provided": nombre de suggestions données,
+   - "occurrences": nombre d'occurrences.
+
+   Voici le texte à analyser :
+   ```{text}```
+
+   \n{format_instruction}
+    """
+
+def vous_pouvez(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = vous_pouvez_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-4o', 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
+    }

requirements.txt

@@ -0,0 +1,101 @@
+aiohappyeyeballs==2.4.0
+aiohttp==3.10.5
+aiosignal==1.3.1
+altair==5.4.1
+annotated-types==0.7.0
+anyio==4.4.0
+attrs==24.2.0
+blinker==1.8.2
+blis==0.7.11
+cachetools==5.5.0
+catalogue==2.0.10
+certifi==2024.8.30
+charset-normalizer==3.3.2
+click==8.1.7
+cloudpathlib==0.19.0
+confection==0.1.5
+cymem==2.0.8
+dataclasses-json==0.6.7
+distro==1.9.0
+fr-core-news-md @ https://github.com/explosion/spacy-models/releases/download/fr_core_news_md-3.7.0/fr_core_news_md-3.7.0-py3-none-any.whl#sha256=f6a4fa799b1daf2a635fe55a7de6b344379dc542d54d4c490113f0bc94bed4b8
+fr-core-news-sm @ https://github.com/explosion/spacy-models/releases/download/fr_core_news_sm-3.7.0/fr_core_news_sm-3.7.0-py3-none-any.whl#sha256=37e9f1f6a278a5138fabdabcc92cc559da917f9b24c76f0adf6758720d7eab10
+frozenlist==1.4.1
+gitdb==4.0.11
+GitPython==3.1.43
+greenlet==3.1.0
+h11==0.14.0
+httpcore==1.0.5
+httpx==0.27.2
+idna==3.8
+Jinja2==3.1.4
+jiter==0.5.0
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-specifications==2023.12.1
+langchain==0.2.16
+langchain-community==0.2.17
+langchain-core==0.2.39
+langchain-openai==0.1.24
+langchain-text-splitters==0.2.4
+langcodes==3.4.0
+langsmith==0.1.120
+language_data==1.2.0
+marisa-trie==1.2.0
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+marshmallow==3.22.0
+mdurl==0.1.2
+multidict==6.1.0
+murmurhash==1.0.10
+mypy-extensions==1.0.0
+narwhals==1.8.0
+numpy==1.26.4
+openai==1.45.0
+orjson==3.10.7
+packaging==24.1
+pandas==2.2.2
+pillow==10.4.0
+preshed==3.0.9
+protobuf==5.28.1
+pyarrow==17.0.0
+pydantic==2.9.1
+pydantic_core==2.23.3
+pydeck==0.9.1
+Pygments==2.18.0
+python-dateutil==2.9.0.post0
+pytz==2024.2
+PyYAML==6.0.2
+referencing==0.35.1
+regex==2024.9.11
+requests==2.32.3
+rich==13.8.1
+rpds-py==0.20.0
+setuptools==75.0.0
+shellingham==1.5.4
+six==1.16.0
+smart-open==7.0.4
+smmap==5.0.1
+sniffio==1.3.1
+spacy==3.7.6
+spacy-legacy==3.0.12
+spacy-loggers==1.0.5
+SQLAlchemy==2.0.34
+srsly==2.4.8
+streamlit==1.38.0
+tenacity==8.5.0
+thinc==8.2.5
+tiktoken==0.7.0
+toml==0.10.2
+tornado==6.4.1
+tqdm==4.66.5
+typer==0.12.5
+typing-inspect==0.9.0
+typing_extensions==4.12.2
+tzdata==2024.1
+urllib3==2.2.3
+wasabi==1.1.3
+watchdog==4.0.2
+weasel==0.4.1
+wrapt==1.16.0
+yarl==1.11.1