adding the remaining prompts

app.py

@@ -15,6 +15,13 @@ 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
+
 # Interface Streamlit
 st.title("Analyse du texte")
 
@@ -31,6 +38,12 @@ List_prompt = {
     "< 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(),
 }
 
 # Menu déroulant pour sélectionner l'analyse
@@ -237,5 +250,107 @@ 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 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)}")
+        
     else:
         st.error("Veuillez entrer du texte pour lancer l'analyse.")

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="sk-your-api-key")
+
+    # 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_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="sk-your-api-key")
+
+    # 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_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="sk-your-api-key")
+
+    # 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_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="sk-your-api-key")
+
+    # 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="sk-your-api-key")
+
+    # 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
+    }