align to PEP8

app.py

@@ -7,23 +7,24 @@ import re
 import tempfile
 import time
 from os import getenv
-from typing import Any, Optional, Union
+from typing import Any, Optional, Union, Dict, List, Tuple, IO
 
 # Third-party libraries
 import streamlit as st
 from audiorecorder import audiorecorder
 from openai import OpenAI
 from pydub import AudioSegment
+import requests
 
-def load_ui_language(file_path: Optional[str] = "ui_lang_support.json") -> dict:
+def load_ui_language(file_path: Optional[str] = "ui_lang_support.json") -> Dict[str, Any]:
     """
-    Load UI language translations from a JSON file.
+    Charge les traductions de l'interface utilisateur à partir d'un fichier JSON.
 
     Args:
-        file_path (Optional[str]): Path to the JSON file containing translations.
+        file_path (Optional[str]): Chemin vers le fichier JSON contenant les traductions.
 
     Returns:
-        dict: A dictionary containing UI language translations.
+        Dict[str, Any]: Un dictionnaire contenant les traductions de l'interface utilisateur.
     """
     try:
         with open(file_path, 'r', encoding='utf-8') as file:
@@ -41,30 +42,30 @@ def load_ui_language(file_path: Optional[str] = "ui_lang_support.json") -> dict:
 # Dictionary to store translations
 translations = load_ui_language()
 
-def get_translation(key):
+def get_translation(key: str) -> str:
     """
-    Get translation for a given key based on the selected interface language.
+    Obtient la traduction pour une clé donnée basée sur la langue d'interface sélectionnée.
 
     Args:
-        key (str): The translation key.
+        key (str): La clé de traduction.
 
     Returns:
-        str: The translated text.
+        str: Le texte traduit.
     """
     return translations[st.session_state.interface_language][key]
 
 # OpenAI client configuration with API key
 client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
 
-def read_file(file_name):
+def read_file(file_name: str) -> str:
     """
-    Read and return the content of text files.
+    Lit et retourne le contenu des fichiers texte.
 
     Args:
-        file_name (str): The name of the file to read.
+        file_name (str): Le nom du fichier à lire.
 
     Returns:
-        str: The content of the file or an error message.
+        str: Le contenu du fichier ou un message d'erreur.
     """
     try:
         with open(file_name, 'r', encoding='utf-8') as file:
@@ -75,16 +76,16 @@ def read_file(file_name):
     except IOError as e:
         return f"{get_translation('erreur_lecture_fichier')} {str(e)}"
 
-def split_audio(audio_file, max_size_mb=25):
+def split_audio(audio_file: str, max_size_mb: int = 25) -> List[str]:
     """
-    Split an audio file into segments of 25 MB or less.
+    Divise un fichier audio en segments de 25 Mo ou moins.
 
     Args:
-        audio_file (str): Path to the audio file.
-        max_size_mb (int): Maximum size of each segment in MB.
+        audio_file (str): Chemin vers le fichier audio.
+        max_size_mb (int): Taille maximale de chaque segment en Mo.
 
     Returns:
-        list: List of paths to the split audio segments.
+        List[str]: Liste des chemins vers les segments audio divisés.
     """
     try:
         audio = AudioSegment.from_wav(audio_file)
@@ -111,16 +112,16 @@ def split_audio(audio_file, max_size_mb=25):
         return []
 
 # Fonction modifiée pour transcrire l'audio en texte
-def transcribe_audio(audio_file, language=None):
+def transcribe_audio(audio_file: IO, language: Optional[str] = None) -> str:
     """
-    Transcribe audio file to text.
+    Transcrit un fichier audio en texte.
 
     Args:
-        audio_file (file): The audio file to transcribe.
-        language (str, optional): The language of the audio. Defaults to None.
+        audio_file (IO): Le fichier audio à transcrire.
+        language (Optional[str]): La langue de l'audio. Par défaut None.
 
     Returns:
-        str: The transcribed text.
+        str: Le texte transcrit.
     """
     max_size_mb = 25
     file_size_mb = os.path.getsize(audio_file.name) / (1024 * 1024)
@@ -137,7 +138,7 @@ def transcribe_audio(audio_file, language=None):
                         language=language
                     )
                     full_transcript += f"{transcript.text} "
-                os.unlink(segment)  # Delete temporary file
+                os.unlink(segment)  # Supprime le fichier temporaire
             return full_transcript.strip()
         else:
             with open(audio_file.name, "rb") as audio_file:
