...not done...

pages/main.py

@@ -63,7 +63,7 @@ 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_file: str, max_size_mb: int = 25) -> List[str]:
+def split_audio(audio_data: Union[str, bytes], max_size_mb: int = 25) -> List[str]:
     """
     Divise un fichier audio en segments de taille maximale spécifiée.
 
@@ -75,26 +75,35 @@ def split_audio(audio_file: str, max_size_mb: int = 25) -> List[str]:
         List[str]: Liste des chemins vers les segments audio divisés.
     """
     try:
-        audio = AudioSegment.from_file(audio_file, format="wav")
+        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")
         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):
-            tmp_file = tempfile.TemporaryFile()
+            tmp_seg_file = tempfile.TemporaryFile()
             end = min(start + segment_duration_ms, duration_ms)
             segment = audio[start:end]
-            segment.export(tmp_file, format="mp3")
-            tmp_file.seek(0)
-            segments.append(base64.b64encode(tmp_file.read()).decode())
-            tmp_file.close()
+            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()
 
+        temp_audio_file.close()
         return segments
     except Exception as e:
         print(f"Erreur lors du découpage de l'audio : {e}")
         return []
 
-def transcribe_segment(segment_path: str, language: Optional[str] = None) -> str:
+def transcribe_segment(segment_data: Union[str, bytes], language: Optional[str] = None) -> str:
     """
     Transcrit un segment audio en texte.
 
@@ -106,26 +115,26 @@ def transcribe_segment(segment_path: str, language: Optional[str] = None) -> str
         str: Le texte transcrit.
     """
     try:
-        with open(segment_path, "rb") as audio_segment:
-            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 = tempfile.TemporaryFile()
+        if isinstance(segment_data, str):
+            audio_segment.write(segment_data.encode())
+        else:
+            audio_segment.write(segment_data)
+
+        audio_segment.seek(0)
+        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 {segment_path} : {e}")
-        print("\'"*3, end="")
-        print("\n# # #\n{}\n# # #\n".format(
-            language
-            ), 
-            end=""
-        )
-        print("\'"*3, end="")
+        print(f"Erreur lors de la transcription du segment : {e}")
         return ""
 
-def transcribe_audio(audio_file: Union[str, IO], language: Optional[str] = None) -> str:
+def transcribe_audio(audio_data: Union[str, bytes], language: Optional[str] = None) -> str:
     """
     Transcrit un fichier audio en texte.
 
@@ -140,30 +149,43 @@ def transcribe_audio(audio_file: Union[str, IO], language: Optional[str] = None)
     
     try:
         with st.status("Transcription de l'audio en cours...") as status:
-            audio_file_path = audio_file if isinstance(audio_file, str) else audio_file.name
-            file_size_mb = os.path.getsize(audio_file_path) / (1024 * 1024)
+            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...")
-                segments = split_audio(audio_file_path, max_size_mb)
+                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(base64.b64decode(segments.encode()))}...")
+                    status.update(label=f"Transcription du segment {i+1}/{len(segments)}...")
                     transcript = transcribe_segment(
                         base64.b64decode(segment.encode()), 
                         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...")
-                transcript = transcribe_segment(audio_file_path, language)
+                temp_audio_file.seek(0)
+                transcript = transcribe_segment(temp_audio_file.read(), language)
                 status.update(label="Transcription terminée", state="complete")
+                
                 return transcript
     except Exception as e:
         st.error(f"Erreur lors de la transcription : {e}")
         return ""
+    finally:
+        temp_audio_file.close()
 
 
 def detect_language(input_text: str, temperature: float = 0.01) -> str:
@@ -639,6 +661,100 @@ def main_page():
             # st.write(f"🗣️ {get_translation('enregistrez_message')}")
 
 
+        elif st.session_state.audio:
+            # 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")
+                
+                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")
+
+                # Transcrire l'audio en texte
+                st.session_state.transcription = transcribe_audio(tmp_file, language=st.session_state.language_detected)
+                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}"
+                )
+            )
+
+            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 = ""
+
+                # 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 
+                        )
+                    ), 
+                    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}",
+                    )
+            #
+            clear_inputs_garbages()
+
+
 def clear_inputs_garbages(sessions_state_list: Optional[list] = 
     [ 'transcription', 'operation_prompt', 'system_prompt',
     'audio_list', 'full_response', 'tts_audio',