Update app.py

app.py

@@ -1,136 +1,98 @@
+import streamlit as st
+from transformers import pipeline
+import speech_recognition as sr
 from gtts import gTTS
 import tempfile
+import os
+import base64
+
+# Initialize the translation pipeline
+@st.cache_resource
+def load_translation_pipeline(model_name):
+    return pipeline("translation", model=model_name)
+
+# Initialize speech recognition
+recognizer = sr.Recognizer()
+
+def translate_text(input_text, model):
+    return model(input_text)[0]["translation_text"]
+
+def speech_to_text(audio_file):
+    with sr.AudioFile(audio_file) as source:
+        audio_data = recognizer.record(source)
+        return recognizer.recognize_google(audio_data)
 
 def text_to_speech(text, language):
     tts = gTTS(text=text, lang=language)
     temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
     tts.save(temp_file.name)
     return temp_file.name
-import pyttsx3
 
-def text_to_speech(text, language):
-    engine = pyttsx3.init()
-    engine.setProperty('rate', 150)  # Speed of speech
-    engine.setProperty('volume', 1)  # Volume level (0.0 to 1.0)
+# Streamlit app
+st.title("Real-Time Language Translator")
+st.write("Translate voice and text between multiple languages in real-time!")
+
+# Language selection
+st.sidebar.header("Settings")
+input_lang = st.sidebar.selectbox("Select Input Language", ["English", "French", "Spanish", "German", "Hindi"])
+output_lang = st.sidebar.selectbox("Select Output Language", ["English", "French", "Spanish", "German", "Hindi"])
 
-    # Use eSpeak-ng for different languages
-    engine.setProperty('voice', language)  # Setting language
+# Language codes mapping
+lang_codes = {
+    "English": "en",
+    "French": "fr",
+    "Spanish": "es",
+    "German": "de",
+    "Hindi": "hi"
+}
 
-    # Save the speech to an audio file
-    engine.save_to_file(text, "output_audio.mp3")
-    engine.runAndWait()
-    return "output_audio.mp3"
+input_code = lang_codes[input_lang]
+output_code = lang_codes[output_lang]
 
+# Model selection
+model_name = f"Helsinki-NLP/opus-mt-{input_code}-{output_code}"
+translation_pipeline = load_translation_pipeline(model_name)
 
-# Example usage
-translated_text = GoogleTranslator(source='en', target='es').translate("Hello World")
+# Input options
+st.header("Input Options")
+input_mode = st.radio("Choose Input Mode:", ["Text", "Voice"])
 
-# Import necessary libraries
-import streamlit as st
-from deep_translator import GoogleTranslator
-import speech_recognition as sr
-import pyttsx3
-
-# Function to translate text
-def translate_text(text, target_language):
-    """
-    Translate text to the target language.
-    :param text: Input text to be translated.
-    :param target_language: Target language code ('en', 'ur', 'zh-cn', etc.).
-    :return: Translated text.
-    """
-    try:
-        translated = GoogleTranslator(source='auto', target=target_language).translate(text)
-        return translated
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-# Function to convert speech to text
-def speech_to_text(audio_file):
-    """
-    Convert speech to text using SpeechRecognition.
-    :param audio_file: Audio file from user input.
-    :return: Transcribed text.
-    """
-    recognizer = sr.Recognizer()
-    try:
-        with sr.AudioFile(audio_file) as source:
-            audio = recognizer.record(source)
-            text = recognizer.recognize_google(audio)
-            return text
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-# Function to convert text to speech
-def text_to_speech(text, language):
-    """
-    Convert text to speech using pyttsx3.
-    :param text: Text to be spoken.
-    :param language: Language of the text.
-    :return: None (speaks the text directly).
-    """
-    engine = pyttsx3.init()
-    # Set language for TTS
-    voices = engine.getProperty('voices')
-    if language == 'en':
-        engine.setProperty('voice', voices[0].id)  # English
-    elif language == 'ur':
-        engine.setProperty('voice', voices[-1].id)  # Try for Urdu (depends on system setup)
-    else:
-        engine.setProperty('voice', voices[0].id)  # Default to English
-    engine.say(text)
-    engine.runAndWait()
-
-# Streamlit app UI
-st.title("Real-Time Voice-to-Voice Translator 🌍🗣️")
-st.markdown("""
-This app translates voice input between different languages and provides the translated output as speech.
-1. Select the input and output languages.
-2. Upload your audio file for translation.
-3. Get the translated audio output.
-""")
-
-# Language options
-language_options = {
-    "English 🇺🇸": "en",
-    "Urdu 🇵🇰": "ur",
-    "Chinese 🇨🇳": "zh-cn",
-    "Italian 🇮🇹": "it",
-    "German 🇩🇪": "de",
-    "Japanese 🇯🇵": "ja",
-    "Korean 🇰🇷": "ko"
-}
+if input_mode == "Text":
+    input_text = st.text_area(f"Enter text in {input_lang}:")
+    if st.button("Translate"):
+        if input_text.strip():
+            translated_text = translate_text(input_text, translation_pipeline)
+            st.success(f"Translated Text in {output_lang}: {translated_text}")
 
