...not done...

pages/main.py

@@ -14,6 +14,7 @@ from typing import List
 from typing import Optional
 from typing import Tuple
 from typing import Union
+from io import BytesIO
 
 # Third-party libraries
 import requests
@@ -63,91 +64,48 @@ def process_tts_message(text_response: str) -> Tuple[Optional[bytes], Optional[f
         st.error(f"Une erreur s'est produite lors de la conversion texte-parole : {e}")
         return None, None
 
-def split_audio(audio_data: Union[str, bytes], max_size_mb: int = 25) -> List[str]:
+# ecrire ici la fonction: split_audio
+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 (str): Chemin vers le fichier audio.
+        audio_file: Fichier audio ouvert en mode binaire.
         max_size_mb (int): Taille maximale de chaque segment en Mo.
 
     Returns:
-        List[str]: Liste des chemins vers les segments audio divisés.
+        List[bytes]: Liste des segments audio divisés sous forme de bytes.
     """
     try:
-        temp_audio_file = tempfile.TemporaryFile()
-        if isinstance(audio_data, str):
-            temp_audio_file.write(audio_data.encode())
-            temp_audio_file.seek(0)
-        else:
-            temp_audio_file.write(audio_data)
-            temp_audio_file.seek(0)
-
-        audio = AudioSegment.from_file(temp_audio_file, format="wav")
+        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))
+        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):
-            tmp_seg_file = tempfile.TemporaryFile()
             end = min(start + segment_duration_ms, duration_ms)
             segment = audio[start:end]
-            segment.export(tmp_seg_file, format="mp3")
-            tmp_seg_file.seek(0)
-            segments.append(base64.b64encode(tmp_seg_file.read()).decode())
-            tmp_seg_file.close()
+            
+            with io.BytesIO() as buffer:
+                segment.export(buffer, format="mp3")
+                segments.append(buffer.getvalue())
 
-        temp_audio_file.close()
         return segments
     except Exception as e:
-        print(f"Erreur lors du découpage de l'audio : {e}")
+        print(f"Une erreur s'est produite lors de la division de l'audio : {e}")
         return []
 
-def transcribe_segment(segment_data: Union[str, bytes], language: Optional[str] = None) -> str:
-    """
-    Transcrit un segment audio en texte.
-
-    Args:
-        segment_path (str): Chemin vers le segment audio.
-        language (Optional[str]): La langue de l'audio.
-
-    Returns:
-        str: Le texte transcrit.
-    """
-    try:
-        audio_segment = tempfile.TemporaryFile()
-        if isinstance(segment_data, str):
-            audio_segment.write(segment_data.encode())
-        else:
-            audio_segment.write(segment_data)
-
-        audio_segment.seek(0)
-        if not (language):
-            transcript = client.audio.transcriptions.create(
-                model="whisper-1",
-                file=audio_segment,
-                response_format="text"
-            )
-        else:
-            transcript = client.audio.transcriptions.create(
-                model="whisper-1",
-                file=audio_segment,
-                language=language, # semble que language soit mal formatter au format ISO6391
-                response_format="text"
-            )
-
-        audio_segment.close()
-        return transcript
-    except Exception as e:
-        print(f"Erreur lors de la transcription du segment : {e}")
-        return ""
 
-def transcribe_audio(audio_data: Union[str, bytes], language: Optional[str] = None) -> str:
+def transcribe_audio(filepath: Union[str, IO], language: Optional[str] = None) -> str:
     """
-    Transcrit un fichier audio en texte.
+    Transcrit un fichier audio temporaire en texte.
 
     Args:
-        audio_file (Union[str, IO]): Le chemin du fichier audio ou un objet fichier ouvert.
+        filepath Chemin vers le fichier audio temporaire à transcrire.
         language (Optional[str]): La langue de l'audio. Par défaut None.
 
     Returns:
@@ -156,50 +114,42 @@ def transcribe_audio(audio_data: Union[str, bytes], language: Optional[str] = No
     max_size_mb = 25
     
     try:
-        with st.status("Transcription de l'audio en cours...") as status:
-            temp_audio_file = tempfile.TemporaryFile()
-            if isinstance(audio_data, str):
-                temp_audio_file.write(audio_data.encode())
-                temp_audio_file.seek(0)
-            elif isinstance(audio_data, bytes):
-                temp_audio_file.write(audio_data)
-                temp_audio_file.seek(0)
-
-            file_size_mb = temp_audio_file.tell() / (1024 * 1024)
-
-            if file_size_mb > max_size_mb:
-                status.update(label="Découpage de l'audio en segments...")
-                temp_audio_file.seek(0)
-                segments = split_audio(temp_audio_file.read(), max_size_mb)
-                full_transcript = ""
-                for i, segment in enumerate(segments):
-                    status.update(label=f"Transcription du segment {i+1}/{len(segments)}...")
-                    if not (language):
-                        transcript = transcribe_segment(
-                            base64.b64decode(segment.encode())
-                        )
-                    else:
-                        transcript = transcribe_segment(
-                            base64.b64decode(segment.encode()), 
-                            language=language
-                        )
-                    
-                    full_transcript += f"{transcript} "
-                status.update(label="Transcription terminée", state="complete")
-                
-                return full_transcript.strip()
-            else:
-                status.update(label="Transcription de l'audio...")
-                temp_audio_file.seek(0)
-                transcript = transcribe_segment(temp_audio_file.read(), language)
-                status.update(label="Transcription terminée", state="complete")
+        transcriptions = []
+        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
+            # verifier si le fichier audio fait plus de 25 Mo
+
+            # Diviser l'audio en segments de taille maximale
+            #segments = split_audio(f, max_size_mb)
+            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)
+
+
+                response = client.audio.transcriptions.create(
+                    model="whisper-1",
+                    file=("audio.mp3", buffer),
+                    language=language,
+                    response_format="text"
+                )
+                transcriptions.append(response)
                 
-                return transcript
+        return " ".join(transcriptions)
     except Exception as e:
-        st.error(f"Erreur lors de la transcription : {e}")
+        print(f"Erreur lors de la transcription de l'audio : {e}")
         return ""
-    finally:
-        temp_audio_file.close()
 
 
 def detect_language(input_text: str, temperature: float = 0.01) -> str:
@@ -252,13 +202,13 @@ def detect_language(input_text: str, temperature: float = 0.01) -> str:
 
 
 
-def concatenate_audio_files(audio_list: List[Tuple[bytes, float]]) -> Optional[bytes]:
+def concatenate_audio_files(audio_list: List[Tuple[Union[bytes, str], 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.
+        audio_list (List[Tuple[Union[bytes, str], float]]): Une liste de tuples, chacun contenant
+            des octets audio (ou une chaîne base64) et la durée.
 
     Returns:
         Optional[bytes]: L'audio concaténé sous forme d'octets, ou None en cas d'erreur.
@@ -278,13 +228,20 @@ def concatenate_audio_files(audio_list: List[Tuple[bytes, float]]) -> Optional[b
         # 5 secondes de silence
         silence = AudioSegment.silent(duration=1500)  # 1500 ms = 1.5 secondes
         
-        for audio_bytes, _ in audio_list:
+        for audio_data, _ in audio_list:
+            # Convertir en bytes si c'est une chaîne base64
+            if isinstance(audio_data, str):
+                audio_bytes = base64.b64decode(audio_data)
+            else:
+                audio_bytes = audio_data
+
             # 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")
@@ -677,102 +634,113 @@ def main_page():
 
             # Traitement de l'entrée audio de l'utilisateur
             if len(st.session_state.audio) > 0:
-                tmp_file = tempfile.TemporaryFile()
-                st.session_state.audio.export(tmp_file, format="wav")
-                tmp_file.seek(0)
-                
-                st.write(f"Frame rate: {st.session_state.audio.frame_rate}, Frame width: {st.session_state.audio.frame_width}, Duration: {st.session_state.audio.duration_seconds} seconds")
+                if st.session_state.audio:
+                    try:
+                        st.subheader(f"Frame rate: {st.session_state.audio.frame_rate}, Frame width: {st.session_state.audio.frame_width}, Duration: {st.session_state.audio.duration_seconds} seconds")
 
-                # Transcrire l'audio en texte
-                st.session_state.transcription = transcribe_audio(
-                    tmp_file.read(), 
-                    language=st.session_state.language_detected
-                )
+                        with tempfile.NamedTemporaryFile(suffix=".mp3", delete_on_close=False) as tmp_file:
+                            st.session_state.audio.export(tmp_file, format="mp3")
+                            tmp_file.close()
 
-                tmp_file.close()
-                
-                # Detecter la langue du texte transcrit (si la langue source n'est pas détectée)
-                if st.session_state.language_detected is None:
-                    st.session_state.language_detected = detect_language(
-                        input_text=st.session_state.transcription, temperature=0.01
-                    )
-                    st.markdown(
-                        f"- {get_translation('langue_detectee')}".format(
-                            f"{convert_iso6391_to_language_name(st.session_state.language_detected)}"
-                        )
-                    )
-                st.markdown(
-                    f"🎤 {get_translation('transcription_audio')}".format(
-                        f"{st.session_state.transcription}"
-                    )
-                )
+                            # Transcrire l'audio en texte
+                            st.session_state.transcription = transcribe_audio(
+                                tmp_file, 
+                                language=st.session_state.language_detected
+                            )
 
-                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 = ""
+                        st.markdown(
+                            f"🎤 {get_translation('transcription_audio')}".format(
+                                f"{st.session_state.transcription}"
+                            )
+                        )
 
-                    # Initialisation du mode de traitement pour la langue cible actuelle
-                    st.session_state.system_prompt, st.session_state.operation_prompt = init_process_mode(from_lang=
-                        (
-                            st.session_state.language_detected if "language_detected" in st.session_state.language_detected else convert_language_name_to_iso6391( 
-                                st.session_state.interface_language 
+                        # Detecter la langue du texte transcrit (si la langue source n'est pas détectée)
+                        if st.session_state.language_detected is None:
+                            st.session_state.language_detected = detect_language(
+                                input_text=st.session_state.transcription, temperature=0.01
+                            )
+                            st.markdown(
+                                f"- {get_translation('langue_detectee')}".format(
+                                    f"{convert_iso6391_to_language_name(st.session_state.language_detected)}"
+                                )
                             )
-                        ), 
-                        to_lang=st.session_state.target_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.enable_tts_for_input_from_audio_record,
-                            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)
+                        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 = ""
 
-                            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 )
+                            # Initialisation du mode de traitement pour la langue cible actuelle
+                            st.session_state.system_prompt, st.session_state.operation_prompt = init_process_mode(from_lang=
+                                (
+                                    st.session_state.language_detected if "language_detected" in st.session_state.language_detected else convert_language_name_to_iso6391( 
+                                        st.session_state.interface_language 
                                     )
-                            else:
-                                pass
+                                ), 
+                                to_lang=st.session_state.target_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.enable_tts_for_input_from_audio_record,
+                                    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/mp3", 
+                                        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/mp3",
+                                    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] - Erreur lors de l'exportation de l'audio : {str(e)}")
+                    finally:
+                        clear_inputs_garbages()
+                    #    if 'tmp_file' in locals():
+                    #        os.unlink(tmp_file.name)
+
+                
+                
 
-                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/mp3", 
-                                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/mp3",
-                            use_container_width=True,
-                            type="primary",
-                            key=f"download_button_{st.session_state.langues}_{st.session_state.timestamp}",
-                        )
-                #
-                clear_inputs_garbages()
 
 
 def clear_inputs_garbages(sessions_state_list: Optional[list] = 
@@ -863,4 +831,4 @@ with st.sidebar:
 
 
 
-main_page()
+main_page()