Update app.py

app.py

@@ -1,106 +1,109 @@
 import os
+import torch
+import torchaudio
+import soundfile as sf
+from flask import Flask, request, jsonify, send_file
+from flask_cors import CORS
+from transformers import VitsModel, AutoTokenizer
 
-# Set ALL cache directories before importing any model libraries
+# Set environment variables for Hugging Face cache (prevents permission issues)
 os.environ["HUGGINGFACE_HUB_CACHE"] = "/tmp/huggingface_cache"
 os.environ["TRANSFORMERS_CACHE"] = "/tmp/transformers_cache"
 os.environ["HF_HOME"] = "/tmp/hf_home"
 os.environ["TORCH_HOME"] = "/tmp/torch_home"
 
-from flask import Flask, request, jsonify, send_file
-from flask_cors import CORS
-import torch
-import torchaudio
-import soundfile as sf
-from transformers import VitsModel, AutoTokenizer
-
 app = Flask(__name__)
-CORS(app)  # Allow Android requests
+CORS(app)  # Allow external requests
 
-# Set a writable directory for Hugging Face cache
-os.environ["HUGGINGFACE_HUB_CACHE"] = "/tmp/huggingface_cache"
-
-# Model paths for different languages (Hugging Face Hub)
+# Language models (Hugging Face)
 MODELS = {
     "kapampangan": "facebook/mms-tts-pam",
     "tagalog": "facebook/mms-tts-tgl",
     "english": "facebook/mms-tts-eng"
 }
 
-# Load models and processors
+# Model storage
 loaded_models = {}
 loaded_processors = {}
 
-for lang, path in MODELS.items():
+# Load models and processors
+for lang, model_path in MODELS.items():
     try:
-        print(f"Loading {lang} model from Hugging Face: {path}...")
-        loaded_models[lang] = VitsModel.from_pretrained(path)
-        loaded_processors[lang] = AutoTokenizer.from_pretrained(path)
-        print(f"{lang.capitalize()} model loaded successfully!")
+        print(f"🔄 Loading {lang} model: {model_path}...")
+        loaded_models[lang] = VitsModel.from_pretrained(model_path)
+        loaded_processors[lang] = AutoTokenizer.from_pretrained(model_path)
+        print(f"✅ {lang.capitalize()} model loaded successfully!")
     except Exception as e:
-        print(f"Error loading {lang} model: {str(e)}")
-        loaded_models[lang] = None  # Mark as unavailable
+        print(f"❌ Error loading {lang} model: {e}")
+        loaded_models[lang] = None
         loaded_processors[lang] = None
 
-SAMPLE_RATE = 16000  # Default sample rate
-OUTPUT_DIR = "/tmp/"  # Use /tmp for Hugging Face Spaces (limited storage)
+# Constants
+SAMPLE_RATE = 16000
+OUTPUT_DIR = "/tmp/"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 @app.route("/", methods=["GET"])
 def home():
-    """ Root route to check if the server is running """
+    """ Root route to check if the API is running """
     return jsonify({"message": "TTS API is running. Use /tts to generate speech."})
 
 @app.route("/tts", methods=["POST"])
 def generate_tts():
-    """ API endpoint to generate speech based on the selected language. """
-    data = request.get_json()
-    text_input = data.get("text", "").strip()
-    language = data.get("language", "kapampangan").lower()
+    """ API endpoint to generate TTS audio """
+    try:
+        # Get request data
+        data = request.get_json()
+        text_input = data.get("text", "").strip()
+        language = data.get("language", "kapampangan").lower()
 
-    if language not in MODELS:
-        return jsonify({"error": "Invalid language. Choose 'kapampangan', 'tagalog', or 'english'."}), 400
+        # Validate inputs
+        if language not in MODELS:
+            return jsonify({"error": "Invalid language. Choose 'kapampangan', 'tagalog', or 'english'."}), 400
 
-    if not text_input:
-        return jsonify({"error": "No text provided"}), 400
+        if not text_input:
+            return jsonify({"error": "No text provided"}), 400
 
-    if loaded_models[language] is None:
-        return jsonify({"error": f"Model for {language} failed to load"}), 500
+        if loaded_models[language] is None:
+            return jsonify({"error": f"Model for {language} failed to load"}), 500
 
-    print(f"Generating speech for: '{text_input}' in {language}")
+        print(f"🔄 Generating speech for '{text_input}' in {language}...")
 
-    try:
-        # Select the correct model and processor
-        model = loaded_models[language]
+        # Process text input
         processor = loaded_processors[language]
-
-        # Tokenize input text
+        model = loaded_models[language]
         inputs = processor(text_input, return_tensors="pt")
 
-        # Generate audio
+        # Generate speech
         with torch.no_grad():
             output = model.generate(**inputs)
 
         waveform = output.cpu().numpy().flatten()
 
-        # Save as WAV file
+        # Save to file
         output_filename = os.path.join(OUTPUT_DIR, f"{language}_output.wav")
         sf.write(output_filename, waveform, SAMPLE_RATE)
 
+        print(f"✅ Speech generated! File saved: {output_filename}")
+
         return jsonify({
             "message": "TTS audio generated",
-            "file_url": f"/static/{language}_output.wav"
+            "file_url": f"/download/{language}_output.wav"
         })
+
     except Exception as e:
-        print(f"Error generating TTS: {str(e)}")
+        print(f"❌ Error generating TTS: {e}")
         return jsonify({"error": "Internal server error"}), 500
 
-@app.route("/static/<filename>")
-def serve_audio(filename):
-    """ Serve the generated WAV file. """
+@app.route("/download/<filename>", methods=["GET"])
+def download_audio(filename):
+    """ Serve generated audio files """
     file_path = os.path.join(OUTPUT_DIR, filename)
     if os.path.exists(file_path):
-        return send_file(file_path, mimetype="audio/wav")
+        return send_file(file_path, mimetype="audio/wav", as_attachment=True)
     return jsonify({"error": "File not found"}), 404
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860, debug=True)
 
+