Update app.py

app.py

@@ -2,26 +2,35 @@ import os
 import requests
 import json
 import re
-import io
-import tempfile
+import base64
 from datetime import datetime, timedelta, timezone
 from bs4 import BeautifulSoup
 from flask import Flask, request, Response, stream_with_context, render_template_string
-from supertonic import TTS
 
 app = Flask(__name__)
 
 # ----------------------------------------------------
-# INIT TTS MODEL (SUPERTONIC 3) LOADED IN MEMORY
+# REMOTE TTS HELPER (CALLS EXTERNAL FASTAPI ENDPOINT)
 # ----------------------------------------------------
-print("Loading Supertonic TTS Model...")
-try:
-    tts = TTS(auto_download=True)
-    print("TTS Model loaded successfully!")
-except Exception as e:
-    print(f"Error initializing TTS: {e}")
-    tts = None
+REMOTE_TTS_URL = "https://vedalabs-rekha-tts-demo.hf.space/synthesize"
 
+def get_remote_tts(text, voice='M2', language='English'):
+    try:
+        payload = {
+            "text": text,
+            "voice": voice,
+            "language": language
+        }
+        response = requests.post(REMOTE_TTS_URL, json=payload, timeout=30)
+        if response.status_code != 200:
+            return None, f"TTS API error: {response.status_code}"
+        return response.content, None
+    except Exception as e:
+        return None, str(e)
+
+# ----------------------------------------------------
+# AVAILABLE VOICES & LANGUAGES (for reference)
+# ----------------------------------------------------
 VOICES = ["M1", "M2", "M3", "M4", "M5", "F1", "F2", "F3", "F4", "F5"]
 LANGUAGES = {
     "English": "en", "Korean": "ko", "Japanese": "ja", "Arabic": "ar",
@@ -34,8 +43,6 @@ LANGUAGES = {
     "Turkish": "tr", "Ukrainian": "uk", "Vietnamese": "vi"
 }
 
-VOICE_STYLES_CACHE = {}
-
 # ----------------------------------------------------
 # GPS REVERSE GEOCODING
 # ----------------------------------------------------
@@ -68,7 +75,6 @@ def web_search_scraper(query, num_results=5, user_address=None):
         params = {"engine": "google", "q": search_query, "api_key": serpapi_key, "num": num_results, "hl": "en", "gl": "in"}
         response = requests.get("https://serpapi.com/search", params=params, timeout=10)
         data = response.json()
-        
         if "organic_results" in data:
             for item in data["organic_results"]:
                 title = item.get("title", "")
@@ -128,7 +134,7 @@ def home():
         return f"<h1>System Error</h1><p>index.html missing: {str(e)}</p>"
 
 # ----------------------------------------------------
-# CHAT API ENDPOINT
+# CHAT API ENDPOINT (with TTS via remote endpoint)
 # ----------------------------------------------------
 @app.route('/api/chat', methods=['POST'])
 def chat():
@@ -239,6 +245,33 @@ STRICT DIRECTIVES:
         "stream": True
     }
 
+    tts_flag = data.get("tts", False)
+    if tts_flag:
+        payload["stream"] = False
+        try:
+            response = requests.post(INVOKE_URL, headers=headers, json=payload, timeout=60)
+            if response.status_code != 200:
+                return Response(json.dumps({"error": f"API Error {response.status_code}"}), status=500, mimetype='application/json')
+            resp_json = response.json()
+            full_text = resp_json['choices'][0]['message']['content']
+            clean_text = re.sub(r'<think>.*?</think>', '', full_text, flags=re.DOTALL).strip()
+            if not clean_text:
+                clean_text = full_text
+            voice_tts = data.get("voice", "M2")
+            lang_tts = data.get("language_name", "English")
+            audio_bytes, error = get_remote_tts(clean_text, voice=voice_tts, language=lang_tts)
+            if error:
+                return Response(json.dumps({"error": error}), status=500, mimetype='application/json')
+            return Response(
+                json.dumps({
+                    "text": full_text,
+                    "audio_base64": base64.b64encode(audio_bytes).decode('utf-8')
+                }),
+                mimetype='application/json'
+            )
+        except Exception as e:
+            return Response(json.dumps({"error": str(e)}), status=500, mimetype='application/json')
+
     try:
         response = requests.post(INVOKE_URL, headers=headers, json=payload, stream=True, timeout=60)
         if response.status_code != 200:
@@ -265,20 +298,16 @@ STRICT DIRECTIVES:
                             yield decoded + "\n\n"
                     else:
                         yield decoded + "\n\n"
-                        
         return Response(stream_with_context(generate()), mimetype='text/event-stream')
     except Exception as e:
         err_msg = json.dumps({"error": str(e)})
         return Response(f"data: {err_msg}\n\n", mimetype='text/event-stream')
 
 # ----------------------------------------------------
-# TTS DIRECT API ENDPOINT - MATCHING GRADIO SPACE LOGIC
+# TTS DIRECT API ENDPOINT (NOW REMOTE)
 # ----------------------------------------------------
 @app.route('/api/tts', methods=['POST'])
 def generate_tts():
-    if tts is None:
-        return Response(json.dumps({"error": "TTS model failed to load on server."}), status=500, mimetype='application/json')
-    
     data = request.get_json() or {}
     text = data.get("text", "")
     voice = data.get("voice", "M2")
@@ -287,32 +316,10 @@ def generate_tts():
     if not text.strip():
         return Response(json.dumps({"error": "Text is empty."}), status=400, mimetype='application/json')
 
-    try:
-        lang_code = LANGUAGES.get(language_name, "en")
-        # Get voice style (cached for efficiency)
-        if voice not in VOICE_STYLES_CACHE:
-            VOICE_STYLES_CACHE[voice] = tts.get_voice_style(voice_name=voice)
-        style = VOICE_STYLES_CACHE[voice]
-        if style is None:
-            return Response(json.dumps({"error": f"Voice '{voice}' not available."}), status=400, mimetype='application/json')
-        
-        # Synthesize - exactly like Gradio: raw text, no cleaning
-        wav, duration = tts.synthesize(text, voice_style=style, lang=lang_code)
-        
-        # Save to a temporary file using tts.save_audio (ensures correct WAV encoding)
-        with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp_file:
-            tmp_path = tmp_file.name
-        tts.save_audio(wav, tmp_path)
-        
-        # Read the WAV file and return it
-        with open(tmp_path, 'rb') as f:
-            audio_data = f.read()
-        os.unlink(tmp_path)  # clean up
-        
-        return Response(audio_data, mimetype="audio/wav")
-    except Exception as e:
-        print(f"TTS Synthesis Error: {e}")
-        return Response(json.dumps({"error": f"TTS synthesis failed: {str(e)}"}), status=500, mimetype='application/json')
+    audio_bytes, error = get_remote_tts(text, voice=voice, language=language_name)
+    if error:
+        return Response(json.dumps({"error": error}), status=500, mimetype='application/json')
+    return Response(audio_bytes, mimetype="audio/wav")
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860)