Update app.py

app.py

@@ -1,101 +1,58 @@
+import gradio as gr
 from transformers import pipeline
 from langdetect import detect
 from gtts import gTTS
-import gradio as gr
-import tempfile
-
-# 🌍 Supported language codes (Portuguese removed)
-LANG_CODE = {
-    "en": "English", "es": "Spanish", "fr": "French", "de": "German",
-    "it": "Italian", "nl": "Dutch", "ru": "Russian", "zh": "Chinese"
-}
+import os
 
-# Reverse map: English → "en"
-LANG_NAME_TO_CODE = {v: k for k, v in LANG_CODE.items()}
+# 🔥 Load Hugging Face translation model
+translator = pipeline("translation", model="Helsinki-NLP/opus-mt-mul-en")
 
-# Cache translation pipelines
-translation_cache = {}
-
-def detect_language(text):
+def translate_text(text, target_lang, speech_output):
     try:
-        lang_code = detect(text)
-        return LANG_CODE.get(lang_code, lang_code)
-    except:
-        return "Unknown"
-
-def get_translation_pipeline(src_code, tgt_code):
-    model_name = f"Helsinki-NLP/opus-mt-{src_code}-{tgt_code}"
-    key = (src_code, tgt_code)
-    if key not in translation_cache:
-        try:
-            translation_cache[key] = pipeline("translation", model=model_name, device=-1)
-        except:
-            translation_cache[key] = None
-    return translation_cache[key]
+        # Detect source language
+        source_lang = detect(text)
 
-def generate_audio_file(text, lang_code):
-    try:
-        tts = gTTS(text=text, lang=lang_code)
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
-        tts.save(temp_file.name)
-        return temp_file.name
-    except:
-        return None
+        # Translate text
+        translation = translator(text, tgt_lang=target_lang)
+        translated_text = translation[0]['translation_text']
 
-def translate_text(input_text, target_lang, speak=False):
-    if not input_text.strip():
-        return "Please enter some text to translate.", None, "Unknown"
+        # Generate speech if enabled
+        audio_file = None
+        if speech_output:
+            tts = gTTS(translated_text, lang=target_lang)
+            audio_file = "output.mp3"
+            tts.save(audio_file)
 
-    detected_lang = detect_language(input_text)
-    if detected_lang == "Unknown":
-        return "Could not detect source language.", None, detected_lang
+        return f"Detected Language: {source_lang}\n\nTranslation: {translated_text}", audio_file
 
-    if detected_lang == target_lang:
-        return f"Source and target languages are the same. Text: {input_text}", None, detected_lang
-
-    src_code = LANG_NAME_TO_CODE.get(detected_lang)
-    tgt_code = LANG_NAME_TO_CODE.get(target_lang)
-
-    if not src_code or not tgt_code:
-        return f"Unsupported language pair: {detected_lang} → {target_lang}", None, detected_lang
-
-    translator = get_translation_pipeline(src_code, tgt_code)
-    if not translator:
-        return f"No model found for {detected_lang} → {target_lang}", None, detected_lang
-
-    try:
-        result = translator(input_text, max_length=512)
-        translated_text = result[0]['translation_text']
-        audio_path = generate_audio_file(translated_text, tgt_code) if speak else None
-        return translated_text, audio_path, detected_lang
     except Exception as e:
-        return f"Translation failed: {str(e)}", None, detected_lang
+        return f"⚠️ Error: {str(e)}", None
 
-# Gradio UI
-with gr.Blocks() as app:
-    gr.Markdown("# 🌍 AI Translator with Auto-Detect and Speech Output")
+# 🎨 Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("# 🌍 LinguaCast\nAI-Powered Multilingual Translator with Speech Output")
 
     with gr.Row():
         with gr.Column():
-            input_text = gr.Textbox(lines=4, label="Enter text to translate")
+            text_input = gr.Textbox(label="Enter your text", placeholder="Type here...")
             target_lang = gr.Dropdown(
-                choices=list(LANG_NAME_TO_CODE.keys()),
-                value="French",
-                label="Target Language"
+                ["en", "es", "fr", "de", "it", "nl", "ru", "zh"], 
+                label="Select Target Language", 
+                value="en"
             )
-            speak_checkbox = gr.Checkbox(label="🔊 Enable speech output", value=True)
-            translate_button = gr.Button("🔁 Translate")
+            speech_output = gr.Checkbox(label="Enable Speech Output", value=False)
+            submit_btn = gr.Button("Translate")
 
         with gr.Column():
-            output_text = gr.Textbox(lines=4, label="Translated Text")
-            output_audio = gr.Audio(label="Speech Output", autoplay=True)
-            detected_lang = gr.Textbox(label="Detected Language", interactive=False)
+            result_output = gr.Textbox(label="Translation Result")
+            audio_output = gr.Audio(label="Speech Output", type="filepath")
 
-    translate_button.click(
+    submit_btn.click(
         translate_text,
-        inputs=[input_text, target_lang, speak_checkbox],
-        outputs=[output_text, output_audio, detected_lang]
+        inputs=[text_input, target_lang, speech_output],
+        outputs=[result_output, audio_output]
     )
 
+# Run the app
 if __name__ == "__main__":
-    app.launch()
+    demo.launch()