align to PEP8

app.py

@@ -1,4 +1,4 @@
-# Bibliothèques standard
+# Standard libraries
 import base64
 import io
 import json
@@ -9,51 +9,85 @@ import time
 from os import getenv
 from typing import Any, Optional, Union
 
-# Bibliothèques tierces
+# Third-party libraries
 import streamlit as st
 from audiorecorder import audiorecorder
 from openai import OpenAI
 from pydub import AudioSegment
 
-def charger_ui_langue(chemin_fichier: Optional[str] = "ui_lang_support.json") -> dict:
+def load_ui_language(file_path: Optional[str] = "ui_lang_support.json") -> dict:
+    """
+    Load UI language translations from a JSON file.
+
+    Args:
+        file_path (Optional[str]): Path to the JSON file containing translations.
+
+    Returns:
+        dict: A dictionary containing UI language translations.
+    """
     try:
-        with open(chemin_fichier, 'r', encoding='utf-8') as fichier:
-            return json.load(fichier)
+        with open(file_path, 'r', encoding='utf-8') as file:
+            return json.load(file)
     except FileNotFoundError:
-        print(_("erreur_fichier_non_trouve").format(chemin_fichier))
+        print(get_translation("erreur_fichier_non_trouve").format(file_path))
         return {}
     except json.JSONDecodeError:
