feat: persist voice profiles to Voice_Profile/ with auto-load on startup

Voice profile persistence:
- Profiles saved to Voice_Profile/<id>/profile.pt + metadata.json on clone
- On app startup, most recent profile auto-loaded as default voice
- voice_profile_state initialized with saved profile (or None for stock)
- synthesize_cloned() falls back to disk if not in memory cache
- has_profile() checks both memory cache and disk
- create_voice_profile() now accepts voice_name param for metadata
- Player shows actual cloned voice name (from metadata) instead of generic label

New APIs in voice_clone.py:
- save_profile_to_disk(profile_id, voice_name) -> Path
- load_profile_from_disk(profile_id) -> bool
- list_saved_profiles() -> list[dict]
- load_default_profile() -> str | None

Voice_Profile/ added to .gitignore (user data).
102 tests pass (28 latency/persistence + 74 integration).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

.gitignore

@@ -1,2 +1,3 @@
 __pycache__/
 sample_sounds/
+Voice_Profile/

app.py

@@ -9,6 +9,7 @@ from pathlib import Path
 
 from tts import split_into_chunks, generate_audio_stream
 from inference import transcribe_audio, answer_story_question
+from voice_clone import load_default_profile, list_saved_profiles
 
 # Create directories for sample audio files
 os.makedirs("sample_sounds", exist_ok=True)
@@ -337,6 +338,20 @@ def render_cloned_voices_html(voices_list):
     return markup
 
 
+# Load default voice profile from Voice_Profile/ (if any saved from previous sessions)
+_default_profile_id = load_default_profile()
+_saved_profiles = list_saved_profiles()
+if _default_profile_id:
+    _default_voice_name = next(
+        (p["voice_name"] for p in _saved_profiles if p["profile_id"] == _default_profile_id),
+        "Cloned Voice"
+    )
+    print(f"[VoiceBook] Default voice profile loaded: {_default_profile_id} ({_default_voice_name})")
+else:
+    _default_voice_name = None
+    print("[VoiceBook] No saved voice profile — using stock voice as default.")
+
+
 # Gradio Application Core setup
 with gr.Blocks(title="VoiceBook Gradio Hub") as demo:
 
@@ -344,7 +359,7 @@ with gr.Blocks(title="VoiceBook Gradio Hub") as demo:
     voices_state = gr.State(mock_voices)
     paragraphs_state = gr.State([])
     tts_chunks_state = gr.State([])
