dev-patch-1

.gitignore

@@ -94,8 +94,3 @@ ENV/
 # Données sensibles ou de configuration locale
 credentials.json
 config.ini
-
-test_samples/
-test-samples/
-
-.python-version

README.md

@@ -1,49 +1,13 @@
 ---
-title: Demorrha v1
-emoji: 🔥
-colorFrom: purple
-colorTo: green
-python_version: 3.10.15
+title: Demorrha
+emoji: 🐨
+colorFrom: yellow
+colorTo: blue
 sdk: streamlit
-sdk_version: 1.40.0
+sdk_version: 1.38.0
 app_file: app.py
-pinned: true
+pinned: false
 license: gpl-3.0
-thumbnail: >-
-  https://cdn-uploads.huggingface.co/production/uploads/6616ef2ccba578190b887876/RSTUMUn6KegraYqq66pbG.jpeg
-short_description: 'Quest: "Break down the language barriers between people..."'
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-
-# Demorrha v1
-> Quest: "Break down the language barriers between people..."
-
-Demorrha is an AI-powered translation assistant that helps facilitate communication across different languages. It provides real-time translation capabilities through text, audio, and file inputs.
-
-## Key Features
-- Multi-language support with up to 4 target languages simultaneously
-- Text-to-Speech and Speech-to-Text capabilities
-- File upload support for text documents
-- User-friendly interface with customizable settings
-- Real-time streaming translations
-
-## Getting Started
-Visit the app at [Demorrha on Hugging Face](https://huggingface.co/spaces/ImPolymath/demorrha)
-
-## Usage
-1. Select your interface language
-2. Choose up to 4 target languages for translation
-3. Input text, upload a file, or use voice input
-4. Get real-time translations in your selected languages
-
-## Technical Details
-- Built with Streamlit
-- Uses OpenAI's GPT models for translation
-- Integrates Azure Speech Services for voice capabilities
-- Supports multiple file formats for text extraction
-
-## Contributing
-Contributions are welcome! Please feel free to submit a Pull Request.
-

app.py

@@ -16,35 +16,22 @@ from typing import Tuple
 from typing import Union
 
 # Third-party libraries
+import requests
 import streamlit as st
+from audiorecorder import audiorecorder
+from openai import OpenAI
+from pydub import AudioSegment
 
 
-from var_app import __version__
+__version__ = "1.1.4"
 
 # Au début du fichier, après les imports
-#st.set_page_config(
-#    page_title=f"DEMORRHA - (v{__version__})",
-#    page_icon="👹",
-#    layout="wide",
-#    initial_sidebar_state="collapsed"
-#)
-
-
-LANGUAGES_EMOJI = {
-    "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": "🏴󠁧󠁢󠁷󠁬󠁳󠁿"
-}
-
+st.set_page_config(
+    page_title=f"DEMORRHA - (v{__version__})",
+    page_icon="👹",
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
 
 def load_ui_language(file_path: Optional[str] = "ui_lang_support.json") -> Dict[str, Any]:
     """
@@ -69,48 +56,681 @@ def load_ui_language(file_path: Optional[str] = "ui_lang_support.json") -> Dict[
         print(f"{get_translation('erreur_lecture_fichier')} {e}")
         return {}
 
+# Dictionary to store translations
+translations = load_ui_language()
 
 def get_translation(key: str) -> str:
     """
     Obtient la traduction pour une clé donnée basée sur la langue d'interface sélectionnée.
+
+    Args:
+        key (str): La clé de traduction.
+
+    Returns:
+        str: Le texte traduit.
     """
-    lang = st.session_state.get('interface_language', 'English')
-    return translations.get(lang, {}).get(key, key)
+    return translations[st.session_state.interface_language][key]
 
-# Dictionary to store translations
-translations = load_ui_language()
+# OpenAI client configuration with API key
+client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
+
+def read_file(file_name: str) -> str:
+    """
+    Lit et retourne le contenu des fichiers texte.
+
+    Args:
+        file_name (str): Le nom du fichier à lire.
 
+    Returns:
+        str: Le contenu du fichier ou un message d'erreur.
+    """
+    try:
+        with open(file_name, 'r', encoding='utf-8') as file:
+            content = file.read()
+        return content
+    except FileNotFoundError:
+        return f"{get_translation('erreur_fichier_non_trouve')} {file_name}"
+    except IOError as e:
+        return f"{get_translation('erreur_lecture_fichier')} {str(e)}"
 
+def split_audio(audio_file: str, max_size_mb: int = 25) -> List[str]:
+    """
+    Divise un fichier audio en segments de 25 Mo ou moins.
 
+    Args:
+        audio_file (str): Chemin vers le fichier audio.
+        max_size_mb (int): Taille maximale de chaque segment en Mo.
 
-def main():
-    if 'interface_language' not in st.session_state:
-        # default language
-        st.session_state.interface_language = 'English'
-
-
-    pages = {
-        "Configuration" : [
-            st.Page("pages/configuration_ui_lang.py", title="Language selection"),
-        ],
-        "Translator" : [
-            st.Page("pages/main.py", title="Main page"),
-        ],
-    }
-    pg = st.navigation(pages)
-    pg.run()
+    Returns:
+        List[str]: Liste des chemins vers les segments audio divisés.
+    """
+    try:
+        audio = AudioSegment.from_wav(audio_file)
+        duration_ms = len(audio)
+        segment_duration_ms = int(
+            (max_size_mb * 1024 * 1024 * 8) /
+            (audio.frame_rate * audio.sample_width * audio.channels)
+        )
+
+        segments = []
+        for start in range(0, duration_ms, segment_duration_ms):
+            end = min(start + segment_duration_ms, duration_ms)
+            segment = audio[start:end]
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_segment:
+                segment.export(temp_segment.name, format="wav")
+                segments.append(temp_segment.name)
+
+        return segments
+    except IOError as e:
+        print(f"Erreur lors de la lecture ou de l'écriture du fichier audio : {e}")
+        return []
+    except ValueError as e:
+        print(f"Erreur de valeur lors du traitement de l'audio : {e}")
+        return []
+
+# Fonction modifiée pour transcrire l'audio en texte
+def transcribe_audio(audio_file: IO, language: Optional[str] = None) -> str:
+    """
+    Transcrit un fichier audio en texte.
+
+    Args:
+        audio_file (IO): Le fichier audio à transcrire.
+        language (Optional[str]): La langue de l'audio. Par défaut None.
+
+    Returns:
+        str: Le texte transcrit.
+    """
+    max_size_mb = 25
+    file_size_mb = os.path.getsize(audio_file.name) / (1024 * 1024)
+    
+    try:
+        with st.status("Transcription de l'audio en cours...") as status:
+            if file_size_mb > max_size_mb:
+                status.update(label="Découpage de l'audio en segments...")
+                segments = split_audio(audio_file.name, max_size_mb)
+                full_transcript = ""
+                for i, segment in enumerate(segments):
+                    status.update(label=f"Transcription du segment {i+1}/{len(segments)}...")
+                    with open(segment, "rb") as audio_segment:
+                        transcript = client.audio.transcriptions.create(
+                            model="whisper-1",
+                            file=audio_segment,
+                            language=language
+                        )
+                        full_transcript += f"{transcript.text} "
+                    os.unlink(segment)  # Supprime le fichier temporaire
+                status.update(label="Transcription terminée", state="complete")
+                return full_transcript.strip()
+            else:
+                status.update(label="Transcription de l'audio...")
+                with open(audio_file.name, "rb") as audio_file:
+                    transcript = client.audio.transcriptions.create(
+                        model="whisper-1",
+                        file=audio_file,
+                        language=language
+                    )
+                status.update(label="Transcription terminée", state="complete")
+                return transcript.text
+    except IOError as e:
+        st.error(f"Erreur d'entrée/sortie lors de la transcription : {e}")
+        return ""
+    except client.APIError as e:
+        st.error(f"Erreur API lors de la transcription : {e}")
+        return ""
+
+# Fonction pour détecter la langue d'un texte donné
+def detect_language(input_text: str, temperature: float = 0.01) -> 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.01.
+
+    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:
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            temperature=temperature,
+            messages=[
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": input_text
+                }
+            ]
+        )
+        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)}")
+
+def get_duration_pydub(audio_file: str) -> float:
+    """
+    Obtient la durée d'un fichier audio en utilisant pydub.
+
+    Args:
+        audio_file (str): Chemin vers le fichier audio.
+
+    Returns:
+        float: Durée du fichier audio en secondes.
+    """
+    try:
+        audio = AudioSegment.from_file(audio_file)
+        return audio.duration_seconds
+    except FileNotFoundError:
+        print(f"Erreur : Le fichier audio '{audio_file}' n'a pas été trouvé.")
+        return 0.0
+    except Exception as e:
+        print(f"Erreur lors de la lecture du fichier audio : {str(e)}")
+        return 0.0
+
+def text_to_speech(text: str) -> Tuple[Optional[bytes], float]:
+    """
+    Convertit du texte en parole en utilisant l'API OpenAI.
+
+    Args:
+        text (str): Le texte à convertir en parole.
+
+    Returns:
+        Tuple[Optional[bytes], float]: Un tuple contenant les octets audio et la durée de l'audio en secondes.
+    """
+    try:
+        response = client.audio.speech.create(
+            model="tts-1",
+            voice=st.session_state.tts_voice,
+            input=text
+        )
+        
+        # Sauvegarde l'audio dans un fichier temporaire
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
+            response.stream_to_file(temp_audio.name)
+            
+            # Lit le contenu du fichier audio
+            with open(temp_audio.name, "rb") as audio_file:
+                audio_bytes = audio_file.read()
+
+            # Obtient la durée de l'audio en secondes
+            audio_duration = get_duration_pydub(temp_audio.name)
+
+        return audio_bytes, audio_duration
+    except Exception as e:
+        print(f"Erreur lors de la conversion texte-parole : {str(e)}")
+        return None, 0.0
+
+def concatenate_audio_files(audio_list: List[Tuple[bytes, float]]) -> Optional[bytes]:
+    """
+    Concatène plusieurs fichiers audio avec des effets sonores.
+
+    Args:
+        audio_list (List[Tuple[bytes, float]]): Une liste de tuples, chacun contenant
+            des octets audio et la durée.
+
+    Returns:
+        Optional[bytes]: L'audio concaténé sous forme d'octets, ou None en cas d'erreur.
+    """
+    # Créer un segment audio vide
+    final_audio = AudioSegment.empty()
     
+    try:
+        # Charger les effets sonores
+        begin_sound = AudioSegment.from_mp3(
+            "sound-effects/voice-message-play-begin/voice-message-play-begin-1.mp3"
+        )
+        end_sound = AudioSegment.from_mp3(
+            "sound-effects/voice-message-play-ending/voice-message-play-ending-1.mp3"
+        )
+        
+        # 5 secondes de silence
+        silence = AudioSegment.silent(duration=1500)  # 1500 ms = 1.5 secondes
+        
+        for audio_bytes, _ in audio_list:
+            # Convertir les octets en un segment audio
+            segment = AudioSegment.from_mp3(io.BytesIO(audio_bytes))
+            
+            # Ajouter le son de début, le segment TTS, le son de fin et le silence
+            final_audio += begin_sound + segment + end_sound + silence
+        
+        # Convertir le segment audio final en octets
+        buffer = io.BytesIO()
+        final_audio.export(buffer, format="mp3")
+        return buffer.getvalue()
+    except IOError as e:
+        print(f"Erreur lors de la lecture ou de l'écriture des fichiers audio : {e}")
+        return None
+    except Exception as e:
+        print(f"Une erreur inattendue s'est produite : {e}")
+        return None
+
+def process_message(
+    message: str,
+    operation_prompt: str = "",
+    tts_enabled: bool = False
+) -> Tuple[Optional[bytes], Optional[float]]:
+    """
+    Traite les messages des utilisateurs et génère une réponse.
+
+    Args:
+        message (str): Le message d'entrée de l'utilisateur.
+        operation_prompt (str, optional): Prompt supplémentaire pour l'opération. Par défaut "".
+        tts_enabled (bool, optional): Si la synthèse vocale est activée. Par défaut False.
+
+    Returns:
+        Tuple[Optional[bytes], Optional[float]]: Un tuple contenant l'audio TTS et sa durée,
+        ou (None, None) si TTS est désactivé ou en cas d'erreur.
+    """
+    payload_content = f'{operation_prompt} :\n"""\n{message}\n"""'
+
+    st.session_state.messages.append({"role": "user", "content": payload_content})
+    with st.chat_message("user", avatar="👤"):
+        st.markdown(message)
+
+    with st.chat_message("assistant", avatar="👻"):
+        message_placeholder = st.empty()
+        full_response = ""
+        
+        with st.status("Traitement en cours...", expanded=True) as status:
+            status.update(label="Génération de la réponse", state="running", expanded=True)
+            try:
+                for response in client.chat.completions.create(
+                        model="gpt-4o-mini",
+                        messages=st.session_state.messages,
+                        stream=True,
+                        temperature=0.1):
+                    full_response += (response.choices[0].delta.content or "")
+                    message_placeholder.markdown(full_response + "▌")
+                # Utiliser regex pour supprimer les trois premiers et derniers guillemets doubles
+                full_response = re.sub(r'^"{3}|"{3}$', '', full_response.strip())
+                message_placeholder.markdown(full_response)
+                status.update(label="Réponse générée avec succès", state="complete")
+            except Exception as e:
+                st.error(f"Une erreur s'est produite lors de la génération de la réponse : {e}")
+                status.update(label="Erreur lors de la génération de la réponse", state="error")
+                return None, None
+    
+    st.session_state.messages.append(
+        {"role": "assistant", "content": full_response}
+    )
+
+    if tts_enabled:
+        with st.status("Conversion texte-parole en cours...", expanded=True) as status:
+            status.update(label="Conversion texte-parole", state="running", expanded=True)
+            try:
+                tts_audio, tts_duration = text_to_speech(full_response)
+                status.update(label="Conversion texte-parole réussie", state="complete")
+                return tts_audio, tts_duration
+            except Exception as e:
+                st.error(f"Une erreur s'est produite lors de la conversion texte-parole : {e}")
+                status.update(label="Erreur lors de la conversion texte-parole", state="error")
+                return None, None
+    return None, None
+
+class GlobalSystemPrompts:
+    """Class to store global system prompts."""
+
+    @staticmethod
+    def linguascribe():
+        """
+        Retrieve the system prompt for the Linguascribe feature.
+
+        Returns:
+            str: The system prompt for Linguascribe.
+        """
+        try:
+            system_prompt = read_file('linguascribe.prompt')
+            return system_prompt
+        except FileNotFoundError:
+            print("Le fichier 'linguascribe.prompt' n'a pas été trouvé.")
+            return ""
+        except IOError as e:
+            print(f"Erreur lors de la lecture du fichier 'linguascribe.prompt': {e}")
+            return ""
+
+# Function to configure the translation mode
+def set_translation_mode(from_lang: str, dest_lang: str) -> Tuple[str, str]:
+    """
+    Configure les prompts globaux pour le mode de traduction.
+
+    Args:
+        from_lang (str): La langue source.
+        dest_lang (str): La langue de destination.
+
+    Returns:
+        Tuple[str, str]: Un tuple contenant le prompt système et le prompt d'opération.
+    """
+    system_prompt = GlobalSystemPrompts.linguascribe()
+    operation_prompt = f"Translate({from_lang} to {dest_lang})"
+    return system_prompt, operation_prompt
+
+# List of languages supported by the application
+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"
+]
+
+LANGUAGES_EMOJI = {
+    "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": "🏴󠁧󠁢󠁷󠁬󠁳󠁿"
+}
 
-    #if 'init_launch_app' not in st.session_state:
-    #    st.session_state.init_launch_app = True
+def convert_language_name_to_iso6391(language_data: Union[str, Dict[str, str]]) -> str:
+    """
+    Convertit un nom de langue en son code ISO 639-1.
+
+    Args:
+        language_data (Union[str, Dict[str, str]]): Le nom de la langue ou un dictionnaire
+            contenant le nom de la langue.
+
+    Returns:
+        str: Le code ISO 639-1 pour la langue donnée, ou 'en' si non trouvé.
+    """
+    # Dictionnaire associant les noms de langues aux codes ISO 639-1
+    language_to_iso: Dict[str, str] = {
+        "Afrikaans": "af", "Arabic": "ar", "Armenian": "hy", "Azerbaijani": "az",
+        "Belarusian": "be", "Bosnian": "bs", "Bulgarian": "bg", "Catalan": "ca",
+        "Chinese": "zh", "Croatian": "hr", "Czech": "cs", "Danish": "da",
+        "Dutch": "nl", "English": "en", "Estonian": "et", "Finnish": "fi",
+        "French": "fr", "Galician": "gl", "German": "de", "Greek": "el",
+        "Hebrew": "he", "Hindi": "hi", "Hungarian": "hu", "Icelandic": "is",
+        "Indonesian": "id", "Italian": "it", "Japanese": "ja", "Kannada": "kn",
+        "Kazakh": "kk", "Korean": "ko", "Latvian": "lv", "Lithuanian": "lt",
+        "Macedonian": "mk", "Malay": "ms", "Marathi": "mr", "Maori": "mi",
+        "Nepali": "ne", "Norwegian": "no", "Persian": "fa", "Polish": "pl",
+        "Portuguese": "pt", "Romanian": "ro", "Russian": "ru", "Serbian": "sr",
+        "Slovak": "sk", "Slovenian": "sl", "Spanish": "es", "Swahili": "sw",
+        "Swedish": "sv", "Tagalog": "tl", "Tamil": "ta", "Thai": "th",
+        "Turkish": "tr", "Ukrainian": "uk", "Urdu": "ur", "Vietnamese": "vi",
+        "Welsh": "cy"
+    }
     
-    #if 'interface_language' not in st.session_state:
-    #    st.session_state.interface_language = 'English'
+    # Vérifier si language_data est un dictionnaire
+    if isinstance(language_data, dict):
+        language_name = language_data.get('language', '')
+    else:
+        language_name = language_data
+
+    try:
+        # Retourner le code ISO 639-1 correspondant au nom de la langue
+        return language_to_iso[language_name]
+    except KeyError:
+        # Gérer spécifiquement l'exception KeyError
+        print(f"Langue non trouvée : {language_name}")
+        return "en"  # Par défaut 'en' si la langue n'est pas trouvée
+
+def on_languages_change() -> None:
+    """Fonction de rappel pour le changement de langue(s) de destination."""
+    selected_language_names: List[str] = st.session_state.language_selector
+    st.session_state.selected_languages = [
+        {"language": lang, "iso-639-1": convert_language_name_to_iso6391(lang)}
+        for lang in selected_language_names
+    ]
+
+
+def init_process_mode() -> Tuple[str, str]:
+    """
+    Initialise le mode de traitement pour la traduction si nécessaire.
+
+    Returns:
+        Tuple[str, str]: Un tuple contenant le prompt système et le prompt d'opération.
+    """
+    if st.session_state["process_mode"] == "translation":
+        system_prompt, operation_prompt = set_translation_mode(
+            from_lang=st.session_state.language_detected,
+            dest_lang=st.session_state.target_language
+        )
+        return system_prompt, operation_prompt
+    return "", ""
+
+# Fonction principale de l'application
+def main():
+    """Fonction principale qui configure et exécute l'application Streamlit."""
+
+    # Initialisation des variables d'état de session
+    if "ui_loaded" not in st.session_state:
+        st.session_state["ui_loaded"] = False
+
+    if "language_detected" not in st.session_state:
+        st.session_state["language_detected"] = None
+
+    if "process_mode" not in st.session_state:
+        st.session_state["process_mode"] = "translation"
+
+    if "target_language" not in st.session_state:
+        st.session_state.target_language = "en"
+
+    if "selected_languages" not in st.session_state:
+        st.session_state.selected_languages = [
+            {"language": "English", "iso-639-1": "en"}
+        ]
+        
+    if "interface_language" not in st.session_state:
+        st.session_state.interface_language = "French"  # Langue par défaut
+
+    system_prompt, operation_prompt = init_process_mode()
+
+    # Initialisation de l'historique des messages avec le prompt système
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+
+    # Vérification de l'existence d'un message système dans st.session_state.messages
+    if not any(message["role"] == "system" for message in st.session_state.messages):
+        st.session_state.messages.insert(0, {"role": "system", "content": system_prompt})
+
+    # Interface utilisateur pour le chat textuel
+    if user_input := st.chat_input(get_translation("entrez_message")):
+        # Traitement du message texte de l'utilisateur
+        if st.session_state.language_detected is None:
+            st.session_state.language_detected = detect_language(
+                input_text=user_input, temperature=0.01
+            )
+        
+        audio_list = []
+        for cursor_selected_lang in st.session_state.selected_languages:
+            st.session_state.target_language = cursor_selected_lang["iso-639-1"]
+            
+            # Initialisation du mode de traitement pour la langue cible actuelle
+            system_prompt, operation_prompt = init_process_mode()
+
+            # Traitement du message utilisateur pour la langue cible actuelle
+            try:
+                tts_audio, tts_duration = process_message(
+                    user_input,
+                    operation_prompt=f"{operation_prompt}",
+                    tts_enabled=st.session_state.enable_tts_for_input_from_text_field
+                )
+                if tts_audio is not None:
+                    audio_list.append((tts_audio, tts_duration))
+            except Exception as e:
+                st.error(f"Erreur lors du traitement du message : {str(e)}")
+        
+        if audio_list:
+            try:
+                final_audio = concatenate_audio_files(audio_list)
+                with st.container(border=True):
+                    st.audio(final_audio, format="audio/mp3", autoplay=st.session_state.autoplay_tts)
+                    
+                    # Générer un nom de fichier unique
+                    timestamp = time.strftime("%Y%m%d-%H%M%S")
+                    langues = "_".join([lang["iso-639-1"] for lang in st.session_state.selected_languages])
+                    nom_fichier = f"reponse_audio_{langues}_{timestamp}.mp3"
+
+                    st.download_button(
+                        label=f"📥 {get_translation('telecharger_audio')}",
+                        data=final_audio,
+                        file_name=nom_fichier,
+                        mime="audio/mp3",
+                        use_container_width=True,
+                        type="primary",
+                        key=f"download_button_{langues}_{timestamp}",
+                    )
+            except Exception as e:
+                st.error(f"Erreur lors de la concaténation des fichiers audio : {str(e)}")
+
+    with st.container(border=True):
+        # Interface utilisateur pour l'enregistrement audio
+        st.write(f"🗣️ {get_translation('enregistrez_message')}")
+        if audio := audiorecorder(
+            start_prompt=get_translation("cliquez_enregistrer"),
+            stop_prompt=get_translation("cliquez_arreter"),
+            pause_prompt=get_translation("cliquez_pause"),
+            show_visualizer=True,
+            key="vocal_chat_input"
+        ):
+            # Traitement de l'entrée audio de l'utilisateur
+            if len(audio) > 0:
+                try:
+                    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio:
+                        audio.export(temp_audio.name, format="wav")
+                        transcription = transcribe_audio(temp_audio, language=st.session_state.language_detected)
+                    os.unlink(temp_audio.name)  # Suppression du fichier temporaire
+                    if st.session_state.language_detected is None:
+                        st.session_state.language_detected = detect_language(
+                            input_text=transcription, temperature=0.01
+                        )
+                        st.write(get_translation("langue_detectee").format(st.session_state.language_detected))
+
+                    #st.write(get_translation("transcription").format(transcription))
+
+                    audio_list = []
+                    for cursor_selected_lang in st.session_state.selected_languages:
+                        st.session_state.target_language = cursor_selected_lang["iso-639-1"]
+                        
+                        # Initialisation du mode de traitement pour la langue cible actuelle
+                        system_prompt, operation_prompt = init_process_mode()
+                        
+                        # Traitement du message utilisateur pour la langue cible actuelle
+                        try:
+                            tts_audio, tts_duration = process_message(
+                                transcription,
+                                operation_prompt=f"{operation_prompt}",
+                                tts_enabled=st.session_state.enable_tts_for_input_from_audio_record
+                            )
+                            if tts_audio is not None:
+                                audio_list.append((tts_audio, tts_duration))
+                        except Exception as e:
+                            st.error(f"Erreur lors du traitement du message audio : {str(e)}")
+                    if audio_list:
+                        try:
+                            final_audio = concatenate_audio_files(audio_list)
+                            with st.container(border=True):
+                                st.audio(final_audio, format="audio/mp3", autoplay=st.session_state.autoplay_tts)                    
+                                # Ajout d'un bouton de téléchargement pour l'audio final
+                                st.download_button(
+                                    label=f"📥 {get_translation('telecharger_audio')}",
+                                    data=final_audio,
+                                    file_name="audio_concatene.mp3",
+                                    mime="audio/mp3"
+                                )
+                        except Exception as e:
+                            st.error(f"Erreur lors de la concaténation des fichiers audio : {str(e)}")
+                except Exception as e:
+                    st.error(f"Erreur lors du traitement de l'audio : {str(e)}")
+
+    # Configuration de la barre latérale
+    with st.sidebar:
+        st.logo("img/logo_2.png", icon_image="img/logo_2.png")
+        st.header(get_translation("sidebar_titre"))
+
+        with st.expander(f"{get_translation('a_propos')}",
+                          expanded=False,
+                          icon="ℹ️"):
+            st.subheader(f"version: {__version__}")
+            st.info(get_translation("info_app"))
+        
+        with st.container(border=True):
+            st.subheader(get_translation("langue_interface"))
+            # Sélection de la langue de l'interface
+            st.selectbox(
+                label=get_translation("choix_langue_interface"),
+                options=list(translations.keys()),
+                key="interface_language",
+                index=(
+                    list(translations.keys()).index("French")
+                    if "interface_language" not in st.session_state
+                    else list(translations.keys()).index(st.session_state.interface_language)
+                ),
+                format_func=lambda lang: f"{LANGUAGES_EMOJI.get(lang, '')} {lang}"
+            )
+
+        with st.expander(f"{get_translation('selection_langue')}", 
+                         expanded=True, 
+                         icon="🌐"):
+            # Conteneur pour la sélection de langue
+
+            # Sélection multiple des langues de destination
+            st.multiselect(
+                label=get_translation("langues_destination"),
+                placeholder=get_translation("placeholder_langues"),
+                options=SUPPORTED_LANGUAGES,
+                default=["English"],
+                key="language_selector",
+                max_selections=4,
+                on_change=on_languages_change,
+                format_func=lambda lang: f"{LANGUAGES_EMOJI.get(lang, '')} {lang}"
+            )
 
-    #if st.session_state.init_launch_app:
-    #    st.switch_page("pages/configuration_ui_lang.py")
-    #else:
-    #    st.switch_page("pages/main.py")
+        with st.expander(f"{get_translation('parametres_tts')}", 
+                         expanded=True, 
+                         icon="🔊"):
+            st.selectbox(
+                get_translation("choix_voix_tts"),
+                options=["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
+                index=3,  # "onyx" est à l'index 3
+                key="tts_voice"
+            )
+            st.checkbox(
+                get_translation("activer_tts_texte"),
+                key="enable_tts_for_input_from_text_field",
+                value=True
+            )
+            st.checkbox(
+                get_translation("activer_tts_audio"),
+                key="enable_tts_for_input_from_audio_record",
+                value=True
+            )
+            st.checkbox(
+                get_translation("lecture_auto_tts"),
+                key="autoplay_tts",
+                value=True
+            )
 
 # Point d'entrée de l'application
 if __name__ == "__main__":

core/DetectLanguage.py

@@ -1,153 +0,0 @@
-#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}")

core/audio_files.py

@@ -1,142 +0,0 @@
-#coding: utf-8
-from pydub import AudioSegment
-#from openai import OpenAI
-#from io import BytesIO
-#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
-import base64
-import io
-import tempfile
-import os
-import streamlit as st
-
-def concatenate_audio_files(audio_list: List[Tuple[Union[bytes, str], float]]) -> Optional[bytes]:
-    """
-    Concatène une liste de fichiers audio avec des effets sonores.
-
-    Args:
-        audio_list (List[Tuple[Union[bytes, str], float]]): Liste de tuples contenant les données audio
-            (en bytes ou base64) et leur durée.
-
-    Returns:
-        Optional[bytes]: Données audio concaténées ou None en cas d'erreur.
-
-    Raises:
-        ValueError: Si la liste d'audio est vide ou invalide.
-        IOError: Si une erreur se produit lors de la lecture/écriture des fichiers.
-    """
-    if not audio_list:
-        st.error("Erreur : Aucun fichier audio à concaténer")
-        return None
-
-    final_audio = AudioSegment.empty()
-    temp_files = []  # Pour le nettoyage des fichiers temporaires
-
-    try:
-        # Charger les effets sonores
-        try:
-            begin_sound = AudioSegment.from_mp3(
-                "sound-effects/voice-message-play-begin/voice-message-play-begin-1.mp3"
-            )
-            end_sound = AudioSegment.from_mp3(
-                "sound-effects/voice-message-play-ending/voice-message-play-ending-1.mp3"
-            )
-        except IOError as e:
-            st.warning("Impossible de charger les effets sonores, continuation sans effets")
-            begin_sound = end_sound = AudioSegment.empty()
-        
-        # 1.5 secondes de silence
-        silence = AudioSegment.silent(duration=1500)
-        
-        for audio_data, _ in audio_list:
-            try:
-                # Convertir en bytes si c'est une chaîne base64
-                if isinstance(audio_data, str):
-                    try:
-                        audio_bytes = base64.b64decode(audio_data)
-                    except Exception as e:
-                        st.error(f"Erreur de décodage base64 : {e}")
-                        continue
-                else:
-                    audio_bytes = audio_data
-
-                # Créer un fichier temporaire pour l'audio
-                temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp3')
-                temp_files.append(temp_file.name)
-                temp_file.write(audio_bytes)
-                temp_file.close()
-
-                # Convertir les octets en un segment audio
-                segment = AudioSegment.from_mp3(temp_file.name)
-                
-                # Ajouter le son de début, le segment TTS, le son de fin et le silence
-                final_audio += begin_sound + segment + end_sound + silence
-                
-            except Exception as e:
-                st.warning(f"Erreur lors du traitement d'un segment audio : {e}")
-                continue
-        
-        if len(final_audio) == 0:
-            raise ValueError("Aucun segment audio n'a pu être traité correctement")
-        
-        # Convertir le segment audio final en octets
-        buffer = io.BytesIO()
-        final_audio.export(buffer, format="mp3")
-        return buffer.getvalue()
-
-    except ValueError as e:
-        st.error(f"Erreur de validation : {e}")
-        return None
-    except IOError as e:
-        st.error(f"Erreur lors de la lecture ou de l'écriture des fichiers audio : {e}")
-        return None
-    except Exception as e:
-        st.error(f"Une erreur inattendue s'est produite : {e}")
-        return None
-    finally:
-        # Nettoyage des fichiers temporaires
-        for temp_file in temp_files:
-            try:
-                os.remove(temp_file)
-            except Exception:
-                pass
-
-
-def split_audio(audio_file, max_size_mb: int = 25) -> List[bytes]:
-    """
-    Divise un fichier audio en segments de taille maximale spécifiée.
-
-    Args:
-        audio_file: Fichier audio ouvert en mode binaire.
-        max_size_mb (int): Taille maximale de chaque segment en Mo.
-
-    Returns:
-        List[bytes]: Liste des segments audio divisés sous forme de bytes.
-    """
-    try:
-        audio_file.seek(0)
-        audio = AudioSegment.from_file(audio_file)
-        duration_ms = len(audio)
-        segment_duration_ms = int(
-            (max_size_mb * 1024 * 1024 * 8) /
-            (audio.frame_rate * audio.sample_width * audio.channels)
-        )
-
-        segments = []
-        for start in range(0, duration_ms, segment_duration_ms):
-            end = min(start + segment_duration_ms, duration_ms)
-            segment = audio[start:end]
-            
-            with io.BytesIO() as buffer:
-                segment.export(buffer, format="mp3")
-                segments.append(buffer.getvalue())
-
-        return segments
-    except Exception as e:
-        print(f"Une erreur s'est produite lors de la division de l'audio : {e}")
-        return []

core/audio_isolation.py

@@ -1,66 +0,0 @@
-#!/usr/bin/env python3
-#coding: utf-8
-
-# FEATURE:
-#  Removes background noise from audio
-# REQUIREMENT:
-#  That use the ELEVENLABS API
-
-from typing import Optional
-from typing import Union
-from typing import IO
-from typing import List
-from typing import Dict
-from typing import Any
-import requests
-import json
-import os
-import tempfile
-from io import BytesIO
-from pydub import AudioSegment
-
-from dotenv import load_dotenv
-from elevenlabs import ElevenLabs
-
-def isolate_audio(fichier_audio: str):
-    load_dotenv()
-    client = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))
-    buffer = BytesIO()
-    
-    with open(fichier_audio, 'rb') as audio_file:
-        isolated_audio_iterator = client.audio_isolation.audio_isolation(audio=audio_file)
-
-        for chunk in isolated_audio_iterator:
-            buffer.write(chunk)
-    
-    buffer.seek(0)
-    return buffer
-    
-    
-#if __name__ == "__main__":
-#    buffer = isolate_audio("audio.mp3")
-#    with open("audio_isole.mp3", "wb") as output_file:
-#        output_file.write(buffer.read())
-
-def isolate_audio(audio: AudioSegment) -> AudioSegment:
-    """
-    Isoler la voix dans un extrait audio.
-    
-    Args:
-        audio (AudioSegment): L'audio original.
-    
-    Returns:
-        AudioSegment: L'audio avec la voix isolée.
-    """
-    # Implémentez ici votre algorithme d'isolation
-    # Par exemple, utiliser un filtre passe-bande pour conserver les fréquences vocales
-    # Ceci est un exemple simplifié
-
-    # Définir les fréquences de coupure pour la voix humaine
-    low_freq = 80  # Fréquence minimale en Hz
-    high_freq = 3000  # Fréquence maximale en Hz
-
-    # Appliquer le filtre passe-bande
-    isolated_audio = audio.low_pass_filter(high_freq).high_pass_filter(low_freq)
-
-    return isolated_audio

core/clients_connection_check.py

@@ -1,11 +0,0 @@
-#coding: utf-8
-
-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

core/converter.py

@@ -1,99 +0,0 @@
-#coding: utf-8
-
-from typing import Optional
-from typing import Union
-from typing import Dict
-from typing import Any
-from typing import List
-
-def convert_language_name_to_iso6391(language_data: Union[str, Dict[str, str]]) -> str:
-    """
-    Convertit un nom de langue en son code ISO 639-1.
-
-    Args:
-        language_data (Union[str, Dict[str, str]]): Le nom de la langue ou un dictionnaire
-            contenant le nom de la langue.
-
-    Returns:
-        str: Le code ISO 639-1 pour la langue donnée, ou 'en' si non trouvé.
-    """
-    # Dictionnaire associant les noms de langues aux codes ISO 639-1
-    language_to_iso: Dict[str, str] = {
-        "Afrikaans": "af", "Arabic": "ar", "Armenian": "hy", "Azerbaijani": "az",
-        "Belarusian": "be", "Bosnian": "bs", "Bulgarian": "bg", "Catalan": "ca",
-        "Chinese": "zh", "Croatian": "hr", "Czech": "cs", "Danish": "da",
-        "Dutch": "nl", "English": "en", "Estonian": "et", "Finnish": "fi",
-        "French": "fr", "Galician": "gl", "German": "de", "Greek": "el",
-        "Hebrew": "he", "Hindi": "hi", "Hungarian": "hu", "Icelandic": "is",
-        "Indonesian": "id", "Italian": "it", "Japanese": "ja", "Kannada": "kn",
-        "Kazakh": "kk", "Korean": "ko", "Latvian": "lv", "Lithuanian": "lt",
-        "Macedonian": "mk", "Malay": "ms", "Marathi": "mr", "Maori": "mi",
-        "Nepali": "ne", "Norwegian": "no", "Persian": "fa", "Polish": "pl",
-        "Portuguese": "pt", "Romanian": "ro", "Russian": "ru", "Serbian": "sr",
-        "Slovak": "sk", "Slovenian": "sl", "Spanish": "es", "Swahili": "sw",
-        "Swedish": "sv", "Tagalog": "tl", "Tamil": "ta", "Thai": "th",
-        "Turkish": "tr", "Ukrainian": "uk", "Urdu": "ur", "Vietnamese": "vi",
-        "Welsh": "cy"
-    }
-    default_ = "en"
-
-    # Vérifier si language_data est un dictionnaire
-    if isinstance(language_data, dict):
-        language_name = language_data.get('language', '')
-    else:
-        language_name = language_data
-
-    try:
-        # Retourner le code ISO 639-1 correspondant au nom de la langue
-        return language_to_iso[language_name]
-    except KeyError:
-        if f"{language_name}" in language_to_iso.values():
-            return language_name
-        else:
-            # Gérer spécifiquement l'exception KeyError
-            print(f"Langue non trouvée : {language_name}")
-            return default_
-        
-
-
-def convert_iso6391_to_language_name(language_code: str, 
-                                     filter_mode=True) -> str:
-    """
-    Convertit un code ISO 639-1 en nom de langue.
-
-    Args:
-        language_code (str): Le code ISO 639-1 de la langue.
-
-    Returns:
-        str: Le nom de la langue correspondant au code ISO 639-1, ou 'English' si non trouvé.
-    """
-    # Dictionnaire associant les codes ISO 639-1 aux noms de langues
-    iso_to_language: Dict[str, str] = {
-        "af": "Afrikaans", "ar": "Arabic", "hy": "Armenian", "az": "Azerbaijani",
-        "be": "Belarusian", "bs": "Bosnian", "bg": "Bulgarian", "ca": "Catalan",
-        "zh": "Chinese", "hr": "Croatian", "cs": "Czech", "da": "Danish",
-        "nl": "Dutch", "en": "English", "et": "Estonian", "fi": "Finnish",
-        "fr": "French", "gl": "Galician", "de": "German", "el": "Greek",
-        "he": "Hebrew", "hi": "Hindi", "hu": "Hungarian", "is": "Icelandic",
-        "id": "Indonesian", "it": "Italian", "ja": "Japanese", "kn": "Kannada",
-        "kk": "Kazakh", "ko": "Korean", "lv": "Latvian", "lt": "Lithuanian",
-        "mk": "Macedonian", "ms": "Malay", "mr": "Marathi", "mi": "Maori",
-        "ne": "Nepali", "no": "Norwegian", "fa": "Persian", "pl": "Polish",
-        "pt": "Portuguese", "ro": "Romanian", "ru": "Russian", "sr": "Serbian",
-        "sk": "Slovak", "sl": "Slovenian", "es": "Spanish", "sw": "Swahili",
-        "sv": "Swedish", "tl": "Tagalog", "ta": "Tamil", "th": "Thai",
-        "tr": "Turkish", "uk": "Ukrainian", "ur": "Urdu", "vi": "Vietnamese",
-        "cy": "Welsh"
-    }
-    default_ = "English"
-
-    try:
-        # Retourner le nom de la langue correspondant au code ISO 639-1
-        return iso_to_language[language_code]
-    except KeyError:
-        if f"{language_code}" in iso_to_language.values():
-            return language_code
-        else:
-            # Gérer spécifiquement l'exception KeyError
-            print(f"Code de langue non trouvé : {language_code}")
-            return default_

core/core.py

@@ -1,108 +0,0 @@
-#coding: utf-8
-
-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 core.files import load_ui_language
-from core.files import read_file
-from core.demorrha import DemorrhaAssistant
-from var_app import GlobalSystemPrompts
-import streamlit as st
-from openai import OpenAI
-
-from dotenv import load_dotenv
-# Charger les variables d'environnement depuis le fichier .env
-load_dotenv()
-
-class uiLang:
-    # Dictionary to store translations
-    translations = load_ui_language()
-
-translations=uiLang.translations
-
-client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
-
-def get_translation(key: str) -> str:
-    """
-    Obtient la traduction pour une clé donnée basée sur la langue d'interface sélectionnée.
-    """
-    lang = st.session_state.get('interface_language', 'English')
-    return translations.get(lang, {}).get(key, key)
-
-
-def process_message(
-    message: str,
-    operation_prompt_: Optional[str] = "",
-    system_prompt_: Optional[str] = ""
-):
-    """
-    Traite les messages des utilisateurs et génère une réponse.
-
-    Args:
-        message (str): Le message d'entrée de l'utilisateur.
-        operation_prompt (str, optional): Prompt supplémentaire pour l'opération. Par défaut "".
-        tts_enabled (bool, optional): Si la synthèse vocale est activée. Par défaut False.
-
-    """
-    demorrha = DemorrhaAssistant()
-    demorrha.load_assistant("Demorrha")
-    demorrha.set_payload(f"{message}", f"{operation_prompt_}")
-
-    st.session_state["full_response"] = "" 
-    try:
-        response_generator = demorrha.use_assistant()
-        for response in response_generator:
-            st.session_state.full_response = response
-            yield st.session_state.full_response 
-        
-        # Utiliser regex pour supprimer les trois premiers et derniers guillemets doubles
-        st.session_state.full_response = re.sub(r'^"{3}|"{3}$', '', st.session_state.full_response.strip())
-        st.session_state.messages = [] 
-        yield st.session_state.full_response
-    except Exception as e:
-        st.error(f"Une erreur s'est produite lors de la génération de la réponse : {e}")
-        return ""    
-
-# Function to configure the translation mode
-def set_translation_mode(from_lang: str, dest_lang: str) -> Tuple[str, str]:
-    """
-    Configure les prompts globaux pour le mode de traduction.
-
-    Args:
-        from_lang (str): La langue source.
-        dest_lang (str): La langue de destination.
-
-    Returns:
-        Tuple[str, str]: Un tuple contenant le prompt système et le prompt d'opération.
-    """
-    system_prompt_ = GlobalSystemPrompts.linguascribe()
-    operation_prompt_ = f"Translate({from_lang} to {dest_lang})"
-    return system_prompt_, operation_prompt_
-
-def init_process_mode(
-        from_lang: str,
-        to_lang: str,
-        process_mode: Optional[ Union[str, List[str]]] = "translator"
-) -> Tuple[str, str]:
-    """
-    Initialise le mode de traitement pour la traduction si nécessaire.
-
-    Returns:
-        Tuple[str, str]: Un tuple contenant le prompt système et le prompt d'opération.
-    """
-    # from  (e.g.: st.session_state.language_detected)
-    # dest  (e.g.: st.session_state.target_language)
-    if "translator" in process_mode:
-        system_prompt, operation_prompt = set_translation_mode(
-            from_lang=f"{from_lang}",
-            dest_lang=f"{to_lang}"
-        )
-        return system_prompt, operation_prompt
-    return "", ""
-

core/demorrha.py

@@ -1,216 +0,0 @@
-#coding: utf-8
-
-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 var_app import GlobalSystemPrompts
-import streamlit as st
-from openai import OpenAI
-
-from dotenv import load_dotenv
-# Charger les variables d'environnement depuis le fichier .env
-
-class DemorrhaAssistant(object):
-    def __init__(self):
-        load_dotenv()
-        self.client = self.initialize_client()
-        self.vector_store = None
-        self.list_vector_store_ids = []
-
-    def initialize_client(self):
-        # Initialiser le client OpenAI avec la clé API
-        api_key = getenv("OPENAI_API_KEY")
-        return OpenAI(api_key=api_key)
-
-    def search_assistant(self, assistant_name="Demorrha"):
-        last_id = None
-        while True:
-            # Lister tous les assistants
-            assistants_list = self.client.beta.assistants.list(
-                order="desc",
-                limit="20",
-                after=last_id
-            )
-
-            if len(assistants_list.data) < 1:
-                break
-
-            last_id = assistants_list.data[-1].id
-            for assistant in assistants_list.data:
-                if assistant.name == assistant_name:
-                    return assistant.id
-        return None
-
-    def search_vector_store(self, vector_store_name="Demorrha_Style"):
-        last_id=None
-        while True:
-            # Lister tous les assistants
-            vector_store_list = self.client.beta.vector_stores.list(
-                order="desc",
-                limit="20",
-                after=last_id
-            )
-
-            if len(vector_store_list.data) < 1:
-                break
-            last_id = vector_store_list.data[-1].id
-            for vector_store in vector_store_list.data:
-                if vector_store.name == f"{vector_store_name}":
-                    return vector_store.id
-        return None
-
-    def load_vector_store(self, vector_store_name="Demorrha_Style"):
-        vector_store_id = self.search_vector_store(vector_store_name)
-        if vector_store_id is None:
-            vector_store = self.client.beta.vector_stores.create(name=f"{vector_store_name}")
-            self.vector_store = vector_store
-        else:
-            self.vector_store = self.client.beta.vector_stores.retrieve(vector_store_id)
-        return self
-
-    def get_vector_store(self):
-        return self.vector_store
-
-    def upload_file(self, 
-                    file_path, 
-                    purpose="assistants"):
-        return self.client.files.create(
-            file=open(file_path, "rb"),
-            purpose=purpose
-        )
-
-    def list_files_in_vector_store(self, vector_store_id):
-        files_list = []
-        last_id=None
-        while True:
-            files_list = self.client.beta.vector_stores.files.list(
-                vector_store_id=vector_store_id,
-                limit="20",
-                after=last_id
-            )
-
-            if len(files_list.data) < 1:
-                break
-            last_id = files_list.data[-1].id
-            for file in files_list.data:
-                files_list.append(file)
-        return files_list
-
-    def attach_file_to_vectore_store(self,
-                                     vector_store_id,
-                                     file_id):
-        return self.client.beta.vector_stores.files.create(
-            vector_store_id=vector_store_id,
-            file_id=file_id
-        )
-
-    def load_assistant(self, assistant_name="Demorrha"):
-        self.set_system_prompt(GlobalSystemPrompts.linguascribe())
-        # system_prompt = GlobalSystemPrompts.linguascribe()
-        assistant_id = self.search_assistant(assistant_name)
-        if assistant_id is None:
-            self.assistant = self.client.beta.assistants.create(
-                model="gpt-4o-mini",
-                name="Demorrha",
-                description="Traite les messages des utilisateurs et génère une traduction.",
-                instructions=f"{self.system_prompt}",
-                temperature=0.1,
-                tools=[{"type": "file_search"}]
-            )
-        else:
-            self.assistant = self.client.beta.assistants.retrieve(assistant_id)
-        return self
-    
-    def get_assistant(self):
-        return self.assistant if not isinstance(self.assistant, None) else None
-    
-    def get_assistant_id(self):
-        return self.assistant.id if not isinstance(self.assistant, None) else None
-
-    def add_file_to_vector_store(self, file_paths):
-        file_streams = [open(path, "rb") for path in file_paths]
-        file_batch = self.client.beta.vector_stores.file_batches.upload_and_poll(
-            vector_store_id=self.vector_store.id, files=file_streams
-        )
-        return file_batch
-    
-    def set_payload(self, 
-                    content_message:str, 
-                    operation_prompt: Optional[str] = ""):
-        self.payload_content = f'{operation_prompt} :\n"""\n{content_message}\n"""'
-        return self
-
-    def set_system_prompt(self, 
-                          system_prompt: Optional[str] = ""):
-        self.system_prompt = system_prompt
-        return self
-    
-    def add_vector_store_to_ressource(self, vector_store_id):
-        self.list_vector_store_ids.append(vector_store_id)
-        return self
-    
-    def get_vector_store_ids(self):
-        return self.list_vector_store_ids
-    
-    def empty_vector_store_ids(self):
-        self.list_vector_store_ids = []
-        return self
-
-    def update_vector_store_ids(self):
-        self.assistant = self.client.beta.assistants.update(
-            assistant_id=self.assistant.id,
-            tool_resources={"file_search": {"vector_store_ids": self.list_vector_store_ids}},
-        )
-
-    def use_assistant(self):
-        # Utiliser l'assistant ici
-        full_response = ""
-        with self.client.beta.threads.create_and_run(
-            assistant_id=self.assistant.id,
-            thread={
-                "messages": [
-                    {"role": "user", "content": self.payload_content}
-                ]
-            },
-            stream=True
-        ) as stream:
-            for event in stream:
-                if event.event == "thread.message.delta":
-                    full_response += event.data.delta.content[0].text.value
-                    yield full_response + "▌"
-                elif event.event == "thread.message.completed":
-                    yield event.data.content[0].text.value
-                    return 
-
-if __name__ == "__main__":
-    demorrha = DemorrhaAssistant()
-    vector_store = demorrha.load_vector_store().get_vector_store()
-    demorrha.empty_vector_store_ids()
-    print(vector_store)
-
-    if vector_store.status == "completed":
-        if vector_store.file_counts.total > 0:
-            if vector_store.file_counts.completed == vector_store.file_counts.total:
-                print("Le chargement du vecteur est terminé.")
-                demorrha.add_vector_store_to_ressource(vector_store.id)
-        else:
-            file_paths = ["style.txt"]
-            file_batch = demorrha.add_file_to_vector_store(file_paths)
-            print("Fichier ajouté au vector_store:", file_batch)
-
-    # Exemple d'utilsation de l'assistant
-    demorrha.load_assistant("Demorrha")
-    demorrha.update_vector_store_ids()
-    demorrha.set_payload("Tu dois faire preuve de courage pour trouver la force.", "Traduit le texte en Anglais. Et applique les instructions du fichier \'style.txt\'")
-    response_generator = demorrha.use_assistant()
-    final_response = ""
-    for response in response_generator:
-        print(response, end="\r")
-        final_response = response
-    print(f"\nRéponse finale de l'assistant: {final_response}")

core/files.py

@@ -1,53 +0,0 @@
-import json
-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
-
-def load_ui_language(file_path: Optional[str] = "ui_lang_support.json") -> Dict[str, Any]:
-    """
-    Charge les traductions de l'interface utilisateur à partir d'un fichier JSON.
-
-    Args:
-        file_path (Optional[str]): Chemin vers le fichier JSON contenant les traductions.
-
-    Returns:
-        Dict[str, Any]: Un dictionnaire contenant les traductions de l'interface utilisateur.
-    """
-    try:
-        with open(file_path, 'r', encoding='utf-8') as file:
-            return json.load(file)
-    except FileNotFoundError:
-        print(f"File Not Found: {file_path}")
-        return None
-    except json.JSONDecodeError:
-        print(f"JSON decoding error : {file_path}")
-        return None
-    except IOError as e:
-        print(f"I/O Error : {e}")
-        return None
-
-
-# usage e.g.: read a plaintext prompt file  
-def read_file(file_name: str) -> str:
-    """
-    Lit et retourne le contenu des fichiers texte.
-
-    Args:
-        file_name (str): Le nom du fichier à lire.
-
-    Returns:
-        str: Le contenu du fichier ou un message d'erreur.
-    """
-    try:
-        with open(file_name, 'r', encoding='utf-8') as file:
-            content = file.read()
-        return content
-    except FileNotFoundError:
-        return f"File Not Found : {file_name}"
-    except IOError as e:
-        return f"I/O Error : {str(e)}"
-

core/moderation.py

@@ -1,60 +0,0 @@
-#coding: utf-8
-
-from typing import Any
-from typing import Dict
-#from typing import List
-#from typing import Tuple
-
-from typing import Optional
-#from typing import Union
-from os import getenv 
-import json
-
-from openai import OpenAI
-from dotenv import load_dotenv
-
-def moderate_text(input_text: str, 
-                  model: Optional[str] = "omni-moderation-latest") -> Dict[str, Any]:
-    
-    # Load environment variables from the .env file
-    load_dotenv()
-
-    # correct values for `model` is "omni-moderation-latest" and "text-moderation-latest"
-    try:
-        client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
-        response = client.moderations.create(
-            model=f"{model}",
-            input=f"{input_text}"
-        )
-        return response
-    except Exception as e:
-        print(f"An error occurred: {e}")
-        return None
-
-def api_moderation_openai_text(text_to_moderate: str) -> Dict[str, Any]:
-    response = moderate_text(text_to_moderate)
-    if response:
-        moderation_result = json.loads(response.to_json())
-        
-        result_dict = {
-            "flagged": False,
-            "results": []
-        }
-        
-        for result in moderation_result["results"]:
-            result_dict["flagged"] = result_dict["flagged"] or result["flagged"]
-            result_dict["results"].append({
-                "categories": result["categories"],
-                "category_scores": result["category_scores"],
-                "category_applied_input_types": result["category_applied_input_types"]
-            })
-        
-        return result_dict
-    else:
-        return {"error": "La modération a échoué"}
-
-
-#if __name__=='__main__':
-#    text_to_moderate = "Ceci est un exemple de texte à modérer."
-#    result = api_moderation_openai_text(text_to_moderate)
-#    print("Résultat de la modération :", result)

core/sound_generation.py

@@ -1 +0,0 @@
-#coding: utf-8

core/speech_to_text.py

@@ -1,255 +0,0 @@
-#coding: utf-8
-# Importation des bibliothèques nécessaires selon les bonnes pratiques PEP8
-import requests  # Pour envoyer des requêtes HTTP à l'API
-import json      # Pour traiter les réponses JSON de l'API
-from os import getenv 
-from pydub import AudioSegment
-from openai import OpenAI
-from io import BytesIO
-#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
-import os
-import streamlit as st
-
-from core.DetectLanguage import detect_language
-
-def huggingface_endpoints_stt(
-        filepath: Union[str, IO]
-    ) -> str:
-    """
-    Transcrit un fichier audio en texte en utilisant l'API Hugging Face.
-
-    Args:
-        filepath (Union[str, IO]): Chemin vers le fichier audio ou objet IO contenant l'audio à transcrire.
-
-    Returns:
-        str: Le texte transcrit à partir de l'audio.
-
-    Raises:
-        Exception: Si une erreur survient lors de l'appel à l'API Hugging Face.
-    """
-
-    file_path = filepath if isinstance(filepath, str) else filepath.name
-
-    # Définir l'URL de l'endpoint d'inférence sur Hugging Face
-    API_URL = f"{getenv('HF_WHISPER_ENDPOINT')}"
-    # Inclure votre token d'accès Hugging Face dans les en-têtes de la requête
-    headers = {
-        "Authorization": f"Bearer {getenv('HF_API_TOKEN')}"
-    }
-
-    # Ajouter le type de contenu audio à l'en-tête de la requête
-    ext = file_path.split('.')[-1].lower()
-    if ext == "mp3":
-         mime_type = "audio/mpeg"
-    else:
-         mime_type = f"audio/{ext}"
-    headers["Content-Type"] = mime_type
-
-    # Ouvrir le fichier audio en mode binaire
-    with open(file_path, "rb") as audio:
-        # Envoyer une requête POST à l'API avec le fichier audio
-        response = requests.post(API_URL, headers=headers, data=audio)
-        
-        # Vérifier si la requête a réussi (code 200)
-        if response.status_code == 200:
-            # Extraire la transcription du texte de la réponse JSON
-            transcription = json.loads(response.content.decode("utf-8"))
-            return transcription.get("text", "Pas de transcription disponible.")
-        else:
-            # En cas d'erreur, afficher le code de statut et le message
-            raise Exception(f"Erreur API: {response.status_code}, {response.text}")
-
-
-
-# ############################################################
-
-
-def transcribe_audio(
-        filepath: Union[str, IO], 
-        language: Optional[str] = None
-    ) -> str:
-    """
-    Transcrit un fichier audio en texte.
-
-    Args:
-        filepath (Union[str, IO]): Chemin vers le fichier audio ou objet IO.
-        language (Optional[str]): Code de langue ISO 639-1 pour la transcription.
-
-    Returns:
-        str: Le texte transcrit ou une chaîne vide en cas d'erreur.
-
-    Raises:
-        ValueError: Si le fichier audio est invalide ou vide.
-        IOError: Si une erreur se produit lors de la lecture du fichier.
-    """
-    if not filepath:
-        st.error("Erreur : Aucun fichier audio fourni")
-        return ""
-
-    try:
-        # Vérifier si le fichier existe et est accessible
-        if isinstance(filepath, str) and not os.path.exists(filepath):
-            raise FileNotFoundError(f"Le fichier {filepath} n'existe pas")
-
-        # Vérifier la taille du fichier
-        file_size = os.path.getsize(filepath) if isinstance(filepath, str) else filepath.tell()
-        if file_size == 0:
-            raise ValueError("Le fichier audio est vide")
-
-        # Transcription avec Hugging Face
-        try:
-            transcription = huggingface_endpoints_stt(filepath)
-            if transcription:
-                return transcription
-        except Exception as hf_error:
-            st.warning(f"Erreur avec l'endpoint Hugging Face, tentative avec OpenAI : {hf_error}")
-
-        # Transcription avec OpenAI comme fallback
-        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-        audio_file = open(filepath if isinstance(filepath, str) else filepath.name, "rb")
-        transcription = client.audio.transcriptions.create(
-            model="whisper-1",
-            file=audio_file,
-            language=language
-        )
-        return transcription.text
-
-    except FileNotFoundError as e:
-        st.error(f"Erreur : {e}")
-        return ""
-    except ValueError as e:
-        st.error(f"Erreur : {e}")
-        return ""
-    except IOError as e:
-        st.error(f"Erreur lors de la lecture du fichier audio : {e}")
-        return ""
-    except Exception as e:
-        st.error(f"Une erreur inattendue s'est produite lors de la transcription : {e}")
-        return ""
-
-
-# ############################################################
-
-def translate_audio(filepath: Union[str, IO]) -> str:
-    """
-    Traduit un fichier audio temporaire en Anglais.
-
-    Args:
-        filepath Chemin vers le fichier audio temporaire à traduire.
-
-    Returns:
-        str: Le texte traduit.
-    """
-    max_size_mb = 25
-    translated_text = []
-    client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
-    try:
-        with open(filepath if isinstance(filepath, str) else filepath.name, "rb") as f:
-            # filepath peut etre un chemin vers un fichier audio ou un objet IO
-            f.seek(0) 
-            audio = AudioSegment.from_file(f)
-            duration_ms = len(audio)
-            segment_duration_ms = int(
-                (max_size_mb * 1024 * 1024 * 8) /
-                (audio.frame_rate * audio.sample_width * audio.channels)
-            )
-
-            for start in range(0, duration_ms, segment_duration_ms):
-                end = min(start + segment_duration_ms, duration_ms)
-                segment = audio[start:end]
-
-                buffer = BytesIO()
-                segment.export(buffer, format="mp3")
-                buffer.seek(0)
-
-                translation = client.audio.translations.create(
-                    model="whisper-1", 
-                    file=("audio.mp3", buffer)
-                )
-                translated_text.append(translation)
-
-        return " ".join(translated_text)
-    except Exception as e:
-        print(f"Erreur lors de la traduction de l'audio : {e}")
-        return ""
-
-
-
-
-
-
-# ############################################################
-
-
-class SpeechToText(object):
-    def __init__(self, 
-                 api_key: str):
-        self.api_key = api_key
-        self.client = OpenAI(api_key=self.api_key)
-    
-    def aquire_audio(self, 
-                     filepath: Union[str, IO, List[Union[str, IO]]]):
-        """
-        Integrer la detection de langue :
-         Ajoute un appel a la fonction detect_language juste apres l'aquisition de l'audio et avant de choisir entre transcrire ou traduire.
-        """
-        if isinstance(filepath, str):
-            file_paths = [filepath]
-        elif isinstance(filepath, IO):
-            file_paths = [filepath.name]
-        else:
-            file_paths = [f'{file_path}' if isinstance(filepath, List) and isinstance(file_path, str) else file_path.name for file_path in filepath]
-
-        # create the list 'file_streams'
-        file_streams = [open(filepath, "rb") for filepath in file_paths]
-
-        def create_assistant():
-            return self.client.beta.assistants.create(
-                     name="Audio Language Detector",
-                     instructions=" ".join([
-                        "Act as an language detection function for an audio file.",
-                        "You are the assistant designed to detect the language of an audio file.",
-                        "This assistant is designed to detect the language of an audio file.",
-                        "You receive an audio file as input, and you analyze it to determine the language spoken in the audio.",
-                        "The assistant will return the detected language of the audio in ISO 639-1 format.",
-                        ""
-                     ]),
-                     model="gpt-4o",
-                     tools=[{"type": "file_search"}]
-                    )
-
-
-        def create_vector_store():
-            return self.client.beta.vector_stores.create(
-                     name="Audio Language Detection"
-                    )
-
-
-        assistant = create_assistant()
-        vectore_store = create_vector_store()
-
-        file_batch = self.client.beta.vector_stores.file_batches.upload_and_poll(
-            vector_store_id=vectore_store.id,
-            files=file_streams
-        )
-
-        # update the assistant to use the vector store
-        assistant = self.client.beta.assistants.update(
-            assistant_id=assistant.id,
-            tool_ressources={"file_search": {"vector_store_ids": [vectore_store.id]}}
-        )
-
-        ## Create a thread
-
-        ### Upload the user provided audio
-        message_file = self.client.files.create(
-            file=open(file_paths[0], "rb")
-        )
-
-

core/text_to_speech.py

@@ -1,162 +0,0 @@
-#coding: utf-8
-
-import os
-import tempfile
-
-
-#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 base64 import b64encode
-
-from openai import OpenAI
-from pydub import AudioSegment
-import streamlit as st
-
-#from dotenv import load_dotenv
-# Charger les variables d'environnement depuis le fichier .env
-#load_dotenv()
-
-class openai_tts(object):
-    def __init__(self,                  
-                 tts_voice: Optional[str] = "nova",
-                 tts_model: Optional[str] = "tts-1",
-                 response_format: Optional[str] = "mp3",
-                 speed: Optional[float] = 1.0
-                 ):
-        self.client = None
-        self.init_supported_formats__()
-        self.init_api_client()
-
-        if response_format:
-            self.set_response_format(response_format)
-        if tts_voice:
-            self.set_tts_voice(tts_voice)
-        if tts_model:
-            self.set_tts_model(tts_model)
-        if speed:
-            self.set_tts_speed(speed)
-
-    def set_tts_speed(self, speed):
-        if not (0.25 <= speed <= 4.0):
-            raise ValueError(f"[TTS] - Speed must be between 0.25 and 4.0. Provided value: {speed}")
-        else:
-            self.speed = speed
-        return self
-
-    def set_tts_voice(self, voice):
-        voix_valides = ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]
-        if voice not in voix_valides:
-            raise ValueError(f"[TTS] - Invalid TTS voice: {voice}. Valid voices are: {', '.join(voix_valides)}.")
-        else:
-            self.tts_voice = voice
-        return self
-
-    def set_tts_model(self, model):
-        if model not in ["tts-1", "tts-1-hd"]:
-            raise ValueError(f"[TTS] - Invalid TTS model: {model}. Valid models are 'tts-1' and 'tts-1-hd'.")
-        else:
-            self.tts_model = model
-        return self
-
-    def init_supported_formats__(self):
-        self.supported_formats = [ 'mp3', 'opus', 'aac', 'flac', 'wav', 'pcm' ]
-        return self
-
-    def set_response_format(self, format: str):
-        if format not in self.supported_formats:
-            raise ValueError(f"[TTS] - Unsupported format: {format}. Supported formats are: {', '.join(self.supported_formats)}")
-        else:
-            self.response_format = format
-        return self
-        
-    def init_api_client(self):
-        if not (self.client):
-            # OpenAI client configuration with API key
-            self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-        return self
-
-    def text_to_speech(self, 
-                    input_text: str) -> Tuple[Optional[bytes], float]:
-        """
-        Convertit du texte en parole en utilisant l'API OpenAI.
-
-        Args:
-            input_text (str): Le texte à convertir en parole.
-
-        Returns:
-            Dict[str, Union[float, str]]: Un dictionnaire contenant:
-                - 'audio_duration' (float): La durée de l'audio en secondes.
-                - 'data_bytes' (str): Les données audio encodées en base64.
-        """
-        response = self.client.audio.speech.create(
-            model=self.tts_model,
-            voice=self.tts_voice,
-            input=input_text,
-            response_format=self.response_format,
-            speed=self.speed
-        )
-        data_output = response.read()
-
-        tmp_file = tempfile.TemporaryFile()
-        tmp_file.write(data_output)
-        tmp_file.seek(0)
-        audio = AudioSegment.from_file(tmp_file, format=self.response_format)
-        duration = len(audio) / 1000
-        tmp_file.close()
-        
-        return {
-         "audio_duration": duration,
-         "data_bytes": b64encode(data_output).decode()
-        }
-
-
-def process_tts_message(text_response: str) -> Tuple[Optional[bytes], Optional[float]]:
-    """
-    Convertit un texte en parole en utilisant l'API OpenAI TTS.
-    
-    Args:
-        text_response (str): Le texte à convertir en parole.
-        
-    Returns:
-        Tuple[Optional[bytes], Optional[float]]: Un tuple contenant les données audio encodées en base64 
-        et la durée de l'audio, ou (None, None) en cas d'erreur.
-    """
-    if not text_response or not isinstance(text_response, str):
-        st.error("Erreur : Le texte à convertir est invalide ou vide")
-        return None, None
-
-    try:
-        tts = openai_tts(
-            tts_voice=st.session_state.tts_voice,
-            tts_model="tts-1",
-            response_format="mp3",
-            speed=1.0
-        )
-        tts_output_ = tts.text_to_speech(text_response)
-        return tts_output_["data_bytes"], tts_output_["audio_duration"]
-        
-    except ValueError as ve:
-        # Erreurs de validation (voix invalide, format non supporté, etc.)
-        st.error(f"Erreur de configuration TTS : {ve}")
-        return None, None
-        
-    except (KeyError, AttributeError) as ke:
-        # Erreurs liées aux variables de session manquantes
-        st.error("Erreur : Configuration TTS incomplète ou invalide")
-        return None, None
-        
-    except Exception as e:
-        # Autres erreurs (réseau, API, etc.)
-        st.error(f"Une erreur s'est produite lors de la conversion texte-parole : {e}")
-        return None, None
-
-
-if __name__ == "__main__":
-    
-    openai_tts().text_to_speech("Hello, I am an AI assistant. How can I help you?")
-    

