Create app.py

app.py

@@ -0,0 +1,115 @@
+from transformers import pipeline
+from langdetect import detect
+from gtts import gTTS
+import pyttsx3
+import gradio as gr
+import os
+import tempfile
+
+# 🌍 Supported language codes 
+LANG_CODE = {
+    "en": "English", "es": "Spanish", "fr": "French", "de": "German",
+    "it": "Italian", "nl": "Dutch", "ru": "Russian", "zh": "Chinese"
+}
+
+# Reverse lookup
+LANG_NAME_TO_CODE = {v: k for k, v in LANG_CODE.items()}
+
+# Cache for loaded models
+translation_cache = {}
+
+# Detect language
+def detect_language(text):
+    try:
+        lang_code = detect(text)
+        return LANG_CODE.get(lang_code, lang_code)
+    except:
+        return "Unknown"
+
+# Load pipeline per language pair
+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]
+
+# Offline TTS
+def speak_text(text, lang="en"):
+    engine = pyttsx3.init()
+    engine.setProperty("rate", 150)
+    engine.setProperty("voice", lang)
+    engine.say(text)
+    engine.runAndWait()
+
+# Optional audio file (gTTS)
+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
+
+# Main translation logic
+def translate_text(input_text, target_lang, speak=False):
+    if not input_text.strip():
+        return "Please enter some text to translate.", None, "Unknown"
+
+    detected_lang = detect_language(input_text)
+    if detected_lang == "Unknown":
+        return "Could not detect source language.", None, detected_lang
+
+    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
+
+# Gradio UI
+with gr.Blocks() as app:
+    gr.Markdown("# 🌍 AI Translator with Speech & Auto-Language Detection")
+
+    with gr.Row():
+        with gr.Column():
+            input_text = gr.Textbox(lines=4, label="Enter text to translate")
+            target_lang = gr.Dropdown(
+                choices=list(LANG_NAME_TO_CODE.keys()),
+                value="French",
+                label="Target Language"
+            )
+            speak_checkbox = gr.Checkbox(label="🔊 Enable speech output", value=True)
+            translate_button = 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)
+
+    translate_button.click(
+        translate_text,
+        inputs=[input_text, target_lang, speak_checkbox],
+        outputs=[output_text, output_audio, detected_lang]
+    )
+
+if __name__ == "__main__":
+    app.launch(share=True, server_name="0.0.0.0", server_port=7862)