Update app.py

app.py

@@ -1,5 +1,5 @@
 import os
-# Paksa PyTorch agar hanya melihat CPU dan matikan CUDA murni sebelum library lain di-import
+# Paksa PyTorch murni berjalan di CPU sebelum library lain masuk
 os.environ["CUDA_VISIBLE_DEVICES"] = ""
 
 import re
@@ -7,6 +7,7 @@ import gc
 import inspect
 import tempfile
 import traceback
+from pathlib import Path
 from threading import Lock
 
 import requests
@@ -14,48 +15,41 @@ import torch
 import torchaudio as ta
 import gradio as gr
 
-# =====================================================================
-# OPTIMASI EKSTREM LEVEL CPU & PYTORCH (ANTI-NGARET & DEPREKASI)
-# =====================================================================
-# Batasi thread PyTorch secara agresif agar tidak rebutan core di shared CPU
+# Optimasi Core CPU shared Hugging Face agar fokus
 torch.set_num_threads(2)
 torch.set_num_interop_threads(2)
-
-# Matikan kalkulasi gradient secara global karena ini murni inference/synthesis
 torch.set_grad_enabled(False)
-
-# Hard patch untuk mendepresiasi CUDA di library pihak ketiga
 torch.cuda.is_available = lambda: False  # noqa: E731
 
+# Override global torch load untuk keamanan CPU
 _original_torch_load = torch.load
 def _torch_load_cpu(*args, **kwargs):
     kwargs["map_location"] = torch.device("cpu")
     return _original_torch_load(*args, **kwargs)
 torch.load = _torch_load_cpu
 
-if hasattr(torch.jit, "load"):
-    _original_jit_load = torch.jit.load
-    def _jit_load_cpu(*args, **kwargs):
-        kwargs["map_location"] = torch.device("cpu")
-        return _original_jit_load(*args, **kwargs)
-    torch.jit.load = _jit_load_cpu
-
 # =====================================================================
-# CONFIG (BATASAN REASONS & KONTROL MEMORI)
+# CONFIG & PATH MANAGEMENT
 # =====================================================================
 MODEL_REPO = "grandhigh/Chatterbox-TTS-Indonesian"
 CHECKPOINT_FILENAME = "t3_cfg.safetensors"
 DEVICE = "cpu"
 
-MAX_TOTAL_CHARS = int(os.getenv("MAX_TOTAL_CHARS", "2400"))       # total karakter per request
-MAX_CHARS_PER_CHUNK = int(os.getenv("MAX_CHARS_PER_CHUNK", "220")) # karakter per chunk
-MAX_CHUNKS = int(os.getenv("MAX_CHUNKS", "12"))                     # maksimal jumlah chunk
-PAUSE_SECONDS = float(os.getenv("PAUSE_SECONDS", "0.15"))          # jeda antar chunk
+MAX_TOTAL_CHARS = int(os.getenv("MAX_TOTAL_CHARS", "2400"))
+MAX_CHARS_PER_CHUNK = int(os.getenv("MAX_CHARS_PER_CHUNK", "220"))
+MAX_CHUNKS = int(os.getenv("MAX_CHUNKS", "12"))
+PAUSE_SECONDS = float(os.getenv("PAUSE_SECONDS", "0.15"))
 DOWNLOAD_TIMEOUT = int(os.getenv("DOWNLOAD_TIMEOUT", "90"))
 
-# =====================================================================
-# MODEL IMPORT & SINGLETON LAZY LOADING
-# =====================================================================
+# Jalur untuk suara default bawaan sistem (Taruh file suara 1:15 kamu di folder assets Space ini)
+ROOT_DIR = Path(__file__).parent
+ASSETS_DIR = ROOT_DIR / "assets"
+ASSETS_DIR.mkdir(exist_ok=True)
+DEFAULT_SPEAKER_PATH = ASSETS_DIR / "default_speaker.wav"
+
+# Global Cache untuk mengunci embedding suara agar tidak dihitung ulang setiap request
+CACHED_EMBEDDINGS = {}
+
 from chatterbox.tts import ChatterboxTTS
 from huggingface_hub import hf_hub_download
 from safetensors.torch import load_file
