Update inference_gradio.py

inference_gradio.py

@@ -12,9 +12,7 @@ import torchaudio
 import soundfile as sf
 from pathlib import Path
 
-from cached_path import cached_path
-
-from lemas_tts.api import TTS
+from lemas_tts.api import TTS, PRETRAINED_ROOT, CKPTS_ROOT
 
 # Global variables
 tts_api = None
@@ -34,21 +32,15 @@ device = (
 )
 
 REPO_ROOT = Path(__file__).resolve().parent
-# Local pretrained root (used when running from a repo / Space that bundles weights)
-# PRETRAINED_ROOT = str(REPO_ROOT / "pretrained_models")
-
-# HF location for pretrained assets (used as a fallback when local files are missing)
-PRETRAINED_ROOT = "hf://LEMAS-Project/LEMAS-TTS/pretrained_models"
-CKPTS_ROOT = os.path.join(PRETRAINED_ROOT, "ckpts")
 
-# 1) 指向你仓库里的 libespeak-ng.so
-ESPEAK_LIB = os.path.join(PRETRAINED_ROOT, "espeak-ng-lib", "libespeak-ng.so")
+# 1) 指向 `pretrained_models` 里的 libespeak-ng.so（本地路径）
+ESPEAK_LIB = Path(PRETRAINED_ROOT) / "espeak-ng-lib" / "libespeak-ng.so"
 os.environ["PHONEMIZER_ESPEAK_LIBRARY"] = str(ESPEAK_LIB)
 
-# 2) 指向你仓库里的 espeak-ng-data
-ESPEAK_DATA_DIR = os.path.join(PRETRAINED_ROOT, "espeak-ng-data")
-os.environ["ESPEAK_DATA_PATH"] = ESPEAK_DATA_DIR
-os.environ["ESPEAKNG_DATA_PATH"] = ESPEAK_DATA_DIR
+# 2) 指向 `pretrained_models` 里的 espeak-ng-data（本地路径）
+ESPEAK_DATA_DIR = Path(PRETRAINED_ROOT) / "espeak-ng-data"
+os.environ["ESPEAK_DATA_PATH"] = str(ESPEAK_DATA_DIR)
+os.environ["ESPEAKNG_DATA_PATH"] = str(ESPEAK_DATA_DIR)
 
 
 class UVR5:
@@ -68,7 +60,8 @@ class UVR5:
 
         model_path = os.path.join(model_dir, "Kim_Vocal_1.onnx")
         config_path = os.path.join(model_dir, "MDX-Net-Kim-Vocal1.json")
