Update app.py

app.py

@@ -1,27 +1,31 @@
 import os
-import gradio as gr
+from flask import Flask, request, jsonify, send_file, send_from_directory
 from faster_whisper import WhisperModel
 import google.generativeai as genai
 from gtts import gTTS, lang
 import tempfile
 import soundfile as sf
 from kokoro import KPipeline
+from werkzeug.utils import secure_filename
+from flask_cors import CORS
 
-# Configure Gemini API (use environment variable for Hugging Face Spaces)
+app = Flask(__name__, static_folder='static')
+CORS(app)
+
+# Configure Gemini API
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
-    raise ValueError("GEMINI_API_KEY environment variable not set. Please set it in the Hugging Face Spaces Secrets.")
+    raise ValueError("GEMINI_API_KEY environment variable not set")
 genai.configure(api_key=GEMINI_API_KEY)
 
-# Initialize the faster-whisper model with fallback compute type
+# Initialize Whisper model
 model_size = "Systran/faster-whisper-large-v3"
 try:
     whisper_model = WhisperModel(model_size, device="auto", compute_type="float16")
 except ValueError:
-    print("Float16 not supported, falling back to int8 on CPU")
     whisper_model = WhisperModel(model_size, device="cpu", compute_type="int8")
 
-# Language codes for Kokoro TTS
+# Language configurations
 KOKORO_LANGUAGES = {
     "American English": "a",
     "British English": "b",
@@ -34,156 +38,80 @@ KOKORO_LANGUAGES = {
     "Brazilian Portuguese": "p"
 }
 
-# Function to transcribe audio using faster-whisper
-def transcribe_audio(audio_file):
-    try:
-        segments, info = whisper_model.transcribe(audio_file, beam_size=5)
-        transcription = " ".join([segment.text for segment in segments])
-        detected_language = info.language
-        return transcription, detected_language, None
-    except Exception as e:
-        return None, None, f"Transcription error: {str(e)}"
+GTTS_LANGUAGES = lang.tts_langs()
+SUPPORTED_LANGUAGES = sorted(list(KOKORO_LANGUAGES.keys()) + list(GTTS_LANGUAGES.values()))
+
+@app.route('/')
+def serve_index():
+    return send_from_directory(app.static_folder, 'index.html')
+
+@app.route('/languages')
+def get_languages():
+    return jsonify(SUPPORTED_LANGUAGES)
 
-# Function to translate text using Gemini API with a magic prompt
-def translate_text(text, target_language):
+@app.route('/translate', methods=['POST'])
+def translate_audio():
     try:
+        if 'audio' not in request.files:
+            return jsonify({'error': 'No audio file uploaded'}), 400
+            
+        audio_file = request.files['audio']
+        target_language = request.form.get('language', 'English')
+        
+        if not audio_file or audio_file.filename == '':
+            return jsonify({'error': 'Invalid audio file'}), 400
+
+        # Save temporary audio file
+        filename = secure_filename(audio_file.filename)
+        temp_input_path = os.path.join(tempfile.gettempdir(), filename)
+        audio_file.save(temp_input_path)
+        
+        # Transcribe audio
+        segments, info = whisper_model.transcribe(temp_input_path, beam_size=5)
+        transcription = " ".join([segment.text for segment in segments])
+        
+        # Translate text
         model = genai.GenerativeModel("gemini-2.0-flash")
-        prompt = f"Translate the following text to {target_language} and return only the translated text with no additional explanation or commentary:\n\n{text}"
+        prompt = f"Translate to {target_language} preserving meaning and cultural nuances:\n\n{transcription}"
         response = model.generate_content(prompt)
         translated_text = response.text.strip()
-        return translated_text, None
-    except Exception as e:
-        return None, f"Translation error: {str(e)}"
-
-# Function to convert text to speech using Kokoro or gTTS based on language
-def text_to_speech(text, language):
-    try:
-        # Check if the language is supported by Kokoro
-        if language in KOKORO_LANGUAGES:
-            # Use Kokoro TTS
-            lang_code = KOKORO_LANGUAGES[language]
+        
+        # Generate TTS
+        if target_language in KOKORO_LANGUAGES:
+            lang_code = KOKORO_LANGUAGES[target_language]
             pipeline = KPipeline(lang_code=lang_code)
-            generator = pipeline(text, voice="af_heart", speed=1, split_pattern=r'\n+')
-            audio_data = None
-            for i, (gs, ps, audio) in enumerate(generator):
-                audio_data = audio  # Use the first segment
-                break
-            if audio_data is None:
-                raise ValueError("No audio generated by Kokoro")
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as fp:
-                sf.write(fp.name, audio_data, 24000)
-                return fp.name, None
+            generator = pipeline(translated_text, voice="af_heart", speed=1)
+            audio_data = next((audio for _, _, audio in generator), None)
+            if audio_data:
+                _, temp_output_path = tempfile.mkstemp(suffix=".wav")
+                sf.write(temp_output_path, audio_data, 24000)
         else:
-            # Fallback to gTTS
-            lang_map = lang.tts_langs()
-            tts_lang = next((k for k, v in lang_map.items() if v.lower() == language.lower()), "en")
-            tts = gTTS(text=text, lang=tts_lang, slow=False)
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as fp:
-                tts.save(fp.name)
-                return fp.name, None
+            lang_code = next((k for k, v in GTTS_LANGUAGES.items() if v == target_language), 'en')
+            tts = gTTS(translated_text, lang=lang_code)
+            _, temp_output_path = tempfile.mkstemp(suffix=".mp3")
+            tts.save(temp_output_path)
+        
+        return jsonify({
+            'transcription': transcription,
+            'translation': translated_text,
+            'audio_url': f'/download/{os.path.basename(temp_output_path)}'
+        })
+        
     except Exception as e:
-        return None, f"TTS error: {str(e)}"
-
-# Main function to process audio input and return outputs
-def process_audio(audio_file, target_language):
-    if audio_file is None:
-        return "Please upload an audio file or record audio.", None, None, None
-    
-    transcription, detected_language, error = transcribe_audio(audio_file)
-    if error:
-        return error, None, None, None
-    
-    translated_text, error = translate_text(transcription, target_language)
-    if error:
-        return error, transcription, None, None
-    
-    audio_output, error = text_to_speech(translated_text, target_language)
-    if error:
-        return error, transcription, translated_text, None
-    
-    return None, transcription, translated_text, audio_output
+        app.logger.error(f"Error processing request: {str(e)}")
+        return jsonify({'error': str(e)}), 500
 
-# Gradio interface with custom CSS and JavaScript
-css = """
-body {
-    font-family: 'Arial', sans-serif;
-    background-color: #f4f4f4;
-    color: #333;
-}
-.gradio-container {
-    max-width: 800px;
-    margin: 0 auto;
-    padding: 20px;
-    background-color: #fff;
-    border-radius: 10px;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-}
-.gradio-header {
-    text-align: center;
-    margin-bottom: 20px;
-}
-.gradio-header h1 {
-    font-size: 2.5em;
-    color: #444;
-}
-.gradio-row {
-    display: flex;
-    flex-direction: column;
-    gap: 15px;
-}
-.gradio-button {
-    background-color: #007bff;
-    color: white;
-    border: none;
-    padding: 10px 20px;
-    border-radius: 5px;
-    cursor: pointer;
-    font-size: 1em;
-}
-.gradio-button:hover {
-    background-color: #0056b3;
-}
-.gradio-output {
-    background-color: #f9f9f9;
-    padding: 15px;
-    border-radius: 5px;
-    border: 1px solid #ddd;
-}
-"""
-
-js = """
-function updateUI() {
-    // Add any custom JavaScript here if needed
-}
-"""
-
-with gr.Blocks(css=css, title="AI Audio Translator") as demo:
-    gr.Markdown("# AI Audio Translator", elem_classes="gradio-header")
-    gr.Markdown("Upload an audio file or record via microphone, select a target language, and get the transcription, translation, and translated audio! Uses Kokoro TTS for supported languages, otherwise gTTS.")
-    
-    supported_langs = list(set(list(KOKORO_LANGUAGES.keys()) + list({v: k for k, v in lang.tts_langs().items()}.keys())))
-    
-    with gr.Row(elem_classes="gradio-row"):
-        audio_input = gr.Audio(sources=["upload", "microphone"], type="filepath", label="Input Audio")
-        target_lang = gr.Dropdown(
-            choices=sorted(supported_langs),
-            value="Spanish",
-            label="Target Language"
+@app.route('/download/<filename>')
+def download_file(filename):
+    try:
+        return send_file(
+            os.path.join(tempfile.gettempdir(), filename),
+            mimetype="audio/mpeg",
+            as_attachment=True,
+            download_name=f"translated_{filename}"
         )
-    
-    submit_btn = gr.Button("Translate", elem_classes="gradio-button")
-    
-    with gr.Row(elem_classes="gradio-row"):
-        error_output = gr.Textbox(label="Error", visible=True, elem_classes="gradio-output")
-        transcription_output = gr.Textbox(label="Transcription", elem_classes="gradio-output")
-        translation_output = gr.Textbox(label="Translated Text", elem_classes="gradio-output")
-        audio_output = gr.Audio(label="Translated Audio", elem_classes="gradio-output")
-    
-    submit_btn.click(
-        fn=process_audio,
-        inputs=[audio_input, target_lang],
-        outputs=[error_output, transcription_output, translation_output, audio_output]
-    )
+    except FileNotFoundError:
+        return jsonify({'error': 'File not found'}), 404
 
-# Launch the app
-demo.launch()
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000, debug=True)