adding five other patherns

app.py

@@ -9,7 +9,11 @@ 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
 
 # Interface Streamlit
 st.title("Analyse du texte")
@@ -20,7 +24,12 @@ List_prompt = {
     "< 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 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(),
 }
 
 # Menu déroulant pour sélectionner l'analyse
@@ -73,6 +82,7 @@ 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 pattern 'ce qui explique' >":
             try:
                 # Analyser le texte pour les fautes de style
@@ -89,6 +99,7 @@ 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 des adverbes en -ment >":
             try:
                 # Analyser le texte pour les fautes de style
@@ -105,6 +116,7 @@ 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 des connecteurs 'cependant' >":
             try:
                 # Analyser le texte pour les fautes de style
@@ -121,5 +133,91 @@ 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 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)}")
+        
     else:
         st.error("Veuillez entrer du texte pour lancer l'analyse.")

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