scripts/gen_ui_lang_support.py

#!/usr/bin/env python3
#coding:utf-8

from os import getenv
from typing import Optional, Any, Union
import re
import json
import time
import datetime

from openai import OpenAI


SUPPORTED_LANGUAGES=[
    "Afrikaans", "Arabic", "Armenian", "Azerbaijani", "Belarusian", "Bosnian", "Bulgarian", "Catalan", "Chinese", "Croatian", "Czech", "Danish", "Dutch", "English", "Estonian", "Finnish", "French", "Galician", "German", "Greek", "Hebrew", "Hindi", "Hungarian", "Icelandic", "Indonesian", "Italian", "Japanese", "Kannada", "Kazakh", "Korean", "Latvian", "Lithuanian", "Macedonian", "Malay", "Marathi", "Maori", "Nepali", "Norwegian", "Persian", "Polish", "Portuguese", "Romanian", "Russian", "Serbian", "Slovak", "Slovenian", "Spanish", "Swahili", "Swedish", "Tagalog", "Tamil", "Thai", "Turkish", "Ukrainian", "Urdu", "Vietnamese", "Welsh"
]

SUPPORTED_LANGUAGES_FR_ = [
    "Afrikaans", "Arabe", "Arménien", "Azéri", "Biélorusse", "Bosniaque", "Bulgare", "Catalan", "Chinois", "Croate", "Tchèque", "Danois", "Néerlandais", "Anglais", "Estonien", "Finnois", "Français", "Galicien", "Allemand", "Grec", "Hébreu", "Hindi", "Hongrois", "Islandais", "Indonésien", "Italien", "Japonais", "Kannada", "Kazakh", "Coréen", "Letton", "Lituanien", "Macédonien", "Malais", "Marathi", "Maori", "Népalais", "Norvégien", "Persan", "Polonais", "Portugais", "Roumain", "Russe", "Serbe", "Slovaque", "Slovène", "Espagnol", "Swahili", "Suédois", "Tagalog", "Tamoul", "Thaï", "Turc", "Ukrainien", "Ourdou", "Vietnamien", "Gallois"
]

traductions_ui_dict = {
    "Français": {
        "titre": "------- DEMORRHA -------",
        "entrez_message": "Entrez votre message ici:",
        "enregistrez_message": "Ou enregistrez votre message audio :",
        "cliquez_enregistrer": "Cliquez pour enregistrer",
        "cliquez_arreter": "Cliquez pour arrêter l'enregistrement",
        "cliquez_pause": "Cliquez pour mettre en pause",
        "langue_detectee": "Langue détectée : {}", 
        "transcription": "Transcription : {}",
        "sidebar_titre": "DEMORRHA - v1",
        "a_propos": "À propos",
        "info_app": "\n".join([
            "Cette application utilise Streamlit et l'API d'OpenAI pour créer un chat interactif avec des modèles de langages avancés dans le but de fournir un outil permettant la communication entre les êtres humains.",
            "Cet outil a pour objectif de montrer la voie dans un acte saint de la volonté de son auteur : ",
            "Abattre les barrières linguistiques entre les hommes."
        ]),
        "selection_langue": "Sélection de la langue",
        "langues_destination": "Choisissez les langues de destination",
        "placeholder_langues": "Sélectionnez une à quatre langue(s)",
        "parametres_tts": "Paramètres TTS",
        "choix_voix_tts": "Choisissez la voix TTS",
        "activer_tts_texte": "Activer TTS pour les entrées textuelles",
        "activer_tts_audio": "Activer TTS pour les entrées audio",
        "erreur_fichier_non_trouve": "Erreur : Le fichier '{}' n'a pas été trouvé.",
        "erreur_lecture_fichier": "Une erreur s'est produite lors de la lecture du fichier : {}",
        "langue_interface": "Langue de l'interface",
        "choix_langue_interface": "Choisissez la langue de l'interface",
        "envoyer": "Envoyer",
        "effacer": "Effacer",
        "historique_conversation": "Historique de la conversation",
        "effacer_historique": "Effacer l'historique",
        "erreur_api": "Une erreur s'est produite lors de l'appel à l'API : {}",
        "erreur_traitement": "Une erreur s'est produite lors du traitement de votre message : {}",
        "erreur_tts": "Une erreur s'est produite lors de la génération du texte en parole : {}",
        "chargement": "Chargement en cours...",
        "aucun_message": "Aucun message pour le moment. Commencez la conversation !"
    }
}


