Update app.py

app.py

@@ -19,26 +19,27 @@ os.environ["TTS_HOME"] = TEMP_DIR
 os.environ["COQUI_TOS_AGREED"] = "1"
 
 app = FastAPI(
-    title="PasBlast Comprehensive Coqui XTTS-v2 API",
-    description="API Komplet untuk seluruh kapabilitas Coqui XTTS-v2 yang dimungkinkan berjalan di CPU Space.",
-    version="1.0.0"
+    title="PasBlast Dynamic Coqui API",
+    description="API Komplet dengan Dynamic Model Loading. Memanfaatkan 16GB RAM untuk menjalankan berbagai model secara leluasa.",
+    version="2.0.0"
 )
 security = HTTPBasic()
 
-tts_model = None
+# Dictionary untuk menampung beberapa model sekaligus di dalam 16GB RAM
+active_models = {}
 
-def get_xtts_instance() -> TTS:
-    global tts_model
-    if tts_model is None:
+def get_tts_instance(model_name: str) -> TTS:
+    if model_name not in active_models:
         try:
-            print("Memuat model XTTS-v2 ke RAM...")
-            tts_model = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
-            print("Model berhasil dimuat!")
+            print(f"Mencoba memuat model '{model_name}' ke RAM...")
+            # Muat model baru dan simpan ke dictionary
+            active_models[model_name] = TTS(model_name=model_name, gpu=False)
+            print(f"Model '{model_name}' berhasil dimuat ke memori!")
         except Exception as e:
             error_trace = traceback.format_exc()
-            print(f"Error Load Model: {error_trace}")
-            raise HTTPException(status_code=500, detail=f"Gagal memuat model XTTS-v2: {str(e)}")
-    return tts_model
+            print(f"Error Load Model {model_name}: {error_trace}")
+            raise HTTPException(status_code=500, detail=f"Gagal memuat model {model_name}: {str(e)}")
+    return active_models[model_name]
 
 # --- OTENTIKASI KEAMANAN ---
 def verify_auth(credentials: HTTPBasicCredentials = Depends(security)):
