Update app.py

app.py

@@ -1,10 +1,11 @@
 import streamlit as st
-import os
 import speech_recognition as sr
 from transformers import MarianMTModel, MarianTokenizer
 from gtts import gTTS
 from io import BytesIO
-import tempfile
+import queue
+import threading
+import pyaudio
 
 def load_model(source_lang, target_lang):
     model_name = f"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}"
@@ -24,19 +25,6 @@ def translate_text(tokenizer, model, text):
     translated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
     return translated_text
 
-def audio_to_text(audio_file):
-    recognizer = sr.Recognizer()
-    with sr.AudioFile(audio_file) as source:
-        audio_data = recognizer.record(source)
-        try:
-            text = recognizer.recognize_google(audio_data)
-            return text
-        except sr.UnknownValueError:
-            st.error("Speech Recognition could not understand the audio.")
-        except sr.RequestError as e:
-            st.error(f"Could not request results from Speech Recognition service; {e}")
-        return ""
-
 def text_to_audio(text, lang):
     tts = gTTS(text=text, lang=lang)
     audio_file = BytesIO()
@@ -44,10 +32,28 @@ def text_to_audio(text, lang):
     audio_file.seek(0)
     return audio_file
 
-def main():
-    st.title("Audio Language Translation App")
-    st.write("Translate audio between multiple languages using open-source models.")
+def recognize_speech_live(q):
+    recognizer = sr.Recognizer()
+    mic = sr.Microphone()
+    
+    with mic as source:
+        recognizer.adjust_for_ambient_noise(source)
+        st.info("Start speaking...")
+        while True:
+            try:
+                audio_data = recognizer.listen(source)
+                text = recognizer.recognize_google(audio_data)
+                q.put(text)
+            except sr.UnknownValueError:
+                q.put("[Unintelligible]")
+            except Exception as e:
+                st.error(f"Error during speech recognition: {e}")
+                break
 
+def main():
+    st.title("Real-Time Audio Language Translation")
+    st.write("Translate spoken words in real time using open-source models.")
+    
     # Language selection
     languages = {
         "English": "en",
@@ -71,35 +77,35 @@ def main():
     source_lang_code = languages[source_language]
     target_lang_code = languages[target_language]
 
-    # Load the model and tokenizer
+    # Load the model
     tokenizer, model = load_model(source_lang_code, target_lang_code)
+    if not (tokenizer and model):
+        return
 
-    if tokenizer and model:
-        # Audio input
-        uploaded_audio = st.file_uploader("Upload an audio file (WAV format):", type=["wav"])
+    # Real-time speech recognition
+    q = queue.Queue()
+    transcription_placeholder = st.empty()
+    translation_placeholder = st.empty()
+    audio_placeholder = st.empty()
 
-        if uploaded_audio is not None:
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio:
-                temp_audio.write(uploaded_audio.read())
-                temp_audio_path = temp_audio.name
+    if st.button("Start Real-Time Translation"):
+        st.write("Processing...")
 
-            st.audio(uploaded_audio, format="audio/wav")
+        # Start speech recognition in a separate thread
+        threading.Thread(target=recognize_speech_live, args=(q,), daemon=True).start()
 
-            with st.spinner("Converting audio to text..."):
-                input_text = audio_to_text(temp_audio_path)
-                st.success("Audio converted to text!")
-                st.text_area("Transcribed text:", input_text, height=100)
+        while True:
+            if not q.empty():
+                spoken_text = q.get()
+                transcription_placeholder.text_area("Transcribed Text:", spoken_text, height=100)
 
-            if st.button("Translate and Generate Audio"):
-                with st.spinner("Translating text..."):
-                    translated_text = translate_text(tokenizer, model, input_text)
-                    st.success("Translation completed!")
-                    st.text_area("Translated text:", translated_text, height=100)
+                # Translate text
+                translated_text = translate_text(tokenizer, model, spoken_text)
+                translation_placeholder.text_area("Translated Text:", translated_text, height=100)
 
-                with st.spinner("Generating audio..."):
-                    output_audio = text_to_audio(translated_text, target_lang_code)
-                    st.success("Audio generated!")
-                    st.audio(output_audio, format="audio/mp3")
+                # Generate and play translated audio
+                translated_audio = text_to_audio(translated_text, target_lang_code)
+                audio_placeholder.audio(translated_audio, format="audio/mp3")
 
 if __name__ == "__main__":
     main()