pattern_vous_pouvez.py

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
    }