-        print(_("erreur_lecture_fichier").format(
-            "Erreur de décodage JSON"
+        print(get_translation("erreur_lecture_fichier").format(
+            "JSON decoding error"
         ))
         return {}
     except Exception as e:
-        print(_("erreur_lecture_fichier").format(str(e)))
+        print(get_translation("erreur_lecture_fichier").format(str(e)))
         return {}
 
-# Dictionnaire pour stocker les traductions
-traductions = charger_ui_langue()
+# Dictionary to store translations
+translations = load_ui_language()
+
+def get_translation(key):
+    """
+    Get translation for a given key based on the selected interface language.
 
-# Fonction pour obtenir les traductions en fonction de la langue sélectionnée
-def _(key):
-    return traductions[st.session_state.interface_language][key]
+    Args:
+        key (str): The translation key.
 
-# Configuration du client OpenAI avec la clé API
+    Returns:
+        str: The translated text.
+    """
+    return translations[st.session_state.interface_language][key]
+
+# OpenAI client configuration with API key
 client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
 
-# Fonction pour lire et retourner le contenu de fichiers textes
 def read_file(file_name):
+    """
+    Read and return the content of text files.
+
+    Args:
+        file_name (str): The name of the file to read.
+
+    Returns:
+        str: The content of the file or an error message.
+    """
     try:
         with open(file_name, 'r', encoding='utf-8') as file:
             content = file.read()
         return content
     except FileNotFoundError:
-        return _("erreur_fichier_non_trouve").format(file_name)
+        return get_translation("erreur_fichier_non_trouve").format(file_name)
     except Exception as e:
-        return _("erreur_lecture_fichier").format(str(e))
+        return get_translation("erreur_lecture_fichier").format(str(e))
 
-# Fonction pour diviser un fichier audio en segments de 25 Mo ou moins
 def split_audio(audio_file, max_size_mb=25):
+    """
+    Split an audio file into segments of 25 MB or less.
+
+    Args:
+        audio_file (str): Path to the audio file.
+        max_size_mb (int): Maximum size of each segment in MB.
+
+    Returns:
+        list: List of paths to the split audio segments.
+    """
     audio = AudioSegment.from_wav(audio_file)
     duration_ms = len(audio)
     segment_duration_ms = int(
@@ -73,6 +107,16 @@ def split_audio(audio_file, max_size_mb=25):
 
 # Fonction modifiée pour transcrire l'audio en texte
 def transcribe_audio(audio_file, language=None):
+    """
+    Transcribe audio file to text.
+
+    Args:
+        audio_file (file): The audio file to transcribe.
+        language (str, optional): The language of the audio. Defaults to None.
+
+    Returns:
+        str: The transcribed text.
+    """
     max_size_mb = 25
     file_size_mb = os.path.getsize(audio_file.name) / (1024 * 1024)
     
@@ -87,7 +131,7 @@ def transcribe_audio(audio_file, language=None):
                     language=language
                 )
                 full_transcript += transcript.text + " "
-            os.unlink(segment)  # Supprimer le fichier temporaire
+            os.unlink(segment)  # Delete temporary file
         return full_transcript.strip()
     else:
         with open(audio_file.name, "rb") as audio_file:
@@ -99,16 +143,24 @@ def transcribe_audio(audio_file, language=None):
         return transcript.text
 
 # Fonction pour détecter la langue d'un texte donné
-def language_detection(input_text, temperature=0.01):
+def detect_language(input_text, temperature=0.01):
+    """
+    Detect the language of a given text.
+
+    Args:
+        input_text (str): The text to detect the language from.
+        temperature (float, optional): The temperature for the language model. Defaults to 0.01.
+
+    Returns:
+        str: The detected language in ISO-639-1 format.
+    """
     system_prompt = "".join([
-        "Je souhaite que vous agissiez en tant que fonction linguistique.",
-        "Je m'exprimerai dans n'importe quelle langue, et vous en détecterez ",
-        "la langue.",
-        "Vous fournirez le résultat de votre détection au format ISO-639-1.",
-        "Votre réponse doit représenter l'argument `language` et contenir ",
-        "seulement sa valeur de type chaîne de caractères.",
-        "La langue de l'audio d'entrée. Fournir la langue d'entrée au format ",
-        "ISO-639-1 améliorera la précision et la latence."
+        "Act as a language detection function. ",
+        "I will provide text in any language, and you will detect its language. ",
+        "Provide the result of your detection in ISO-639-1 format. ",
+        "Your response should represent the `language` argument and contain ",
+        "only its string value. ",
+        "Providing the input language in ISO-639-1 format will improve accuracy and latency."
     ])
     response = client.chat.completions.create(
         model="gpt-4o-mini",
@@ -127,35 +179,61 @@ def language_detection(input_text, temperature=0.01):
     return response.choices[0].message.content
 
 def get_duration_pydub(audio_file):
+    """
+    Get the duration of an audio file using pydub.
+
+    Args:
+        audio_file (str): Path to the audio file.
+
+    Returns:
+        float: Duration of the audio file in seconds.
+    """
     audio = AudioSegment.from_file(audio_file)
     return audio.duration_seconds
 
-# Fonction pour convertir du texte en parole
 def text_to_speech(text):
+    """
+    Convert text to speech using the OpenAI API.
+
+    Args:
+        text (str): The text to convert to speech.
+
+    Returns:
+        tuple: A tuple containing the audio bytes and the duration of the audio in seconds.
+    """
     response = client.audio.speech.create(
         model="tts-1",
         voice=st.session_state.tts_voice,
         input=text
     )
     
-    # Sauvegarder l'audio dans un fichier temporaire
+    # Save the audio to a temporary file
     with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
         response.stream_to_file(temp_audio.name)
         
-        # Lire le contenu du fichier audio
+        # Read the content of the audio file
         with open(temp_audio.name, "rb") as audio_file:
             audio_bytes = audio_file.read()
 
-        # Lire la durée de l'audio en secondes
+        # Get the duration of the audio in seconds
         audio_duration = get_duration_pydub(temp_audio.name)
 
     return audio_bytes, audio_duration
 
 def concatenate_audio_files(audio_list):
-    # Créer un segment audio vide
+    """
+    Concatenate multiple audio files with sound effects.
+
+    Args:
+        audio_list (list): A list of tuples, each containing audio bytes and duration.
+
+    Returns:
+        bytes: The concatenated audio as bytes.
+    """
+    # Create an empty audio segment
     final_audio = AudioSegment.empty()
     
-    # Charger les effets sonores
+    # Load sound effects
     begin_sound = AudioSegment.from_mp3(
         "sound-effects/voice-message-play-begin/voice-message-play-begin-1.mp3"
     )
@@ -163,23 +241,33 @@ def concatenate_audio_files(audio_list):
         "sound-effects/voice-message-play-ending/voice-message-play-ending-1.mp3"
     )
     
-    # Silence de 5 secondes
-    silence = AudioSegment.silent(duration=5000)  # 5000 ms = 5 secondes
+    # 5 seconds of silence
+    silence = AudioSegment.silent(duration=5000)  # 5000 ms = 5 seconds
     
     for audio_bytes, _ in audio_list:
-        # Convertir les bytes en un segment audio
+        # Convert bytes to an audio segment
         segment = AudioSegment.from_mp3(io.BytesIO(audio_bytes))
         
-        # Ajouter le son de début, le segment TTS, le son de fin, et le silence
+        # Add the start sound, TTS segment, end sound, and silence
         final_audio += begin_sound + segment + end_sound + silence
     
-    # Convertir le segment audio final en bytes
+    # Convert the final audio segment to bytes
     buffer = io.BytesIO()
     final_audio.export(buffer, format="mp3")
     return buffer.getvalue()
 
-# Fonction pour traiter les messages de l'utilisateur et générer une réponse
 def process_message(message, operation_prompt="", tts_enabled=False):
+    """
+    Process user messages and generate a response.
+
+    Args:
+        message (str): The user's input message.
+        operation_prompt (str, optional): Additional prompt for operation. Defaults to "".
+        tts_enabled (bool, optional): Whether text-to-speech is enabled. Defaults to False.
+
+    Returns:
+        tuple: A tuple containing the TTS audio and its duration, or (None, None) if TTS is disabled.
+    """
     payload_content = f'{operation_prompt} :\n"""\n{message}\n"""'
 
     st.session_state.messages.append({"role": "user", "content": payload_content})
@@ -196,8 +284,7 @@ def process_message(message, operation_prompt="", tts_enabled=False):
                 temperature=0.1):
             full_response += (response.choices[0].delta.content or "")
             message_placeholder.markdown(full_response + "▌")
-        # Utiliser un regex pour retirer les trois premières et dernières
-        # doubles quotes
+        # Use regex to remove the first and last three double quotes
         full_response = re.sub(r'^"{3}|"{3}$', '', full_response.strip())
         message_placeholder.markdown(full_response)
     
@@ -210,28 +297,41 @@ def process_message(message, operation_prompt="", tts_enabled=False):
         return tts_audio, tts_duration
     return None, None
 
-# Classe pour stocker les prompts système globaux
 class GlobalSystemPrompts:
-    # Méthode pour récupérer le prompt système pour la fonctionnalité Linguascribe
+    """Class to store global system prompts."""
+
+    @staticmethod
     def linguascribe():
+        """
+        Retrieve the system prompt for the Linguascribe feature.
+
+        Returns:
+            str: The system prompt for Linguascribe.
+        """
         system_prompt = f"{read_file('linguascribe.prompt')}"
         return system_prompt
 
 
-# Variables globales pour les prompts
+# Global variables for prompts
 system_prompt = ""
-op_prompt = ""
+operation_prompt = ""
 
+# Function to configure the translation mode
+def set_translation_mode(from_lang, dest_lang):
+    """
+    Set the global prompts for translation mode.
 
-# Fonction pour configurer le mode de traduction
-def set_mode_translation(from_lang, dest_lang):
+    Args:
+        from_lang (str): The source language.
+        dest_lang (str): The destination language.
+    """
     global system_prompt
-    global op_prompt
+    global operation_prompt
     system_prompt = GlobalSystemPrompts.linguascribe()
-    op_prompt = f"Translate({from_lang} to {dest_lang})"
+    operation_prompt = f"Translate({from_lang} to {dest_lang})"
 
 
-# Liste des langues supportées par l'application
+# List of languages supported by the application
 SUPPORTED_LANGUAGES = [
     "Afrikaans", "Arabic", "Armenian", "Azerbaijani", "Belarusian", "Bosnian",
     "Bulgarian", "Catalan", "Chinese", "Croatian", "Czech", "Danish", "Dutch",
@@ -244,9 +344,17 @@ SUPPORTED_LANGUAGES = [
     "Turkish", "Ukrainian", "Urdu", "Vietnamese", "Welsh"
 ]
 
-# Fonction pour convertir le nom d'une langue en code ISO 639-1
 def convert_language_name_to_iso6391(language_data):
-    # Dictionnaire de correspondance entre les noms de langues et les codes ISO 639-1
+    """
+    Convert a language name to its ISO 639-1 code.
+
+    Args:
+        language_data (Union[str, dict]): The language name or a dictionary containing the language name.
+
+    Returns:
+        str: The ISO 639-1 code for the given language, or 'en' if not found.
+    """
+    # Dictionary mapping language names to ISO 639-1 codes
     language_to_iso = {
         "Afrikaans": "af", "Arabic": "ar", "Armenian": "hy", "Azerbaijani": "az",
         "Belarusian": "be", "Bosnian": "bs", "Bulgarian": "bg", "Catalan": "ca",
@@ -265,20 +373,21 @@ def convert_language_name_to_iso6391(language_data):
         "Welsh": "cy"
     }
     
-    # Vérifier si language_data est un dictionnaire
+    # Check if language_data is a dictionary
     if isinstance(language_data, dict):
         language_name = language_data.get('language')
     else:
         language_name = language_data
 
-    # Retourne le code ISO 639-1 correspondant au nom de la langue
-    return language_to_iso.get(language_name, "en")  # Par défaut, retourne 'en' si la langue n'est pas trouvée
+    # Return the ISO 639-1 code corresponding to the language name
+    return language_to_iso.get(language_name, "en")  # Default to 'en' if the language is not found
 
-# Fonction principale de l'application
+# Main function of the application
 def main():
+    """Main function that sets up and runs the Streamlit application."""
     st.title("------- DEMORRHA -------")
 
-    # Initialisation des variables d'état de la session
+    # Initialize session state variables
     if "language_detected" not in st.session_state:
         st.session_state["language_detected"] = None
 
@@ -300,31 +409,31 @@ def main():
         st.session_state["enable_tts_for_input_from_audio_record"] = True
 
     if "interface_language" not in st.session_state:
-        st.session_state.interface_language = "French"  # Langue par défaut
+        st.session_state.interface_language = "French"  # Default language
 
     def init_process_mode():
-        # Configuration du mode de traduction si nécessaire
+        """Initialize the process mode for translation if necessary."""
         if "translation" == st.session_state["process_mode"]:
-            set_mode_translation(
+            set_translation_mode(
                 from_lang=st.session_state.language_detected,
                 dest_lang=st.session_state.target_language
             )
 
     init_process_mode()
 
-    # Initialisation de l'historique des messages avec le prompt système
+    # Initialize message history with system prompt
     if "messages" not in st.session_state:
         st.session_state.messages = []
 
-    # Vérifier si un message système existe déjà dans st.session_state.messages
+    # Check if a system message already exists in 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(_("entrez_message")):
-        # Traitement du message textuel de l'utilisateur
-        if None == st.session_state.language_detected:
-            st.session_state.language_detected = language_detection(
+    # User interface for text chat
+    if user_input := st.chat_input(get_translation("entrez_message")):
+        # Process user's text message
+        if st.session_state.language_detected is None:
+            st.session_state.language_detected = detect_language(
                 input_text=user_input, temperature=0.01
             )
         
@@ -332,13 +441,13 @@ def main():
         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
+            # Initialize processing mode for current target language
             init_process_mode()
 
-            # Traitement du message de l'utilisateur pour la langue cible actuelle
+            # Process user message for current target language
             tts_audio, tts_duration = process_message(
                 user_input,
-                operation_prompt=f"{op_prompt}",
+                operation_prompt=f"{operation_prompt}",
                 tts_enabled=st.session_state.enable_tts_for_input_from_text_field
             )
             if tts_audio is not None:
@@ -349,41 +458,41 @@ def main():
             st.audio(final_audio, format="audio/mp3", autoplay=True)
 
     with st.container(border=True):
-        # Interface utilisateur pour l'enregistrement audio
-        st.write(_("enregistrez_message"))
+        # User interface for audio recording
+        st.write(get_translation("enregistrez_message"))
         audio = audiorecorder(
-            start_prompt=_("cliquez_enregistrer"),
-            stop_prompt=_("cliquez_arreter"),
-            pause_prompt=_("cliquez_pause"),
+            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
+    # Process user's audio input
     if len(audio) > 0:
         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)  # Supprimer le fichier temporaire
-        if None == st.session_state.language_detected:
-            st.session_state.language_detected = language_detection(
+        os.unlink(temp_audio.name)  # Delete temporary file
+        if st.session_state.language_detected is None:
+            st.session_state.language_detected = detect_language(
                 input_text=transcription, temperature=0.01
             )
-            st.write(_("langue_detectee").format(st.session_state.language_detected))
+            st.write(get_translation("langue_detectee").format(st.session_state.language_detected))
 
-        st.write(_("transcription").format(transcription))
+        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
+            # Initialize processing mode for current target language
             init_process_mode()
             
-            # Traitement du message de l'utilisateur pour la langue cible actuelle
+            # Process user message for current target language
             tts_audio, tts_duration = process_message(
                 transcription,
-                operation_prompt=f"{op_prompt}",
+                operation_prompt=f"{operation_prompt}",
                 tts_enabled=st.session_state.enable_tts_for_input_from_audio_record
             )
             if tts_audio is not None:
@@ -392,14 +501,14 @@ def main():
             final_audio = concatenate_audio_files(audio_list)
             st.audio(final_audio, format="audio/mp3", autoplay=True)
 
-    # Configuration de la barre latérale
+    # Sidebar configuration
     with st.sidebar:
-        st.header(_("sidebar_titre"))
-        st.markdown("## " + _("a_propos"))
-        st.info(_("info_app"))
+        st.header(get_translation("sidebar_titre"))
+        st.markdown("## " + get_translation("a_propos"))
+        st.info(get_translation("info_app"))
 
-        # Fonction de rappel pour le changement de(s) langue(s) de destination selectionnée(s)
         def on_languages_change():
+            """Callback function for destination language(s) change."""
             selected_language_names = st.session_state.language_selector
             st.session_state.selected_languages = [
                 {"language": lang, "iso-639-1": convert_language_name_to_iso6391(lang)}
@@ -407,27 +516,27 @@ def main():
             ]
         
         with st.container(border=True):
-            st.subheader(_("langue_interface"))
-            # Sélection de la langue de l'interface
+            st.subheader(get_translation("langue_interface"))
+            # Interface language selection
             st.selectbox(
-                label=_("choix_langue_interface"),
-                options=list(traductions.keys()),
+                label=get_translation("choix_langue_interface"),
+                options=list(translations.keys()),
                 key="interface_language",
                 index=(
-                    list(traductions.keys()).index("French")
+                    list(translations.keys()).index("French")
                     if "interface_language" not in st.session_state
-                    else list(traductions.keys()).index(st.session_state.interface_language)
+                    else list(translations.keys()).index(st.session_state.interface_language)
                 )
             )
 
         with st.container(border=True):
-            # Conteneur pour la sélection de la langue
-            st.subheader(_("selection_langue"))
+            # Container for language selection
+            st.subheader(get_translation("selection_langue"))
 
-            # Sélection multiple des langues de destination
+            # Multiple selection of destination languages
             st.multiselect(
-                label=_("langues_destination"),
-                placeholder=_("placeholder_langues"),
+                label=get_translation("langues_destination"),
+                placeholder=get_translation("placeholder_langues"),
                 options=SUPPORTED_LANGUAGES,
                 default=["English"],
                 key="language_selector",
@@ -436,22 +545,22 @@ def main():
             )
 
         with st.container(border=True):
-            st.subheader(_("parametres_tts"))
+            st.subheader(get_translation("parametres_tts"))
             st.selectbox(
-                _("choix_voix_tts"),
+                get_translation("choix_voix_tts"),
                 options=["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
-                index=3,  # "onyx" est à l'index 3
+                index=3,  # "onyx" is at index 3
                 key="tts_voice"
             )
             st.checkbox(
-                _("activer_tts_texte"),
+                get_translation("activer_tts_texte"),
                 key="enable_tts_for_input_from_text_field"
             )
             st.checkbox(
-                _("activer_tts_audio"),
+                get_translation("activer_tts_audio"),
                 key="enable_tts_for_input_from_audio_record"
             )
 
-# Point d'entrée de l'application
+# Application entry point
 if __name__ == "__main__":
     main()