pattern_important_crucial.py

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="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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
    }