@@ -63,7 +57,6 @@ from safetensors.torch import load_file
 _model = None
 _model_lock = Lock()
 
-
 def get_model():
     global _model
     if _model is None:
@@ -87,61 +80,47 @@ def get_model():
     return _model
 
 
-def _download_wav(url: str) -> str:
-    r = requests.get(url, timeout=DOWNLOAD_TIMEOUT)
-    r.raise_for_status()
-
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-    tmp.write(r.content)
-    tmp.close()
-    return tmp.name
-
-
 def _resolve_audio_input(audio_file, audio_url: str):
     if isinstance(audio_file, str) and audio_file.strip():
         return audio_file
-
     if isinstance(audio_file, dict):
         p = audio_file.get("path")
         if p:
             return p
-
     if audio_url and audio_url.strip():
-        return _download_wav(audio_url.strip())
-
+        try:
+            r = requests.get(audio_url.strip(), timeout=DOWNLOAD_TIMEOUT)
+            r.raise_for_status()
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+            tmp.write(r.content)
+            tmp.close()
+            return tmp.name
+        except Exception:
+            pass
+            
+    # KUNCI UTAMA: Jika tidak ada file/url yang dikirim, otomatis alihkan ke Default Voice bawaan sistem
+    if DEFAULT_SPEAKER_PATH.exists():
+        return str(DEFAULT_SPEAKER_PATH)
+        
     return None
 
 
-def _prepare_text_exact(text: str) -> str:
-    t = re.sub(r"\s+", " ", (text or "").strip())
-    if not t:
-        raise gr.Error("Text prompt tidak boleh kosong.")
-    if not re.search(r"[.!?…]$", t):
-        t += "."
-    return t
-
-
 def _split_text_safely(text: str, max_chars: int = MAX_CHARS_PER_CHUNK):
     text = re.sub(r"\s+", " ", (text or "").strip())
     if not text:
         return []
-
     sentences = re.split(r"(?<=[.!?])\s+", text)
     chunks = []
     current = ""
-
     for s in sentences:
         s = s.strip()
         if not s:
             continue
-
         parts = [s] if len(s) <= max_chars else re.split(r"(?<=[,;:])\s+", s)
-
         for p in parts:
             p = p.strip()
             if not p:
                 continue
-
             if len(p) > max_chars:
                 words = p.split()
                 tmp = ""
@@ -156,7 +135,6 @@ def _split_text_safely(text: str, max_chars: int = MAX_CHARS_PER_CHUNK):
                 if tmp:
                     chunks.append(tmp)
                 continue
-
             candidate = f"{current} {p}".strip() if current else p
             if len(candidate) <= max_chars:
                 current = candidate
@@ -164,108 +142,100 @@ def _split_text_safely(text: str, max_chars: int = MAX_CHARS_PER_CHUNK):
                 if current:
                     chunks.append(current)
                 current = p
-
     if current:
         chunks.append(current)
-
     return chunks
 
-
-def _generate_with_safe_kwargs(model, text: str, prompt_path: str):
-    sig = inspect.signature(model.generate)
-    params = sig.parameters
-    kwargs = {}
-
-    if "audio_prompt_path" in params:
-        kwargs["audio_prompt_path"] = prompt_path
-
-    if "temperature" in params:
-        kwargs["temperature"] = 0.05
-    if "top_p" in params:
-        kwargs["top_p"] = 0.7
-    if "exaggeration" in params:
-        kwargs["exaggeration"] = 0.25
-    if "cfg_weight" in params:
-        kwargs["cfg_weight"] = 0.3
-    if "max_new_tokens" in params:
-        kwargs["max_new_tokens"] = 260  # Kunci agar model tidak runaway loop tokens
-
-    try:
-        return model.generate(text, **kwargs)
-    except TypeError:
-        if "text" in params:
-            kwargs["text"] = text
-            return model.generate(**kwargs)
-        return model.generate(text)
-
 # =====================================================================
-# MAIN INFERENCE ENGINE (REFACTORED WITH INFERENCE_MODE)
+# ENGINE INFERENCE DENGAN DUAL-SPEAKER SELECTION & EMBEDDING CACHE
 # =====================================================================
 def clone_voice(text: str, audio_file, audio_url: str, progress=gr.Progress(track_tqdm=False)):