pages/configuration_ui_lang.py

@@ -1,128 +0,0 @@
-# Standard libraries
-#import base64
-#import io
-import json
-#import os
-#import re
-#import tempfile
-#import time
-#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
-
-# Third-party libraries
-import streamlit as st
-
-
-from var_app import __version__
-
-LANGUAGES_EMOJI = {
-    "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": "🏴󠁧󠁢󠁷󠁬󠁳󠁿"
-}
-
-def load_ui_language(file_path: Optional[str] = "ui_lang_support.json") -> Dict[str, Any]:
-    """
-    Charge les traductions de l'interface utilisateur à partir d'un fichier JSON.
-
-    Args:
-        file_path (Optional[str]): Chemin vers le fichier JSON contenant les traductions.
-
-    Returns:
-        Dict[str, Any]: Un dictionnaire contenant les traductions de l'interface utilisateur.
-    """
-    try:
-        with open(file_path, 'r', encoding='utf-8') as file:
-            return json.load(file)
-    except FileNotFoundError:
-        print(f"{get_translation('erreur_fichier_non_trouve')} {file_path}")
-        return {}
-    except json.JSONDecodeError:
-        print(f"{get_translation('erreur_lecture_fichier')} JSON decoding error")
-        return {}
-    except IOError as e:
-        print(f"{get_translation('erreur_lecture_fichier')} {e}")
-        return {}
-
-def get_translation(key: str) -> str:
-    """
-    Obtient la traduction pour une clé donnée basée sur la langue d'interface sélectionnée.
-    """
-    lang = st.session_state.get('interface_language', 'English')
-    return translations.get(lang, {}).get(key, key)
-
-# Dictionary to store translations
-translations = load_ui_language()
-
-def language_selection_page():
-    st.set_page_config(initial_sidebar_state="collapsed")
-    #st.set_page_config(page_icon="👹")
-    #st.set_page_config(layout="wide")
-    # Fonction de rappel pour mettre à jour la langue temporaire lorsque la sélection change
-    def update_temp_language():
-        st.session_state['temp_interface_language'] = st.session_state['language_selector']
-        
-    # Initialiser la langue temporaire si elle n'existe pas
-    if 'temp_interface_language' not in st.session_state:
-        st.session_state['temp_interface_language'] = st.session_state.get('interface_language', 'English')
-    
-    
-    # Sélecteur de langue avec un callback pour mettre à jour la langue temporaire 
-    with st.container(
-            border=True, 
-            key='lang_choices_container', 
-            height=None
-        ):
-
-        TITRE_LANGSELMENU=translations[st.session_state['temp_interface_language']].get('selection_de_la_langue', 'Language Selection')
-        # Titre basé sur la langue temporaire
-        st.header(
-            f":blue[{TITRE_LANGSELMENU}]"
-            ,divider=True)
-        
-        selecteur_du_choix, boutton_de_validation = st.columns(2, 
-                                vertical_alignment='top',
-                                gap="small")
-
-        selected_language = selecteur_du_choix.selectbox(
-            translations[st.session_state['temp_interface_language']].get('choix_selection_langue', 'Choose the interface language'),
-            options=list(translations.keys()),
-            index=list(translations.keys()).index(st.session_state['temp_interface_language']),
-            format_func=lambda lang: f"{LANGUAGES_EMOJI.get(lang, '')} {lang}",
-            key='language_selector',
-            on_change=update_temp_language,
-            label_visibility="collapsed"
-        )
-
-        # Bouton de confirmation avec traduction
-        if boutton_de_validation.button(
-            translations[st.session_state['temp_interface_language']].get(
-                'confirmer', 'Confirm'), 
-            key='confirm_button_ui_lang_choice',
-            type="secondary",
-            use_container_width=True,
-            disabled = False
-            ):
-                st.session_state.interface_language = selected_language
-                st.session_state.init_launch_app = False
-                st.switch_page(st.Page("pages/main.py", title="Main page"))
- 
-language_selection_page()
-
-
-

