update pour ajouter est une étape

app.py

@@ -3,13 +3,15 @@ import json
 import logging
 import os
 import spacy
-
 from typing import List, Tuple
 from pydantic import BaseModel, Field
 from langchain.output_parsers import PydanticOutputParser
 from langchain.prompts import PromptTemplate
 from langchain.chat_models import ChatOpenAI
 
+# Import the function for detecting the "est une étape" pattern
+from est_une_etape import une_etape
+
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
@@ -109,7 +111,7 @@ st.title("Analyse du texte")
 # Menu déroulant pour sélectionner l'analyse
 option = st.selectbox(
     "Choisissez l'analyse à effectuer :",
-    ("Détection des fautes de style", "Détection du verbe 'permettre'")
+    ("< Détection du pattern 'est une étape' >")# , "Détection du verbe 'permettre'"
 )
 
 # Champ de saisie du texte
@@ -118,10 +120,10 @@ 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 des fautes de style":
+        if option == "< Détection du pattern 'est une étape' >":
             try:
                 # Analyser le texte pour les fautes de style
-                result = analyze_style_errors(input_text)
+                result = une_etape(input_text)
 
                 # Afficher les résultats en JSON formaté
                 st.subheader("Résultats de l'analyse des fautes de style")

est_une_etape.py

@@ -0,0 +1,174 @@
+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()
+        }
+
+
+# Fonction pour générer un output parser
+def generate_output_parser(response: str) -> dict:
+    try:
+        parsed_response = json.loads(response)
+        detection_result = DetectionResult(
+            patterns=[PatternDetail(
+                pattern=item["pattern"],
+                adjectif=item["adjectif"],
+                indices=item["indices"],
+                sentence=item["sentence"],
+                alternative_suggestions=AlternativeSuggestion(
+                    suggestion_1=item["alternative_suggestions"][0],
+                    suggestion_2=item["alternative_suggestions"][1]
+                )
+            ) for item in parsed_response["patterns"]],
+            summary=Summary(
+                total_patterns_detected=parsed_response["summary"]["total_patterns_detected"],
+                alternative_suggestions_provided=parsed_response["summary"]["alternative_suggestions_provided"],
+                occurrences=parsed_response["summary"]["occurrences"]
+            )
+        )
+        return detection_result.to_dict()
+    except Exception as e:
+        return {"error": f"Failed to parse response: {str(e)}"}
+
+
+
+def une_etape(text):
+    # Créer le template avec la variable text intégrée directement
+    prompt_template = """
+    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}
+    """
+
+    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)
+
+    # Retourne les suggestions ou les erreurs de parsing
+    return json_result
+
+
+# # Exemple d'utilisation avec le texte à analyser
+# textea = """
+# Dans le développement personnel, chaque progrès est une étape cruciale vers une meilleure version de soi-même.
+# De plus, sur le chemin de la réussite professionnelle, l'acquisition de nouvelles compétences constitue une étape incontournable.
+# Dans la vie de toute organisation, la prise de décisions stratégiques représente une étape déterminante pour son avenir.
+# Chaque crise surmontée marque une étape importante dans le renforcement de la résilience,
+# tandis que le franchissement d'un obstacle majeur signifie une étape de transition vers de nouveaux horizons.
+# Enfin, la signature d'un contrat décisif symbolise une étape clé dans la réalisation des objectifs à long terme.
+# """
+
+# # Appel de la fonction et affichage du résultat
+# print(une_etape(textea))