-        configs = json.loads(open(config_path, "r", encoding="utf-8").read())
+        with open(config_path, "r", encoding="utf-8") as f:
+            configs = json.load(f)
         model_data = ModelData(
             model_path=model_path,
             audio_path=model_dir,
@@ -90,8 +83,8 @@ class UVR5:
         return output_audio.squeeze().T.numpy(), 44100
 
 denoise_model = UVR5(
-    model_dir=cached_path(os.path.join(PRETRAINED_ROOT, "uvr5")),
-    code_dir=cached_path(str(REPO_ROOT / "uvr5")),
+    model_dir=str(Path(PRETRAINED_ROOT) / "uvr5"),
+    code_dir=str(REPO_ROOT / "uvr5"),
 )
 
 def load_wav(audio_info, sr=16000, channel=1):
@@ -124,11 +117,6 @@ def cancel_denoise(audio_info):
 def get_checkpoints_project(project_name=None, is_gradio=True):
     """Get available checkpoint files"""
     checkpoint_dir = [str(CKPTS_ROOT)]
-    # Remote ckpt locations on HF (used if local ckpts are not present)
-    remote_ckpts = {
-        "multilingual_grl": f"{PRETRAINED_ROOT}/ckpts/multilingual_grl/multilingual_grl.safetensors",
-        "multilingual_prosody": f"{PRETRAINED_ROOT}/ckpts/multilingual_prosody/multilingual_prosody.safetensors",
-    }
 
     if project_name is None:
         # Look for checkpoints in local directory
@@ -138,16 +126,12 @@ def get_checkpoints_project(project_name=None, is_gradio=True):
                 files_checkpoints.extend(glob(os.path.join(path, "**/*.pt"), recursive=True))
                 files_checkpoints.extend(glob(os.path.join(path, "**/*.safetensors"), recursive=True))
                 break
-        # Fallback: use HF ckpts
-        if not files_checkpoints:
-            files_checkpoints = list(remote_ckpts.values())
     else:
         if os.path.isdir(checkpoint_dir[0]):
             files_checkpoints = glob(os.path.join(checkpoint_dir[0], project_name, "*.pt"))
             files_checkpoints.extend(glob(os.path.join(checkpoint_dir[0], project_name, "*.safetensors")))
         else:
-            ckpt = remote_ckpts.get(project_name)
-            files_checkpoints = [ckpt] if ckpt is not None else []
+            files_checkpoints = []
     print("files_checkpoints:", project_name, files_checkpoints)
     # Separate pretrained and regular checkpoints
     pretrained_checkpoints = [f for f in files_checkpoints if "pretrained_" in os.path.basename(f)]
@@ -180,7 +164,7 @@ def get_checkpoints_project(project_name=None, is_gradio=True):
 def get_available_projects():
     """Get available project names from data directory"""
     data_paths = [
-        cached_path(str(PRETRAINED_ROOT / "data")),
+        str(Path(PRETRAINED_ROOT) / "data"),
     ]
     
     project_list = []
@@ -204,16 +188,9 @@ def infer(
 ):
     global last_checkpoint, last_device, tts_api, last_ema
 
-    # Resolve checkpoint path (local or HF)
+    # Resolve checkpoint path (local or HF-style, though we now rely on local PRETRAINED_ROOT)
     ckpt_path = file_checkpoint
-    if isinstance(ckpt_path, str) and ckpt_path.startswith("hf://"):
-        try:
-            ckpt_resolved = str(cached_path(ckpt_path))
-        except Exception as e:
-            traceback.print_exc()
-            return None, f"Error downloading checkpoint: {str(e)}", ""
-    else:
-        ckpt_resolved = ckpt_path
+    ckpt_resolved = ckpt_path
 
     if not os.path.isfile(ckpt_resolved):
         return None, "Checkpoint not found!", ""
@@ -236,39 +213,19 @@ def infer(
         # Automatically enable prosody encoder when using the prosody checkpoint
         use_prosody_encoder = True if "prosody" in str(ckpt_resolved) else False
 
-        # Resolve vocab file (local or HF)
-        local_vocab = cached_path(str(PRETRAINED_ROOT / "data" / project / "vocab.txt"))
-        if local_vocab.is_file():
-            vocab_file = str(local_vocab)
-        else:
-            remote_vocab_map = {
-                "multilingual_grl": cached_path(f"{PRETRAINED_ROOT}/data/multilingual_grl/vocab.txt"),
-                "multilingual_prosody": cached_path(f"{PRETRAINED_ROOT}/data/multilingual_prosody/vocab.txt"),
-            }
-            remote_vocab = remote_vocab_map.get(project)
-            if remote_vocab is None:
-                return None, "Vocab file not found!", ""
-            try:
-                vocab_file = str(cached_path(remote_vocab))
-            except Exception as e:
-                traceback.print_exc()
-                return None, f"Error downloading vocab: {str(e)}", ""
-
-        # Resolve prosody encoder config & weights
-        local_prosody_cfg = CKPTS_ROOT / "prosody_encoder" / "pretssel_cfg.json"
-        local_prosody_ckpt = CKPTS_ROOT / "prosody_encoder" / "prosody_encoder_UnitY2.pt"
-        if local_prosody_cfg.is_file():
-            prosody_cfg_path = str(local_prosody_cfg)
-        else:
-            prosody_cfg_path = str(
-                cached_path(f"{PRETRAINED_ROOT}/ckpts/prosody_encoder/pretssel_cfg.json")
-            )
-        if local_prosody_ckpt.is_file():
-            prosody_ckpt_path = str(local_prosody_ckpt)
-        else:
-            prosody_ckpt_path = str(
-                cached_path(f"{PRETRAINED_ROOT}/ckpts/prosody_encoder/prosody_encoder_UnitY2.pt")
-            )
+        # Resolve vocab file (local)
+        local_vocab = Path(PRETRAINED_ROOT) / "data" / project / "vocab.txt"
+        if not local_vocab.is_file():
+            return None, "Vocab file not found!", ""
+        vocab_file = str(local_vocab)
+
+        # Resolve prosody encoder config & weights (local)
+        local_prosody_cfg = Path(CKPTS_ROOT) / "prosody_encoder" / "pretssel_cfg.json"
+        local_prosody_ckpt = Path(CKPTS_ROOT) / "prosody_encoder" / "prosody_encoder_UnitY2.pt"
+        if not local_prosody_cfg.is_file() or not local_prosody_ckpt.is_file():
+            return None, "Prosody encoder files not found!", ""
+        prosody_cfg_path = str(local_prosody_cfg)
+        prosody_ckpt_path = str(local_prosody_ckpt)
 
         try:
             tts_api = TTS(
@@ -481,16 +438,8 @@ with gr.Blocks(title="LEMAS-TTS Inference") as app:
 
     # Examples
     def _resolve_example(name: str) -> str:
-        local = cached_path(os.path.join(PRETRAINED_ROOT, "data", "test_examples", name))
-        if os.path.isfile(local):
-            return local
-        remote_map = {
-            "en.wav": cached_path(os.path.join(PRETRAINED_ROOT, "data", "test_examples", "en.wav")),
-            "es.wav": cached_path(os.path.join(PRETRAINED_ROOT, "data", "test_examples", "es.wav")),
-            "pt.wav": cached_path(os.path.join(PRETRAINED_ROOT, "data", "test_examples", "pt.wav")),
-        }
-        url = remote_map.get(name)
-        return str(cached_path(url)) if url is not None else ""
+        local = Path(PRETRAINED_ROOT) / "data" / "test_examples" / name
+        return str(local) if local.is_file() else ""
 
     examples = gr.Examples(
         examples=[
@@ -598,7 +547,7 @@ def main(port, host, share, api):
         server_port=port,
         share=share,
         show_api=api,
-        allowed_paths=[str(cached_path(os.path.join(PRETRAINED_ROOT, "data")))],
+        allowed_paths=[str(Path(PRETRAINED_ROOT) / "data")],
     )