Update app.py

app.py

@@ -12,140 +12,175 @@ from gtts import gTTS, lang
 from kokoro import KPipeline
 
 import google.generativeai as genai
-from google.generativeai.types import GenerateContentConfig, SpeechConfig, VoiceConfig, PrebuiltVoiceConfig
+from google.generativeai.types import (
+    GenerateContentConfig,
+    SpeechConfig,
+    VoiceConfig,
+    PrebuiltVoiceConfig,
+)
+
+# -----------------------------------------------------------------------------
+#  Configuration
+# -----------------------------------------------------------------------------
+
+# 1) Make sure you've run:
+#      pip install --upgrade google-generativeai gTTS soundfile kokoro flask flask-cors werkzeug
+#
+# 2) Set your Gemini API key in the environment:
+#      export GEMINI_API_KEY="your_real_api_key_here"
 
-# Load API key
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
-    raise ValueError("GEMINI_API_KEY environment variable not set")
+    raise RuntimeError("GEMINI_API_KEY environment variable not set")
 
 genai.configure(api_key=GEMINI_API_KEY)
+client = genai.Client(api_key=GEMINI_API_KEY)
 
-# Flask app setup
-app = Flask(__name__, static_folder='static')
-CORS(app)
-
-# Supported languages
+# Kokoro and gTTS language maps
 KOKORO_LANGUAGES = {
-    "American English": "a", "British English": "b", "Mandarin Chinese": "z",
-    "Spanish": "e", "French": "f", "Hindi": "h", "Italian": "i", "Brazilian Portuguese": "p"
+    "American English": "a",
+    "British English": "b",
+    "Mandarin Chinese": "z",
+    "Spanish": "e",
+    "French": "f",
+    "Hindi": "h",
+    "Italian": "i",
+    "Brazilian Portuguese": "p",
 }
 GTTS_LANGUAGES = lang.tts_langs()
-GTTS_LANGUAGES['ja'] = 'Japanese'
-SUPPORTED_LANGUAGES = sorted(set(KOKORO_LANGUAGES.keys()) | set(GTTS_LANGUAGES.values()))
+GTTS_LANGUAGES["ja"] = "Japanese"  # explicit Japanese support
+
+SUPPORTED_LANGUAGES = sorted(
+    set(KOKORO_LANGUAGES.keys()) | set(GTTS_LANGUAGES.values())
+)
 
-# Voice name for Gemini TTS
-DEFAULT_GEMINI_VOICE = "Kore"
+# Voice name for Gemini TTS preview
+GEMINI_VOICE_NAME = "Kore"
 
-def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
+# -----------------------------------------------------------------------------
+#  Helpers
+# -----------------------------------------------------------------------------
+
+def wave_file(filename: str, pcm: bytes, channels=1, rate=24000, sample_width=2):
+    """Write raw PCM into a .wav file."""
     with wave.open(filename, "wb") as wf:
         wf.setnchannels(channels)
         wf.setsampwidth(sample_width)
         wf.setframerate(rate)
         wf.writeframes(pcm)
 
-@app.route('/')
+# -----------------------------------------------------------------------------
+#  Flask App
+# -----------------------------------------------------------------------------
+
+app = Flask(__name__, static_folder="static")
+CORS(app)
+
+
+@app.route("/")
 def serve_index():
-    return send_from_directory(app.static_folder, 'index.html')
+    # serve your index.html from ./static/index.html
+    return send_from_directory(app.static_folder, "index.html")
 
-@app.route('/languages')
-def get_languages():
+
+@app.route("/languages")
+def list_languages():
     return jsonify(SUPPORTED_LANGUAGES)
 
-@app.route('/translate', methods=['POST'])
+
+@app.route("/translate", methods=["POST"])
 def translate_audio():
     try:
-        if 'audio' not in request.files:
-            return jsonify({'error': 'No audio file uploaded'}), 400
+        # 1. Receive file + target language
+        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')
+        audio_file = request.files["audio"]
+        target_lang = request.form.get("language", "English")
 
-        if not audio_file or audio_file.filename == '':
-            return jsonify({'error': 'Invalid audio file'}), 400
+        if not audio_file or audio_file.filename == "":
+            return jsonify(error="Invalid audio file"), 400
 
-        allowed_mime_types = ['audio/wav', 'audio/mpeg', 'audio/mp4', 'audio/webm']
-        if audio_file.mimetype not in allowed_mime_types:
-            return jsonify({'error': f'Unsupported file type: {audio_file.mimetype}'}), 400
+        # 2. Validate MIME type
+        if audio_file.mimetype not in ("audio/wav", "audio/mpeg", "audio/mp4", "audio/webm"):
+            return jsonify(error=f"Unsupported file type: {audio_file.mimetype}"), 400
 
-        # Transcribe audio with Gemini
-        model = genai.GenerativeModel("models/gemini-1.5-flash")
-        audio_blob = {
-            'mime_type': audio_file.mimetype,
-            'data': audio_file.read()
-        }
+        # 3. Transcribe with Gemini
+        model = genai.GenerativeModel("gemini-2.0-flash")
+        blob = {"mime_type": audio_file.mimetype, "data": audio_file.read()}
 
         convo = model.start_chat()
