core/DetectLanguage.py

#coding: utf-8

# Standard libraries
#import json
#import re

from os import getenv
#from typing import Any
#from typing import Dict
#from typing import IO
#from typing import List
#from typing import Optional
#from typing import Tuple
#from typing import Union
#from io import BytesIO

# Third-party libraries
import requests

from openai import OpenAI
#from pydub import AudioSegment

def check_openai_api_key(api_key):
    import openai
    client = openai.OpenAI(api_key=api_key)
    try:
        client.models.list()
    except openai.AuthenticationError:
        return False
    else:
        return True


class PRESET_MODELS:
    # for detect language with GPT-4o-mini and GPT-4o models: 
    # meta-paramaters presets (check_level:(low, medium, high), deterministict: (maximum, medium, minimum))
    def get_preset__detect_language(check_level: str = "medium", deterministic: str = "medium"):
        if check_level == "low":
            if deterministic == "maximum":
                return {"temperature": 0.1, "frequency_penalty": 0.5, "presence_penalty": 0.5}
            elif deterministic == "medium":
                return {"temperature": 0.2, "frequency_penalty": 0.5, "presence_penalty": 0.5}
            elif deterministic == "minimum":
                return {"temperature": 0.3, "frequency_penalty": 0.5, "presence_penalty": 0.5}
        elif check_level == "medium":
            if deterministic == "maximum":
                return {"temperature": 0.1, "frequency_penalty": 0.2, "presence_penalty": 0.2}
            elif deterministic == "medium":
                return {"temperature": 0.2, "frequency_penalty": 0.2, "presence_penalty": 0.2}
            elif deterministic == "minimum":
                return {"temperature": 0.3, "frequency_penalty": 0.2, "presence_penalty": 0.2}
        elif check_level == "high":
            if deterministic == "maximum":
                return {"temperature": 0.01, "frequency_penalty": 0.1, "presence_penalty": 0.1}
            elif deterministic == "medium":
                return {"temperature": 0.05, "frequency_penalty": 0.1, "presence_penalty": 0.1}
            elif deterministic == "minimum":
                return {"temperature": 0.1, "frequency_penalty": 0.1, "presence_penalty": 0.1}
        else:
            return {"temperature": 0.2, "frequency_penalty": 0.2, "presence_penalty": 0.2}

def detect_language(input_text: str, temperature: float = 0.01, context_window: int = 128) -> str:
    """
    Détecte la langue d'un texte donné.

    Args:
        input_text (str): Le texte dont il faut détecter la langue.
        temperature (float): La température pour le modèle de langage. Par défaut à 0.2.
        context_window (int): Longueur de la fenêtre de contexte à utiliser pour la détection.

    Returns:
        str: La langue détectée au format ISO-639-1.

    Raises:
        ValueError: Si la réponse de l'API est invalide.
        requests.RequestException: En cas d'erreur de communication avec l'API.
    """
    system_prompt = (
        "Agissez comme une fonction de détection de langue. "
        "Je fournirai du texte dans n'importe quelle langue, et vous détecterez sa langue. "
        "Fournissez le résultat de votre détection au format ISO-639-1. "
        "Votre réponse doit représenter l'argument `language` et ne contenir "
        "que sa valeur sous forme de chaîne. "
        "Fournir la langue d'entrée au format ISO-639-1 améliorera la précision et la latence."
    )
    try:
        client = OpenAI(api_key=getenv("OPENAI_API_KEY"))

        #################

        response = client.chat.completions.create(
            model="gpt-4o-mini",
            temperature=temperature,
            messages=[
                {
                    "role": "system",
                    "content": system_prompt
                },
                {
                    "role": "user",
                    "content": input_text
                }
            ],
            frequency_penalty=0.2,
            presence_penalty=0,
            max_tokens=context_window
        )
        detected_language = response.choices[0].message.content
        if not detected_language:
            raise ValueError("La réponse de l'API est vide")
        return detected_language
    except requests.RequestException as e:
        raise requests.RequestException(f"Erreur de communication avec l'API : {str(e)}")
    except Exception as e:
        raise ValueError(f"Erreur inattendue lors de la détection de la langue : {str(e)}")


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

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