pages/main.py

@@ -1,675 +0,0 @@
-# Standard libraries
-#import base64
-import io
-#import json
-import os
-import uuid
-#import re
-import tempfile
-import time
-from datetime import datetime
-#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 typing import AnyStr
-#from io import BytesIO
-#from copy import deepcopy
-import hashlib
-
-# Third-party libraries
-import requests
-import streamlit as st
-#import streamlit.components.v1 as components
-
-#from audiorecorder import audiorecorder
-from openai import OpenAI
-from pydub import AudioSegment
-import warnings
-# Ignore DeprecationWarning
-warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-from dotenv import load_dotenv
-# Charger les variables d'environnement depuis le fichier .env
-load_dotenv()
-
-from var_app import __version__
-from var_app import LANGUAGES_EMOJI
-from var_app import SUPPORTED_LANGUAGES
-from var_app import CHAT_FILES_UPLOAD_ALLOWED_TYPES
-from core.core import translations
-from core.core import get_translation
-from core.converter import convert_iso6391_to_language_name
-from core.converter import convert_language_name_to_iso6391
-from core.files import read_file
-from core.text_to_speech import openai_tts
-from core.DetectLanguage import detect_language
-from core.speech_to_text import huggingface_endpoints_stt
-from core.speech_to_text import transcribe_audio
-from core.audio_files import concatenate_audio_files
-from core.audio_files import split_audio
-from core.text_to_speech import process_tts_message
-from core.files import load_ui_language
-from core.core import process_message
-from core.core import init_process_mode
-from core.moderation import api_moderation_openai_text
-from core.audio_isolation import isolate_audio
-
-def init_langs_for_processing(
-        target_language: Optional[AnyStr] = "en",
-        interface_language: Optional[AnyStr] = "English",
-        language_detected: Optional[AnyStr] = None 
-    ) -> Tuple[str, str]:
-    # Initialisation du mode de traitement pour la langue cible actuelle
-    system_prompt, operation_prompt = init_process_mode(
-        from_lang = (
-            language_detected if "language_detected" in language_detected else convert_language_name_to_iso6391( 
-                interface_language 
-            )
-        ), 
-        to_lang = target_language 
-    )
-    return (system_prompt, operation_prompt)
-
-#def detection_langue_du_message_utilisateur(
-#        user_input: str,
-#        detect_lang_from_text: Optional[bool] = True,
-#        ):
-#    # Traitement du message texte de l'utilisateur
-#    if (detect_lang_from_text):
-#        language_detected = detect_language(
-#            input_text = user_input, 
-#            temperature = 0.01,
-#            context_window = 512,
-#            model="gpt-4o-mini"
-#        )
-#        return { 
-#                "text":f"{user_input}", 
-#                "language": language_detected.strip()
-#            }
-#    else:
-#        return { 
-#                "text":f"{user_input}", 
-#                "language": "default"
-#            }
-
-def user_message_moderation_check(
-        user_message: Optional[str] = None ):
-    # Appeler la fonction de modération
-    moderation_result = api_moderation_openai_text(user_message)
-    if moderation_result.get("flagged"):
-        st.error("Votre message a été jugé inapproprié et ne peut pas être traité.")
-        return  # Arrêter le traitement si le message est inapproprié
-    elif "error" in moderation_result:
-        st.error(moderation_result["error"])
-        return  # Gérer les erreurs de modération
-
-def hash_file(file):
-    hasher = hashlib.md5()
-    buf = file.read()
-    hasher.update(buf)
-    file.seek(0)
-    return hasher.hexdigest()
-
-def callback_change_edited_text(key, value, modified_text):
-    if value["type"] in ["txt"]:
-        st.session_state.changed_uploaded_files[key]["bytes_data"] = st.session_state[modified_text].encode()
-    elif value["type"] in ["wav", "mp3"]:
-        st.session_state.changed_uploaded_files[key]["audio_transcription"] = st.session_state[modified_text]
-
-def save_attachment(attachment):
-    """Sauvegarde la pièce jointe et retourne le chemin."""
-    # Créer un dossier pour les pièces jointes s'il n'existe pas
-    attachments_dir = 'attachments'
-    os.makedirs(attachments_dir, exist_ok=True)
-    
-    # Générer un nom de fichier unique
-    file_extension = os.path.splitext(attachment.name)[1]
-    filename = f"{uuid.uuid4()}{file_extension}"
-    file_path = os.path.join(attachments_dir, filename)
-    
-    # Sauvegarder le fichier
-    with open(file_path, 'wb') as f:
-        f.write(attachment.getbuffer())
-    
-    return file_path
-
-# Au début du fichier, après les imports
-st.set_page_config(
-    page_title=f"DEMORRHA - (v{__version__})",
-    page_icon="👹",
-    layout="wide",
-    initial_sidebar_state="collapsed"
-)
-
-@st.dialog("STT Settings")
-def stt_settings(state__stt_voice_isolation):
-    with st.expander(f"{get_translation('parametres_stt')}", 
-                    expanded=True, 
-                    icon="🎤"):
-        set__stt_voice_isolation = st.checkbox(
-            get_translation("isolation_voix"),
-            value=state__stt_voice_isolation
-        )
-
-    if st.button("Submit"):
-        st.session_state.stt_voice_isolation = set__stt_voice_isolation
-        st.rerun()
-
-@st.dialog("TTS Settings")
-def tts_settings(name__tts_voice, 
-         state__tts_with_text, 
-         state__tts_with_audio, 
-         state__autoplay_tts):
-    with st.expander(f"{get_translation('parametres_tts')}", 
-                    expanded=True, 
-                    icon="🔊"):
-        set__tts_voice = st.selectbox(
-            get_translation("choix_voix_tts"),
-            options=["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
-            index=list(["alloy", "echo", "fable", "onyx", "nova", "shimmer"]).index(name__tts_voice)
-        )
-        set__tts_with_text = st.checkbox(
-            get_translation("activer_tts_texte"),
-            value=state__tts_with_text
-        )
-        set__tts_with_audio = st.checkbox(
-            get_translation("activer_tts_audio"),
-            value=state__tts_with_audio
-        )
-        set__autoplay_tts = st.checkbox(
-            get_translation("lecture_auto_tts"),
-            value=state__autoplay_tts
-        )
-
-    if st.button("Submit"):
-        st.session_state.autoplay_tts = set__autoplay_tts
-        st.session_state.enable_tts_for_input_from_audio_record = set__tts_with_audio
-        st.session_state.enable_tts_for_input_from_text_field = set__tts_with_text
-        st.session_state.tts_voice = set__tts_voice
-        st.rerun()
-
-@st.fragment
-def recorder_released():
-    if "audio_list" not in st.session_state:
-        st.session_state.audio_list = []
-    
-    if "rec_widget" in st.session_state:
-        if st.session_state.rec_widget:
-            audio_recorded = True
-        else:
-            audio_recorded = False
-
-        if audio_recorded:
-            audio = AudioSegment.from_wav(io.BytesIO(st.session_state.rec_widget.getvalue()))
-            st.write(f"Frame rate: {audio.frame_rate}, Frame width: {audio.frame_width}, Duration: {audio.duration_seconds} seconds")
-
-            if st.session_state.stt_voice_isolation:
-                # Isoler l'audio ici
-                audio = isolate_audio(audio)
-            
-            # if not st.session_state.language_detected:
-            #    # 1. Verifie si audio.duration_seconds est superieur a 600 secondes (10 minutes)
-            #    if audio.duration_seconds > 600:
-            #        # PyDub handles time in milliseconds
-            #        ten_minutes = 10 * 60 * 1000
-            #        first_ten_minutes_audio = audio[:ten_minutes]
-            #    else:
-            #        # less than ten minutes ... nervermind, the name of this variable is
-            #        first_ten_minutes_audio = deepcopy(audio)
-            #        
-            #    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as tmp_extract:
-            #        first_ten_minutes_audio.export(tmp_extract, format="mp3")
-            #        tmp_extract.close()
-            #
-            #        # il faut transcrire sans specifier l'argument language dans la fonction transcribe_audio
-            #        # ensuite on pourra utiliser la fonction detect_language pour detecter la langue du texte transcrit
-            #        
-            #        # Transcrire les 10 premiers minutes audio en texte
-            #        st.session_state.language_detected = detect_language( 
-            #            input_text = transcribe_audio(tmp_extract),
-            #            temperature = 0.2,
-            #            context_window = 512,
-            #            model = "gpt-4o-mini" 
-            #        )
-            #        first_ten_minutes_audio = AudioSegment.empty()
-            #
-            #    st.markdown(
-            #        f"- {get_translation('langue_detectee')} {convert_iso6391_to_language_name(st.session_state.language_detected)}"
-            #    )
-            #            
-            #
-            # ##############################################################
-
-            try:
-                with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as tmp_file:
-                    audio.export(tmp_file, format="mp3")
-                    tmp_file.close()
-
-                    # Transcrire l'audio en texte
-                    #st.session_state.transcription = transcribe_audio(
-                    #    tmp_file, 
-                    #    language=convert_language_name_to_iso6391(st.session_state.interface_language)
-                    #)
-                    st.session_state.transcription = huggingface_endpoints_stt(tmp_file)
-                    audio = AudioSegment.empty()
-
-                st.markdown(
-                    f"🌐 {get_translation('langue_interface')} {st.session_state.interface_language}({convert_language_name_to_iso6391(st.session_state.interface_language)})"
-                )
-
-                st.markdown(
-                    f"🎤 {get_translation('transcription_audio')} {st.session_state.transcription}"
-                )
-                
-                st.session_state.audio_list = []
-                for cursor_selected_lang in st.session_state.selected_languages:
-                    st.session_state.target_language = cursor_selected_lang["iso-639-1"]
-                    st.session_state.full_response = ""
-
-
-                    # Initialisation du mode de traitement pour la langue cible actuelle
-                    st.session_state.system_prompt, st.session_state.operation_prompt = init_langs_for_processing(
-                        target_language = st.session_state.target_language, 
-                        interface_language = st.session_state.interface_language, 
-                        language_detected = st.session_state.interface_language
-                    )
-
-                    with st.chat_message("assistant", avatar="👻"):
-                        message_placeholder = st.empty()
-                        st.session_state.response_generator = process_message(
-                            st.session_state.transcription, 
-                            st.session_state.operation_prompt,
-                            st.session_state.system_prompt
-                        )
-
-                        for response_chunk in st.session_state.response_generator:
-                            message_placeholder.markdown(response_chunk)
-                        st.session_state.end_response = st.session_state.response_generator.close()
-                        
-                        if st.session_state.full_response != "":
-                            message_placeholder.markdown(st.session_state.full_response)
-                            if st.session_state.enable_tts_for_input_from_audio_record:
-                                st.session_state.tts_audio, st.session_state.tts_duration = process_tts_message(
-                                    st.session_state.full_response
-                                )
-                                
-                                if st.session_state.tts_audio:
-                                    st.session_state.audio_list.append(
-                                        ( st.session_state.tts_audio, 
-                                        st.session_state.tts_duration )
-                                    )
-                            else:
-                                pass
-
-                if st.session_state.audio_list:
-                    st.session_state.final_audio = concatenate_audio_files(st.session_state.audio_list)
-                    
-                    with st.container(border=True):
-
-                        # Générer un nom de fichier unique
-                        st.session_state.timestamp = time.strftime("%Y%m%d-%H%M%S")
-                        st.session_state.langues = "_".join([lang["iso-639-1"] for lang in st.session_state.selected_languages])
-                        st.session_state.nom_fichier = f"reponse_audio_{st.session_state.langues}_{st.session_state.timestamp}.mp3"
-
-                        st.audio(st.session_state.final_audio, 
-                                format="audio/mpeg", 
-                                autoplay=st.session_state.autoplay_tts)
-
-                        st.download_button(
-                            label=f"📥 {get_translation('telecharger_audio')}",
-                            data=st.session_state.final_audio,
-                            file_name=st.session_state.nom_fichier,
-                            mime="audio/mpeg",
-                            use_container_width=True,
-                            type="primary",
-                            key=f"download_button_{st.session_state.langues}_{st.session_state.timestamp}",
-                        )
-
-            except Exception as e:
-                st.error(f"[AUDIO] - {get_translation('erreur_importation_audio')}: {str(e)}")
-
-def main_page():
-    """Page principale de l'application."""
-
-    if "audio_list" not in st.session_state:
-        st.session_state.audio_list = []
-
-    if "ui_chat_input_disabled" not in st.session_state:
-        st.session_state.ui_chat_input_disabled = False
-
-    if "ui_audio_input_disabled" not in st.session_state:
-        st.session_state.ui_audio_input_disabled = False
-
-    if "ui_filesuploader_disabled" not in st.session_state:
-        st.session_state.ui_filesuploader_disabled = False
-
-    # Dictionnaire pour stocker les fichiers modifiés
-    if 'changed_uploaded_files' not in st.session_state:
-        st.session_state.changed_uploaded_files = {}
-
-    # Dictionnaire pour stocker le contenu modifié des fichiers
-    if 'edited_texts' not in st.session_state:
-        st.session_state.edited_texts = {}
-
-    # Liste pour stocker les fichiers audio
-    if 'audio_files' not in st.session_state:
-        st.session_state.audio_files = []
-
-    # Initialisation des variables d'état de session
-    if "ui_loaded" not in st.session_state:
-        st.session_state["ui_loaded"] = False
-
-    if "language_detected" not in st.session_state:
-        st.session_state["language_detected"] = None
-
-    if "process_mode" not in st.session_state:
-        st.session_state["process_mode"] = "translation"
-
-    if "target_language" not in st.session_state:
-        st.session_state.target_language = "en"
-
-    if "selected_languages" not in st.session_state:
-        st.session_state.selected_languages = [
-            {"language": "English", "iso-639-1": "en"}
-        ]
-        
-    if "interface_language_select" not in st.session_state:
-        st.session_state.interface_language_select = "English"  # Langue par défaut
-
-    if "stt_voice_isolation" not in st.session_state:
-        st.session_state["stt_voice_isolation"] = False
-
-    if "enable_tts_for_input_from_audio_record" not in st.session_state:
-        st.session_state["enable_tts_for_input_from_audio_record"] = False
-    
-    if "autoplay_tts" not in st.session_state:
-        st.session_state["autoplay_tts"] = False
-     
-    if "enable_tts_for_input_from_text_field" not in st.session_state:
-        st.session_state["enable_tts_for_input_from_text_field"] = False
-
-    if "tts_voice" not in st.session_state:
-        st.session_state["tts_voice"] = "onyx"
-
-    # Initialisation de l'historique des messages avec le prompt système
-    if "messages" not in st.session_state:
-        st.session_state.messages = []
-
-    def set_session_selected_languages(
-        selected_language_names: Optional[ List[ AnyStr ] ] = ["English"]
-    ) -> None:
-        st.session_state.selected_languages = [
-            {"language": lang, "iso-639-1": convert_language_name_to_iso6391(lang)}
-            for lang in selected_language_names
-        ]
-
-    def on_languages_change() -> None:
-        """Fonction de rappel pour le changement de langue(s) de destination."""
-        selected_language_names: List[str] = st.session_state.language_selector
-        set_session_selected_languages(selected_language_names)
-
-    # Configuration de la barre latérale
-    with st.sidebar:
-        st.logo("img/logo_2.png", icon_image="img/logo_2.png")
-        st.header(get_translation("sidebar_titre"))
-
-        st.write(f"#### Settings")
-        if st.button(f"Speech-To-Text"):
-            stt_settings(state__stt_voice_isolation=st.session_state.stt_voice_isolation)
-
-        if st.button(f"Text-To-Speech"):
-            tts_settings(
-                name__tts_voice = st.session_state.tts_voice,
-                state__tts_with_text = st.session_state.enable_tts_for_input_from_text_field,
-                state__tts_with_audio = st.session_state.enable_tts_for_input_from_audio_record,
-                state__autoplay_tts = st.session_state.autoplay_tts
-            )
-
-        with st.expander(f"{get_translation('a_propos')}",
-                        expanded=False,
-                        icon="ℹ️"):
-            st.subheader(f"version: {__version__}")
-            st.info(get_translation("info_app"))
-
-        with st.expander(f"{get_translation('selection_langue')}", 
-                        expanded=True, 
-                        icon="🌐"):
-            # Conteneur pour la sélection de langue
-            # Sélection multiple des langues de destination
-            st.multiselect(
-                label=get_translation("langues_destination"),
-                placeholder=get_translation("placeholder_langues"),
-                options=SUPPORTED_LANGUAGES,
-                default=["English"],
-                key="language_selector",
-                max_selections=4,
-                on_change=on_languages_change,
-                format_func=lambda lang: f"{LANGUAGES_EMOJI.get(lang, '')} {lang}"
-            )
-
-    if st.session_state.get('show_report_form', False):
-        # show_report_form()
-        pass
-    else:
-        with st.container(border=True):
-
-            chat_input_tabs1, chat_input_tabs2, chat_input_tabs3 = st.tabs(["text_input", "audio_input", "file_upload_input"])
-            
-            st.session_state.ui_chat_input_disabled = False
-            st.session_state.ui_audio_input_disabled = False
-            st.session_state.ui_filesuploader_disabled = False
-
-    
-        with chat_input_tabs1:
-            with st.container(border=True):
-                # Interface utilisateur pour le chat textuel
-                st.session_state.user_input = st.chat_input(
-                    get_translation("entrez_message"),
-                    disabled=st.session_state.ui_chat_input_disabled
-                )
-
-                if st.session_state.user_input:
-                    # Désactiver temporairement l'interface pendant le traitement
-                    st.session_state.ui_chat_input_disabled = True
-                    st.session_state.ui_audio_input_disabled = True
-                    st.session_state.ui_filesuploader_disabled = True
-
-                    try:
-                        # Vérification de la modération
-                        user_message_moderation_check(st.session_state.user_input)
-
-                        # Détection de la langue du message
-                        language_detected = detect_language(
-                            input_text=st.session_state.user_input,
-                            temperature=0.01,
-                            context_window=512,
-                            model="gpt-4o-mini"
-                        )
-
-                        # Réinitialiser l'état précédent
-                        st.session_state.full_response = ""
-                        st.session_state.audio_list = []
-
-                        with st.chat_message("user", avatar="👤"):
-                            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                            st.write(timestamp)
-                            with st.container(border=True):
-                                st.subheader(f"🌐 lang: {convert_iso6391_to_language_name(language_detected)}")
-                                st.markdown(st.session_state.user_input)
-
-                        # Traitement pour chaque langue sélectionnée
-                        for lang in st.session_state.selected_languages:
-                            st.session_state.target_language = lang["iso-639-1"]
-                            
-                            # Initialisation du mode de traitement avec la langue détectée
-                            st.session_state.system_prompt, st.session_state.operation_prompt = init_langs_for_processing(
-                                target_language=st.session_state.target_language,
-                                interface_language=st.session_state.interface_language,
-                                language_detected=language_detected
-                            )
-
-                            with st.chat_message("assistant", avatar="👻"):
-                                with st.status(f"Processing response in {lang['language']}...", expanded=True) as status:
-                                    message_placeholder = st.empty()
-                                    st.session_state.response_generator = process_message(
-                                        st.session_state.user_input,
-                                        st.session_state.operation_prompt,
-                                        st.session_state.system_prompt
-                                    )
-
-                                    full_response = ""
-                                    for response_chunk in st.session_state.response_generator:
-                                        full_response += response_chunk
-                                        message_placeholder.markdown(full_response)
-                                    
-                                    st.session_state.response_generator.close()
-                                    st.session_state.full_response = full_response
-
-                                    # Générer l'audio si TTS est activé
-                                    if st.session_state.enable_tts_for_input_from_text_field:
-                                        status.update(label=f"Generating audio in {lang['language']}...")
-                                        tts_audio, tts_duration = process_tts_message(
-                                            full_response
-                                        )
-                                        if tts_audio:
-                                            st.session_state.audio_list.append(
-                                                (tts_audio, tts_duration)
-                                            )
-                                    status.update(label="Done!", state="complete")
-
-                        # Générer l'audio final si nécessaire
-                        if st.session_state.audio_list:
-                            with st.container(border=True):
-                                st.session_state.final_audio = concatenate_audio_files(st.session_state.audio_list)
-                                
-                                # Générer un nom de fichier unique
-                                st.session_state.timestamp = time.strftime("%Y%m%d-%H%M%S")
-                                st.session_state.langues = "_".join([lang["iso-639-1"] for lang in st.session_state.selected_languages])
-                                st.session_state.nom_fichier = f"reponse_audio_{st.session_state.langues}_{st.session_state.timestamp}.mp3"
-
-                                st.audio(
-                                    st.session_state.final_audio,
-                                    format="audio/mpeg",
-                                    autoplay=st.session_state.autoplay_tts
-                                )
-
-                                st.download_button(
-                                    label=f"📥 {get_translation('telecharger_audio')}",
-                                    data=st.session_state.final_audio,
-                                    file_name=st.session_state.nom_fichier,
-                                    mime="audio/mpeg",
-                                    use_container_width=True,
-                                    type="primary",
-                                    key=f"download_button_{st.session_state.langues}_{st.session_state.timestamp}"
-                                )
-
-                    except Exception as e:
-                        st.error(f"Une erreur s'est produite : {str(e)}")
-                    finally:
-                        # Réactiver l'interface
-                        st.session_state.ui_chat_input_disabled = False
-                        st.session_state.ui_audio_input_disabled = False
-                        st.session_state.ui_filesuploader_disabled = False
-
-        with chat_input_tabs3:
-            with st.container(border=True):
-                # Interface utilisateur pour l'upload de fichiers
-                st.session_state.uploaded_files = st.file_uploader(
-                    "Choose files to upload", 
-                    accept_multiple_files=True,
-                    type=CHAT_FILES_UPLOAD_ALLOWED_TYPES,
-                    key="chat_files_upload",
-                    disabled=st.session_state.ui_filesuploader_disabled
-                )
-
-        with chat_input_tabs2:
-            with st.container(border=True):
-                # Interface utilisateur pour l'enregistrement audio
-                st.audio_input(
-                        "Record a voice message",
-                        on_change=recorder_released, 
-                        key="rec_widget",
-                        disabled=st.session_state.ui_audio_input_disabled
-                )
-
-
-    with st.container(border=True):
-        if st.session_state.user_input:
-            # Traitement du message texte
-            user_message_moderation_check(st.session_state.user_input)
-
-            # Réinitialiser l'état précédent
-            st.session_state.full_response = ""
-            st.session_state.audio_list = []
-
-            with st.chat_message("user", avatar="👤"):
-                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                st.write(timestamp)
-                with st.container(border=True):
-                    st.subheader(f"🌐 lang: {st.session_state.interface_language}")
-                    st.markdown(st.session_state.user_input)
-
-            for lang in st.session_state.selected_languages:
-                st.session_state.target_language = lang["iso-639-1"]
-                st.session_state.system_prompt, st.session_state.operation_prompt = init_langs_for_processing(
-                    target_language=st.session_state.target_language,
-                    interface_language=st.session_state.interface_language,
-                    language_detected=st.session_state.interface_language
-                )
-                with st.chat_message("assistant", avatar="👻"):
-                    message_placeholder = st.empty()
-                    st.session_state.response_generator = process_message(
-                        st.session_state.user_input,
-                        st.session_state.operation_prompt,
-                        st.session_state.system_prompt
-                    )
-                    for response_chunk in st.session_state.response_generator:
-                        message_placeholder.markdown(response_chunk)
-                    st.session_state.response_generator.close()
-
-        if st.session_state.uploaded_files:
-            # Traitement des fichiers téléchargés
-            for uploaded_file in st.session_state.uploaded_files:
-                file_path = save_attachment(uploaded_file)
-                with st.chat_message("user", avatar="👤"):
-                    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                    st.write(timestamp)
-                    st.subheader(f"Fichier téléchargé: {uploaded_file.name}")
-                if uploaded_file.type.startswith("text"):
-                    uploaded_file.seek(0)
-                    content = uploaded_file.read().decode("utf-8")
-                    with st.chat_message("user", avatar="👤"):
-                        st.markdown(content)
-                    for lang in st.session_state.selected_languages:
-                        st.session_state.target_language = lang["iso-639-1"]
-                        st.session_state.system_prompt, st.session_state.operation_prompt = init_langs_for_processing(
-                            target_language=st.session_state.target_language,
-                            interface_language=st.session_state.interface_language,
-                            language_detected=st.session_state.interface_language
-                        )
-                        with st.chat_message("assistant", avatar="👻"):
-                            message_placeholder = st.empty()
-                            st.session_state.response_generator = process_message(
-                                content,
-                                st.session_state.operation_prompt,
-                                st.session_state.system_prompt
-                            )
-                            for response_chunk in st.session_state.response_generator:
-                                message_placeholder.markdown(response_chunk)
-                            st.session_state.response_generator.close()
-                else:
-                    with st.chat_message("assistant", avatar="👻"):
-                        st.markdown("Type de fichier non supporté pour le traitement. Seul le texte est supporté.")
-
-main_page()
-
-
-
-
-
-

requirements.txt

@@ -1,5 +1,6 @@
-streamlit==1.40.0
+streamlit
+streamlit-audiorecorder
+streamlit-autorefresh
+replicate
 openai
-pydub
-python-dotenv
-elevenlabs
+pydub

scripts/gen_ui_lang_support.py

@@ -56,29 +56,7 @@ traductions_ui_dict = {
         "chargement": "Chargement en cours...",
         "aucun_message": "Aucun message pour le moment. Commencez la conversation !",
         "telecharger_audio": "Télécharger l'audio",
-        "lecture_auto_tts": "Lecture audio automatique de la synthese vocale",
-        "traitement_en_cours": "Traitement en cours...",
-        "traitement_termine": "Traitement terminé !",
-        "traduction_en_cours": "Traduction en cours...",
-        "erreur_traduction": "Une erreur s'est produite lors de la traduction de votre message : {}",
-        "traduction_terminee": "Traduction terminée !",
-        "synthese_vocale_en_cours": "Synthèse vocale en cours...",
-        "erreur_synthese_vocale": "Une erreur s'est produite lors de la synthèse vocale : {}",
-        "synthese_vocale_terminee": "Synthèse vocale terminée !",
-        "concatenation_audio_en_cours": "Concaténation audio en cours...",
-        "erreur_concatenation_audio": "Une erreur s'est produite lors de la concaténation audio : {}",
-        "concatenation_audio_terminee": "Concaténation audio terminée !",
-        "transcription_audio_en_cours": "Transcription audio en cours...",
-        "erreur_transcription_audio": "Une erreur s'est produite lors de la transcription audio : {}",
-        "transcription_audio_terminee": "Transcription audio terminée !",
-        "detection_langue_en_cours": "Détection de la langue en cours...",
-        "erreur_detection_langue": "Une erreur s'est produite lors de la détection de la langue : {}",
-        "detection_langue_terminee": "Détection de la langue terminée !",
-        "transcription_audio": "Transcription audio : {}",
-    	"confirmer" : "Confirmer",
-	"Annuler" : "Annuler",
-	"selection_de_la_langue": "Sélection de la langue",
-	"choix_selection_langue": "Choisissez la langue de l'interface"
+        "lecture_auto_tts": "Lecture audio automatique de la synthese vocale"
     }
 }
 

