pushing error of style

app.py

@@ -21,7 +21,8 @@ from pattern_il_suffit_de import detect_il_suffit_de, il_suffit_de_prompt_templa
 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
+from erreurs_de_langue import detect_errors, academie_prompt_template
+from erreur_de_style import detect_erreur_de_style, erreur_de_style_prompt_template
 
 # Interface Streamlit
 st.title("Analyse du texte")
@@ -45,7 +46,8 @@ List_prompt = {
     "< 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()
+    "< Détection des erreurs de 'langue courante' >" : academie_prompt_template(),
+    "< Détection des erreurs de style >": erreur_de_style_prompt_template()
 }
 
 # Menu déroulant pour sélectionner l'analyse
@@ -354,7 +356,7 @@ if st.button("Lancer l'analyse"):
                 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" :
+        elif option == "< Détection des erreurs de 'langue courante' >" :
             try:
                 # Analyser le texte pour les fautes de style
                 result = detect_errors(input_text)
@@ -371,5 +373,21 @@ if st.button("Lancer l'analyse"):
                 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_erreur_de_style(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.")

erreur_de_style.py

@@ -0,0 +1,168 @@
+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 erreur_de_style_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 fautes de style. Cela inclut :
+        - Les répétitions de mots (le même terme répété à moins de 100 mots d'intervalle, hors déterminants et stop-words).
+        - Les répétitions d'idées (lorsqu'une idée est répétée inutilement).
+        - Les formulations maladroites (des phrases qui ne sont pas fluides ou qui rendent la lecture difficile).
+        - Les mauvais choix de mots (par exemple lorsque le rédacteur utilise une expression inappropriée ou peu précise).
+
+        Voici quelques exemples d'erreurs que tu dois détecter et corriger :
+        - Répétition : "Le chat noir est un chat qui porte bonheur", mais on dit "Le chat noir est un félin qui porte bonheur"
+        - Formulation maladroite : "Il a fait la chose qu'il ne fallait pas faire", mais on dit "Il a commis une erreur"
+        - Mauvais choix de mots : "Il a pris une décision rapide", mais on dit "Il a pris une décision précipitée"
+
+        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": [errors
+            {{
+              "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_erreur_de_style(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = erreur_de_style_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
+    }