align to PEP8

app.py

@@ -29,15 +29,13 @@ def load_ui_language(file_path: Optional[str] = "ui_lang_support.json") -> dict:
         with open(file_path, 'r', encoding='utf-8') as file:
             return json.load(file)
     except FileNotFoundError:
-        print(get_translation("erreur_fichier_non_trouve").format(file_path))
+        print(f"{get_translation('erreur_fichier_non_trouve')} {file_path}")
         return {}
     except json.JSONDecodeError:
-        print(get_translation("erreur_lecture_fichier").format(
-            "JSON decoding error"
-        ))
+        print(f"{get_translation('erreur_lecture_fichier')} JSON decoding error")
         return {}
-    except Exception as e:
-        print(get_translation("erreur_lecture_fichier").format(str(e)))
+    except IOError as e:
+        print(f"{get_translation('erreur_lecture_fichier')} {e}")
         return {}
 
 # Dictionary to store translations
@@ -73,9 +71,9 @@ def read_file(file_name):
             content = file.read()
         return content
     except FileNotFoundError:
-        return get_translation("erreur_fichier_non_trouve").format(file_name)
-    except Exception as e:
-        return get_translation("erreur_lecture_fichier").format(str(e))
+        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, max_size_mb=25):
     """
@@ -88,22 +86,29 @@ def split_audio(audio_file, max_size_mb=25):
     Returns:
         list: List of paths to the split audio segments.
     """
-    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)
+    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)
+        )
 
-    return segments
+        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, language=None):
@@ -120,63 +125,82 @@ def transcribe_audio(audio_file, language=None):
     max_size_mb = 25
     file_size_mb = os.path.getsize(audio_file.name) / (1024 * 1024)
     
-    if file_size_mb > max_size_mb:
-        segments = split_audio(audio_file.name, max_size_mb)
-        full_transcript = ""
-        for segment in segments:
-            with open(segment, "rb") as audio_segment:
+    try:
+        if file_size_mb > max_size_mb:
+            segments = split_audio(audio_file.name, max_size_mb)
+            full_transcript = ""
+            for segment in 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)  # Delete temporary file
+            return full_transcript.strip()
+        else:
+            with open(audio_file.name, "rb") as audio_file:
                 transcript = client.audio.transcriptions.create(
                     model="whisper-1",
-                    file=audio_segment,
+                    file=audio_file,
                     language=language
                 )
-                full_transcript += transcript.text + " "
-            os.unlink(segment)  # Delete temporary file
-        return full_transcript.strip()
-    else:
-        with open(audio_file.name, "rb") as audio_file:
-            transcript = client.audio.transcriptions.create(
-                model="whisper-1",
-                file=audio_file,
-                language=language
-            )
-        return transcript.text
+            return transcript.text
+    except IOError as e:
+        print(f"Erreur d'entrée/sortie lors de la transcription : {e}")
+        return ""
+    except client.APIError as e:
+        print(f"Erreur API lors de la transcription : {e}")
+        return ""
 
 # Fonction pour détecter la langue d'un texte donné
 def detect_language(input_text, temperature=0.01):
     """
-    Detect the language of a given text.
+    Détecte la langue d'un texte donné.
 
     Args:
-        input_text (str): The text to detect the language from.
-        temperature (float, optional): The temperature for the language model. Defaults to 0.01.
+        input_text (str): Le texte dont il faut détecter la langue.
+        temperature (float, optional): La température pour le modèle de langage. Par défaut à 0.01.
 
     Returns:
-        str: The detected language in ISO-639-1 format.
+        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 = "".join([
-        "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",
-        temperature=temperature,
-        messages=[
-            {
-                "role": "system",
-                "content": system_prompt
-            },
-            {
-                "role": "user",
-                "content": f"{input_text}"
-            }
-        ]
+    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."
     )
-    return response.choices[0].message.content
+    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):
     """
@@ -188,8 +212,15 @@ def get_duration_pydub(audio_file):
     Returns:
         float: Duration of the audio file in seconds.
     """
-    audio = AudioSegment.from_file(audio_file)
-    return audio.duration_seconds
+    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):
     """
@@ -201,60 +232,71 @@ def text_to_speech(text):
     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
-    )
-    
-    # Save the audio to a temporary file
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
-        response.stream_to_file(temp_audio.name)
+    try:
+        response = client.audio.speech.create(
+            model="tts-1",
+            voice=st.session_state.tts_voice,
+            input=text
+        )
         
-        # Read the content of the audio file
-        with open(temp_audio.name, "rb") as audio_file:
-            audio_bytes = audio_file.read()
+        # Save the audio to a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
+            response.stream_to_file(temp_audio.name)
+            
+            # Read the content of the audio file
+            with open(temp_audio.name, "rb") as audio_file:
+                audio_bytes = audio_file.read()
 
-        # Get the duration of the audio in seconds
-        audio_duration = get_duration_pydub(temp_audio.name)
+            # Get the duration of the audio in seconds
+            audio_duration = get_duration_pydub(temp_audio.name)
 