scripts/list_and_delete_assistants.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python3
-#coding: utf-8
-import os
-
-def list_and_delete_fine_tuned_models():
-    import openai
-    from openai import OpenAI
-    # Assurez-vous que votre clé API est définie dans les variables d'environnement
-    api_key = os.getenv("OPENAI_API_KEY")
-    client = OpenAI(api_key=api_key)
-    
-    while True:
-        # Lister tous les assistants
-        assistants_list = client.beta.assistants.list(
-            order="desc",
-            limit="20",
-        )
-
-        if len(assistants_list.data) < 1:
-            break
-
-        for assistant in assistants_list.data:
-            print(f"Suppression de : {assistant.id} ({assistant.name}) ...", end="")
-            response = client.beta.assistants.delete(assistant.id)
-            if response.deleted:
-                print("OK")
-            else:
-                print("FAILED")
-
-if __name__ == '__main__':
-    list_and_delete_fine_tuned_models()

scripts/ui_lang_updater.py

@@ -1,177 +0,0 @@
-#!/usr/bin/env python3
-#coding:utf-8
-
-from openai import OpenAI
-from os import getenv
-from typing import Optional
-from typing import Union
-from typing import Any
-import re
-import json
-import datetime
-
-
-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"
-]
-
-
-
-
-def read_json_file(file_path: str) -> dict:
-    with open(file_path, "r", encoding='utf-8') as json_file:
-        return json.load(json_file)
-
-def write_json_file(file_path: str, data: Union[str, bytes, dict]) -> None:
-    try:
-        if type(data) == str:
-            data = data.encode("utf-8")
-        if type(data) == dict:
-            data = json.dumps(data, indent=4, ensure_ascii=False, sort_keys=False).encode("utf-8")
-        with open(file_path, "wb") as json_file:
-            json_file.write(data)
-            json_file.close()
-    except Exception as e:
-        raise e
-
-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-mini",
-                            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())
-
-
-def translate_ui_template_string(file_path: str, 
-                                 base_ui_lang: str, 
-                                 target_ui_lang: str) -> str:
-    openai_client = get_openai_connected_client()
-    PROMPT_ = get_prompt_translation_ui_text(base_ui_lang, target_ui_lang)
-    ui_lang_dict = read_json_file(file_path)
-    traductions_ui_dict[target_ui_lang] = {}
-    for key, text_ui in ui_lang_dict[base_ui_lang].items():
-        operation_prompt = f"Translate(\'{base_ui_lang}\' to \'{target_ui_lang}\')"
-        traduction_text_ui = remove_response_separator(
-            create_chat_completion(
-                openai_client, 
-                PROMPT_, 
-                f'{operation_prompt} :\n\"\"\"\n{text_ui}\n\"\"\"'
-            )
-        ).strip()
-        traductions_ui_dict[target_ui_lang][key] = traduction_text_ui
-    return json.dumps(traductions_ui_dict, indent=4, ensure_ascii=False, sort_keys=False)
-
-
-def generate_ui_lang_support(
-    base_ui_lang: Optional[str]   = "French", 
-    target_ui_lang: Optional[Union[str, list]] = SUPPORTED_LANGUAGES,
-    ui_lang_support_filepath: Optional[str] = "ui_lang_support.json",
-    skip_translated: Optional[bool] = True) -> str:
-
-    traductions_ui_dict = read_json_file(ui_lang_support_filepath)
-    
-    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 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.")
-
-    openai_client = get_openai_connected_client()
-    
-    cnt=0
-    for to_lang in target_ui_lang:
-        cnt += 1
-        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)
-        if f"{to_lang}" not in traductions_ui_dict.keys():
-            traductions_ui_dict[to_lang] = {}
-        it_cnt=0
-        for key, text_ui in traductions_ui_dict[base_ui_lang].items():
-            it_cnt += 1
-            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")
-            if (f"{key}" not in traductions_ui_dict[to_lang].keys() ) or (not skip_translated):
-                operation_prompt = f"Translate(\'{base_ui_lang}\' to \'{to_lang}\')"
-                traduction_text_ui = remove_response_separator(
-                    create_chat_completion(
-                        openai_client, 
-                        PROMPT_, 
-                        f'{operation_prompt} :\n\"\"\"\n{text_ui}\n\"\"\"'
-                    )
-                ).strip()
-                traductions_ui_dict[to_lang][key] = traduction_text_ui
-        
-    return json.dumps(traductions_ui_dict, indent=4, ensure_ascii=False, sort_keys=False)
-
-def init_template_base_lang(file_path: str, 
-                            base_ui_lang_dict: dict) -> None:
-    base_ui_lang = json.dumps(base_ui_lang_dict, indent=4, ensure_ascii=False, sort_keys=False).encode("utf-8")
-    with open(f"/tmp/{file_path}.json", "wb") as json_file:
-        json_file.write(base_ui_lang)
-        json_file.close()
-
-def read_template_base_lang(file_path: str) -> str:
-    with open(f"/tmp/{file_path}.json", "rb") as json_file:
-        bytes_data = json_file.read() 
-        data = bytes_data.decode("utf-8")
-    return data
-
-
-if __name__ == "__main__":
-
-    JSON_UI_LANG_SUPPORT = generate_ui_lang_support(
-            base_ui_lang="French", 
-            target_ui_lang=SUPPORTED_LANGUAGES
-    )
-
-    # encoding , fr_FR.UTF-8
-    if type(JSON_UI_LANG_SUPPORT) == str:
-        JSON_UI_LANG_SUPPORT = JSON_UI_LANG_SUPPORT.encode("utf-8")
-    
-    # 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)

var_app.py

@@ -1,57 +0,0 @@
-__version__ = "1.3.10"
-
-from core.files import read_file
-
-CHAT_FILES_UPLOAD_ALLOWED_TYPES = [
-    "txt",
-    "wav", "mp3"
-]
-
-# List of languages supported by the application
-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"
-]
-
-LANGUAGES_EMOJI = {
-    "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": "🏴󠁧󠁢󠁷󠁬󠁳󠁿"
-}
-
-class GlobalSystemPrompts:
-    """Class to store global system prompts."""
-
-    @staticmethod
-    def linguascribe():
-        """
-        Retrieve the system prompt for the Linguascribe feature.
-
-        Returns:
-            str: The system prompt for Linguascribe.
-        """
-        try:
-            system_prompt = read_file('linguascribe.prompt')
-            return system_prompt
-        except FileNotFoundError:
-            print("Le fichier 'linguascribe.prompt' n'a pas été trouvé.")
-            return ""
-        except IOError as e:
-            print(f"Erreur lors de la lecture du fichier 'linguascribe.prompt': {e}")
-            return ""