adding epoque prompt

app.py

@@ -4,7 +4,8 @@ import logging
 from langchain.chat_models import ChatOpenAI
 
 # Import the function for detecting the "est une étape" pattern
-from est_une_etape import une_etape, est_une_etape_prompt_template
+from pattern_epoque import epoque, epoque_prompt_template
+from pattern_est_une_etape import une_etape, est_une_etape_prompt_template
 
 # Interface Streamlit
 st.title("Analyse du texte")
@@ -12,6 +13,7 @@ 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(),
     # Ajoutez d'autres options ici si nécessaire
 }
 
@@ -23,7 +25,7 @@ option = st.selectbox(
 
 # Afficher le prompt correspondant à l'option sélectionnée
 selected_prompt = List_prompt.get(option, "")
-st.subheader("Prompt correspondant à l'option sélectionnée")
+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
@@ -38,7 +40,7 @@ if st.button("Lancer l'analyse"):
                 result = une_etape(input_text)
 
                 # Afficher les résultats en JSON formaté
-                st.subheader("Résultats de l'analyse des fautes de style")
+                st.subheader("Résultats de l'analyse du pattern 'est une étape'")
                 st.json(result['result'], expanded=True)
 
                 # Afficher le prompt final
@@ -48,21 +50,22 @@ if st.button("Lancer l'analyse"):
             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 verbe 'permettre'":
-            pass
-            # try:
-            #     # Détecter les formes du verbe "permettre"
-            #     result = detect_permettre_forms(input_text)
 
-            #     # Afficher les résultats
-            #     st.subheader("Résultats de la détection du verbe 'permettre'")
-            #     if result:
-            #         for mot, index in result:
-            #             st.write(f"Mot : '{mot}' à l'index {index}")
-            #     else:
-            #         st.write("Aucune forme du verbe 'permettre' n'a été trouvée.")
-            # except Exception as e:
-            #     logging.error(f"Error during detection: {e}")
-            #     st.error(f"Une erreur s'est produite lors de la détection : {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)}")
     else:
         st.error("Veuillez entrer du texte pour lancer l'analyse.")

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
+    }