-        convo.send_message("You are a professional transcriber. Transcribe this audio accurately and verbatim.")
-        response = convo.send_message(audio_blob)
-        transcription = response.text.strip()
+        convo.send_message(
+            "You are a professional transcriber. Transcribe this audio accurately, verbatim."
+        )
+        resp = convo.send_message(blob)
+        transcription = resp.text.strip()
 
-        # Translate
-        prompt = f"Translate the following text to {target_language}:\n\n{transcription}"
-        translation_response = model.generate_content(prompt)
-        translated_text = translation_response.text.strip()
+        # 4. Translate with Gemini
+        prompt = f"Translate the following text to {target_lang}, preserving meaning and cultural nuances:\n\n{transcription}"
+        translation_resp = model.generate_content(prompt)
+        translated_text = translation_resp.text.strip()
 
-        # Try Gemini 2.5 TTS
+        # 5. Try Gemini TTS 2.5 preview
         try:
-            tts_response = genai.generate_content(
-                model="models/gemini-2.5-flash-preview-tts",
+            tts_resp = client.models.generate_content(
+                model="gemini-2.5-flash-preview-tts",
                 contents=translated_text,
-                generation_config=GenerateContentConfig(
-                    response_mime_type="audio/wav"
+                config=GenerateContentConfig(
+                    response_modalities=["AUDIO"],
+                    speech_config=SpeechConfig(
+                        voice_config=VoiceConfig(
+                            prebuilt_voice_config=PrebuiltVoiceConfig(
+                                voice_name=GEMINI_VOICE_NAME
+                            )
+                        )
+                    ),
                 ),
-                speech_config=SpeechConfig(
-                    voice_config=VoiceConfig(
-                        prebuilt_voice=PrebuiltVoiceConfig(voice_name=DEFAULT_GEMINI_VOICE)
-                    )
-                )
             )
-
-            data = tts_response.candidates[0].content.parts[0].inline_data.data
-            temp_output_path = os.path.join(tempfile.gettempdir(), "tts_gemini.wav")
-            wave_file(temp_output_path, data)
-
-        except Exception as gemini_tts_error:
-            app.logger.warning(f"Gemini TTS failed: {gemini_tts_error}")
-            # Fallback to Kokoro or gTTS
-            if target_language in KOKORO_LANGUAGES:
-                lang_code = KOKORO_LANGUAGES[target_language]
-                pipeline = KPipeline(lang_code=lang_code)
+            pcm_data = tts_resp.candidates[0].content.parts[0].inline_data.data
+            out_path = os.path.join(tempfile.gettempdir(), f"tts_gemini.wav")
+            wave_file(out_path, pcm_data)
+
+        except Exception:
+            # Fallback: Kokoro
+            if target_lang in KOKORO_LANGUAGES:
+                code = KOKORO_LANGUAGES[target_lang]
+                pipeline = KPipeline(lang_code=code)
                 generator = pipeline(translated_text, voice="af_heart", speed=1)
 
-                audio_segments = [audio for _, _, audio in generator if audio is not None]
-                if audio_segments:
-                    audio_data = np.concatenate(audio_segments)
-                    temp_output_path = os.path.join(tempfile.gettempdir(), "tts_kokoro.wav")
-                    sf.write(temp_output_path, audio_data, 24000)
+                segments = [audio for _, _, audio in generator if audio is not None]
+                if segments:
+                    arr = np.concatenate(segments)
+                    out_path = os.path.join(tempfile.gettempdir(), "tts_kokoro.wav")
+                    sf.write(out_path, arr, 24000)
                 else:
-                    raise ValueError("No audio generated by Kokoro.")
-            else:
-                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 = os.path.join(tempfile.gettempdir(), "tts_gtts.mp3")
-                tts.save(temp_output_path)
+                    raise RuntimeError("Kokoro produced no audio")
 
-        return jsonify({
-            'transcription': transcription,
-            'translation': translated_text,
-            'audio_url': f'/download/{os.path.basename(temp_output_path)}'
-        })
+            # Final fallback: gTTS
+            else:
+                gtts_code = next((k for k, v in GTTS_LANGUAGES.items() if v == target_lang), "en")
+                tts = gTTS(translated_text, lang=gtts_code)
+                out_path = os.path.join(tempfile.gettempdir(), "tts_gtts.mp3")
+                tts.save(out_path)
+
+        return jsonify(
+            transcription=transcription,
+            translation=translated_text,
+            audio_url=f"/download/{os.path.basename(out_path)}",
+        )
 
     except Exception as e:
-        app.logger.error(f"Processing error: {str(e)}")
-        return jsonify({'error': str(e)}), 500
+        app.logger.exception("Error in /translate")
+        return jsonify(error=str(e)), 500
+
 
-@app.route('/download/<filename>')
+@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}"
-        )
-    except FileNotFoundError:
-        return jsonify({'error': 'File not found'}), 404
+    path = os.path.join(tempfile.gettempdir(), filename)
+    if not os.path.isfile(path):
+        return jsonify(error="File not found"), 404
+    return send_file(path, as_attachment=True, download_name=f"translated_{filename}")
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)