@@ -155,13 +156,13 @@ def transcribe_audio(audio_file, language=None):
         return ""
 
 # Fonction pour détecter la langue d'un texte donné
-def detect_language(input_text, temperature=0.01):
+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, optional): La température pour le modèle de langage. Par défaut à 0.01.
+        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.
@@ -202,15 +203,15 @@ def detect_language(input_text, temperature=0.01):
     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):
+def get_duration_pydub(audio_file: str) -> float:
     """
-    Get the duration of an audio file using pydub.
+    Obtient la durée d'un fichier audio en utilisant pydub.
 
     Args:
-        audio_file (str): Path to the audio file.
+        audio_file (str): Chemin vers le fichier audio.
 
     Returns:
-        float: Duration of the audio file in seconds.
+        float: Durée du fichier audio en secondes.
     """
     try:
         audio = AudioSegment.from_file(audio_file)
@@ -222,15 +223,15 @@ def get_duration_pydub(audio_file):
         print(f"Erreur lors de la lecture du fichier audio : {str(e)}")
         return 0.0
 
-def text_to_speech(text):
+def text_to_speech(text: str) -> Tuple[Optional[bytes], float]:
     """
-    Convert text to speech using the OpenAI API.
+    Convertit du texte en parole en utilisant l'API OpenAI.
 
     Args:
-        text (str): The text to convert to speech.
+        text (str): Le texte à convertir en parole.
 
     Returns:
-        tuple: A tuple containing the audio bytes and the duration of the audio in seconds.
+        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(
@@ -239,15 +240,15 @@ def text_to_speech(text):
             input=text
         )
         
-        # Save the audio to a temporary file
+        # Sauvegarde l'audio dans un fichier temporaire
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
             response.stream_to_file(temp_audio.name)
             
-            # Read the content of the audio file
+            # Lit le contenu du fichier audio
             with open(temp_audio.name, "rb") as audio_file:
                 audio_bytes = audio_file.read()
 
-            # Get the duration of the audio in seconds
+            # Obtient la durée de l'audio en secondes
             audio_duration = get_duration_pydub(temp_audio.name)
 
         return audio_bytes, audio_duration
@@ -255,15 +256,16 @@ def text_to_speech(text):
         print(f"Erreur lors de la conversion texte-parole : {str(e)}")
         return None, 0.0
 
-def concatenate_audio_files(audio_list):
+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): Une liste de tuples, chacun contenant des octets audio et la durée.
+        audio_list (List[Tuple[bytes, float]]): Une liste de tuples, chacun contenant
+            des octets audio et la durée.
 
     Returns:
-        bytes: L'audio concaténé sous forme d'octets.
+        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()
@@ -298,19 +300,24 @@ def concatenate_audio_files(audio_list):
         print(f"Une erreur inattendue s'est produite : {e}")
         return None
 
-def process_message(message, operation_prompt="", tts_enabled=False):
+def process_message(
+    message: str,
+    operation_prompt: str = "",
+    tts_enabled: bool = False
+) -> Tuple[Optional[bytes], Optional[float]]:
     """
-    Process user messages and generate a response.
+    Traite les messages des utilisateurs et génère une réponse.
 
     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.
+        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: A tuple containing the TTS audio and its duration, or (None, None) if TTS is disabled.
+        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 = '{} :\n"""\n{}\n"""'.format(operation_prompt, message)
+    payload_content = f'{operation_prompt} :\n"""\n{message}\n"""'
 
     st.session_state.messages.append({"role": "user", "content": payload_content})
     with st.chat_message("user"):
@@ -327,11 +334,11 @@ 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 + "▌")
-            # Use regex to remove the first and last three double quotes
+            # 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)
         except Exception as e:
-            st.error("Une erreur s'est produite lors de la génération de la réponse : {}".format(str(e)))
+            st.error(f"Une erreur s'est produite lors de la génération de la réponse : {e}")
             return None, None
     
     st.session_state.messages.append(
@@ -343,7 +350,7 @@ def process_message(message, operation_prompt="", tts_enabled=False):
             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)))
+            st.error(f"Une erreur s'est produite lors de la conversion texte-parole : {e}")
             return None, None
     return None, None
 
@@ -635,4 +642,4 @@ def main():
 
 # Point d'entrée de l'application
 if __name__ == "__main__":
-    main()
+    main()