-# Language selection
-input_language = st.selectbox("Select input language", options=list(language_options.keys()))
-output_language = st.selectbox("Select output language", options=list(language_options.keys()))
+            # Option to download translation as audio
+            if st.checkbox("Play Translated Audio"):
+                audio_file = text_to_speech(translated_text, output_code)
+                audio_bytes = open(audio_file, "rb").read()
+                st.audio(audio_bytes, format="audio/mp3")
 
-# File uploader for audio input
-uploaded_audio = st.file_uploader("Upload your audio file (WAV format)", type=["wav"])
+                # Provide download link
+                b64 = base64.b64encode(audio_bytes).decode()
+                href = f'<a href="data:audio/mp3;base64,{b64}" download="translation.mp3">Download Translated Audio</a>'
+                st.markdown(href, unsafe_allow_html=True)
+else:
+    audio_file = st.file_uploader("Upload an audio file (WAV format)", type=["wav"])
+    if audio_file is not None:
+        if st.button("Translate"):
+            try:
+                input_text = speech_to_text(audio_file)
+                st.write(f"Recognized Text in {input_lang}: {input_text}")
+                translated_text = translate_text(input_text, translation_pipeline)
+                st.success(f"Translated Text in {output_lang}: {translated_text}")
 
-if uploaded_audio:
-    st.audio(uploaded_audio, format="audio/wav", start_time=0)
-    if st.button("Translate"):
-        input_lang_code = language_options[input_language]
-        output_lang_code = language_options[output_language]
-        
-        # Step 1: Convert speech to text
-        st.info("Transcribing audio...")
-        transcribed_text = speech_to_text(uploaded_audio)
-        if "Error" in transcribed_text:
-            st.error(transcribed_text)
-        else:
-            st.success(f"Transcribed Text: {transcribed_text}")
-            
-            # Step 2: Translate text
-            st.info("Translating text...")
-            translated_text = translate_text(transcribed_text, output_lang_code)
-            if "Error" in translated_text:
-                st.error(translated_text)
-            else:
-                st.success(f"Translated Text: {translated_text}")
-                
-                # Step 3: Convert translated text to speech
-                st.info("Converting translated text to speech...")
-                text_to_speech(translated_text, output_lang_code)
-                st.success("Translation complete! Check the output above.")
+                # Option to download translation as audio
+                if st.checkbox("Play Translated Audio"):
+                    audio_file = text_to_speech(translated_text, output_code)
+                    audio_bytes = open(audio_file, "rb").read()
+                    st.audio(audio_bytes, format="audio/mp3")
+
+                    # Provide download link
+                    b64 = base64.b64encode(audio_bytes).decode()
+                    href = f'<a href="data:audio/mp3;base64,{b64}" download="translation.mp3">Download Translated Audio</a>'
+                    st.markdown(href, unsafe_allow_html=True)
+            except Exception as e:
+                st.error(f"Error: {e}")