Update app.py

app.py

@@ -12,10 +12,11 @@ import soundfile as sf
 import torchaudio
 import wave
 import time
+import re
 from fastapi import FastAPI, HTTPException, UploadFile, File, Form, BackgroundTasks
 from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
-from typing import Dict, Any, Optional, Tuple
+from typing import Dict, Any, Optional, Tuple, List
 from datetime import datetime, timedelta
 
 # Configure logging
@@ -34,20 +35,12 @@ models_loaded = False
 loading_in_progress = False
 loading_thread = None
 model_status = {
-    "stt": "not_loaded",
+    "stt_mms": "not_loaded",
+    "stt_whisper_small": "not_loaded",
     "mt": "not_loaded",
-    "tts": "not_loaded"
+    "tts": {}  # Will store status for each language
 }
 error_message = None
-current_tts_language = "tgl"  # Track the current TTS language
-
-# Model instances
-stt_processor = None
-stt_model = None
-mt_model = None
-mt_tokenizer = None
-tts_model = None
-tts_tokenizer = None
 
 # Define the valid languages and mappings
 LANGUAGE_MAPPING = {
@@ -68,6 +61,31 @@ NLLB_LANGUAGE_CODES = {
     "pag": "pag_Latn"
 }
 
+# Model dictionaries for different languages
+stt_models = {
+    "mms": None,
+    "mms_processor": None,
+    "whisper_small": None,
+    "whisper_small_processor": None
+}
+
+mt_model = None
+mt_tokenizer = None
+
+tts_models = {}  # Will store models for each language
+tts_tokenizers = {}  # Will store tokenizers for each language
+
+# List of inappropriate words/phrases for content filtering
+INAPPROPRIATE_WORDS = [
+    "fuck", "shit", "asshole", "bitch", "dick", "pussy", "cunt", 
+    "whore", "slut", "bastard", "damn", "hell", "piss", "nigger", 
+    "faggot", "retard", "crap", "porn", "sex", "penis", "vagina",
+    # Tagalog inappropriate words
+    "puta", "putangina", "gago", "bobo", "tanga", "tarantado", 
+    "inutil", "ulol", "kantot", "jakol", "tite", "pekpek",
+    # Add more as needed
+]
+
 # Function to save PCM data as a WAV file
 def save_pcm_to_wav(pcm_data: list, sample_rate: int, output_path: str):
     # Convert pcm_data to a NumPy array of 16-bit integers
@@ -105,6 +123,53 @@ def detect_speech(waveform: torch.Tensor, sample_rate: int, threshold: float = 0
     # For now, we assume if RMS is above threshold, there is speech
     return True
 
+# Function to check for inappropriate content
+def check_inappropriate_content(text: str) -> bool:
+    """
+    Checks if the text contains inappropriate content.
+    Returns True if inappropriate content is detected, False otherwise.
+    """
+    # Convert text to lowercase for case-insensitive matching
+    text_lower = text.lower()
+    
+    # Check if any inappropriate word is in the text
+    for word in INAPPROPRIATE_WORDS:
+        # Use word boundary regex to match whole words only
+        pattern = r'\b' + re.escape(word) + r'\b'
+        if re.search(pattern, text_lower):
+            logger.warning(f"Inappropriate content detected: '{word}'")
+            return True
+    
+    return False
+
+# Function to perform text-to-speech conversion
+def text_to_speech(text: str, language_code: str) -> Tuple[Optional[np.ndarray], Optional[int], Optional[str]]:
+    """
+    Convert text to speech using the appropriate TTS model.
+    Returns the speech waveform, sample rate, and any error message.
+    """
+    if language_code not in tts_models or tts_models[language_code] is None:
+        error_msg = f"TTS model for {language_code} not loaded"
+        logger.error(error_msg)
+        return None, None, error_msg
+    
+    try:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        inputs = tts_tokenizers[language_code](text, return_tensors="pt").to(device)
+        
+        with torch.no_grad():
+            output = tts_models[language_code](**inputs)
+        
+        speech = output.waveform.cpu().numpy().squeeze()
+        speech = (speech * 32767).astype(np.int16)
+        sample_rate = tts_models[language_code].config.sampling_rate
+        
+        return speech, sample_rate, None
+    except Exception as e:
+        error_msg = f"Error during TTS conversion: {str(e)}"
+        logger.error(error_msg)
+        return None, None, error_msg
+
 # Function to clean up old audio files
 def cleanup_old_audio_files():
     logger.info("Starting cleanup of old audio files...")
@@ -129,38 +194,46 @@ def schedule_cleanup():
 # Function to load models in background
 def load_models_task():
     global models_loaded, loading_in_progress, model_status, error_message
-    global stt_processor, stt_model, mt_model, mt_tokenizer, tts_model, tts_tokenizer
+    global stt_models, mt_model, mt_tokenizer, tts_models, tts_tokenizers
     
     try:
         loading_in_progress = True
+        device = "cuda" if torch.cuda.is_available() else "cpu"
         
-        # Load STT model (MMS with fallback to Whisper)
-        logger.info("Starting to load STT model...")
-        from transformers import AutoProcessor, AutoModelForCTC, WhisperProcessor, WhisperForConditionalGeneration
+        # Load STT models (both MMS and Whisper)
+        logger.info("Starting to load STT models...")
         
+        # Load MMS STT model
         try:
             logger.info("Loading MMS STT model...")
-            model_status["stt"] = "loading"
-            stt_processor = AutoProcessor.from_pretrained("facebook/mms-1b-all")
-            stt_model = AutoModelForCTC.from_pretrained("facebook/mms-1b-all")
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-            stt_model.to(device)
+            model_status["stt_mms"] = "loading"
+            from transformers import AutoProcessor, AutoModelForCTC
+            
+            stt_models["mms_processor"] = AutoProcessor.from_pretrained("facebook/mms-1b-all")
+            stt_models["mms"] = AutoModelForCTC.from_pretrained("facebook/mms-1b-all")
+            stt_models["mms"].to(device)
             logger.info("MMS STT model loaded successfully")
-            model_status["stt"] = "loaded_mms"
+            model_status["stt_mms"] = "loaded"
         except Exception as mms_error:
             logger.error(f"Failed to load MMS STT model: {str(mms_error)}")
-            logger.info("Falling back to Whisper STT model...")
-            try:
-                stt_processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
-                stt_model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
-                stt_model.to(device)
-                logger.info("Whisper STT model loaded successfully as fallback")
-                model_status["stt"] = "loaded_whisper"
-            except Exception as whisper_error:
-                logger.error(f"Failed to load Whisper STT model: {str(whisper_error)}")
-                model_status["stt"] = "failed"
-                error_message = f"STT model loading failed: MMS error: {str(mms_error)}, Whisper error: {str(whisper_error)}"
-                return
+            model_status["stt_mms"] = "failed"
+            error_message = f"MMS STT model loading failed: {str(mms_error)}"
+        
+        # Load Whisper Small STT model
+        try:
+            logger.info("Loading Whisper Small STT model...")
+            model_status["stt_whisper_small"] = "loading"
+            from transformers import WhisperProcessor, WhisperForConditionalGeneration
+            
+            stt_models["whisper_small_processor"] = WhisperProcessor.from_pretrained("openai/whisper-small")
+            stt_models["whisper_small"] = WhisperForConditionalGeneration.from_pretrained("openai/whisper-small")
+            stt_models["whisper_small"].to(device)
+            logger.info("Whisper Small STT model loaded successfully")
+            model_status["stt_whisper_small"] = "loaded"
+        except Exception as whisper_error:
+            logger.error(f"Failed to load Whisper Small STT model: {str(whisper_error)}")
+            model_status["stt_whisper_small"] = "failed"
+            error_message = f"Whisper Small STT model loading failed: {str(whisper_error)}"
 
         # Load MT model
         logger.info("Starting to load MT model...")
@@ -178,40 +251,62 @@ def load_models_task():
             logger.error(f"Failed to load MT model: {str(e)}")
             model_status["mt"] = "failed"
             error_message = f"MT model loading failed: {str(e)}"
-            return
-
-        # Load TTS model (default to Tagalog, will be updated dynamically)
-        logger.info("Starting to load TTS model...")
+        
+        # Load TTS models for all supported languages
+        logger.info("Starting to load TTS models for all languages...")
         from transformers import VitsModel, AutoTokenizer
         
-        try:
-            logger.info("Loading MMS-TTS model for Tagalog...")
-            model_status["tts"] = "loading"
-            tts_model = VitsModel.from_pretrained("facebook/mms-tts-tgl")
-            tts_tokenizer = AutoTokenizer.from_pretrained("facebook/mms-tts-tgl")
-            tts_model.to(device)
-            logger.info("TTS model loaded successfully")
-            model_status["tts"] = "loaded"
-        except Exception as e:
-            logger.error(f"Failed to load TTS model for Tagalog: {str(e)}")
-            # Fallback to English TTS if the target language fails
+        for lang_name, lang_code in LANGUAGE_MAPPING.items():
             try:
-                logger.info("Falling back to MMS-TTS English model...")
-                tts_model = VitsModel.from_pretrained("facebook/mms-tts-eng")
-                tts_tokenizer = AutoTokenizer.from_pretrained("facebook/mms-tts-eng")
-                tts_model.to(device)
-                logger.info("Fallback TTS model loaded successfully")
-                model_status["tts"] = "loaded (fallback)"
-                current_tts_language = "eng"
-            except Exception as e2:
-                logger.error(f"Failed to load fallback TTS model: {str(e2)}")
-                model_status["tts"] = "failed"
-                error_message = f"TTS model loading failed: {str(e)} (fallback also failed: {str(e2)})"
-                return
+                logger.info(f"Loading MMS-TTS model for {lang_name} ({lang_code})...")
+                model_status["tts"][lang_code] = "loading"
+                
+                # Load the model and tokenizer
+                tts_models[lang_code] = VitsModel.from_pretrained(f"facebook/mms-tts-{lang_code}")
+                tts_tokenizers[lang_code] = AutoTokenizer.from_pretrained(f"facebook/mms-tts-{lang_code}")
+                
+                # Move to GPU if available
+                tts_models[lang_code].to(device)
+                
+                logger.info(f"TTS model for {lang_name} loaded successfully")
+                model_status["tts"][lang_code] = "loaded"
+            except Exception as e:
+                logger.error(f"Failed to load TTS model for {lang_name}: {str(e)}")
+                model_status["tts"][lang_code] = "failed"
+                
+                # Try to load English as fallback if this is not English
+                if lang_code != "eng":
+                    try:
+                        logger.info(f"Trying to load English TTS model as fallback for {lang_name}...")
+                        # Only load English model once if not already loaded
+                        if "eng" not in tts_models or tts_models["eng"] is None:
+                            tts_models["eng"] = VitsModel.from_pretrained("facebook/mms-tts-eng")
+                            tts_tokenizers["eng"] = AutoTokenizer.from_pretrained("facebook/mms-tts-eng")
+                            tts_models["eng"].to(device)
+                            model_status["tts"]["eng"] = "loaded"
+                        
+                        # Point this language to use English model
+                        tts_models[lang_code] = tts_models["eng"]
+                        tts_tokenizers[lang_code] = tts_tokenizers["eng"]
+                        model_status["tts"][lang_code] = "loaded (fallback to eng)"
+                    except Exception as e2:
+                        logger.error(f"Failed to load English fallback TTS model: {str(e2)}")
+                        model_status["tts"][lang_code] = "failed (with fallback)"
         
-        models_loaded = True
-        logger.info("Model loading completed successfully")
+        # Set models_loaded flag based on which critical models are loaded
+        # Consider the system usable if we have at least one STT model, the MT model, and at least one TTS model
+        stt_loaded = model_status["stt_mms"] == "loaded" or model_status["stt_whisper_small"] == "loaded"
+        mt_loaded = model_status["mt"] == "loaded"
+        any_tts_loaded = any(status == "loaded" or status.startswith("loaded (fallback") 
+                             for status in model_status["tts"].values())
         
+        models_loaded = stt_loaded and mt_loaded and any_tts_loaded
+        
+        if models_loaded:
+            logger.info("Critical models loaded successfully - system is ready")
+        else:
+            logger.warning("Some critical models failed to load - system may have limited functionality")
+            
     except Exception as e:
         error_message = str(e)
         logger.error(f"Error in model loading task: {str(e)}")
@@ -221,7 +316,7 @@ def load_models_task():
 # Start loading models in background
 def start_model_loading():
     global loading_thread, loading_in_progress
-    if not loading_in_progress and not models_loaded:
+    if not loading_in_progress:
         loading_in_progress = True
         loading_thread = threading.Thread(target=load_models_task)
         loading_thread.daemon = True
@@ -259,89 +354,61 @@ async def health_check():
         "error": error_message
     }
 
-@app.post("/update-languages")
-async def update_languages(source_lang: str = Form(...), target_lang: str = Form(...)):
-    global stt_processor, stt_model, tts_model, tts_tokenizer, current_tts_language
-    
-    if source_lang not in LANGUAGE_MAPPING or target_lang not in LANGUAGE_MAPPING:
+@app.post("/synthesize-speech")
+async def synthesize_speech(text: str = Form(...), language: str = Form(...)):
+    """Endpoint to synthesize speech from text without translation"""
+    if language not in LANGUAGE_MAPPING:
         raise HTTPException(status_code=400, detail="Invalid language selected")
     
-    source_code = LANGUAGE_MAPPING[source_lang]
-    target_code = LANGUAGE_MAPPING[target_lang]
+    logger.info(f"Speech synthesis requested for text in {language}")
+    request_id = str(uuid.uuid4())
+    language_code = LANGUAGE_MAPPING[language]
     
-    # Update the STT model based on the source language (MMS or Whisper)
-    try:
-        logger.info("Updating STT model for source language...")
-        from transformers import AutoProcessor, AutoModelForCTC, WhisperProcessor, WhisperForConditionalGeneration
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        
-        try:
-            logger.info(f"Loading MMS STT model for {source_code}...")
-            stt_processor = AutoProcessor.from_pretrained("facebook/mms-1b-all")
-            stt_model = AutoModelForCTC.from_pretrained("facebook/mms-1b-all")
-            stt_model.to(device)
-            # Set the target language for MMS
-            if source_code in stt_processor.tokenizer.vocab.keys():
-                stt_processor.tokenizer.set_target_lang(source_code)
-                stt_model.load_adapter(source_code)
-                logger.info(f"MMS STT model updated to {source_code}")
-                model_status["stt"] = "loaded_mms"
-            else:
-                logger.warning(f"Language {source_code} not supported by MMS, using default")
-                model_status["stt"] = "loaded_mms_default"
-        except Exception as mms_error:
-            logger.error(f"Failed to load MMS STT model for {source_code}: {str(mms_error)}")
-            logger.info("Falling back to Whisper STT model...")
-            try:
-                stt_processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
-                stt_model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
-                stt_model.to(device)
-                logger.info("Whisper STT model loaded successfully as fallback")
-                model_status["stt"] = "loaded_whisper"
-            except Exception as whisper_error:
-                logger.error(f"Failed to load Whisper STT model: {str(whisper_error)}")
-                model_status["stt"] = "failed"
-                error_message = f"STT model update failed: MMS error: {str(mms_error)}, Whisper error: {str(whisper_error)}"
-                return {"status": "failed", "error": error_message}
-    except Exception as e:
-        logger.error(f"Error updating STT model: {str(e)}")
-        model_status["stt"] = "failed"
-        error_message = f"STT model update failed: {str(e)}"
-        return {"status": "failed", "error": error_message}
+    # Check if the TTS model is loaded
+    if language_code not in tts_models or tts_models[language_code] is None:
+        return {
+            "request_id": request_id,
+            "status": "failed",
+            "message": f"TTS model for {language} not loaded yet",
+            "output_audio": None,
+            "is_inappropriate": False
+        }
     
-    # Update the TTS model based on the target language
-    try:
-        logger.info(f"Loading MMS-TTS model for {target_code}...")
-        from transformers import VitsModel, AutoTokenizer
-        tts_model = VitsModel.from_pretrained(f"facebook/mms-tts-{target_code}")
-        tts_tokenizer = AutoTokenizer.from_pretrained(f"facebook/mms-tts-{target_code}")
-        tts_model.to(device)
-        current_tts_language = target_code
-        logger.info(f"TTS model updated to {target_code}")
-        model_status["tts"] = "loaded"
-    except Exception as e:
-        logger.error(f"Failed to load TTS model for {target_code}: {str(e)}")
-        try:
-            logger.info("Falling back to MMS-TTS English model...")
-            tts_model = VitsModel.from_pretrained("facebook/mms-tts-eng")
-            tts_tokenizer = AutoTokenizer.from_pretrained("facebook/mms-tts-eng")
-            tts_model.to(device)
-            current_tts_language = "eng"
-            logger.info("Fallback TTS model loaded successfully")
-            model_status["tts"] = "loaded (fallback)"
-        except Exception as e2:
-            logger.error(f"Failed to load fallback TTS model: {str(e2)}")
-            model_status["tts"] = "failed"
-            error_message = f"TTS model loading failed: {str(e)} (fallback also failed: {str(e2)})"
-            return {"status": "failed", "error": error_message}
+    # Check for inappropriate content
+    is_inappropriate = check_inappropriate_content(text)
+    
+    # Generate speech
+    speech, sample_rate, error = text_to_speech(text, language_code)
+    
+    if error:
+        return {
+            "request_id": request_id,
+            "status": "failed",
+            "message": error,
+            "output_audio": None,
+            "is_inappropriate": is_inappropriate
+        }
     
-    logger.info(f"Updating languages: {source_lang} → {target_lang}")
-    return {"status": f"Languages updated to {source_lang} → {target_lang}"}
+    # Save the synthesized audio
+    output_filename = f"{request_id}.wav"
+    output_path = os.path.join(AUDIO_DIR, output_filename)
+    save_pcm_to_wav(speech.tolist(), sample_rate, output_path)
+    
+    # Generate URL to the WAV file
+    output_audio_url = f"https://jerich-talklasapp2.hf.space/audio_output/{output_filename}"
+    
+    return {
+        "request_id": request_id,
+        "status": "completed",
+        "message": "Speech synthesis completed",
+        "output_audio": output_audio_url,
+        "is_inappropriate": is_inappropriate
+    }
 
 @app.post("/translate-text")
 async def translate_text(text: str = Form(...), source_lang: str = Form(...), target_lang: str = Form(...)):
     """Endpoint to translate text and convert to speech"""
-    global mt_model, mt_tokenizer, tts_model, tts_tokenizer, current_tts_language
+    global mt_model, mt_tokenizer
     
     if not text:
         raise HTTPException(status_code=400, detail="No text provided")
@@ -376,55 +443,23 @@ async def translate_text(text: str = Form(...), source_lang: str = Form(...), ta
             translated_text = f"Translation failed: {str(e)}"
     else:
         logger.warning("MT model not loaded, skipping translation")
-
-    # Update TTS model if the target language doesn't match the current TTS language
-    if current_tts_language != target_code:
-        try:
-            logger.info(f"Updating TTS model for {target_code}...")
-            from transformers import VitsModel, AutoTokenizer
-            tts_model = VitsModel.from_pretrained(f"facebook/mms-tts-{target_code}")
-            tts_tokenizer = AutoTokenizer.from_pretrained(f"facebook/mms-tts-{target_code}")
-            tts_model.to(device)
-            current_tts_language = target_code
-            logger.info(f"TTS model updated to {target_code}")
-            model_status["tts"] = "loaded"
-        except Exception as e:
-            logger.error(f"Failed to load TTS model for {target_code}: {str(e)}")
-            try:
-                logger.info("Falling back to MMS-TTS English model...")
-                tts_model = VitsModel.from_pretrained("facebook/mms-tts-eng")
-                tts_tokenizer = AutoTokenizer.from_pretrained("facebook/mms-tts-eng")
-                tts_model.to(device)
-                current_tts_language = "eng"
-                logger.info("Fallback TTS model loaded successfully")
-                model_status["tts"] = "loaded (fallback)"
-            except Exception as e2:
-                logger.error(f"Failed to load fallback TTS model: {str(e2)}")
-                model_status["tts"] = "failed"
-
+    
+    # Check for inappropriate content in the translation
+    is_inappropriate = check_inappropriate_content(translated_text)
+    
     # Convert translated text to speech
+    speech, sample_rate, error = text_to_speech(translated_text, target_code)
+    
     output_audio_url = None
-    if model_status["tts"].startswith("loaded") and tts_model is not None and tts_tokenizer is not None:
-        try:
-            inputs = tts_tokenizer(translated_text, return_tensors="pt").to(device)
-            with torch.no_grad():
-                output = tts_model(**inputs)
-            speech = output.waveform.cpu().numpy().squeeze()
-            speech = (speech * 32767).astype(np.int16)
-            sample_rate = tts_model.config.sampling_rate
-
-            # Save the audio as a WAV file
-            output_filename = f"{request_id}.wav"
-            output_path = os.path.join(AUDIO_DIR, output_filename)
-            save_pcm_to_wav(speech.tolist(), sample_rate, output_path)
-            logger.info(f"Saved synthesized audio to {output_path}")
-
-            # Generate a URL to the WAV file
-            output_audio_url = f"https://jerich-talklasapp.hf.space/audio_output/{output_filename}"
-            logger.info("TTS conversion completed")
-        except Exception as e:
-            logger.error(f"Error during TTS conversion: {str(e)}")
-            output_audio_url = None
+    if speech is not None and sample_rate is not None:
+        # Save the audio as a WAV file
+        output_filename = f"{request_id}.wav"
+        output_path = os.path.join(AUDIO_DIR, output_filename)
+        save_pcm_to_wav(speech.tolist(), sample_rate, output_path)
+        
+        # Generate a URL to the WAV file
+        output_audio_url = f"https://jerich-talklasapp2.hf.space/audio_output/{output_filename}"
+        logger.info("TTS conversion completed")
     
     return {
         "request_id": request_id,
@@ -432,13 +467,14 @@ async def translate_text(text: str = Form(...), source_lang: str = Form(...), ta
         "message": "Translation and TTS completed (or partially completed).",
         "source_text": text,
         "translated_text": translated_text,
-        "output_audio": output_audio_url
+        "output_audio": output_audio_url,
+        "is_inappropriate": is_inappropriate
     }
 
 @app.post("/translate-audio")
 async def translate_audio(audio: UploadFile = File(...), source_lang: str = Form(...), target_lang: str = Form(...)):
     """Endpoint to transcribe, translate, and convert audio to speech"""
-    global stt_processor, stt_model, mt_model, mt_tokenizer, tts_model, tts_tokenizer, current_tts_language
+    global stt_models, mt_model, mt_tokenizer
     
     if not audio:
         raise HTTPException(status_code=400, detail="No audio file provided")
@@ -448,17 +484,38 @@ async def translate_audio(audio: UploadFile = File(...), source_lang: str = Form
     logger.info(f"Translate-audio requested: {audio.filename} from {source_lang} to {target_lang}")
     request_id = str(uuid.uuid4())
     
-    # Check if STT model is loaded
-    if model_status["stt"] not in ["loaded_mms", "loaded_mms_default", "loaded_whisper"] or stt_processor is None or stt_model is None:
-        logger.warning("STT model not loaded, returning placeholder response")
-        return {
-            "request_id": request_id,
-            "status": "processing",
-            "message": "STT model not loaded yet. Please try again later.",
-            "source_text": "Transcription not available",
-            "translated_text": "Translation not available",
-            "output_audio": None
-        }
+    # Check if appropriate STT model is loaded
+    source_code = LANGUAGE_MAPPING[source_lang]
+    use_whisper = source_code in ["eng", "tgl"]  # Use Whisper for English or Tagalog
+    
+    if use_whisper and (model_status["stt_whisper_small"] != "loaded" or stt_models["whisper_small"] is None):
+        logger.warning("Whisper Small STT model not loaded for English/Tagalog, checking MMS")
+        if model_status["stt_mms"] != "loaded" or stt_models["mms"] is None:
+            logger.warning("MMS STT model not loaded either, returning placeholder response")
+            return {
+                "request_id": request_id,
+                "status": "processing",
+                "message": "STT models not loaded yet. Please try again later.",
+                "source_text": "Transcription not available",
+                "translated_text": "Translation not available",
+                "output_audio": None,
+                "is_inappropriate": False
+            }
+        use_whisper = False  # Fall back to MMS
+    elif not use_whisper and (model_status["stt_mms"] != "loaded" or stt_models["mms"] is None):
+        logger.warning("MMS STT model not loaded for non-English/Tagalog, checking Whisper")
+        if model_status["stt_whisper_small"] != "loaded" or stt_models["whisper_small"] is None:
+            logger.warning("Whisper Small STT model not loaded either, returning placeholder response")
+            return {
+                "request_id": request_id,
+                "status": "processing",
+                "message": "STT models not loaded yet. Please try again later.",
+                "source_text": "Transcription not available",
+                "translated_text": "Translation not available",
+                "output_audio": None,
+                "is_inappropriate": False
+            }
+        use_whisper = True  # Fall back to Whisper
     
     # Save the uploaded audio to a temporary file
     with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
@@ -468,6 +525,7 @@ async def translate_audio(audio: UploadFile = File(...), source_lang: str = Form
     transcription = "Transcription not available"
     translated_text = "Translation not available"
     output_audio_url = None
+    is_inappropriate = False
     
     try:
         # Step 1: Load and resample the audio using torchaudio
@@ -490,29 +548,49 @@ async def translate_audio(audio: UploadFile = File(...), source_lang: str = Form
                 "message": "No speech detected in the audio.",
                 "source_text": "No speech detected",
                 "translated_text": "No translation available",
-                "output_audio": None
+                "output_audio": None,
+                "is_inappropriate": False
             }
 
         # Step 3: Transcribe the audio (STT)
         device = "cuda" if torch.cuda.is_available() else "cpu"
-        logger.info(f"Using device: {device}")
-        inputs = stt_processor(waveform.numpy(), sampling_rate=16000, return_tensors="pt").to(device)
-        logger.info("Audio processed, generating transcription...")
+        logger.info(f"Using device: {device} with {'Whisper' if use_whisper else 'MMS'} model")
         
-        with torch.no_grad():
-            if model_status["stt"] == "loaded_whisper":
-                # Whisper model
-                generated_ids = stt_model.generate(**inputs, language="en")
-                transcription = stt_processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
-            else:
-                # MMS model
-                logits = stt_model(**inputs).logits
+        if use_whisper:
+            # Use Whisper Small for English or Tagalog
+            logger.info("Using Whisper Small for transcription")
+            processor = stt_models["whisper_small_processor"]
+            model = stt_models["whisper_small"]
+            
+            inputs = processor(waveform.numpy()[0], sampling_rate=16000, return_tensors="pt").to(device)
+            with torch.no_grad():
+                # Use the language code for forced decoding if source is English or Tagalog
+                language = "en" if source_code == "eng" else "tl" if source_code == "tgl" else None
+                generated_ids = model.generate(
+                    **inputs, 
+                    language=language,
+                    task="transcribe"
+                )
+                transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        else:
+            # Use MMS for other languages
+            logger.info("Using MMS for transcription")
+            processor = stt_models["mms_processor"]
+            model = stt_models["mms"]
+            
+            if source_code in processor.tokenizer.vocab.keys():
+                processor.tokenizer.set_target_lang(source_code)
+                model.load_adapter(source_code)
+            
+            inputs = processor(waveform.numpy(), sampling_rate=16000, return_tensors="pt").to(device)
+            with torch.no_grad():
+                logits = model(**inputs).logits
                 predicted_ids = torch.argmax(logits, dim=-1)
-                transcription = stt_processor.batch_decode(predicted_ids)[0]
+                transcription = processor.batch_decode(predicted_ids)[0]
+        
         logger.info(f"Transcription completed: {transcription}")
 
         # Step 4: Translate the transcribed text (MT)
-        source_code = LANGUAGE_MAPPING[source_lang]
         target_code = LANGUAGE_MAPPING[target_lang]
         
         if model_status["mt"] == "loaded" and mt_model is not None and mt_tokenizer is not None:
@@ -535,53 +613,21 @@ async def translate_audio(audio: UploadFile = File(...), source_lang: str = Form
         else:
             logger.warning("MT model not loaded, skipping translation")
 
-        # Step 5: Update TTS model if the target language doesn't match the current TTS language
-        if current_tts_language != target_code:
-            try:
-                logger.info(f"Updating TTS model for {target_code}...")
-                from transformers import VitsModel, AutoTokenizer
-                tts_model = VitsModel.from_pretrained(f"facebook/mms-tts-{target_code}")
-                tts_tokenizer = AutoTokenizer.from_pretrained(f"facebook/mms-tts-{target_code}")
-                tts_model.to(device)
-                current_tts_language = target_code
-                logger.info(f"TTS model updated to {target_code}")
-                model_status["tts"] = "loaded"
-            except Exception as e:
-                logger.error(f"Failed to load TTS model for {target_code}: {str(e)}")
-                try:
-                    logger.info("Falling back to MMS-TTS English model...")
-                    tts_model = VitsModel.from_pretrained("facebook/mms-tts-eng")
-                    tts_tokenizer = AutoTokenizer.from_pretrained("facebook/mms-tts-eng")
-                    tts_model.to(device)
-                    current_tts_language = "eng"
-                    logger.info("Fallback TTS model loaded successfully")
-                    model_status["tts"] = "loaded (fallback)"
-                except Exception as e2:
-                    logger.error(f"Failed to load fallback TTS model: {str(e2)}")
-                    model_status["tts"] = "failed"
+        # Step 5: Check for inappropriate content in the translation
+        is_inappropriate = check_inappropriate_content(translated_text)
 
         # Step 6: Convert translated text to speech (TTS)
-        if model_status["tts"].startswith("loaded") and tts_model is not None and tts_tokenizer is not None:
-            try:
-                inputs = tts_tokenizer(translated_text, return_tensors="pt").to(device)
-                with torch.no_grad():
-                    output = tts_model(**inputs)
-                speech = output.waveform.cpu().numpy().squeeze()
-                speech = (speech * 32767).astype(np.int16)
-                sample_rate = tts_model.config.sampling_rate
-
-                # Save the audio as a WAV file
-                output_filename = f"{request_id}.wav"
-                output_path = os.path.join(AUDIO_DIR, output_filename)
-                save_pcm_to_wav(speech.tolist(), sample_rate, output_path)
-                logger.info(f"Saved synthesized audio to {output_path}")
-
-                # Generate a URL to the WAV file
-                output_audio_url = f"https://jerich-talklasapp.hf.space/audio_output/{output_filename}"
-                logger.info("TTS conversion completed")
-            except Exception as e:
-                logger.error(f"Error during TTS conversion: {str(e)}")
-                output_audio_url = None
+        speech, sample_rate, error = text_to_speech(translated_text, target_code)
+        
+        if speech is not None and sample_rate is not None:
+            # Save the audio as a WAV file
+            output_filename = f"{request_id}.wav"
+            output_path = os.path.join(AUDIO_DIR, output_filename)
+            save_pcm_to_wav(speech.tolist(), sample_rate, output_path)
+            
+            # Generate a URL to the WAV file
+            output_audio_url = f"https://jerich-talklasapp2.hf.space/audio_output/{output_filename}"
+            logger.info("TTS conversion completed")
         
         return {
             "request_id": request_id,
@@ -589,7 +635,8 @@ async def translate_audio(audio: UploadFile = File(...), source_lang: str = Form
             "message": "Transcription, translation, and TTS completed (or partially completed).",
             "source_text": transcription,
             "translated_text": translated_text,
-            "output_audio": output_audio_url
+            "output_audio": output_audio_url,
+            "is_inappropriate": is_inappropriate
         }
     except Exception as e:
         logger.error(f"Error during processing: {str(e)}")
@@ -599,7 +646,8 @@ async def translate_audio(audio: UploadFile = File(...), source_lang: str = Form
             "message": f"Processing failed: {str(e)}",
             "source_text": transcription,
             "translated_text": translated_text,
-            "output_audio": output_audio_url
+            "output_audio": output_audio_url,
+            "is_inappropriate": is_inappropriate
         }
     finally:
         logger.info(f"Cleaning up temporary file: {temp_path}")