-    return audio_bytes, audio_duration
+        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):
     """
-    Concatenate multiple audio files with sound effects.
+    Concatène plusieurs fichiers audio avec des effets sonores.
 
     Args:
-        audio_list (list): A list of tuples, each containing audio bytes and duration.
+        audio_list (list): Une liste de tuples, chacun contenant des octets audio et la durée.
 
     Returns:
-        bytes: The concatenated audio as bytes.
+        bytes: L'audio concaténé sous forme d'octets.
     """
-    # Create an empty audio segment
+    # Créer un segment audio vide
     final_audio = AudioSegment.empty()
     
-    # Load sound effects
-    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 seconds of silence
-    silence = AudioSegment.silent(duration=5000)  # 5000 ms = 5 seconds
-    
-    for audio_bytes, _ in audio_list:
-        # Convert bytes to an audio segment
-        segment = AudioSegment.from_mp3(io.BytesIO(audio_bytes))
+    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"
+        )
         
-        # Add the start sound, TTS segment, end sound, and silence
-        final_audio += begin_sound + segment + end_sound + silence
-    
-    # Convert the final audio segment to bytes
-    buffer = io.BytesIO()
-    final_audio.export(buffer, format="mp3")
-    return buffer.getvalue()
+        # 5 secondes de silence
+        silence = AudioSegment.silent(duration=5000)  # 5000 ms = 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, operation_prompt="", tts_enabled=False):
     """
@@ -268,7 +310,7 @@ def process_message(message, operation_prompt="", tts_enabled=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"""'
+    payload_content = '{} :\n"""\n{}\n"""'.format(operation_prompt, message)
 
     st.session_state.messages.append({"role": "user", "content": payload_content})
     with st.chat_message("user"):
@@ -277,24 +319,32 @@ def process_message(message, operation_prompt="", tts_enabled=False):
     with st.chat_message("assistant"):
         message_placeholder = st.empty()
         full_response = ""
-        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 + "▌")
-        # 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)
+        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 + "▌")
+            # 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)
+        except Exception as e:
+            st.error("Une erreur s'est produite lors de la génération de la réponse : {}".format(str(e)))
+            return None, None
     
     st.session_state.messages.append(
         {"role": "assistant", "content": full_response}
     )
 
     if tts_enabled:
-        tts_audio, tts_duration = text_to_speech(full_response)
-        return tts_audio, tts_duration
+        try:
+            tts_audio, tts_duration = text_to_speech(full_response)
+            return tts_audio, tts_duration
+        except Exception as e:
+            st.error("Une erreur s'est produite lors de la conversion texte-parole : {}".format(str(e)))
+            return None, None
     return None, None
 
 class GlobalSystemPrompts:
@@ -308,8 +358,15 @@ class GlobalSystemPrompts:
         Returns:
             str: The system prompt for Linguascribe.
         """
-        system_prompt = f"{read_file('linguascribe.prompt')}"
-        return system_prompt
+        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, dest_lang):
@@ -321,7 +378,7 @@ def set_translation_mode(from_lang, dest_lang):
         dest_lang (str): The destination language.
     """
     system_prompt = GlobalSystemPrompts.linguascribe()
-    operation_prompt = f"Translate({from_lang} to {dest_lang})"
+    operation_prompt = "Translate({} to {})".format(from_lang, dest_lang)
     return system_prompt, operation_prompt
 
 # List of languages supported by the application
@@ -337,17 +394,17 @@ SUPPORTED_LANGUAGES = [
     "Turkish", "Ukrainian", "Urdu", "Vietnamese", "Welsh"
 ]
 
-def convert_language_name_to_iso6391(language_data):
+def convert_language_name_to_iso6391(language_data: Union[str, dict]) -> str:
     """
-    Convert a language name to its ISO 639-1 code.
+    Convertit un nom de langue en son code ISO 639-1.
 
     Args:
-        language_data (Union[str, dict]): The language name or a dictionary containing the language name.
+        language_data (Union[str, dict]): Le nom de la langue ou un dictionnaire contenant le nom de la langue.
 
     Returns:
-        str: The ISO 639-1 code for the given language, or 'en' if not found.
+        str: Le code ISO 639-1 pour la langue donnée, ou 'en' si non trouvé.
     """
-    # Dictionary mapping language names to ISO 639-1 codes
+    # Dictionnaire associant les noms de langues aux codes ISO 639-1
     language_to_iso = {
         "Afrikaans": "af", "Arabic": "ar", "Armenian": "hy", "Azerbaijani": "az",
         "Belarusian": "be", "Bosnian": "bs", "Bulgarian": "bg", "Catalan": "ca",
@@ -366,21 +423,26 @@ def convert_language_name_to_iso6391(language_data):
         "Welsh": "cy"
     }
     
-    # Check if language_data is a dictionary
+    # Vérifier si language_data est un dictionnaire
     if isinstance(language_data, dict):
         language_name = language_data.get('language')
     else:
         language_name = language_data
 