-    voice_profile_state = gr.State(None)
+    voice_profile_state = gr.State(_default_profile_id)
 
     gr.HTML("""
     <div style="display: flex; align-items: center; justify-content: space-between; padding: 16px 0; border-bottom: 1px solid #ebdccb; margin-bottom: 24px; flex-wrap: wrap; gap: 16px;">
@@ -589,9 +604,14 @@ with gr.Blocks(title="VoiceBook Gradio Hub") as demo:
         selected = next((b for b in current_inventory if b["title"] == title_chosen), current_inventory[0])
 
         # Show cloned voice name if profile exists
-        from voice_clone import has_profile
+        from voice_clone import has_profile, list_saved_profiles as _list_profiles
         if profile_id and has_profile(profile_id):
-            narrator_label = "🎙️ Your Cloned Voice"
+            saved = _list_profiles()
+            voice_label = next(
+                (p["voice_name"] for p in saved if p["profile_id"] == profile_id),
+                "Cloned Voice"
+            )
+            narrator_label = f"🎙️ {voice_label}"
             narrator_color = "#4ade80"
         else:
             narrator_label = f"🔊 {selected['voice_name']} (stock)"
@@ -668,7 +688,7 @@ with gr.Blocks(title="VoiceBook Gradio Hub") as demo:
         import soundfile as sf
 
         progress(0.1, desc="Extracting speaker embedding from recording...")
-        profile_id = create_voice_profile(recorder_data)
+        profile_id = create_voice_profile(recorder_data, voice_name=v_name.strip())
 
         progress(0.7, desc="Generating voice preview...")
         try:

test_modules/test_latency_optimizations.py

@@ -169,6 +169,58 @@ def test_tts_module_imports():
           "voice_profile_id" in params, f"params: {params}")
 
 
+def test_voice_profile_persistence():
+    print("\n=== Voice profile persistence ===")
+    from voice_clone import (
+        VOICE_PROFILE_DIR, list_saved_profiles, load_default_profile,
+        has_profile, save_profile_to_disk, load_profile_from_disk,
+        _PROFILE_CACHE, _cache_lock,
+    )
+    import inspect
+
+    check("VOICE_PROFILE_DIR exists", VOICE_PROFILE_DIR.exists(),
+          str(VOICE_PROFILE_DIR))
+    check("VOICE_PROFILE_DIR is named Voice_Profile",
+          VOICE_PROFILE_DIR.name == "Voice_Profile")
+
+    # Verify API signatures
+    sig_create = inspect.signature(
+        __import__('voice_clone').create_voice_profile
+    )
+    check("create_voice_profile accepts voice_name",
+          "voice_name" in sig_create.parameters,
+          f"params: {list(sig_create.parameters)}")
+
+    check("list_saved_profiles returns a list",
+          isinstance(list_saved_profiles(), list))
+
+    # load_default_profile returns None when no profiles saved
+    # (since Voice_Profile/ might have profiles from prior runs, just check type)
+    result = load_default_profile()
+    check("load_default_profile returns str or None",
+          result is None or isinstance(result, str), f"got {type(result)}")
+
+    # has_profile checks disk too
+    check("has_profile('nonexistent') is False", has_profile("nonexistent") is False)
+
+
+def test_app_default_profile():
+    print("\n=== App default profile loading ===")
+    source = open(
+        os.path.join(os.path.dirname(os.path.dirname(__file__)), "app.py"),
+        encoding="utf-8"
+    ).read()
+
+    check("App imports load_default_profile",
+          "from voice_clone import load_default_profile" in source)
+    check("App calls load_default_profile()",
+          "_default_profile_id = load_default_profile()" in source)
+    check("voice_profile_state initialized with default",
+          "voice_profile_state = gr.State(_default_profile_id)" in source)
+    check("create_voice_profile passes voice_name",
+          "voice_name=v_name.strip()" in source)
+
+
 if __name__ == "__main__":
     print("=" * 60)
     print("Latency Optimization Tests")
@@ -182,6 +234,8 @@ if __name__ == "__main__":
     test_model_mode_env()
     test_custom_voice_clone_blocked()
     test_tts_module_imports()
+    test_voice_profile_persistence()
+    test_app_default_profile()
 
     print("\n" + "=" * 60)
     print(f"Results: {PASS} passed, {FAIL} failed")

voice_clone.py

@@ -5,6 +5,11 @@ Supports two backends:
   - Base 1.7B: zero-shot voice cloning from reference audio
   - CustomVoice 0.6B: fast predefined speakers (no cloning, lower latency)
 
+Voice profiles are:
+  - Cached in-memory for fast access during a session
+  - Persisted to Voice_Profile/ folder as .pt files for reuse across restarts
+  - Auto-loaded on startup if saved profiles exist
+
 Latency optimizations applied:
   - bfloat16 / float16 precision (auto-detected per GPU arch)
   - FlashAttention-2 when available
@@ -15,13 +20,15 @@ Latency optimizations applied:
   - Reference audio trimmed to 3-5s for faster embedding extraction
 
 Usage:
-    profile_id = create_voice_profile(ref_audio_path)
+    profile_id = create_voice_profile(ref_audio_path, voice_name="Mom")
     wav, sr = synthesize_cloned(text, profile_id)
 """
+import json
 import logging
 import os
 import uuid
 import threading
+from pathlib import Path
 
 import numpy as np
 import soundfile as sf
@@ -59,6 +66,15 @@ REF_AUDIO_MIN_SEC = 3.0
 REF_AUDIO_MAX_SEC = 10.0
 REF_AUDIO_TARGET_SR = 24000
 
+# ---------------------------------------------------------------------------
+# Voice profile persistence
+# ---------------------------------------------------------------------------
+VOICE_PROFILE_DIR = Path(__file__).parent / "Voice_Profile"
+VOICE_PROFILE_DIR.mkdir(exist_ok=True)
+
+# Default profile ID — used when no cloned voice exists
+DEFAULT_PROFILE_ID = "__default__"
+
 # ---------------------------------------------------------------------------
 # Server-side cache: { profile_id -> VoiceClonePromptItem list }
 # ---------------------------------------------------------------------------
@@ -163,9 +179,151 @@ def _trim_reference_audio(audio_path: str) -> str:
         return audio_path
 
 
-def create_voice_profile(ref_audio_path: str) -> str:
+# ---------------------------------------------------------------------------
+# Profile persistence (disk ↔ memory)
+# ---------------------------------------------------------------------------
+
+def save_profile_to_disk(profile_id: str, voice_name: str = "Cloned Voice") -> Path:
+    """
+    Save a cached voice profile to Voice_Profile/ as a .pt file + metadata JSON.
+    Returns the path to the saved .pt file.
+    """
+    with _cache_lock:
+        prompt_items = _PROFILE_CACHE.get(profile_id)
+    if prompt_items is None:
+        raise ValueError(f"Profile '{profile_id}' not found in cache.")
+
+    profile_dir = VOICE_PROFILE_DIR / profile_id
+    profile_dir.mkdir(exist_ok=True)
+
+    # Serialize VoiceClonePromptItem fields
+    serializable = []
+    for item in prompt_items:
+        serializable.append({
+            "ref_code": item.ref_code.cpu() if item.ref_code is not None else None,
+            "ref_spk_embedding": item.ref_spk_embedding.cpu(),
+            "x_vector_only_mode": item.x_vector_only_mode,
+            "icl_mode": item.icl_mode,
+            "ref_text": item.ref_text,
+        })
+
+    pt_path = profile_dir / "profile.pt"
+    torch.save(serializable, pt_path)
+
+    # Save metadata
+    meta = {"profile_id": profile_id, "voice_name": voice_name}
+    meta_path = profile_dir / "metadata.json"
+    with open(meta_path, "w", encoding="utf-8") as f:
+        json.dump(meta, f, indent=2)
+
+    logger.info("Voice profile '%s' (%s) saved to %s", profile_id, voice_name, profile_dir)
+    return pt_path
+
+
+def load_profile_from_disk(profile_id: str) -> bool:
     """
-    Extract speaker embedding from reference audio and cache it.
+    Load a voice profile from Voice_Profile/<profile_id>/profile.pt into memory cache.
+    Returns True if loaded successfully, False otherwise.
+    """
+    profile_dir = VOICE_PROFILE_DIR / profile_id
+    pt_path = profile_dir / "profile.pt"
+
+    if not pt_path.exists():
+        logger.warning("Profile file not found: %s", pt_path)
+        return False
+
+    try:
+        from qwen_tts.inference.qwen3_tts_model import VoiceClonePromptItem
+
+        raw_items = torch.load(pt_path, map_location="cpu", weights_only=False)
+        prompt_items = []
+        for item_dict in raw_items:
+            prompt_items.append(VoiceClonePromptItem(
+                ref_code=item_dict["ref_code"],
+                ref_spk_embedding=item_dict["ref_spk_embedding"],
+                x_vector_only_mode=item_dict["x_vector_only_mode"],
+                icl_mode=item_dict["icl_mode"],
+                ref_text=item_dict.get("ref_text"),
+            ))
+
+        with _cache_lock:
+            _PROFILE_CACHE[profile_id] = prompt_items
+
+        logger.info("Voice profile '%s' loaded from disk.", profile_id)
+        return True
+    except Exception as exc:
+        logger.exception("Failed to load profile '%s': %s", profile_id, exc)
+        return False
+
+
+def list_saved_profiles() -> list[dict]:
+    """
+    List all saved voice profiles from Voice_Profile/ directory.
+    Returns list of {profile_id, voice_name, path} dicts, newest first.
+    """
+    profiles = []
+    if not VOICE_PROFILE_DIR.exists():
+        return profiles
+
+    for entry in VOICE_PROFILE_DIR.iterdir():
+        if not entry.is_dir():
+            continue
+        pt_path = entry / "profile.pt"
+        meta_path = entry / "metadata.json"
+        if not pt_path.exists():
+            continue
+
+        voice_name = "Cloned Voice"
+        if meta_path.exists():
+            try:
+                with open(meta_path, encoding="utf-8") as f:
+                    meta = json.load(f)
+                voice_name = meta.get("voice_name", voice_name)
+            except Exception:
+                pass
+
+        profiles.append({
+            "profile_id": entry.name,
+            "voice_name": voice_name,
+            "path": str(entry),
+            "mtime": pt_path.stat().st_mtime,
+        })
+
+    # Newest first
+    profiles.sort(key=lambda p: p["mtime"], reverse=True)
+    return profiles
+
+
+def load_default_profile() -> str | None:
+    """
+    Load the most recently saved voice profile from Voice_Profile/ into memory.
+    Returns the profile_id if found, None if no saved profiles exist.
+    This is called on app startup to restore the last cloned voice.
+    """
+    saved = list_saved_profiles()
+    if not saved:
+        logger.info("No saved voice profiles found — using stock voice as default.")
+        return None
+
+    newest = saved[0]
+    profile_id = newest["profile_id"]
+    if load_profile_from_disk(profile_id):
+        logger.info(
+            "Default voice profile loaded: '%s' (%s)",
+            profile_id, newest["voice_name"],
+        )
+        return profile_id
+
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Core API
+# ---------------------------------------------------------------------------
+
+def create_voice_profile(ref_audio_path: str, voice_name: str = "Cloned Voice") -> str:
+    """
+    Extract speaker embedding from reference audio, cache it, and save to disk.
     Returns a profile_id string for later synthesis.
 
     Reference audio is trimmed to 3-10s for optimal latency.
@@ -191,7 +349,13 @@ def create_voice_profile(ref_audio_path: str) -> str:
     with _cache_lock:
         _PROFILE_CACHE[profile_id] = prompt_items
 
-    logger.info("Voice profile %s created.", profile_id)
+    # Persist to disk
+    try:
+        save_profile_to_disk(profile_id, voice_name=voice_name)
+    except Exception as exc:
+        logger.warning("Failed to save profile to disk: %s", exc)
+
+    logger.info("Voice profile %s created and saved.", profile_id)
     return profile_id
 
 
@@ -202,6 +366,11 @@ def synthesize_cloned(text: str, profile_id: str) -> tuple[np.ndarray, int]:
     """
     with _cache_lock:
         prompt_items = _PROFILE_CACHE.get(profile_id)
+    if prompt_items is None:
+        # Try loading from disk if not in memory
+        if load_profile_from_disk(profile_id):
+            with _cache_lock:
+                prompt_items = _PROFILE_CACHE.get(profile_id)
     if prompt_items is None:
         raise ValueError(f"Voice profile '{profile_id}' not found. Record voice first.")
 
@@ -250,11 +419,15 @@ def synthesize_cloned_preview(profile_id: str) -> tuple[np.ndarray, int]:
 
 
 def has_profile(profile_id: str | None) -> bool:
-    """Check if a voice profile exists in cache."""
+    """Check if a voice profile exists in cache or on disk."""
     if not profile_id:
         return False
     with _cache_lock:
-        return profile_id in _PROFILE_CACHE
+        if profile_id in _PROFILE_CACHE:
+            return True
+    # Check disk
+    pt_path = VOICE_PROFILE_DIR / profile_id / "profile.pt"
+    return pt_path.exists()
 
 
 def get_model_mode() -> str: