app.py

import streamlit as st
import json
import logging
import os
import spacy
from typing import List, Tuple
from pydantic import BaseModel, Field
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI

# Import the function for detecting the "est une étape" pattern
from est_une_etape import une_etape

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Load the French spaCy model
nlp = spacy.load('fr_core_news_md')

# Pydantic models for style error detection
class StyleErrorDetection(BaseModel):
    erroneous_expression: str = Field(..., description="L'expression ou la tournure incorrecte détectée")
    correct_suggestion: str = Field(..., description="La correction ou suggestion correcte")
    occurrences: int = Field(..., description="Nombre d'occurrences de l'expression erronée")
    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence")

class StyleErrorSummary(BaseModel):
    total_style_errors_detected: int = Field(..., description="Nombre total de fautes de style détectées")

class StyleErrorResult(BaseModel):
    style_errors: List[StyleErrorDetection] = Field(..., description="Liste des fautes de style détectées")
    summary: StyleErrorSummary = Field(..., description="Résumé des fautes de style détectées")

# Create the output parser
output_parser = PydanticOutputParser(pydantic_object=StyleErrorResult)

# Prompt template with format instructions
prompt_template = """
Tu es un détecteur de texte AI très précis. Je vais te donner un texte, et ta mission est de repérer des fautes de style.
Cela inclut les répétitions, les tournures de phrases maladroites, et les mauvais choix de mots.
Pour chaque erreur détectée, tu dois fournir les informations suivantes :
- L'expression ou la tournure incorrecte détectée
- La correction ou suggestion correcte
- Le nombre d'occurrences de l'expression erronée
- Les indices de début et de fin pour chaque occurrence

Le texte à analyser est le suivant :
```{text}```

Voici le format attendu pour la sortie :
{format_instructions}
"""

def get_llm_chain():
    prompt = PromptTemplate(
        input_variables=["text"],
        template=prompt_template,
        partial_variables={"format_instructions": output_parser.get_format_instructions()},
    )

    llm = ChatOpenAI(
        model='gpt-4o',
        temperature=0.5,
        api_key="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",
        verbose=True
    )

    llm_chain = prompt | llm | output_parser
    return llm_chain

def analyze_style_errors(text: str) -> dict:
    logging.info(f"Analyzing text: {text[:100]}...")
    llm_chain = get_llm_chain()
    logging.info("Running the LLM chain.")
    result = llm_chain.invoke({"text": text})
    logging.info("LLM chain completed.")
    return result

# Function to detect forms of the verb "permettre" in a text
def detect_permettre_forms(text: str) -> list:
    doc = nlp(text)
    resultats = []
    for i, token in enumerate(doc):
        # Vérifier si le lemme est "permettre" et que le mot est un verbe (autre que "permis")
        if token.lemma_ == "permettre" and token.pos_ == "VERB" and token.text.lower() != "permis":
            resultats.append((token.text, token.idx))
        # Traiter spécifiquement le mot "permis"
        elif token.text.lower() == "permis":
            est_verbe = False
            # Vérifier si le mot précédent est un auxiliaire
            if i > 0 and doc[i - 1].pos_ == "AUX":
                est_verbe = True
            # Vérifier si le mot suivant est "de" suivi d'un verbe à l'infinitif
            elif i + 2 < len(doc) and doc[i + 1].text.lower() == "de" and doc[i + 2].pos_ == "VERB" and "Inf" in doc[i + 2].tag_:
                est_verbe = True
            # Vérifier si le mot précédent est un déterminant (le, la, un, une, etc.)
            elif i > 0 and doc[i - 1].pos_ == "DET":
                est_verbe = False
            else:
                # Autres cas, on suppose que c'est un nom
                est_verbe = False

            if est_verbe:
                resultats.append((token.text, token.idx))
    return resultats

# Interface Streamlit
st.title("Analyse du texte")

# Menu déroulant pour sélectionner l'analyse
option = st.selectbox(
    "Choisissez l'analyse à effectuer :",
    ("< Détection du pattern 'est une étape' >")# , "Détection du verbe 'permettre'"
)

# Champ de saisie du texte
input_text = st.text_area("Entrez votre texte ici :", height=200)

# Bouton d'analyse
if st.button("Lancer l'analyse"):
    if input_text:
        if option == "< Détection du pattern 'est une étape' >":
            try:
                # Analyser le texte pour les fautes de style
                result = une_etape(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse des fautes de style")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                st.subheader("Prompt final envoyé au modèle")
                st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        elif option == "Détection du verbe 'permettre'":
            try:
                # Détecter les formes du verbe "permettre"
                result = detect_permettre_forms(input_text)

                # Afficher les résultats
                st.subheader("Résultats de la détection du verbe 'permettre'")
                if result:
                    for mot, index in result:
                        st.write(f"Mot : '{mot}' à l'index {index}")
                else:
                    st.write("Aucune forme du verbe 'permettre' n'a été trouvée.")
            except Exception as e:
                logging.error(f"Error during detection: {e}")
                st.error(f"Une erreur s'est produite lors de la détection : {str(e)}")
    else:
        st.error("Veuillez entrer du texte pour lancer l'analyse.")