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()
        }


# Fonction pour générer un output parser
def generate_output_parser(response: str) -> dict:
    try:
        parsed_response = json.loads(response)
        detection_result = DetectionResult(
            patterns=[PatternDetail(
                pattern=item["pattern"],
                adjectif=item["adjectif"],
                indices=item["indices"],
                sentence=item["sentence"],
                alternative_suggestions=AlternativeSuggestion(
                    suggestion_1=item["alternative_suggestions"][0],
                    suggestion_2=item["alternative_suggestions"][1]
                )
            ) for item in parsed_response["patterns"]],
            summary=Summary(
                total_patterns_detected=parsed_response["summary"]["total_patterns_detected"],
                alternative_suggestions_provided=parsed_response["summary"]["alternative_suggestions_provided"],
                occurrences=parsed_response["summary"]["occurrences"]
            )
        )
        return detection_result.to_dict()
    except Exception as e:
        return {"error": f"Failed to parse response: {str(e)}"}



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

    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)

    # Retourne les suggestions ou les erreurs de parsing
    return json_result


# # Exemple d'utilisation avec le texte à analyser
# textea = """
# Dans le développement personnel, chaque progrès est une étape cruciale vers une meilleure version de soi-même.
# De plus, sur le chemin de la réussite professionnelle, l'acquisition de nouvelles compétences constitue une étape incontournable.
# Dans la vie de toute organisation, la prise de décisions stratégiques représente une étape déterminante pour son avenir.
# Chaque crise surmontée marque une étape importante dans le renforcement de la résilience,
# tandis que le franchissement d'un obstacle majeur signifie une étape de transition vers de nouveaux horizons.
# Enfin, la signature d'un contrat décisif symbolise une étape clé dans la réalisation des objectifs à long terme.
# """

# # Appel de la fonction et affichage du résultat
# print(une_etape(textea))