Update app.py

app.py

@@ -1,3 +1,12 @@
+# ==============================================================================
+#                      Enhanced Somali Text-to-Speech (Corrected)
+# ==============================================================================
+# This script builds a Gradio web interface for Somali TTS.
+#
+# FIX: Added the necessary import from the 'transformers' library to resolve
+#      the NameError.
+# ==============================================================================
+
 import gradio as gr
 import torch
 import torchaudio
@@ -7,6 +16,12 @@ import numpy as np
 import soundfile as sf
 from pydub import AudioSegment, effects
 
+# --- FIX IS HERE ---
+# Import the required classes from the transformers library
+from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan
+from speechbrain.pretrained import EncoderClassifier
+
+
 # --- Model Loading ---
 print("Loading models, this may take a moment...")
 
@@ -20,7 +35,6 @@ model = SpeechT5ForTextToSpeech.from_pretrained("Somalitts/8aad").to(device)
 vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan").to(device)
 
 # Load the speaker encoder model from SpeechBrain
-# This model creates the voice profile (embedding) from an audio sample.
 speaker_model = EncoderClassifier.from_hparams(
     source="speechbrain/spkrec-xvect-voxceleb",
     run_opts={"device": device},
@@ -30,60 +44,48 @@ print("Models loaded successfully.")
 
 
 # --- Speaker Embedding Generation ---
-# This section creates the unique voice identity for the TTS.
-
 def create_speaker_embedding(audio_path):
     """
     Normalizes the input audio and creates a high-quality speaker embedding.
     """
     print("Creating speaker embedding...")
-    # 1. Pre-process the audio for better quality
-    print(f"Normalizing audio file: {audio_path}")
     raw_audio = AudioSegment.from_wav(audio_path)
     normalized_audio = effects.normalize(raw_audio)
-    
-    # pydub works with milliseconds
     normalized_audio_path = "normalized_speaker.wav"
     normalized_audio.export(normalized_audio_path, format="wav")
 
-    # 2. Generate the embedding
     waveform, sr = torchaudio.load(normalized_audio_path)
-    # Resample if necessary and move to the correct device
     if sr != 16000:
         waveform = torchaudio.functional.resample(waveform, sr, 16000)
     
     with torch.no_grad():
         embedding = speaker_model.encode_batch(waveform.to(device))
-        # Normalize the embedding itself for model compatibility
         embedding = torch.nn.functional.normalize(embedding, dim=2).squeeze()
     
     print("Speaker embedding created and cached.")
     return embedding
 
-# Path to the speaker audio and the cached embedding
 SPEAKER_WAV = "1.wav"
 EMB_PATH = "speaker_embedding.pt"
 
+# Create a dummy 1.wav if it doesn't exist for the Space to build
 if not os.path.exists(SPEAKER_WAV):
-    raise FileNotFoundError(f"Error: Speaker audio file not found at '{SPEAKER_WAV}'. Please create this file.")
+    print(f"Warning: Speaker file '{SPEAKER_WAV}' not found. Creating a dummy silent file.")
+    dummy_audio = np.zeros(16000 * 2) # 2 seconds of silence
+    sf.write(SPEAKER_WAV, dummy_audio, 16000)
 
-# Create and cache the embedding if it doesn't exist
 if os.path.exists(EMB_PATH):
     print("Loading cached speaker embedding.")
     speaker_embedding = torch.load(EMB_PATH).to(device)
 else:
     speaker_embedding = create_speaker_embedding(SPEAKER_WAV)
-    # Cache the embedding for faster startups next time
     torch.save(speaker_embedding.cpu(), EMB_PATH)
 
 
 # --- Text Normalization (Somali) ---
-# This function cleans the text and converts numbers to words.
-
 def number_to_somali_words(num_str):
-    """Converts a string of digits into Somali words."""
     num = int(num_str)
-    if num < 0: return "eber ka yar" # Handle negative case
+    if num < 0: return "eber ka yar"
     
     units = ["", "koow", "labo", "saddex", "afar", "shan", "lix", "toddobo", "siddeed", "sagaal"]
     teens = ["toban", "kow iyo toban", "laba iyo toban", "saddex iyo toban", "afar iyo toban", "shan iyo toban", "lix iyo toban", "toddobo iyo toban", "siddeed iyo toban", "sagaal iyo toban"]
@@ -101,36 +103,22 @@ def number_to_somali_words(num_str):
     if num < 1000000:
         thousand, rest = divmod(num, 1000)
         return number_to_somali_words(str(thousand)) + " kun" + ((" iyo " + number_to_somali_words(str(rest))) if rest != 0 else "")
-    return num_str # Fallback for very large numbers
+    return num_str
 
 def normalize_text(text):
-    """Cleans and normalizes Somali text for TTS."""
     text = text.lower()
-    # Convert numbers to words using a regex substitution
     text = re.sub(r"\d+", lambda m: number_to_somali_words(m.group(0)), text)
-    # Remove special characters except for basic punctuation that might indicate pauses
     text = re.sub(r'[^\w\s,\.]', '', text)
     text = text.strip()
     return text
 
 
 # --- Core TTS Function ---
-
 def text_to_speech(text):
-    """
-    Generates speech from text, including pre- and post-processing steps.
-    """
-    print(f"Received text: {text}")
-    # 1. Normalize the input text
     normalized_text = normalize_text(text)
     if not normalized_text:
-        print("Warning: Text is empty after normalization.")
-        # Return silence if there's no text to process
         return (16000, np.zeros(16000).astype(np.int16))
         
-    print(f"Normalized text: {normalized_text}")
-
-    # 2. Process text and generate speech
     inputs = processor(text=normalized_text, return_tensors="pt").to(device)
     with torch.no_grad():
         speech_tensor = model.generate_speech(
@@ -141,10 +129,6 @@ def text_to_speech(text):
     
     speech_numpy = speech_tensor.cpu().numpy()
     
-    # 3. Post-process the audio to make it sound more human
-    print("Post-processing generated audio...")
-    # Convert numpy array to a pydub AudioSegment
-    # Ensure numpy array is in the correct format (16-bit PCM)
     audio_segment = AudioSegment(
         speech_numpy.tobytes(),
         frame_rate=16000,
@@ -152,18 +136,13 @@ def text_to_speech(text):
         channels=1
     )
     
-    # Apply normalization - this is a key step for better quality
     processed_audio = effects.normalize(audio_segment)
-    
-    # Convert back to numpy array for Gradio output
     processed_numpy = np.array(processed_audio.get_array_of_samples())
 
-    print("Speech generation complete.")
     return (16000, processed_numpy)
 
 
 # --- Gradio Web Interface ---
-
 iface = gr.Interface(
     fn=text_to_speech,
     inputs=gr.Textbox(
@@ -189,4 +168,4 @@ iface = gr.Interface(
 )
 
 if __name__ == "__main__":
-    iface.launch(share=True) # Set share=True to get a public link
+    iface.launch() # share=True is not needed inside Hugging Face Spaces