Update app.py

app.py

@@ -14,14 +14,12 @@ from TTS.tts.configs.xtts_config import XttsConfig
 from TTS.tts.models.xtts import Xtts
 from vinorm import TTSnorm
 
-# download for mecab
-# os.system("python -m unidic download")
-
+# Initialize Hugging Face API
 HF_TOKEN = os.environ.get("HF_TOKEN")
 api = HfApi(token=HF_TOKEN)
 
-# This will trigger downloading model
-print("Downloading if not downloaded viXTTS")
+# Download model files if not already downloaded
+print("Downloading viXTTS model files if not already present...")
 checkpoint_dir = "model/"
 repo_id = "capleaf/viXTTS"
 use_deepspeed = False
@@ -42,6 +40,7 @@ if not all(file in files_in_dir for file in required_files):
         local_dir=checkpoint_dir,
     )
 
+# Load model configuration and initialize model
 xtts_config = os.path.join(checkpoint_dir, "config.json")
 config = XttsConfig()
 config.load_json(xtts_config)
@@ -52,8 +51,9 @@ MODEL.load_checkpoint(
 if torch.cuda.is_available():
     MODEL.cuda()
 
+# Supported languages
 supported_languages = config.languages
-if not "vi" in supported_languages:
+if "vi" not in supported_languages:
     supported_languages.append("vi")
 
 
@@ -74,7 +74,6 @@ def normalize_vietnamese_text(text):
 
 
 def calculate_keep_len(text, lang):
-    """Simple hack for short sentences"""
     if lang in ["ja", "zh-cn"]:
         return -1
 
@@ -88,52 +87,39 @@ def calculate_keep_len(text, lang):
     return -1
 
 
-def predict(
-    prompt,
-    language,
-    audio_file_pth,
-    normalize_text=True,
-):
+def predict(prompt, language, audio_file_pth, normalize_text=True):
     if language not in supported_languages:
         metrics_text = gr.Warning(
-            f"Language you put {language} in is not in is not in our Supported Languages, please choose from dropdown"
+            f"Language {language} is not supported. Please choose from the dropdown."
         )
-
-        return (None, metrics_text)
-
-    speaker_wav = audio_file_pth
+        return None, metrics_text
 
     if len(prompt) < 2:
-        metrics_text = gr.Warning("Please give a longer prompt text")
-        return (None, metrics_text)
+        metrics_text = gr.Warning("Please provide a longer prompt text.")
+        return None, metrics_text
+
     try:
         metrics_text = ""
         t_latent = time.time()
 
         try:
-            (
-                gpt_cond_latent,
-                speaker_embedding,
-            ) = MODEL.get_conditioning_latents(
-                audio_path=speaker_wav,
+            gpt_cond_latent, speaker_embedding = MODEL.get_conditioning_latents(
+                audio_path=audio_file_pth,
                 gpt_cond_len=30,
                 gpt_cond_chunk_len=4,
                 max_ref_length=60,
             )
-
         except Exception as e:
-            print("Speaker encoding error", str(e))
-            metrics_text = gr.Warning(
-                "It appears something wrong with reference, did you unmute your microphone?"
-            )
-            return (None, metrics_text)
+            print("Speaker encoding error:", str(e))
+            metrics_text = gr.Warning("Error with reference audio.")
+            return None, metrics_text
 
-        prompt = re.sub("([^\x00-\x7F]|\w)(\.|\。|\?)", r"\1 \2\2", prompt)
+        prompt = re.sub("([^\x00-\x7F]|\w)(\.|\。|\?)", r"\1 \2", prompt)
 
         if normalize_text and language == "vi":
             prompt = normalize_vietnamese_text(prompt)
 
-        print("I: Generating new audio...")
+        print("Generating new audio...")
         t0 = time.time()
         out = MODEL.inference(
             prompt,
@@ -145,100 +131,30 @@ def predict(
             enable_text_splitting=True,
         )
         inference_time = time.time() - t0
-        print(f"I: Time to generate audio: {round(inference_time*1000)} milliseconds")
-        metrics_text += (
-            f"Time to generate audio: {round(inference_time*1000)} milliseconds\n"
-        )
+        metrics_text += f"Time to generate audio: {round(inference_time * 1000)} ms\n"
         real_time_factor = (time.time() - t0) / out["wav"].shape[-1] * 24000
-        print(f"Real-time factor (RTF): {real_time_factor}")
         metrics_text += f"Real-time factor (RTF): {real_time_factor:.2f}\n"
 
-        # Temporary hack for short sentences
         keep_len = calculate_keep_len(prompt, language)
         out["wav"] = out["wav"][:keep_len]
 
         torchaudio.save("output.wav", torch.tensor(out["wav"]).unsqueeze(0), 24000)
 
     except RuntimeError as e:
-        if "device-side assert" in str(e):
-            # cannot do anything on cuda device side error, need tor estart
-            print(
-                f"Exit due to: Unrecoverable exception caused by language:{language} prompt:{prompt}",
-                flush=True,
-            )
-            gr.Warning("Unhandled Exception encounter, please retry in a minute")
-            print("Cuda device-assert Runtime encountered need restart")
-
-            error_time = datetime.datetime.now().strftime("%d-%m-%Y-%H:%M:%S")
-            error_data = [
-                error_time,
-                prompt,
-                language,
-                audio_file_pth,
-            ]
-            error_data = [str(e) if type(e) != str else e for e in error_data]
-            print(error_data)
-            print(speaker_wav)
-            write_io = StringIO()
-            csv.writer(write_io).writerows([error_data])
-            csv_upload = write_io.getvalue().encode()
-
-            filename = error_time + "_" + str(uuid.uuid4()) + ".csv"
-            print("Writing error csv")
-            error_api = HfApi()
-            error_api.upload_file(
-                path_or_fileobj=csv_upload,
-                path_in_repo=filename,
-                repo_id="coqui/xtts-flagged-dataset",
-                repo_type="dataset",
-            )
-
-            # speaker_wav
-            print("Writing error reference audio")
-            speaker_filename = error_time + "_reference_" + str(uuid.uuid4()) + ".wav"
-            error_api = HfApi()
-            error_api.upload_file(
-                path_or_fileobj=speaker_wav,
-                path_in_repo=speaker_filename,
-                repo_id="coqui/xtts-flagged-dataset",
-                repo_type="dataset",
-            )
+        print("RuntimeError:", str(e))
+        metrics_text = gr.Warning("An error occurred during processing.")
+        return None, metrics_text
 
-            # HF Space specific.. This error is unrecoverable need to restart space
-            space = api.get_space_runtime(repo_id=repo_id)
-            if space.stage != "BUILDING":
-                api.restart_space(repo_id=repo_id)
-            else:
-                print("TRIED TO RESTART but space is building")
-
-        else:
-            if "Failed to decode" in str(e):
-                print("Speaker encoding error", str(e))
-                metrics_text = gr.Warning(
-                    metrics_text="It appears something wrong with reference, did you unmute your microphone?"
-                )
-            else:
-                print("RuntimeError: non device-side assert error:", str(e))
-                metrics_text = gr.Warning(
-                    "Something unexpected happened please retry again."
-                )
-            return (None, metrics_text)
-    return ("output.wav", metrics_text)
+    return "output.wav", metrics_text
 
 
 title = "viXTTS Demo"
 
-
 with gr.Blocks(analytics_enabled=False) as demo:
     with gr.Row():
         with gr.Column():
-            gr.Markdown(
-                """
-                viXTTS Demo
-                """
-            )
+            gr.Markdown("## viXTTS Demo")
         with gr.Column():
-            # placeholder to align the image
             pass
 
     with gr.Row():
@@ -251,33 +167,13 @@ with gr.Blocks(analytics_enabled=False) as demo:
             language_gr = gr.Dropdown(
                 label="Language",
                 info="Select an output language for the synthesised speech",
-                choices=[
-                    "vi",
-                    "en",
-                    "es",
-                    "fr",
-                    "de",
-                    "it",
-                    "pt",
-                    "pl",
-                    "tr",
-                    "ru",
-                    "nl",
-                    "cs",
-                    "ar",
-                    "zh-cn",
-                    "ja",
-                    "ko",
-                    "hu",
-                    "hi",
-                ],
-                max_choices=1,
+                choices=supported_languages,
                 value="vi",
             )
             normalize_text = gr.Checkbox(
                 label="Normalize Vietnamese Text",
                 info="Normalize Vietnamese Text",
-                default=True,
+                value=True,
             )
             ref_gr = gr.Audio(
                 label="Reference Audio",
@@ -289,19 +185,14 @@ with gr.Blocks(analytics_enabled=False) as demo:
 
         with gr.Column():
             audio_gr = gr.Audio(label="Synthesised Audio", autoplay=True)
-            out_text_gr = gr.Text(label="Metrics")
+            out_text_gr = gr.Textbox(label="Metrics")
 
     tts_button.click(
         predict,
-        [
-            input_text_gr,
-            language_gr,
-            ref_gr,
-            normalize_text,
-        ],
+        [input_text_gr, language_gr, ref_gr, normalize_text],
         outputs=[audio_gr, out_text_gr],
         api_name="predict",
     )
 
 demo.queue()
-demo.launch(debug=True, show_api=True, share=True)
+demo.launch(debug=True, show_api=True)