pattern_est_une_etape.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


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.")
    adjectif: str = Field(..., description="Adjectif associé à l'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,
            "adjectif": self.adjectif,
            "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 est_une_etape_prompt_template() :
    return """
    En tant que rédacteur web expert, votre mission est d'analyser le texte suivant et d'identifier toutes les phrases où une expression similaire à "est une étape" est utilisée, y compris ses variantes , "constitue une étape", "représente une étape", "marque une étape","signifie une étape", "symbolise une étape", etc, particulièrement lorsqu'elles sont associées à des adjectifs exprimant l'importance.
    Exemples d'expressions à rechercher :
    "est une étape importante" → "contribue à l'avancement du processus"
    "représente une étape cruciale" → "fait progresser significativement le projet"
    "symbolise une étape fondamentale" → "marque un tournant dans le développement"

    Regroupe les expressions détectés par phrase et pour chaque phrase, veuillez :
    1. Citez la phrase complète avec ses indices de début et de fin.
    2. Identifiez l'expression ou les expressions exacte avec leurs indices.
    3. Proposez 5 reformulations améliorant le style tout en préservant le sens et le contexte.
    4. Fournissez une justification unique pour les reformulations tout en mentionnant l'adjectif d'importance associé.

    Règles de reformulation :
    - Évitez l'utilisation directe de "étape" associée à des adjectifs d'importance.
    - Remplacez ces constructions par des verbes d'action ou des expressions plus dynamiques.
    - Utilisez un vocabulaire professionnel et formel.
    - Variez la structure des phrases pour éviter la répétition.
    - Assurez-vous que les reformulations transmettent l'importance de l'action sans utiliser explicitement des termes comme "important", "crucial", etc.

    Expressions à rechercher :
    - "est une étape", "constitue une étape", "représente une étape", "marque une étape", "signifie une étape", "symbolise une étape"
    - Ces expressions associées à des adjectifs comme : "important", "essentiel", "crucial", "primordial", "fondamental", "indispensable", "déterminant", "vital", "majeur", "clé", "nécessaire", "stratégique", "significatif"

    Texte à analyser :
    {text}

    Format de sortie JSON :
    {{
      "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 (ex: 'est une étape importante')",
              "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 en s'il est disponible l'adjectif qualificatif à laquelle c'est associés."
        }}
      ],
      "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
      }}
    }}

    Assurez-vous que les indices correspondent aux positions exactes dans le texte original et que le JSON est correctement formaté.
    {format_instruction}"""

# def est_une_etape_prompt_template() :

#     return """
#     Analyser le texte suivant et identifier toutes les phrases où une expression similaire à "est une étape" est utilisée,
#     y compris des variantes comme "est une étape", "constitue une étape", "représente une étape", "marque une étape",
#     "signifie une étape", "symbolise une étape", etc.

#     Recherche particulièrement ces expressions lorsqu'elles sont associées à des adjectifs exprimant l'importance
#     (par exemple, "important", "essentiel", "crucial", "primordial", "fondamental", "indispensable", "déterminant",
#     "vital", "majeur", "clé", "nécessaire", "stratégique", "significatif", etc.), que l'adjectif se trouve avant ou après le mot "étape".

#     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.
#     - Mentionner l'adjectif d'importance associé.
#     - Proposer deux reformulations de la phrase pour changer l'expression détectée et l'adjectif associé,
#       sans employer d'expression équivalente.
#     - Assurez-vous de respecter les règles suivantes :
#       1. Les expressions comme "crucial", "essentiel", "important", "fondamental" doivent être utilisées une seule fois
#          dans l'introduction (premier paragraphe).
#       2. Évitez l'usage de mots comme "il existe", "il faut", "cependant", "de plus", "en revanche", "toutefois" en début de phrase.
#       3. N'utilisez pas "joue un rôle", "il est", ou "est une étape" avec des adjectifs tels qu'"important", "essentiel", etc.

#     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",
#     - "adjectif": "adjectif associé",
#     - "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,

#     Ajoutez également un résumé à la fin :

#     - "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 une_etape(text):
    # Créer le template avec la variable text intégrée directement
    prompt_template = est_une_etape_prompt_template()

    output_parser = PydanticOutputParser(pydantic_object=DetectionResult)

    # Créer le prompt avec le texte intégré
    # prompt = PromptTemplate(template=template, input_variables=["text"])

    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)

    final_prompt = gen_prompt_template.format(text=text)
    # Retourne les suggestions ou les erreurs de parsing

    return {
        "result": json_result,
        "prompt": final_prompt
    }