+    global CACHED_EMBEDDINGS
     try:
         raw_text = (text or "").strip()
         if not raw_text:
             raise gr.Error("Text prompt tidak boleh kosong.")
 
-        if len(raw_text) > MAX_TOTAL_CHARS:
-            raise gr.Error(
-                f"Teks terlalu panjang ({len(raw_text)} karakter). "
-                f"Maksimal {MAX_TOTAL_CHARS} karakter per request."
-            )
-
+        # Tentukan file suara yang dipakai (Custom atau Default Lokal)
         prompt_path = _resolve_audio_input(audio_file, audio_url)
         if not prompt_path:
-            raise gr.Error("Upload WAV atau isi Audio URL WAV.")
+            raise gr.Error("Suara default tidak ditemukan di server. Harap upload sampel audio.")
 
         chunks = _split_text_safely(raw_text, max_chars=MAX_CHARS_PER_CHUNK)
-        if not chunks:
-            raise gr.Error("Gagal memproses teks (chunk kosong).")
-
-        # FILTER SMART: Buang fragmen chunk yang tidak mengandung karakter alfanumerik murni
         chunks = [ch for ch in chunks if re.search(r'[a-zA-Z0-9]', ch)]
 
-        if len(chunks) > MAX_CHUNKS:
-            raise gr.Error(
-                f"Teks terlalu padat ({len(chunks)} chunk). "
-                f"Maksimal {MAX_CHUNKS} chunk per request."
-            )
-
         model = get_model()
         sr = getattr(model, "sr", 24000)
-
-        # Kunci manual seed di luar perulangan
         torch.manual_seed(42)
 
+        # Caching Dinamis berdasarkan path audio agar multi-user/multi-voice tetap aman
+        if prompt_path not in CACHED_EMBEDDINGS:
+            progress(0.0, desc="Mengekstrak dan mengunci embedding karakteristik suara ke RAM...")
+            
+            if hasattr(model, "extract_conditioning") or hasattr(model, "get_speaker_embedding"):
+                extract_fn = getattr(model, "extract_conditioning", getattr(model, "get_speaker_embedding", None))
+                CACHED_EMBEDDINGS[prompt_path] = extract_fn(prompt_path)
+            else:
+                CACHED_EMBEDDINGS[prompt_path] = prompt_path
+                
+            print(f"[CACHE] Karakteristik untuk {prompt_path} berhasil dikunci.")
+
+        speaker_embedding = CACHED_EMBEDDINGS[prompt_path]
+
         wav_parts = []
         pause = torch.zeros(1, int(sr * PAUSE_SECONDS))
-
         total = len(chunks)
         
-        # MANFAATKAN INFERENCE MODE (Jauh lebih hemat RAM & cepat dibanding no_grad)
+        sig = inspect.signature(model.generate)
+        params = sig.parameters
+
         with torch.inference_mode():
             for i, ch in enumerate(chunks, start=1):
-                progress((i - 1) / total, desc=f"Memproses chunk biner {i}/{total}...")
-                ch = _prepare_text_exact(ch)
+                progress((i - 1) / total, desc=f"Memproses kloning materi chunk {i}/{total}...")
+                
+                ch = re.sub(r"\s+", " ", ch.strip())
+                if not re.search(r"[.!?…]$", ch):
+                    ch += "."
+
+                kwargs = {
+                    "temperature": 0.05,
+                    "top_p": 0.7,
+                    "exaggeration": 0.25,
+                    "cfg_weight": 0.3,
+                    "max_new_tokens": 260
+                }
+                
+                if "audio_prompt_path" in params:
+                    kwargs["audio_prompt_path"] = speaker_embedding
+                elif "speaker_embedding" in params:
+                    kwargs["speaker_embedding"] = speaker_embedding
+                else:
+                    kwargs["audio_prompt_path"] = prompt_path
+
+                try:
+                    wav = model.generate(ch, **kwargs)
+                except TypeError:
+                    if "text" in params:
+                        kwargs["text"] = ch
+                        wav = model.generate(**kwargs)
+                    else:
+                        wav = model.generate(ch)
 