@@ -58,7 +59,7 @@ def verify_auth(credentials: HTTPBasicCredentials = Depends(security)):
 def root():
     return {
         "status": "online",
-        "message": "XTTS-v2 API Komplet Aktif. Akses /docs untuk Swagger UI Interaktif.",
+        "message": "Dynamic TTS API Aktif. Menggunakan 16GB RAM Space.",
         "storage_info": {
             "temp_dir": TEMP_DIR,
             "audio_dir": AUDIO_DIR
@@ -74,62 +75,75 @@ def list_models(username: str = Depends(verify_auth)):
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Gagal mengambil list model: {str(e)}")
 
-@app.get("/current_model", tags=["Metadata & Info"])
+@app.get("/current_models", tags=["Metadata & Info"])
 def get_current_model_status(username: str = Depends(verify_auth)):
-    """Mengecek status dan informasi model yang saat ini sedang aktif di memori."""
-    global tts_model
+    """Mengecek model apa saja yang saat ini SEDANG AKTIF dan bersarang di RAM 16GB Anda."""
     return {
-        "loaded_in_memory": tts_model is not None,
-        "active_model_name": "tts_models/multilingual/multi-dataset/xtts_v2" if tts_model else None,
+        "total_loaded_models": len(active_models),
+        "loaded_models_list": list(active_models.keys()),
         "device": "cpu"
     }
 
 @app.get("/speakers", tags=["Metadata & Info"])
-def list_speakers(username: str = Depends(verify_auth)):
-    """Melihat daftar seluruh karakter suara (speaker) bawaan yang didukung oleh XTTS-v2."""
-    tts = get_xtts_instance()
-    return {"total_speakers": len(tts.speakers), "speakers": tts.speakers}
+def list_speakers(
+    model_name: str = "tts_models/multilingual/multi-dataset/xtts_v2", 
+    username: str = Depends(verify_auth)
+):
+    """Melihat daftar seluruh karakter suara bawaan dari model TERTENTU."""
+    tts = get_tts_instance(model_name)
+    speakers = tts.speakers if hasattr(tts, "speakers") and tts.speakers else []
+    return {"model": model_name, "total_speakers": len(speakers), "speakers": speakers}
 
 @app.get("/languages", tags=["Metadata & Info"])
-def list_languages(username: str = Depends(verify_auth)):
-    """Melihat daftar kode bahasa (multilingual) yang didukung resmi oleh XTTS-v2."""
-    tts = get_xtts_instance()
-    # XTTS-v2 mendukung bahasa berkode resmi seperti 'id', 'en', 'es', dll.
-    languages = tts.languages if hasattr(tts, "languages") else ["id", "en", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl", "cs", "ar", "zh-cn", "ja", "hu", "ko"]
-    return {"total_languages": len(languages), "languages": languages}
+def list_languages(
+    model_name: str = "tts_models/multilingual/multi-dataset/xtts_v2", 
+    username: str = Depends(verify_auth)
+):
+    """Melihat daftar kode bahasa yang didukung oleh model TERTENTU."""
+    tts = get_tts_instance(model_name)
+    languages = tts.languages if hasattr(tts, "languages") and tts.languages else []
+    return {"model": model_name, "total_languages": len(languages), "languages": languages}
 
 @app.post("/tts", tags=["Core Generation"])
 def generate_tts(
     text: str = Form(..., description="Teks yang akan diubah menjadi suara"),
-    speaker: str = Form("Ana Florence", description="Nama karakter suara bawaan dari endpoint /speakers"),
-    language: str = Form("id", description="Kode bahasa (contoh: id, en, es)"),
+    model_name: str = Form("tts_models/multilingual/multi-dataset/xtts_v2", description="Nama model dari endpoint /models"),
+    speaker: str = Form(None, description="Nama karakter suara (kosongkan jika model bukan multi-speaker)"),
+    language: str = Form(None, description="Kode bahasa (kosongkan jika model bukan multi-lingual)"),
     temperature: float = Form(0.75, description="Kreativitas variasi suara (0.1 - 1.0)"),
     length_penalty: float = Form(1.0, description="Penalti panjang kalimat"),
     repetition_penalty: float = Form(5.0, description="Penalti pengulangan kata berlebih"),
     username: str = Depends(verify_auth)
 ):
-    """Sintesis teks dasar menggunakan salah satu dari karakter suara bawaan XTTS-v2."""
-    tts = get_xtts_instance()
+    """Sintesis teks dasar menggunakan MODEL APAPUN yang Anda pilih secara dinamis."""
+    tts = get_tts_instance(model_name)
     output_path = os.path.join(AUDIO_DIR, f"tts_{uuid.uuid4().hex}.wav")
     
-    available_speakers = tts.speakers
-    if speaker not in available_speakers:
-        print(f"Speaker '{speaker}' tidak ditemukan. Menggunakan default: '{available_speakers[0]}'")
-        speaker = available_speakers[0]
+    # Validasi dan auto-fallback speaker jika model membutuhkan speaker
+    if hasattr(tts, "speakers") and tts.speakers:
+        if speaker not in tts.speakers:
+            print(f"Speaker '{speaker}' tidak valid untuk model {model_name}. Menggunakan default.")
+            speaker = tts.speakers[0]
+            
+    # Validasi language
+    if hasattr(tts, "languages") and tts.languages:
+        if language not in tts.languages:
+            language = tts.languages[0]
         
     try:
-        print(f"Memproses TTS Dasar untuk {len(text)} karakter teks...")
-        tts.tts_to_file(
-            text=text, 
-            speaker=speaker, 
-            language=language, 
-            file_path=output_path,
-            split_sentences=True,
-            temperature=temperature,
-            length_penalty=length_penalty,
-            repetition_penalty=repetition_penalty
-        )
-        return FileResponse(output_path, media_type="audio/wav", filename="pasblast_tts.wav")
+        print(f"Memproses TTS menggunakan {model_name}...")
+        
+        # Eksekusi berdasarkan apakah model XTTS atau VITS/FastPitch biasa
+        kwargs = {"text": text, "file_path": output_path}
+        if speaker: kwargs["speaker"] = speaker
+        if language: kwargs["language"] = language
+        
+        # XTTS mendukung parameter tuning tambahan, model lama mungkin tidak
+        if "xtts" in model_name.lower():
+            kwargs.update({"split_sentences": True, "temperature": temperature, "length_penalty": length_penalty, "repetition_penalty": repetition_penalty})
+            
+        tts.tts_to_file(**kwargs)
+        return FileResponse(output_path, media_type="audio/wav", filename="pasblast_tts_dynamic.wav")
     except Exception as e:
         error_trace = traceback.format_exc()
         print(f"FATAL ERROR pada /tts: {error_trace}")
@@ -137,15 +151,15 @@ def generate_tts(
 
 @app.post("/tts_voice_clone", tags=["Core Generation"])
 def generate_tts_voice_clone(
-    text: str = Form(..., description="Teks yang ingin disuarakan oleh hasil kloning"),
-    language: str = Form("id", description="Kode bahasa target suara"),
-    reference_audio: UploadFile = File(..., description="File WAV sampel suara target (durasi ideal 5-10 detik, bersih dari noise)"),
-    temperature: float = Form(0.75, description="Kreativitas variasi suara"),
+    text: str = Form(...),
+    model_name: str = Form("tts_models/multilingual/multi-dataset/xtts_v2", description="Harus model yang mendukung kloning (seperti xtts_v2 atau your_tts)"),
+    language: str = Form("id"),
+    reference_audio: UploadFile = File(...),
+    temperature: float = Form(0.75),
     username: str = Depends(verify_auth)
 ):
-    """Zero-shot Voice Cloning: Membuat teks berbunyi persis menyerupai file audio referensi yang diunggah."""
-    tts = get_xtts_instance()
-    
+    """Zero-shot Voice Cloning menggunakan model yang didukung."""
+    tts = get_tts_instance(model_name)
     ref_path = os.path.join(AUDIO_DIR, f"ref_{uuid.uuid4().hex}.wav")
     with open(ref_path, "wb") as buffer:
         shutil.copyfileobj(reference_audio.file, buffer)
@@ -153,51 +167,38 @@ def generate_tts_voice_clone(
     output_path = os.path.join(AUDIO_DIR, f"clone_{uuid.uuid4().hex}.wav")
     
     try:
-        print("Memproses Zero-shot Voice Cloning...")
-        tts.tts_to_file(
-            text=text, 
-            language=language, 
-            speaker_wav=ref_path, 
-            file_path=output_path,
-            split_sentences=True,
-            temperature=temperature
-        )
+        kwargs = {"text": text, "speaker_wav": ref_path, "file_path": output_path}
+        if hasattr(tts, "languages") and tts.languages: kwargs["language"] = language
+        if "xtts" in model_name.lower(): 
+            kwargs.update({"split_sentences": True, "temperature": temperature})
+            
+        tts.tts_to_file(**kwargs)
         return FileResponse(output_path, media_type="audio/wav", filename="pasblast_cloned.wav")
     except Exception as e:
         error_trace = traceback.format_exc()
-        print(f"FATAL ERROR pada /tts_voice_clone: {error_trace}")
         raise HTTPException(status_code=500, detail=f"Gagal memproses Voice Cloning: {str(e)}")
 
 @app.post("/voice_conversion", tags=["Core Generation"])
 def generate_voice_conversion(
-    source_audio: UploadFile = File(..., description="File audio WAV asli berisi ucapan/perkataan seseorang yang ingin diubah suaranya"),
-    reference_audio: UploadFile = File(..., description="File audio WAV target berisi sampel karakter suara baru yang ingin ditiru"),
+    model_name: str = Form("voice_conversion_models/multilingual/vctk/freevc24", description="Model khusus Voice Conversion"),
+    source_audio: UploadFile = File(...),
+    reference_audio: UploadFile = File(...),
     username: str = Depends(verify_auth)
 ):
-    """Voice Conversion (Audio-to-Audio): Mengubah identitas suara pada file audio sumber menjadi karakter suara target tanpa mengubah isi perkataannya."""
-    tts = get_xtts_instance()
-    
+    """Voice Conversion (Audio-to-Audio) secara dinamis."""
+    tts = get_tts_instance(model_name)
     source_path = os.path.join(AUDIO_DIR, f"src_{uuid.uuid4().hex}.wav")
     ref_path = os.path.join(AUDIO_DIR, f"ref_vc_{uuid.uuid4().hex}.wav")
     output_path = os.path.join(AUDIO_DIR, f"vc_{uuid.uuid4().hex}.wav")
     
-    with open(source_path, "wb") as buffer:
-        shutil.copyfileobj(source_audio.file, buffer)
-    with open(ref_path, "wb") as buffer:
-        shutil.copyfileobj(reference_audio.file, buffer)
+    with open(source_path, "wb") as buffer: shutil.copyfileobj(source_audio.file, buffer)
+    with open(ref_path, "wb") as buffer: shutil.copyfileobj(reference_audio.file, buffer)
         
     try:
         if hasattr(tts, "voice_conversion_to_file"):
-            print("Memproses Voice Conversion (Audio-to-Audio)...")
-            tts.voice_conversion_to_file(
-                source_wav=source_path, 
-                target_wav=ref_path, 
-                file_path=output_path
-            )
+            tts.voice_conversion_to_file(source_wav=source_path, target_wav=ref_path, file_path=output_path)
             return FileResponse(output_path, media_type="audio/wav", filename="pasblast_converted.wav")
         else:
-            raise HTTPException(status_code=400, detail="Model aktif saat ini tidak dikonfigurasi untuk fungsi Voice Conversion bawaan.")
+            raise HTTPException(status_code=400, detail=f"Model {model_name} tidak memiliki fitur Voice Conversion.")
     except Exception as e:
-        error_trace = traceback.format_exc()
-        print(f"FATAL ERROR pada /voice_conversion: {error_trace}")
         raise HTTPException(status_code=500, detail=f"Gagal memproses Voice Conversion: {str(e)}")