def generate_ui_lang_support(
    base_ui_lang: Optional[str]   = "Français", 
    target_ui_lang: Optional[Union[str, list]] = SUPPORTED_LANGUAGES_FR_) -> str:
    
    global traductions_ui_dict
    # check if `base_ui_lang` is in `SUPPORTED_LANGUAGES`, if not raise an error
    #if base_ui_lang not in SUPPORTED_LANGUAGES:
    #    raise ValueError(f"La langue de l'interface {base_ui_lang} n'est pas supportée. Les langues supportées sont : {SUPPORTED_LANGUAGES}")

    # check if `target_ui_lang` is a list, if is a list, check if `base_ui_lang` is in the list, if true remove it from the list
    if list == type(target_ui_lang):
        if base_ui_lang in target_ui_lang:
            target_ui_lang.remove(base_ui_lang)
    elif str == type(target_ui_lang):
        if base_ui_lang == target_ui_lang:
            # raise an error if `base_ui_lang` is the same as `target_ui_lang`
            raise ValueError(f"La langue de l'interface {base_ui_lang} est la même que la langue de destination {target_ui_lang}. Veuillez choisir une autre langue de destination.")


    def get_prompt_translation_ui_text(base_lang: str, 
                                       target_lang: str) -> str:
        prompt_ = "\n".join([
            f"Je souhaite que vous agissiez en tant que traducteur linguistique, correcteur d'orthographe et améliorateur.",
            f"Je vous donne un texte en {base_lang} et je vous demande de le traduire en {target_lang}. Puis répondez dans une version corrigée et améliorée de mon texte, dans la langue de destination.",
            f"Je souhaite que vous remplaciez mes mots et phrases par des termes et expressions les plus appropriés dans la langue de destination. Conservez le même sens, mais corrigez les fautes.",
            f"Je vous demande de ne répondre que par les corrections et améliorations, sans ajouter d'explications.",
            f"Lorsque je soumets un texte à traiter, je procéderai de la manière suivante pour délimiter le début et la fin du ou des blocs de texte que tu devras traiter : j'utiliserai trois caractères de guillemets doubles pour délimiter le début d'un bloc de texte à traiter ; j'utiliserai trois caractères de guillemets doubles pour délimiter la fin d'un bloc de texte à traiter. Le texte sera compris entre ces délimitations, que ce soit par format ou par taille du texte dans un bloc à traiter. Si mon texte est sur une seule ligne, il est possible que je place également les délimiteurs de début et de fin sur la même ligne.",
            f"Il est impératif que tu respectes le format d'origine au mieux ; donc, à moins qu'il soit absolument nécessaire de corriger le formatage, respecte au mieux ce détail. (Par exemple, tout en une ligne ou sur plusieurs... tu respectes le formatage d'origine. Par contre, tu peux, par exemple, corriger les espaces, tabulations et autres éléments superflus.)"
        ])
        return prompt_



    def get_openai_connected_client():
        openai_client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
        return openai_client

    def create_chat_completion(client, 
                               system_prompt,
                               user_input,
                               model="gpt-4o",
                               temperature=0.01,):
        response = client.chat.completions.create(
            model=f"{model}",
            temperature=temperature,
            messages=[
                {
                    "role": "system",
                    "content": f"{system_prompt}"
                },
                {
                    "role": "user",
                    "content": f"{user_input}"
                }
            ]
        )
        return response.choices[0].message.content
    
    def remove_response_separator(response_text:str) -> str:
        # Utiliser un regex pour retirer les trois premières et dernières doubles quotes
        return re.sub(r'^"{3}|"{3}$', '', response_text.strip())

    openai_client = get_openai_connected_client()
    
    cnt=0
    for to_lang in target_ui_lang:
        cnt += 1
        # print a progression message:  f"[{cnt}/{len(target_ui_lang)}] Translating UI text to {to_lang}..."
        # Colors like an hacker terminal, because it's cool !
        # {cnt} and {len(target_ui_lang)} are the current and total number of languages to translate , respectively in yellow FG and green FG.
        # '[' ']' are white FG 
        # {to_lang} is the language to translate in cyan FG
        # "Translating UI text to" is in light green FG
        print(f"\033[93m[{cnt}/{len(target_ui_lang)}]\033[0m \033[92mTranslating UI text to \033[0m\033[96m{to_lang}...\033[0m")
        PROMPT_ = get_prompt_translation_ui_text(base_ui_lang, to_lang)
        traductions_ui_dict[to_lang] = {}
        it_cnt=0
        for key, text_ui in traductions_ui_dict[base_ui_lang].items():
            it_cnt += 1
            # print a progression message:  f"  [{it_cnt}/{len(traductions_ui_dict[base_ui_lang].keys())}] + Translating UI text value of key '{key}'..."
            # Colors like an hacker terminal, because it's cool !
            # {it_cnt} and {len(traductions_ui_dict[base_ui_lang].keys())} are the current and total number of UI text values to translate , respectively in yellow FG and green FG.
            # '[' ']' are white FG
            # {key} is the key of the UI text value to translate in cyan FG
            # "Translating UI text value of key" is in light green FG
            print(f"  \033[93m[{it_cnt}/{len(traductions_ui_dict[base_ui_lang].keys())}]\033[0m \033[92mTranslating UI text value of key \033[0m\033[96m'{key}'...\033[0m")
            traduction_text_ui = create_chat_completion(openai_client, PROMPT_, text_ui)
            traductions_ui_dict[to_lang][key] = traduction_text_ui
        
    return json.dumps(traductions_ui_dict, indent=4, sort_keys=False)



if __name__ == "__main__":
    JSON_UI_LANG_SUPPORT = generate_ui_lang_support(
            base_ui_lang="Français", 
            target_ui_lang=SUPPORTED_LANGUAGES_FR_
    )
    if type(JSON_UI_LANG_SUPPORT) == str:
        JSON_UI_LANG_SUPPORT.encode()
    
    # timestamp string format : "MM-DD-YYYY_HH-MM-SS"
    timestamp = datetime.datetime.now().strftime("%m-%d-%Y_%H-%M-%S")
    with open(f"ui_lang_support_{timestamp}.json", "wb") as output_file:
        output_file.write(JSON_UI_LANG_SUPPORT)
        output_file.close()

    # print GREEN FG : "Success and Done !" message
    print("\033[92mSuccess and Done !\033[0m")
    exit(0)