... not done...

core/files.py

@@ -0,0 +1,53 @@
+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/text_to_speech.py

@@ -0,0 +1,116 @@
+#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
+
+
+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"La vitesse doit être comprise entre 0.25 et 4.0. Valeur fournie : {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"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"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"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:
+            Tuple[Optional[bytes], float]: Un tuple contenant les octets audio et la durée de l'audio en secondes.
+        """
+        response = self.client.audio.speech.create(
+            model=self.tts_model,
+            voice=self.tts_voice ,#st.session_state.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()
+        }
+
+"""
+if __name__ == "__main__":
+    
+    openai_tts().text_to_speech("Hello, I am an AI assistant. How can I help you?")
+    
+"""

pages/main.py

@@ -26,6 +26,9 @@ import warnings
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
 from var_app import __version__
+from core.files import load_ui_language
+from core.files import read_file
+from core.files import openai_tts
 
 # Au début du fichier, après les imports
 st.set_page_config(
@@ -35,30 +38,6 @@ st.set_page_config(
     initial_sidebar_state="collapsed"
 )
 
-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:
     """
@@ -70,27 +49,22 @@ def get_translation(key: str) -> str:
 # 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.
+def process_tts_message(text_response: str) -> Tuple[Optional[bytes], Optional[float]]:
+    try:
+        tts_output_ = openai_tts(
+            tts_voice=st.session_state.tts_voice,
+            tts_model="tts-1",
+            response_format="mp3",
+            speed=1.0
+            ).text_to_speech(text_response)
+
+        return tts_output_["data_bytes"], tts_output_["audio_duration"]
+    except Exception as e:
+        st.error(f"Une erreur s'est produite lors de la conversion texte-parole : {e}")
+        return None, None
 
-    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)}"
 
 
 
@@ -244,61 +218,7 @@ def detect_language(input_text: str, temperature: float = 0.01) -> str:
         raise ValueError(f"Erreur inattendue lors de la détection de la langue : {str(e)}")
 
 
-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
-        )
-        
-        with tempfile.TemporaryDirectory() as temp_dir:
-            temp_audio_path = os.path.join(temp_dir, "temp_audio.mp3")
-            response.stream_to_file(temp_audio_path)
-            
-            # Lecture du contenu du fichier audio
-            with open(temp_audio_path, "rb") as audio_file:
-                audio_bytes = audio_file.read()
-
-            # Obtention de la durée de l'audio
-            audio_duration = get_duration_pydub(temp_audio_path)
-
-        return audio_bytes, audio_duration
-
-    except Exception as e:
-        st.error(f"Erreur lors de la conversion texte-parole : {str(e)}")
-        return None, 0.0
-    finally:
-        if temp_audio_path and os.path.exists(temp_audio_path):
-            os.remove(temp_audio_path)
-        if temp_dir and os.path.exists(temp_dir):
-            os.rmdir(temp_dir)
-
-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 Exception as e:
-        st.error(f"Erreur lors de la lecture du fichier audio : {str(e)}")
-        return 0.0
 
 def concatenate_audio_files(audio_list: List[Tuple[bytes, float]]) -> Optional[bytes]:
     """
@@ -382,13 +302,6 @@ def process_message(
         st.error(f"Une erreur s'est produite lors de la génération de la réponse : {e}")
         return ""    
 
-def process_tts_message(text_response: str) -> Tuple[Optional[bytes], Optional[float]]:
-    try:
-        tts_audio_, tts_duration_ = text_to_speech(text_response)
-        return tts_audio_, tts_duration_
-    except Exception as e:
-        st.error(f"Une erreur s'est produite lors de la conversion texte-parole : {e}")
-        return None, None
 
 class GlobalSystemPrompts:
     """Class to store global system prompts."""