pattern_permettre.py

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 Expression(BaseModel):
    expression: str = Field(..., description="Expression détectée (ex: 'est une étape importante')")
    indice_debut: int = Field(..., description="Indice de début de l'expression")
    indice_fin: int = Field(..., description="Indice de fin de l'expression")

class Phrase(BaseModel):
    texte: str = Field(..., description="Phrase complète contenant l'expression ou les expressions détectées")
    indice_debut: int = Field(..., description="Indice de début de la phrase")
    indice_fin: int = Field(..., description="Indice de fin de la phrase")

class Reformulation(BaseModel):
    texte: str = Field(..., description="Texte de la reformulation")

class PhraseDetectee(BaseModel):
    phrase: Phrase = Field(..., description="Détails de la phrase")
    erreurs: List[Expression] = Field(..., description="Liste des expressions détectées dans la phrase")
    reformulations: List[Reformulation] = Field(..., description="Liste des reformulations proposées")
    justification: str = Field(..., description="Justification des reformulations proposées")

class Summary(BaseModel):
    total_erreurs: int = Field(..., description="Nombre total d'expressions détectées")
    total_phrases: int = Field(..., description="Nombre total de phrases contenant des expressions")
    total_reformulations: int = Field(..., description="Nombre total de reformulations proposées")

class DetectionResult(BaseModel):
    phrases_detectees: List[PhraseDetectee] = Field(..., description="Liste des phrases détectées avec détails")
    summary: Summary = Field(..., description="Résumé de la détection")

    def to_dict(self):
        return {
            "phrases_detectees": [phrase.model_dump() for phrase in self.phrases_detectees],
            "summary": self.summary.model_dump()
        }


# Création du template pour la détection avec reformulations
def permettre_prompt_template():
    return """En tant que rédacteur web expert, votre mission est d'analyser le texte suivant et  d'identifier toutes les formes conjuguées du verbe "permettre" dans le texte ci-dessous (exemples : "permet", "permettra", "permis" lorsqu'il est utilisé comme verbe, etc.).

Exclusions : Ignorez les occurrences où "permis" est utilisé comme nom commun (par exemple : "permis de conduire", "permis de construire", etc.).

Instructions supplémentaires :
   - Réalisez une analyse grammaticale en identifiant les mots dont le lemme est "permettre".
   - Ne considérez "permis" que comme un verbe, pas comme un nom commun.
   - Couvrez toutes les formes verbales (présent, passé, futur, infinitif, participe passé, etc.).
   - Évitez de répéter les mêmes formes verbales plusieurs fois dans une phrase.

Exemples d'erreurs à corriger :
- "Ce logiciel permet de gérer les données efficacement", mais on peut dire "Ce logiciel facilite la gestion des données."
- "Cette fonctionnalité permettra d'améliorer la productivité", mais on peut dire "Cette fonctionnalité améliore la productivité."

Pour chaque occurrence trouvée, veuillez :
1. Citer la phrase complète où apparaît l'expression.
2. Identifier l'expression exacte utilisée dans le texte.
3. Expliquer pourquoi l'utilisation du verbe "permettre" peut parfois alourdir le texte ou rendre l'introduction trop familière, directive ou permissive.
4. Proposer deux reformulations de la phrase en :
   - Simplifiant la phrase pour la rendre plus professionnelle, fluide, et en évitant d'utiliser le verbe "permettre" ou ses variantes.
   - Assurant que la reformulation conserve le sens original tout en adoptant un ton plus formel et naturel.

Règles à respecter :
1. Les expressions comme "crucial", "essentiel", "important", "fondamental" ne doivent pas être utilisées plus d'une fois dans l'introduction.
2. Les expressions telles que "il existe", "il faut", "cependant", "de plus", "en revanche", "néanmoins", "toutefois" ne doivent pas être placé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 que "important", "essentiel", etc.
4. "En plus" ne doit pas être utilisé seul au début d'une phrase.


Votre analyse doit être retournée en JSON avec la structure suivante :
{{
    "phrases_detectees": [
    {{
        "phrase": {{
        "texte": "Phrase complète contenant l'expression ou les expressions détectées",
        "indice_debut": x,
        "indice_fin": y
        }},
        "erreurs": [
        {{
            "expression": "Expression détectée",
            "indice_debut": a,
            "indice_fin": b
        }}
        ],
        "reformulations": [
        {{ "texte": "Reformulation 1" }},
        {{ "texte": "Reformulation 2" }},
        {{ "texte": "Reformulation 3" }},
        {{ "texte": "Reformulation 4" }},
        {{ "texte": "Reformulation 5" }}
        ],
        "justification": "Justification des reformulations proposées."
    }}
    ],
    "summary": {{
    "total_erreurs": nombre_total_d_expressions_detectées,
    "total_phrases": nombre_total_de_phrases_contenant_des_expressions,
    "total_reformulations": nombre_total_de_reformulations_proposées
    }}
}}


Texte à analyser :
{text}

Assurez-vous que les indices correspondent aux positions exactes dans le texte original et que le JSON est correctement formaté.
{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
    }