-                wav = _generate_with_safe_kwargs(model, ch, prompt_path)
                 if wav.dim() == 1:
                     wav = wav.unsqueeze(0)
 
-                # Segera pindahkan hasil tensor ke penampung cpu bersih untuk memotong graph memori
                 wav_parts.append(wav.detach().cpu().clone())
                 wav_parts.append(pause)
 
-        # Buang elemen pause buatan di bagian akhir audio tracker
         if wav_parts:
             wav_parts = wav_parts[:-1]
 
-        progress(0.95, desc="Menggabungkan seluruh komponen bytes audio...")
+        progress(0.95, desc="Menggabungkan audio akhir...")
         full_wav = torch.cat(wav_parts, dim=1)
 
         out_path = tempfile.NamedTemporaryFile(delete=False, suffix=".wav").name
         ta.save(out_path, full_wav, sr)
 
-        # PEMBERSIHAN AGRESIF: Paksa Garbage Collector Python membuang sisa array tensor
         del wav_parts
         del full_wav
         gc.collect()
@@ -279,37 +249,18 @@ def clone_voice(text: str, audio_file, audio_url: str, progress=gr.Progress(trac
         raise gr.Error(f"Gagal generate audio: {e}")
 
 # =====================================================================
-# GRADIO INTERFACE DESIGN
+# INTERFACE DESIGN
 # =====================================================================
-with gr.Blocks(title="Chatterbox Indonesian Voice Cloning (CPU Optimized)") as demo:
-    gr.Markdown("## EduScanner AI Voice Engine - Chatterbox CPU Optimized")
-    gr.Markdown(
-        f"""
-**Spesifikasi Keamanan Sumber Daya (Hugging Face Shared CPU Tier):**
-- Batas Maksimal Karakter Masuk: **{MAX_TOTAL_CHARS}** karakter.
-- Pembagian Kapasitas per Chunk: **{MAX_CHARS_PER_CHUNK}** karakter.
-- Manajemen Batas Atas Antrean Fragmentasi: **{MAX_CHUNKS}** chunk.
-"""
-    )
-
-    text_in = gr.Textbox(
-        label="Teks Akademik / Rangkuman (Maks 2400 Karakter)",
-        lines=8,
-        placeholder="Masukkan teks rangkuman materi perkuliahan di sini untuk diubah menjadi suara kloning..."
-    )
-
-    wav_in = gr.Audio(
-        label="Sampel Suara Target (Upload WAV)",
-        type="filepath"
-    )
-
-    url_in = gr.Textbox(
-        label="Atau Gunakan URL Sampel Audio WAV (Opsional)",
-        placeholder="https://domain-kamu.com/assets/sample_suara.wav"
-    )
+with gr.Blocks(title="Chatterbox Dual Voice Hybrid Engine") as demo:
+    gr.Markdown("## EduScanner AI - Dual Voice Solution (Default & Custom)")
+    gr.Markdown("Otomatis menggunakan suara default jika input file dikosongkan.")
 
-    btn = gr.Button("Mulai Sintesis Suara", variant="primary")
-    out_audio = gr.Audio(label="Hasil Audio Hasil Kloning (WAV)", type="filepath")
+    text_in = gr.Textbox(label="Teks Rangkuman", lines=8, placeholder="Masukkan teks di sini...")
+    wav_in = gr.Audio(label="Opsi Custom Voice (Kosongkan jika ingin pakai suara default Syahid)", type="filepath")
+    url_in = gr.Textbox(label="Opsi Link URL Audio Custom", placeholder="https://example.com/suara_lain.wav")
+    
+    btn = gr.Button("Sintesis Audio", variant="primary")
+    out_audio = gr.Audio(label="Hasil Audio (WAV)", type="filepath")
 
     btn.click(
         fn=clone_voice,
@@ -320,6 +271,5 @@ with gr.Blocks(title="Chatterbox Indonesian Voice Cloning (CPU Optimized)") as d
 
 if __name__ == "__main__":
     port = int(os.getenv("PORT", "7860"))
-    # default_concurrency_limit=1 memaksa antrean global agar antarmuka tidak crash kelebihan beban
     demo.queue(default_concurrency_limit=1)
     demo.launch(server_name="0.0.0.0", server_port=port, show_error=True)