core/DetectLanguage.py

#coding: utf-8
from os import getenv
from typing import Optional
import requests
import streamlit as st

from openai import OpenAI

def detect_language(input_text: str, 
                    temperature: Optional[float] = 0.2, 
                    context_window: Optional[int] = 128,
                    model: Optional[str] = "gpt-4o-mini"
                    ) -> str:
    """
    Détecte la langue d'un texte donné avec une vérification croisée si doute.

    Args:
        input_text (str): Le texte dont la langue doit être détectée.
        temperature (Optional[float]): Paramètre de température pour l'API. Par défaut 0.2.
        context_window (Optional[int]): Taille de la fenêtre de contexte. Par défaut 128.
        model (Optional[str]): Modèle à utiliser. Par défaut "gpt-4o-mini".

    Returns:
        str: Code de langue ISO-639-1 détecté.

    Raises:
        ValueError: Si le texte est vide ou invalide.
        requests.RequestException: Si une erreur de communication avec l'API se produit.
    """
    if not input_text or not isinstance(input_text, str):
        st.error("Erreur : Le texte à analyser est vide ou invalide")
        return "en"  # Fallback sur l'anglais par défaut

    system_prompt = (
        "Agissez comme une fonction de détection de langue. "
        "Fournissez la langue d'entrée au format ISO-639-1. "
        "Si vous avez un doute ou une incertitude, indiquez 'doute'."
    )
    
    try:
        # Vérifier la clé API
        api_key = getenv("OPENAI_API_KEY")
        if not api_key:
            raise ValueError("Clé API OpenAI non trouvée dans les variables d'environnement")

        client = OpenAI(api_key=api_key)

        # Appel à l'API avec gestion du timeout
        try:
            response = client.chat.completions.create(
                model=model,
                temperature=temperature,
                messages=[
                    {
                        "role": "system",
                        "content": system_prompt
                    },
                    {
                        "role": "user",
                        "content": input_text
                    }
                ],
                max_tokens=context_window,
                timeout=10  # Timeout de 10 secondes
            )
        except requests.Timeout:
            st.warning("Délai d'attente dépassé pour la détection de langue, utilisation du modèle de secours")
            return call_precise_language_model(input_text)

        if not response or not response.choices:
            raise ValueError("Réponse invalide de l'API")

        detected_language = response.choices[0].message.content.strip()

        # Vérification de la validité du code de langue
        if not detected_language or len(detected_language) < 2:
            raise ValueError("Code de langue invalide reçu de l'API")

        # Si le modèle indique un doute, faire appel à un modèle plus précis
        if "doute" in detected_language.lower():
            st.info("Doute sur la détection de langue, utilisation du modèle de secours")
            return call_precise_language_model(input_text)

        return detected_language

    except requests.RequestException as e:
        st.error(f"Erreur de communication avec l'API : {e}")
        return "en"  # Fallback sur l'anglais
    except ValueError as e:
        st.error(f"Erreur de configuration : {e}")
        return "en"  # Fallback sur l'anglais
    except Exception as e:
        st.error(f"Erreur inattendue lors de la détection de la langue : {e}")
        return "en"  # Fallback sur l'anglais

def call_precise_language_model(input_text: str) -> str:
    """
    Appelle un second modèle plus précis pour vérifier la langue en cas de doute.
    """
    precise_prompt = (
        "Agissez comme un détecteur de langue très précis. "
        "Fournissez la langue d'entrée au format ISO-639-1. "
    )
    
    try:
        client = OpenAI(api_key=getenv("OPENAI_API_KEY"))

        # Modèle plus précis
        response = client.chat.completions.create(
            model="gpt-4o",  # Un modèle plus lourd et précis
            temperature=0.1,
            messages=[
                {
                    "role": "system",
                    "content": precise_prompt
                },
                {
                    "role": "user",
                    "content": input_text
                }
            ],
            max_tokens=128
        )

        precise_language = response.choices[0].message.content.strip()
        return precise_language

    except Exception as e:
        raise ValueError(f"Erreur lors de la vérification précise de la langue : {str(e)}")


if __name__ == "__main__":
    input_text = "Bonjour, comment ça va ?"
    detected_language = detect_language(input_text)
    print(f"La langue détectée est : {detected_language}")

    input_text = "Hello, how are you?"
    detected_language = detect_language(input_text)
    print(f"La langue détectée est : {detected_language}")

    input_text = "Hola, ¿cómo estás?"
    detected_language = detect_language(input_text)
    print(f"La langue détectée est : {detected_language}")

    # maintenant des entrees plus longues, mais surtout plus ambigues, il faut comprendre la langue meme si le texte est ambigu ou melange des mots mirroirs ou des mots provenant de plusieurs langues

    input_text = "Cool raoul, j'y peut rien man, c'est la vie, c'est comme ça"
    detected_language = detect_language(input_text)
    print(f"La langue détectée est : {detected_language}")

    input_text = "Bordel de merde, le cousin s'est fait choper par les flics avec du shit sur lui."
    detected_language = detect_language(input_text)
    print(f"La langue détectée est : {detected_language}")