app.py

import streamlit as st
import json
from pydantic import BaseModel, Field
from typing import List, Tuple
from langchain import LLMChain, PromptTemplate
from langchain.output_parsers import PydanticOutputParser

# Modèles Pydantic pour la détection de fautes de style
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")

    def to_dict(self):
        return {
            "erroneous_expression": self.erroneous_expression,
            "correct_suggestion": self.correct_suggestion,
            "occurrences": self.occurrences,
            "indices": self.indices
        }

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

    def to_dict(self):
        return {
            "total_style_errors_detected": self.total_style_errors_detected
        }

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")

    def to_dict(self):
        return {
            "style_errors": [error.to_dict() for error in self.style_errors],
            "summary": self.summary.to_dict()
        }

# Création du prompt et du modèle LLMChain pour analyser les fautes de style
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}```
"""

# Utilisation de LangChain pour la détection des erreurs
def get_llm_chain():
    output_parser = PydanticOutputParser(pydantic_object=StyleErrorResult)
    prompt = PromptTemplate(input_variables=["text"], template=prompt_template)
    # Remplacez `llm` par votre modèle de langage préféré, tel que OpenAI GPT ou autre
    llm = None  # Remplacez ceci par votre modèle LLM
    llm_chain = LLMChain(llm=llm, prompt=prompt, output_parser=output_parser)
    return llm_chain

# Fonction pour analyser les fautes de style
def analyze_style_errors(text: str) -> dict:
    llm_chain = get_llm_chain()
    result = llm_chain.run(text=text)
    return result.to_dict()

# Interface Streamlit
st.title("Détection des fautes de style")

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

# Bouton d'analyse
if st.button("Lancer l'analyse"):
    if input_text:
        try:
            # Analyse du texte pour détecter les fautes de style
            result = analyze_style_errors(input_text)

            # Affichage des résultats en JSON formaté
            st.subheader("Résultats de l'analyse")
            st.json(result)

        except Exception as e:
            st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
    else:
        st.error("Veuillez entrer du texte pour lancer l'analyse.")