-    # 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
-
-# Main function of the application
+    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
+
+# Fonction principale de l'application
 def main():
-    """Main function that sets up and runs the Streamlit application."""
+    """Fonction principale qui configure et exécute l'application Streamlit."""
     st.title("------- DEMORRHA -------")
 
-    # Initialize session state variables
+    # Initialisation des variables d'état de session
     if "language_detected" not in st.session_state:
         st.session_state["language_detected"] = None
 
@@ -402,10 +464,10 @@ 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"  # Default language
+        st.session_state.interface_language = "French"  # Langue par défaut
 
     def init_process_mode():
-        """Initialize the process mode for translation if necessary."""
+        """Initialise le mode de traitement pour la traduction si nécessaire."""
         if "translation" == st.session_state["process_mode"]:
             system_prompt, operation_prompt = set_translation_mode(
                 from_lang=st.session_state.language_detected,
@@ -416,17 +478,17 @@ def main():
 
     system_prompt, operation_prompt = init_process_mode()
 
-    # Initialize message history with system prompt
+    # Initialisation de l'historique des messages avec le prompt système
     if "messages" not in st.session_state:
         st.session_state.messages = []
 
-    # Check if a system message already exists in 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})
 
-    # User interface for text chat
+    # Interface utilisateur pour le chat textuel
     if user_input := st.chat_input(get_translation("entrez_message")):
-        # Process user's text 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
@@ -436,24 +498,30 @@ def main():
         for cursor_selected_lang in st.session_state.selected_languages:
             st.session_state.target_language = cursor_selected_lang["iso-639-1"]
             
-            # Initialize processing mode for current target language
+            # Initialisation du mode de traitement pour la langue cible actuelle
             system_prompt, operation_prompt = init_process_mode()
 
-            # Process user message for current target language
-            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))
+            # 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:
-            final_audio = concatenate_audio_files(audio_list)
-            st.audio(final_audio, format="audio/mp3", autoplay=True)
+            try:
+                final_audio = concatenate_audio_files(audio_list)
+                st.audio(final_audio, format="audio/mp3", autoplay=True)
+            except Exception as e:
+                st.error(f"Erreur lors de la concaténation des fichiers audio : {str(e)}")
 
     with st.container(border=True):
-        # User interface for audio recording
+        # Interface utilisateur pour l'enregistrement audio
         st.write(get_translation("enregistrez_message"))
         audio = audiorecorder(
             start_prompt=get_translation("cliquez_enregistrer"),
@@ -463,47 +531,56 @@ def main():
             key="vocal_chat_input"
         )
 
-    # Process user's audio input
+    # Traitement de l'entrée audio de l'utilisateur
     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)  # 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(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"]
-            
-            # Initialize processing mode for current target language
-            system_prompt, operation_prompt = init_process_mode()
-            
-            # Process user message for current target language
-            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))
-        if audio_list:
-            final_audio = concatenate_audio_files(audio_list)
-            st.audio(final_audio, format="audio/mp3", autoplay=True)
-
-    # Sidebar configuration
+        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)
+                    st.audio(final_audio, format="audio/mp3", autoplay=True)
+                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.header(get_translation("sidebar_titre"))
-        st.markdown("## " + get_translation("a_propos"))
+        st.markdown(f"## {get_translation('a_propos')}")
         st.info(get_translation("info_app"))
 
         def on_languages_change():
-            """Callback function for destination language(s) change."""
+            """Fonction de rappel pour le changement de langue(s) de destination."""
             selected_language_names = st.session_state.language_selector
             st.session_state.selected_languages = [
                 {"language": lang, "iso-639-1": convert_language_name_to_iso6391(lang)}
@@ -512,7 +589,7 @@ def main():
         
         with st.container(border=True):
             st.subheader(get_translation("langue_interface"))
-            # Interface language selection
+            # Sélection de la langue de l'interface
             st.selectbox(
                 label=get_translation("choix_langue_interface"),
                 options=list(translations.keys()),
@@ -525,10 +602,10 @@ def main():
             )
 
         with st.container(border=True):
-            # Container for language selection
+            # Conteneur pour la sélection de langue
             st.subheader(get_translation("selection_langue"))
 
-            # Multiple selection of destination languages
+            # Sélection multiple des langues de destination
             st.multiselect(
                 label=get_translation("langues_destination"),
                 placeholder=get_translation("placeholder_langues"),
@@ -544,7 +621,7 @@ def main():
             st.selectbox(
                 get_translation("choix_voix_tts"),
                 options=["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
-                index=3,  # "onyx" is at index 3
+                index=3,  # "onyx" est à l'index 3
                 key="tts_voice"
             )
             st.checkbox(
@@ -556,6 +633,6 @@ def main():
                 key="enable_tts_for_input_from_audio_record"
             )
 
-# Application entry point
+# Point d'entrée de l'application
 if __name__ == "__main__":
     main()