first commit

Dockerfile

@@ -0,0 +1,39 @@
+# Dockerfile untuk TTS Bahasa Indonesia API
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first untuk layer caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Create outputs directory
+RUN mkdir -p outputs
+
+# Expose port (default 7860, bisa diubah dengan environment variable PORT)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+# Health check untuk Docker deployment (termasuk HuggingFace Spaces dengan Docker SDK)
+# start-period 60s untuk memberikan waktu model TTS untuk load
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/api/health || exit 1
+
+# Run the application
+CMD ["python", "api.py"]
+

api.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""
+FastAPI Server untuk TTS Bahasa Indonesia
+Berdasarkan tts_standalone.py
+
+API ini menyediakan endpoint untuk menghasilkan audio dari teks Bahasa Indonesia
+dengan menggunakan model TTS yang sudah dilatih khusus untuk bahasa Indonesia.
+
+Fitur:
+- Limit maksimal 10 file di folder outputs
+- Auto cleanup file lama ketika melebihi limit
+- Kompatibel dengan HuggingFace Spaces
+
+Endpoints:
+- POST /api/tts: Generate audio dari teks
+- GET /api/health: Health check endpoint
+- GET /api/speakers: Daftar speaker tersedia
+- GET /api/download/{file_path}: Download file audio
+"""
+
+from fastapi import FastAPI, HTTPException, File, UploadFile
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import Optional
+import uuid
+from pathlib import Path
+import os
+from datetime import datetime
+from tts_standalone import generate_tts, params
+
+app = FastAPI(
+    title="TTS Bahasa Indonesia API",
+    description="API untuk Text-to-Speech Bahasa Indonesia",
+    version="1.0.0"
+)
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Direktori untuk menyimpan file audio hasil TTS
+OUTPUT_DIR = Path("outputs")
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Limit maksimal file yang disimpan
+MAX_FILES = 10
+
+
+# Pydantic models untuk request/response
+class TTSRequest(BaseModel):
+    text: str = Field(..., description="Teks yang akan diubah menjadi suara")
+    speaker: Optional[str] = Field(default=None, description="Nama speaker (default: dari config)")
+    file_path: Optional[str] = Field(default=None, description="Custom file path (optional)")
+
+
+class TTSResponse(BaseModel):
+    success: bool
+    message: str
+    file_path: Optional[str] = None
+    download_url: Optional[str] = None
+    text: Optional[str] = None
+    speaker: Optional[str] = None
+
+
+class HealthResponse(BaseModel):
+    status: str
+    message: str
+
+
+def cleanup_old_files(max_files: int = MAX_FILES):
+    """
+    Menghapus file lama jika jumlah file melebihi max_files.
+    File yang paling lama akan dihapus terlebih dahulu.
+    
+    Args:
+        max_files: Jumlah maksimal file yang diizinkan
+    """
+    try:
+        # Get semua file .wav di OUTPUT_DIR
+        wav_files = list(OUTPUT_DIR.glob("*.wav"))
+        
+        if len(wav_files) <= max_files:
+            return
+        
+        # Sort berdasarkan waktu modifikasi (file lama di depan)
+        wav_files.sort(key=lambda x: x.stat().st_mtime)
+        
+        # Hapus file lama sampai jumlah file <= max_files
+        files_to_delete = wav_files[:len(wav_files) - max_files + 1]
+        
+        for file_path in files_to_delete:
+            try:
+                file_path.unlink()
+                print(f"Deleted old file: {file_path}")
+            except Exception as e:
+                print(f"Error deleting file {file_path}: {e}")
+                
+    except Exception as e:
+        print(f"Error in cleanup_old_files: {e}")
+
+
+@app.get("/api/health", response_model=HealthResponse)
+async def health_check():
+    """
+    Health check endpoint
+    """
+    return HealthResponse(
+        status="healthy",
+        message="TTS API is running"
+    )
+
+
+@app.post("/api/tts", response_model=TTSResponse)
+async def tts_endpoint(request: TTSRequest):
+    """
+    Endpoint untuk generate TTS audio dari teks
+    
+    Request Body (JSON):
+    {
+        "text": "Teks yang akan diubah menjadi suara",
+        "speaker": "gadis",  // Optional, default: dari config
+        "file_path": "custom_filename.wav"  // Optional
+    }
+    """
+    try:
+        # Validasi text
+        if not request.text or not request.text.strip():
+            raise HTTPException(
+                status_code=400,
+                detail="Parameter 'text' wajib diisi dan tidak boleh kosong"
+            )
+        
+        # Get speaker (gunakan default dari config jika tidak ada)
+        speaker = request.speaker or params.get("speaker", "gadis")
+        
+        # Generate file path
+        if request.file_path:
+            # Jika user memberikan custom file path
+            if not request.file_path.endswith(".wav"):
+                request.file_path += ".wav"
+            file_path = OUTPUT_DIR / request.file_path
+        else:
+            # Generate UUID untuk file name
+            short_uuid = str(uuid.uuid4())[:8]
+            file_path = OUTPUT_DIR / f"{speaker}-{short_uuid}.wav"
+        
+        # Cleanup file lama sebelum generate file baru
+        cleanup_old_files(MAX_FILES)
+        
+        # Generate TTS
+        success = generate_tts(request.text, str(file_path), speaker)
+        
+        if success:
+            # Cleanup lagi setelah generate (untuk memastikan)
+            cleanup_old_files(MAX_FILES)
+            
+            return TTSResponse(
+                success=True,
+                message="Audio berhasil dibuat",
+                file_path=str(file_path),
+                download_url=f"/api/download/{file_path}",
+                text=request.text,
+                speaker=speaker
+            )
+        else:
+            raise HTTPException(
+                status_code=500,
+                detail="Gagal membuat audio. Periksa log untuk detail."
+            )
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error: {str(e)}"
+        )
+
+
+@app.get("/api/download/{file_path:path}")
+async def download_file(file_path: str):
+    """
+    Endpoint untuk download file audio
+    
+    Args:
+        file_path: Path relatif ke file audio (contoh: outputs/gadis-abc12345.wav)
+    """
+    try:
+        file_path_obj = Path(file_path)
+        
+        # Security check: pastikan file ada di dalam OUTPUT_DIR
+        try:
+            file_path_obj.resolve().relative_to(OUTPUT_DIR.resolve())
+        except ValueError:
+            raise HTTPException(
+                status_code=400,
+                detail="Invalid file path"
+            )
+        
+        if not file_path_obj.exists():
+            raise HTTPException(
+                status_code=404,
+                detail="File tidak ditemukan"
+            )
+        
+        return FileResponse(
+            path=str(file_path_obj),
+            filename=file_path_obj.name,
+            media_type="audio/wav"
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error: {str(e)}"
+        )
+
+
+@app.get("/api/speakers")
+async def get_speakers():
+    """
+    Endpoint untuk mendapatkan daftar speaker yang tersedia
+    """
+    speakers = [
+        {"id": "wibowo", "name": "Wibowo - Suara jantan berwibawa"},
+        {"id": "ardi", "name": "Ardi - Suara lembut dan hangat"},
+        {"id": "gadis", "name": "Gadis - Suara perempuan yang merdu"},
+        {"id": "JV-00264", "name": "Juminten - Suara perempuan jawa (bahasa jawa)"},
+        {"id": "SU-00060", "name": "Asep - Suara lelaki sunda (bahasa sunda)"}
+    ]
+    
+    return {
+        "success": True,
+        "speakers": speakers,
+        "default": params.get("speaker", "gadis")
+    }
+
+
+@app.get("/")
+async def root():
+    """
+    Root endpoint dengan informasi API
+    """
+    return {
+        "message": "TTS Bahasa Indonesia API",
+        "version": "1.0.0",
+        "docs": "/docs",
+        "endpoints": {
+            "POST /api/tts": "Generate audio dari teks",
+            "GET /api/health": "Health check",
+            "GET /api/speakers": "Daftar speaker tersedia",
+            "GET /api/download/{file_path}": "Download file audio"
+        }
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    # Get port from environment variable (untuk HuggingFace Spaces)
+    port = int(os.environ.get("PORT", 7860))
+    
+    print("=" * 60)
+    print("TTS API Server - Bahasa Indonesia (FastAPI)")
+    print("=" * 60)
+    print("API Endpoints:")
+    print("  POST /api/tts - Generate audio dari teks")
+    print("  GET  /api/health - Health check")
+    print("  GET  /api/speakers - Daftar speaker tersedia")
+    print("  GET  /api/download/{file_path} - Download file audio")
+    print("  GET  /docs - Swagger UI documentation")
+    print("=" * 60)
+    print(f"\nServer starting on http://0.0.0.0:{port}")
+    print(f"Max files in outputs folder: {MAX_FILES}")
+    print("Press CTRL+C to stop\n")
+    
+    uvicorn.run(app, host="0.0.0.0", port=port)

app.py

@@ -0,0 +1,189 @@
+"""
+████████╗████████╗███████╗                                                          
+╚══██╔══╝╚══██╔══╝██╔════╝                                                          
+   ██║      ██║   ███████╗                                                          
+   ██║      ██║   ╚════██║                                                          
+   ██║      ██║   ███████║                                                          
+   ╚═╝      ╚═╝   ╚══════╝                                                          
+██╗███╗   ██╗██████╗  ██████╗ ███╗   ██╗███████╗███████╗██╗ █████╗ ██╗  ██╗██╗   ██╗
+██║████╗  ██║██╔══██╗██╔═══██╗████╗  ██║██╔════╝██╔════╝██║██╔══██╗██║ ██╔╝██║   ██║
+██║██╔██╗ ██║██║  ██║██║   ██║██╔██╗ ██║█████╗  ███████╗██║███████║█████╔╝ ██║   ██║
+██║██║╚██╗██║██║  ██║██║   ██║██║╚██╗██║██╔══╝  ╚════██║██║██╔══██║██╔═██╗ ██║   ██║
+██║██║ ╚████║██████╔╝╚██████╔╝██║ ╚████║███████╗███████║██║██║  ██║██║  ██╗╚██████╔╝
+╚═╝╚═╝  ╚═══╝╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚══════╝╚══════╝╚═╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ 
+                                                                                    
+Script ini dibuat oleh __drat
+
+Petunjuk:
+1. Script ini digunakan untuk menghasilkan suara berbasis teks dengan berbagai pilihan pembicara.
+2. Teknologi yang digunakan meliputi model text-to-speech (TTS) yang canggih dengan konversi teks ke fonem (G2P).
+3. Model yang dipakai dilatih khusus untuk bahasa Indonesia, Jawa, dan Sunda.
+4. Antarmuka dibuat dengan menggunakan Gradio dengan tema kustom bernama MetafisikTheme.
+
+Cara Menggunakan:
+1. Masukkan teks yang ingin diubah menjadi suara.
+2. Pilih kecepatan bicara yang diinginkan.
+3. Pilih bahasa dan pembicara yang diinginkan.
+4. Klik tombol "Lakukan Inferensi Audio" untuk menghasilkan suara.
+"""
+
+import gradio as gr
+import platform
+import json
+from pathlib import Path
+import uuid
+import html
+import subprocess
+import time
+from g2pid import G2P
+from themes import MetafisikTheme  # Impor tema custom dari themes.py
+
+# Inisialisasi G2P (Grapheme to Phoneme)
+g2p = G2P()
+
+# Fungsi untuk mengecek apakah sistem operasi adalah macOS
+def is_mac_os():
+    return platform.system() == 'Darwin'
+
+# Parameter default untuk konfigurasi
+params = {
+    "activate": True,
+    "autoplay": True,
+    "show_text": True,
+    "remove_trailing_dots": False,
+    "voice": "default.wav",
+    "language": "Indonesian",
+    "model_path": "checkpoint_1260000-inference.pth",
+    "config_path": "config.json",
+    "out_path": "output.wav"
+}
+
+SAMPLE_RATE = 16000
+device = None
+
+# Set nama pembicara default
+default_speaker_name = "ardi"
+
+# Fungsi untuk mengubah teks menjadi urutan yang sesuai untuk model
+def text_to_sequence(text):
+    # Implementasikan sesuai dengan kebutuhan model Anda
+    # Sebagai contoh, ini adalah placeholder
+    sequence = [ord(char) for char in text]
+    return sequence
+
+# Fungsi untuk menghasilkan suara dengan progress bar
+def gen_voice(text, speaker_label, speed, language, progress=gr.Progress()):
+    speaker_mapping = {
+        "Wibowo - Suara jantan berwibawa": "wibowo",
+        "Ardi - Suara lembut dan hangat": "ardi",
+        "Gadis - Suara perempuan yang merdu": "gadis",
+        "Juminten - Suara perempuan jawa (bahasa jawa)": "JV-00264",
+        "Asep - Suara lelaki sunda (bahasa sunda)": "SU-00060"
+    }
+    speaker = speaker_mapping.get(speaker_label, default_speaker_name)
+    
+    progress(0, desc="Menginisialisasi G2P")
+    text = html.unescape(text)
+    text_to_tts = g2p(text)  # Konversi teks ke format TTS menggunakan G2P
+    time.sleep(1)
+    progress(0.2, desc="Mengonversi teks ke TTS")
+
+    short_uuid = str(uuid.uuid4())[:8]
+    output_file = Path(f'outputs/{speaker}-{short_uuid}.wav')
+
+    # Perintah untuk menjalankan TTS
+    command = [
+        "tts",
+        "--text", text_to_tts,
+        "--model_path", params["model_path"],
+        "--config_path", params["config_path"],
+        "--speaker_idx", speaker,
+        "--out_path", str(output_file)
+    ]
+
+    progress(0.5, desc="Menjalankan proses TTS")
+    result = subprocess.run(command, capture_output=True, text=True)
+    time.sleep(1)
+    if result.returncode != 0:
+        print(f"Error: {result.stderr}")
+        return None
+
+    progress(1, desc="Selesai")
+    return str(output_file)
+
+# Fungsi untuk memperbarui daftar pembicara
+def update_speakers():
+    speakers = [
+        ("Wibowo - Suara jantan berwibawa", "wibowo"),
+        ("Ardi - Suara lembut dan hangat", "ardi"),
+        ("Gadis - Suara perempuan yang merdu", "gadis"),
+        ("Juminten - Suara perempuan jawa (bahasa jawa)", "JV-00264"),
+        ("Asep - Suara lelaki sunda (bahasa sunda)", "SU-00060")
+    ]
+    return speakers
+
+# Fungsi untuk memperbarui dropdown pembicara
+def update_dropdown(_=None, selected_speaker=default_speaker_name):
+    choices = update_speakers()
+    dropdown_choices = {label: label for label, value in choices}
+    return gr.Dropdown(choices=dropdown_choices, value=selected_speaker, label="Pilih Pembicara", interactive=True, allow_custom_value=True)
+
+# Memuat data bahasa
+with open(Path('languages.json'), encoding='utf8') as f:
+    languages = json.load(f)
+
+# Antarmuka Gradio dengan tema MetafisikTheme
+with gr.Blocks(theme=MetafisikTheme()) as app:
+    
+    gr.Markdown("### TTS Bahasa Indonesia", elem_id="main-title")
+    
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(lines=2, label="Teks", value="Halo, saya adalah pembicara virtual.", elem_id="text-input")
+            speed_slider = gr.Slider(label='Kecepatan Bicara', minimum=0.1, maximum=1.99, value=0.8, step=0.01, elem_id="speed-slider")
+            language_dropdown = gr.Dropdown(list(languages.keys()), label="Bahasa", value="Indonesian", elem_id="language-dropdown")
+            submit_button = gr.Button("🗣️ Lakukan Inferensi Audio", elem_id="submit-button")
+            explanation = gr.HTML("""
+            <div style="margin-top: 20px; color: gray;">
+                <h4>Kegunaan Aplikasi</h4>
+                <p>Aplikasi ini digunakan untuk menghasilkan suara berbasis teks dengan berbagai pilihan pembicara. 
+                Teknologi yang digunakan meliputi model text-to-speech (TTS) yang canggih dengan konversi teks ke fonem.
+                Model yang dipakai dilatih khusus untuk bahasa Indonesia, Jawa dan Sunda.</p>
+                <h4>Cara Penggunaan</h4>
+                <ol>
+                    <li>Masukkan teks yang ingin diubah menjadi suara.</li>
+                    <li>Pilih kecepatan bicara yang diinginkan.</li>
+                    <li>Pilih bahasa dan pembicara yang diinginkan.</li>
+                    <li>Klik tombol "Lakukan Inferensi Audio" untuk menghasilkan suara.</li>
+                </ol>
+                <p></p>
+                <p>Semoga <b>Energi Semesta Digital</b> selalu bersama Anda!</p>
+            </div>
+            """)
+            
+        with gr.Column():
+            with gr.Row():
+                gr.Image("ardi.jpg", label="Ardi")
+                gr.Image("gadis.jpg", label="Gadis")
+                gr.Image("wibowo.jpg", label="Wibowo")
+            
+            speaker_dropdown = update_dropdown()
+            refresh_button = gr.Button("👨‍👨‍👦 Segarkan Pembicara", elem_id="refresh-button")
+            audio_output = gr.Audio(elem_id="audio-output")
+
+            refresh_button.click(fn=update_dropdown, inputs=[], outputs=speaker_dropdown)
+            
+    submit_button.click(
+        fn=gen_voice,
+        inputs=[text_input, speaker_dropdown, speed_slider, language_dropdown],
+        outputs=audio_output
+    )
+
+    gr.HTML("""
+    <footer style="text-align: center; margin-top: 20px; color:silver;">
+        Energi Semesta Digital © 2024 __drat. | 🇮🇩 Untuk Indonesia Jaya!
+    </footer>
+    """)
+
+if __name__ == "__main__":
+    app.launch()

config.json

@@ -0,0 +1,308 @@
+{
+    "output_path": "/workspace/TTS",
+    "logger_uri": null,
+    "run_name": "vits_indonesian_multispeaker",
+    "project_name": null,
+    "run_description": "\ud83d\udc38Coqui trainer run.",
+    "print_step": 25,
+    "plot_step": 100,
+    "model_param_stats": false,
+    "wandb_entity": null,
+    "dashboard_logger": "tensorboard",
+    "log_model_step": 10000,
+    "save_step": 10000,
+    "save_n_checkpoints": 5,
+    "save_checkpoints": true,
+    "save_all_best": false,
+    "save_best_after": 10000,
+    "target_loss": null,
+    "print_eval": true,
+    "test_delay_epochs": -1,
+    "run_eval": true,
+    "run_eval_steps": null,
+    "distributed_backend": "nccl",
+    "distributed_url": "tcp://localhost:54321",
+    "mixed_precision": false,
+    "epochs": 1000,
+    "batch_size": 32,
+    "eval_batch_size": 8,
+    "grad_clip": [
+        1000,
+        1000
+    ],
+    "scheduler_after_epoch": true,
+    "lr": 0.001,
+    "optimizer": "AdamW",
+    "optimizer_params": {
+        "betas": [
+            0.8,
+            0.99
+        ],
+        "eps": 1e-09,
+        "weight_decay": 0.01
+    },
+    "lr_scheduler": "",
+    "lr_scheduler_params": {},
+    "use_grad_scaler": false,
+    "cudnn_enable": true,
+    "cudnn_deterministic": false,
+    "cudnn_benchmark": false,
+    "training_seed": 54321,
+    "model": "vits",
+    "num_loader_workers": 4,
+    "num_eval_loader_workers": 4,
+    "use_noise_augment": false,
+    "audio": {
+        "fft_size": 1024,
+        "sample_rate": 22050,
+        "win_length": 1024,
+        "hop_length": 256,
+        "num_mels": 80,
+        "mel_fmin": 0,
+        "mel_fmax": null
+    },
+    "use_phonemes": false,
+    "phonemizer": null,
+    "phoneme_language": "en-us",
+    "compute_input_seq_cache": true,
+    "text_cleaner": "basic_cleaners",
+    "enable_eos_bos_chars": false,
+    "test_sentences_file": "",
+    "phoneme_cache_path": "/workspace/TTS/phoneme_cache",
+    "characters": {
+        "characters_class": "TTS.tts.models.vits.VitsCharacters",
+        "vocab_dict": null,
+        "pad": "<PAD>",
+        "eos": "<EOS>",
+        "bos": "<BOS>",
+        "blank": "<BLNK>",
+        "characters": "abdefhijklmnoprstuwxz\u014b\u0254\u0259\u025b\u0261\u026a\u0272\u0283\u028a\u0292\u0294\u02c8",
+        "punctuations": " !,.?",
+        "phonemes": null,
+        "is_unique": true,
+        "is_sorted": true
+    },
+    "add_blank": true,
+    "batch_group_size": 0,
+    "loss_masking": null,
+    "min_audio_len": 1,
+    "max_audio_len": Infinity,
+    "min_text_len": 1,
+    "max_text_len": Infinity,
+    "compute_f0": false,
+    "compute_linear_spec": true,
+    "precompute_num_workers": 0,
+    "start_by_longest": false,
+    "datasets": [
+        {
+            "name": "coqui",
+            "path": "dataset",
+            "meta_file_train": "metadata-wibowo.csv",
+            "ignored_speakers": null,
+            "language": "",
+            "meta_file_val": "",
+            "meta_file_attn_mask": ""
+        },
+        {
+            "name": "coqui",
+            "path": "dataset",
+            "meta_file_train": "metadata-ardi.csv",
+            "ignored_speakers": null,
+            "language": "",
+            "meta_file_val": "",
+            "meta_file_attn_mask": ""
+        },
+        {
+            "name": "coqui",
+            "path": "dataset",
+            "meta_file_train": "metadata-gadis.csv",
+            "ignored_speakers": null,
+            "language": "",
+            "meta_file_val": "",
+            "meta_file_attn_mask": ""
+        },
+        {
+            "name": "coqui",
+            "path": "dataset",
+            "meta_file_train": "metadata-javanese.csv",
+            "ignored_speakers": null,
+            "language": "",
+            "meta_file_val": "",
+            "meta_file_attn_mask": ""
+        },
+        {
+            "name": "coqui",
+            "path": "dataset",
+            "meta_file_train": "metadata-sundanese.csv",
+            "ignored_speakers": null,
+            "language": "",
+            "meta_file_val": "",
+            "meta_file_attn_mask": ""
+        }
+    ],
+    "test_sentences": [
+        [
+            "\u02c8budi \u02c8makan \u02c8tahu, \u02c8soto, dan \u02c8tempe",
+            "wibowo",
+            null,
+            null
+        ],
+        [
+            "\u02c8tadi \u02c8pa\u0261i \u02c8ali dan \u02c8\u0283afi s\u0259\u02c8dan\u0294 m\u0259n\u0294\u02c8\u0261unakan \u02c8m\u0254t\u0254r di \u02c8kantor \u02c8m\u0259r\u025bka.",
+            "ardi",
+            null,
+            null
+        ],
+        [
+            "\u02c8ardi dan \u02c8thomas \u02c8m\u0259nud\u0292u \u02c8k\u0259 \u02c8s\u0259kolah \u02c8pada \u02c8puk\u028al \u02c8s\u0259pul\u028ah \u02c8pa\u0261i.",
+            "gadis",
+            null,
+            null
+        ],
+        [
+            "\u02c8ardi dan \u02c8thomas \u02c8m\u0259nud\u0292u \u02c8k\u0259 \u02c8s\u0259kolah \u02c8pada \u02c8puk\u028al \u02c8s\u0259pul\u028ah \u02c8pa\u0261i.",
+            "JV-00264",
+            null,
+            null
+        ],
+        [
+            "\u02c8ardi dan \u02c8thomas \u02c8m\u0259nud\u0292u \u02c8k\u0259 \u02c8s\u0259kolah \u02c8pada \u02c8puk\u028al \u02c8s\u0259pul\u028ah \u02c8pa\u0261i.",
+            "SU-00060",
+            null,
+            null
+        ]
+    ],
+    "eval_split_max_size": null,
+    "eval_split_size": 0.01,
+    "use_speaker_weighted_sampler": false,
+    "speaker_weighted_sampler_alpha": 1.0,
+    "use_language_weighted_sampler": false,
+    "language_weighted_sampler_alpha": 1.0,
+    "use_length_weighted_sampler": false,
+    "length_weighted_sampler_alpha": 1.0,
+    "model_args": {
+        "num_chars": 40,
+        "out_channels": 513,
+        "spec_segment_size": 32,
+        "hidden_channels": 192,
+        "hidden_channels_ffn_text_encoder": 768,
+        "num_heads_text_encoder": 2,
+        "num_layers_text_encoder": 6,
+        "kernel_size_text_encoder": 3,
+        "dropout_p_text_encoder": 0.1,
+        "dropout_p_duration_predictor": 0.5,
+        "kernel_size_posterior_encoder": 5,
+        "dilation_rate_posterior_encoder": 1,
+        "num_layers_posterior_encoder": 16,
+        "kernel_size_flow": 5,
+        "dilation_rate_flow": 1,
+        "num_layers_flow": 4,
+        "resblock_type_decoder": "1",
+        "resblock_kernel_sizes_decoder": [
+            3,
+            7,
+            11
+        ],
+        "resblock_dilation_sizes_decoder": [
+            [
+                1,
+                3,
+                5
+            ],
+            [
+                1,
+                3,
+                5
+            ],
+            [
+                1,
+                3,
+                5
+            ]
+        ],
+        "upsample_rates_decoder": [
+            8,
+            8,
+            2,
+            2
+        ],
+        "upsample_initial_channel_decoder": 512,
+        "upsample_kernel_sizes_decoder": [
+            16,
+            16,
+            4,
+            4
+        ],
+        "periods_multi_period_discriminator": [
+            2,
+            3,
+            5,
+            7,
+            11
+        ],
+        "use_sdp": true,
+        "noise_scale": 1.0,
+        "inference_noise_scale": 0.33,
+        "length_scale": 1,
+        "noise_scale_dp": 1.0,
+        "inference_noise_scale_dp": 0.33,
+        "max_inference_len": null,
+        "init_discriminator": true,
+        "use_spectral_norm_disriminator": false,
+        "use_speaker_embedding": true,
+        "num_speakers": 83,
+        "speakers_file": "speakers.pth",
+        "d_vector_file": null,
+        "speaker_embedding_channels": 256,
+        "use_d_vector_file": false,
+        "d_vector_dim": 0,
+        "detach_dp_input": true,
+        "use_language_embedding": false,
+        "embedded_language_dim": 4,
+        "num_languages": 0,
+        "language_ids_file": null,
+        "use_speaker_encoder_as_loss": false,
+        "speaker_encoder_config_path": "",
+        "speaker_encoder_model_path": "",
+        "condition_dp_on_speaker": true,
+        "freeze_encoder": false,
+        "freeze_DP": false,
+        "freeze_PE": false,
+        "freeze_flow_decoder": false,
+        "freeze_waveform_decoder": false,
+        "encoder_sample_rate": null,
+        "interpolate_z": true,
+        "reinit_DP": true,
+        "reinit_text_encoder": false
+    },
+    "lr_gen": 0.0002,
+    "lr_disc": 0.0002,
+    "lr_scheduler_gen": "ExponentialLR",
+    "lr_scheduler_gen_params": {
+        "gamma": 0.999875,
+        "last_epoch": -1
+    },
+    "lr_scheduler_disc": "ExponentialLR",
+    "lr_scheduler_disc_params": {
+        "gamma": 0.999875,
+        "last_epoch": -1
+    },
+    "kl_loss_alpha": 1.0,
+    "disc_loss_alpha": 1.0,
+    "gen_loss_alpha": 1.0,
+    "feat_loss_alpha": 1.0,
+    "mel_loss_alpha": 45.0,
+    "dur_loss_alpha": 1.0,
+    "speaker_encoder_loss_alpha": 1.0,
+    "return_wav": true,
+    "r": 1,
+    "num_speakers": 0,
+    "use_speaker_embedding": true,
+    "speakers_file": "speakers.pth",
+    "speaker_embedding_channels": 256,
+    "language_ids_file": null,
+    "use_language_embedding": false,
+    "use_d_vector_file": false,
+    "d_vector_file": null,
+    "d_vector_dim": 0
+}

docker-compose.yml

@@ -0,0 +1,23 @@
+version: '3.8'
+
+services:
+  tts-api:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: tts-indonesia-api
+    ports:
+      - "7860:7860"
+    environment:
+      - PORT=7860
+    volumes:
+      # Mount outputs folder untuk persist data (optional)
+      - ./outputs:/app/outputs
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:7860/api/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+

g2pid/.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.DS_Store
+.backup/
+.data/

g2pid/__init__.py

@@ -0,0 +1,3 @@
+from .g2p import G2P
+
+__version__ = "0.0.5"

g2pid/g2p.py

@@ -0,0 +1,220 @@
+import json
+import os
+import re
+
+import numpy as np
+import onnxruntime
+from nltk.tokenize import TweetTokenizer
+from sacremoses import MosesDetokenizer
+
+from .syllable_splitter import SyllableSplitter
+
+ABJAD_MAPPING = {
+    "a": "a",
+    "b": "bé",
+    "c": "cé",
+    "d": "dé",
+    "e": "é",
+    "f": "èf",
+    "g": "gé",
+    "h": "ha",
+    "i": "i",
+    "j": "jé",
+    "k": "ka",
+    "l": "èl",
+    "m": "èm",
+    "n": "èn",
+    "o": "o",
+    "p": "pé",
+    "q": "ki",
+    "r": "èr",
+    "s": "ès",
+    "t": "té",
+    "u": "u",
+    "v": "vé",
+    "w": "wé",
+    "x": "èks",
+    "y": "yé",
+    "z": "zèt",
+}
+
+PHONETIC_MAPPING = {
+    "sy": "ʃ",
+    "ny": "ɲ",
+    "ng": "ŋ",
+    "dj": "dʒ",
+    "'": "ʔ",
+    "c": "tʃ",
+    "é": "e",
+    "è": "ɛ",
+    "ê": "ə",
+    "g": "ɡ",
+    "I": "ɪ",
+    "j": "dʒ",
+    "ô": "ɔ",
+    "q": "k",
+    "U": "ʊ",
+    "v": "f",
+    "x": "ks",
+    "y": "j",
+}
+
+
+dirname = os.path.dirname(__file__)
+
+# Predict pronounciation with BERT Masking
+# Read more: https://w11wo.github.io/posts/2022/04/predicting-phonemes-with-bert/
+class Predictor:
+    def __init__(self, model_path):
+        # fmt: off
+        self.vocab = ['', '[UNK]', 'a', 'n', 'ê', 'e', 'i', 'r', 'k', 's', 't', 'g', 'm', 'u', 'l', 'p', 'o', 'd', 'b', 'h', 'c', 'j', 'y', 'f', 'w', 'v', 'z', 'x', 'q', '[mask]']
+        self.mask_token_id = self.vocab.index("[mask]")
+        # fmt: on
+        self.session = onnxruntime.InferenceSession(model_path)
+
+    def predict(self, word: str) -> str:
+        """
+        Predict the phonetic representation of a word.
+
+        Args:
+            word (str): The word to predict.
+
+        Returns:
+            str: The predicted phonetic representation of the word.
+        """
+        text = [self.vocab.index(c) if c != "e" else self.mask_token_id for c in word]
+        text.extend([0] * (32 - len(text)))  # Pad to 32 tokens
+        inputs = np.array([text], dtype=np.int64)
+        (predictions,) = self.session.run(None, {"input_4": inputs})
+
+        # find masked idx token
+        _, masked_index = np.where(inputs == self.mask_token_id)
+
+        # get prediction at those masked index only
+        mask_prediction = predictions[0][masked_index]
+        predicted_ids = np.argmax(mask_prediction, axis=1)
+
+        # replace mask with predicted token
+        for i, idx in enumerate(masked_index):
+            text[idx] = predicted_ids[i]
+
+        return "".join([self.vocab[i] for i in text if i != 0])
+
+
+class G2P:
+    def __init__(self):
+        self.tokenizer = TweetTokenizer()
+        self.detokenizer = MosesDetokenizer(lang="id")
+
+        dict_path = os.path.join(dirname, "data/dict.json")
+        with open(dict_path) as f:
+            self.dict = json.load(f)
+
+        model_path = os.path.join(dirname, "model/bert_pron.onnx")
+        self.predictor = Predictor(model_path)
+
+        self.syllable_splitter = SyllableSplitter()
+
+    def __call__(self, text: str) -> str:
+        """
+        Convert text to phonetic representation.
+
+        Args:
+            text (str): The text to convert.
+
+        Returns:
+            str: The phonetic representation of the text.
+        """
+        text = text.lower()
+        text = re.sub(r"[^ a-z0-9'\.,?!-]", "", text)
+        text = text.replace("-", " ")
+
+        prons = []
+        words = self.tokenizer.tokenize(text)
+        for word in words:
+            # PUEBI pronunciation
+            if word in self.dict:
+                pron = self.dict[word]
+            elif len(word) == 1 and word in ABJAD_MAPPING:
+                pron = ABJAD_MAPPING[word]
+            elif "e" not in word or not word.isalpha():
+                pron = word
+            elif "e" in word:
+                pron = self.predictor.predict(word)
+
+            # Replace alofon /e/ with e (temporary)
+            pron = pron.replace("é", "e")
+            pron = pron.replace("è", "e")
+
+            # Replace /x/ with /s/
+            if pron.startswith("x"):
+                pron = "s" + pron[1:]
+
+            sylls = self.syllable_splitter.split_syllables(pron)
+            # Decide where to put the stress
+            stress_loc = len(sylls) - 1
+            if len(sylls) > 1 and "ê" in sylls[-2]:
+                if "ê" in sylls[-1]:
+                    stress_loc = len(sylls) - 2
+                else:
+                    stress_loc = len(sylls)
+
+            # Apply rules on syllable basis
+            # All alophone are set to tense by default
+            # and will be changed to lax if needed
+            alophone = {"e": "é", "o": "o"}
+            alophone_map = {"i": "I", "u": "U", "e": "è", "o": "ô"}
+            for i, syll in enumerate(sylls, start=1):
+                # Put Syllable stress
+                if i == stress_loc:
+                    syll = "ˈ" + syll
+
+                # Alophone syllable rules
+                for v in ["e", "o"]:
+                    # Replace with lax allphone [��, ɔ] if
+                    # in closed final syllables
+                    if v in syll and not syll.endswith(v) and i == len(sylls):
+                        alophone[v] = alophone_map[v]
+
+                # Alophone syllable stress rules
+                for v in ["i", "u"]:
+                    # Replace with lax allphone [ɪ, ʊ] if
+                    # in the middle of syllable without stress
+                    # and not ends with coda nasal [m, n, ng] (except for final syllable)
+                    if (
+                        v in syll
+                        and not syll.startswith("ˈ")
+                        and not syll.endswith(v)
+                        and (
+                            not any(syll.endswith(x) for x in ["m", "n", "ng"])
+                            or i == len(sylls)
+                        )
+                    ):
+                        syll = syll.replace(v, alophone_map[v])
+
+                if syll.endswith("nk"):
+                    syll = syll[:-2] + "ng"
+                elif syll.endswith("d"):
+                    syll = syll[:-1] + "t"
+                elif syll.endswith("b"):
+                    syll = syll[:-1] + "p"
+                elif syll.endswith("k") or (
+                    syll.endswith("g") and not syll.endswith("ng")
+                ):
+                    syll = syll[:-1] + "'"
+                sylls[i - 1] = syll
+
+            pron = "".join(sylls)
+            # Apply phonetic and alophone mapping
+            for v in alophone:
+                if v == "o" and pron.count("o") == 1:
+                    continue
+                pron = pron.replace(v, alophone[v])
+            for g, p in PHONETIC_MAPPING.items():
+                pron = pron.replace(g, p)
+            pron = pron.replace("kh", "x")
+
+            prons.append(pron)
+            prons.append(" ")
+
+        return self.detokenizer.detokenize(prons)

g2pid/syllable_splitter.py

@@ -0,0 +1,127 @@
+# Copied from https://github.com/fahadh4ilyas/syllable_splitter
+# MIT License
+import re
+
+
+class SyllableSplitter:
+    def __init__(self):
+        self.consonant = set(
+            [
+                "b",
+                "c",
+                "d",
+                "f",
+                "g",
+                "h",
+                "j",
+                "k",
+                "l",
+                "m",
+                "n",
+                "p",
+                "q",
+                "r",
+                "s",
+                "t",
+                "v",
+                "w",
+                "x",
+                "y",
+                "z",
+                "ng",
+                "ny",
+                "sy",
+                "ch",
+                "dh",
+                "gh",
+                "kh",
+                "ph",
+                "sh",
+                "th",
+            ]
+        )
+        self.double_consonant = set(["ll", "ks", "rs", "rt", "nk", "nd"])
+        self.vocal = set(["a", "e", "ê", "é", "è", "i", "o", "u"])
+
+    def split_letters(self, string):
+        letters = []
+        arrange = []
+
+        while string != "":
+            letter = string[:2]
+
+            if letter in self.double_consonant:
+                if string[2:] != "" and string[2] in self.vocal:
+                    letters += [letter[0]]
+                    arrange += ["c"]
+                    string = string[1:]
+                else:
+                    letters += [letter]
+                    arrange += ["c"]
+                    string = string[2:]
+            elif letter in self.consonant:
+                letters += [letter]
+                arrange += ["c"]
+                string = string[2:]
+            elif letter in self.vocal:
+                letters += [letter]
+                arrange += ["v"]
+                string = string[2:]
+            else:
+                letter = string[0]
+
+                if letter in self.consonant:
+                    letters += [letter]
+                    arrange += ["c"]
+                    string = string[1:]
+                elif letter in self.vocal:
+                    letters += [letter]
+                    arrange += ["v"]
+                    string = string[1:]
+                else:
+                    letters += [letter]
+                    arrange += ["s"]
+                    string = string[1:]
+
+        return letters, "".join(arrange)
+
+    def split_syllables_from_letters(self, letters, arrange):
+        consonant_index = re.search(r"vc{2,}", arrange)
+        while consonant_index:
+            i = consonant_index.start() + 1
+            letters = letters[: i + 1] + ["|"] + letters[i + 1 :]
+            arrange = arrange[: i + 1] + "|" + arrange[i + 1 :]
+            consonant_index = re.search(r"vc{2,}", arrange)
+
+        vocal_index = re.search(r"v{2,}", arrange)
+        while vocal_index:
+            i = vocal_index.start()
+            letters = letters[: i + 1] + ["|"] + letters[i + 1 :]
+            arrange = arrange[: i + 1] + "|" + arrange[i + 1 :]
+            vocal_index = re.search(r"v{2,}", arrange)
+
+        vcv_index = re.search(r"vcv", arrange)
+        while vcv_index:
+            i = vcv_index.start()
+            letters = letters[: i + 1] + ["|"] + letters[i + 1 :]
+            arrange = arrange[: i + 1] + "|" + arrange[i + 1 :]
+            vcv_index = re.search(r"vcv", arrange)
+
+        sep_index = re.search(r"[cvs]s", arrange)
+        while sep_index:
+            i = sep_index.start()
+            letters = letters[: i + 1] + ["|"] + letters[i + 1 :]
+            arrange = arrange[: i + 1] + "|" + arrange[i + 1 :]
+            sep_index = re.search(r"[cvs]s", arrange)
+
+        sep_index = re.search(r"s[cvs]", arrange)
+        while sep_index:
+            i = sep_index.start()
+            letters = letters[: i + 1] + ["|"] + letters[i + 1 :]
+            arrange = arrange[: i + 1] + "|" + arrange[i + 1 :]
+            sep_index = re.search(r"s[cvs]", arrange)
+        return "".join(letters).split("|")
+
+    def split_syllables(self, string):
+        letters, arrange = self.split_letters(string)
+        return self.split_syllables_from_letters(letters, arrange)

languages.json

@@ -0,0 +1,19 @@
+{
+  "Arabic": "ar",
+  "Chinese": "zh-cn",
+  "Czech": "cs",
+  "Dutch": "nl",
+  "English": "en",
+  "French": "fr",
+  "German": "de",
+  "Hungarian": "hu",
+  "Indonesian": "id",
+  "Italian": "it",
+  "Japanese": "ja",
+  "Korean": "ko",
+  "Polish": "pl",
+  "Portuguese": "pt",
+  "Russian": "ru",
+  "Spanish": "es",
+  "Turkish": "tr"
+}

requirements.txt

@@ -0,0 +1,8 @@
+TTS
+sacremoses>=0.0.41
+nltk>=3.7
+onnxruntime>=1.7.0
+torch
+fastapi>=0.100.0
+uvicorn[standard]>=0.23.0
+python-multipart>=0.0.6

themes.py

@@ -0,0 +1,84 @@
+"""
+████████╗████████╗███████╗                                                          
+╚══██╔══╝╚══██╔══╝██╔════╝                                                          
+   ██║      ██║   ███████╗                                                          
+   ██║      ██║   ╚════██║                                                          
+   ██║      ██║   ███████║                                                          
+   ╚═╝      ╚═╝   ╚══════╝                                                          
+██╗███╗   ██╗██████╗  ██████╗ ███╗   ██╗███████╗███████╗██╗ █████╗ ██╗  ██╗██╗   ██╗
+██║████╗  ██║██╔══██╗██╔═══██╗████╗  ██║██╔════╝██╔════╝██║██╔══██╗██║ ██╔╝██║   ██║
+██║██╔██╗ ██║██║  ██║██║   ██║██╔██╗ ██║█████╗  ███████╗██║███████║█████╔╝ ██║   ██║
+██║██║╚██╗██║██║  ██║██║   ██║██║╚██╗██║██╔══╝  ╚════██║██║██╔══██║██╔═██╗ ██║   ██║
+██║██║ ╚████║██████╔╝╚██████╔╝██║ ╚████║███████╗███████║██║██║  ██║██║  ██╗╚██████╔╝
+╚═╝╚═╝  ╚═══╝╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚══════╝╚══════╝╚═╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ 
+                                                                                    
+Script ini dibuat oleh __drat
+
+Petunjuk:
+1. Script ini digunakan untuk menghasilkan suara berbasis teks dengan berbagai pilihan pembicara.
+2. Teknologi yang digunakan meliputi model text-to-speech (TTS) yang canggih dengan konversi teks ke fonem (G2P).
+3. Model yang dipakai dilatih khusus untuk bahasa Indonesia, Jawa, dan Sunda.
+4. Antarmuka dibuat dengan menggunakan Gradio dengan tema kustom bernama MetafisikTheme.
+
+Cara Menggunakan:
+1. Masukkan teks yang ingin diubah menjadi suara.
+2. Pilih kecepatan bicara yang diinginkan.
+3. Pilih bahasa dan pembicara yang diinginkan.
+4. Klik tombol "Lakukan Inferensi Audio" untuk menghasilkan suara.
+"""
+
+from __future__ import annotations
+from typing import Iterable
+from gradio.themes.base import Base
+from gradio.themes.utils import colors, fonts, sizes
+
+class MetafisikTheme(Base):
+    def __init__(
+        self,
+        *,
+        primary_hue: colors.Color | str = colors.orange,
+        secondary_hue: colors.Color | str = colors.yellow,
+        neutral_hue: colors.Color | str = colors.gray,
+        spacing_size: sizes.Size | str = sizes.spacing_md,
+        radius_size: sizes.Size | str = sizes.radius_md,
+        text_size: sizes.Size | str = sizes.text_lg,
+        font: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("Quicksand"),
+            "ui-sans-serif",
+            "sans-serif",
+        ),
+        font_mono: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("IBM Plex Mono"),
+            "ui-monospace",
+            "monospace",
+        ),
+    ):
+        super().__init__(
+            primary_hue=primary_hue,
+            secondary_hue=secondary_hue,
+            neutral_hue=neutral_hue,
+            spacing_size=spacing_size,
+            radius_size=radius_size,
+            text_size=text_size,
+            font=font,
+            font_mono=font_mono,
+        )
+        super().set(
+            body_background_fill="linear-gradient(to bottom, #FFFFE0, #FFFFFF)",  # Gradient from light yellow to white
+            body_background_fill_dark="linear-gradient(to bottom, #FFFFE0, #FFFFFF)",  # Same gradient for dark mode
+            button_primary_background_fill="linear-gradient(90deg, #FFA500, #FF4500)",  # Orange to dark orange gradient
+            button_primary_background_fill_hover="linear-gradient(90deg, #FFB347, #FF6347)",  # Lighter orange gradient
+            button_primary_text_color="white",
+            button_primary_background_fill_dark="linear-gradient(90deg, #FF8C00, #FF4500)",  # Darker orange gradient
+            slider_color="*secondary_300",
+            slider_color_dark="*secondary_600",
+            block_title_text_weight="600",
+            block_border_width="3px",
+            block_shadow="*shadow_drop_lg",
+            button_shadow="*shadow_drop_lg",
+            button_large_padding="32px",
+        )

tts_standalone.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Standalone TTS Program untuk Bahasa Indonesia
+Berdasarkan app.py - TTS Indonesiaku Gratis
+
+Program ini menghasilkan file audio dari teks Bahasa Indonesia
+dengan menggunakan model TTS yang sudah dilatih khusus untuk bahasa Indonesia.
+
+Parameter:
+- text: Teks yang akan diubah menjadi suara
+- file_path: Path file output audio (.wav)
+"""
+
+import subprocess
+import html
+from pathlib import Path
+
+try:
+    from g2pid import G2P
+    # Inisialisasi G2P (Grapheme to Phoneme)
+    g2p = G2P()
+    G2P_AVAILABLE = True
+except ImportError:
+    print("WARNING: G2P module tidak tersedia. Install dependencies dengan: pip install -r requirements.txt")
+    G2P_AVAILABLE = False
+
+# Parameter default untuk konfigurasi
+params = {
+    "model_path": "checkpoint_1260000-inference.pth",
+    "config_path": "config.json",
+    # "speaker": "ardi"  # Default speaker
+    "speaker": "gadis"  # Default speaker
+}
+# params = {
+#     "model_path": "kobov2.pth",
+#     "config_path": "config.json",
+#     # "speaker": "kobov2.index"  # Default speaker
+#     "speaker": "gadis",
+# }
+
+def generate_tts(text, file_path, speaker="ardi"):
+    """
+    Generate TTS audio dari teks Bahasa Indonesia
+    
+    Args:
+        text (str): Teks yang akan diubah menjadi suara
+        file_path (str): Path file output audio (.wav)
+        speaker (str): Nama speaker (default: "ardi")
+    
+    Returns:
+        bool: True jika berhasil, False jika gagal
+    """
+    try:
+        print(f"Memproses teks: {text}")
+        
+        # Konversi teks ke format TTS menggunakan G2P jika tersedia
+        if G2P_AVAILABLE:
+            print("Mengonversi teks ke fonem...")
+            text_to_tts = g2p(text)
+            print(f"Teks setelah konversi G2P: {text_to_tts}")
+        else:
+            print("WARNING: Menggunakan teks asli tanpa konversi G2P")
+            text_to_tts = text
+        
+        # Pastikan direktori output ada
+        output_path = Path(file_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Perintah untuk menjalankan TTS
+        command = [
+            "tts",
+            "--text", text_to_tts,
+            "--model_path", params["model_path"],
+            "--config_path", params["config_path"],
+            "--speaker_idx", speaker,
+            "--out_path", str(output_path)
+        ]
+        
+        print("Menjalankan proses TTS...")
+        print(f"Command: {' '.join(command)}")
+        
+        # Jalankan proses TTS
+        result = subprocess.run(command, capture_output=True, text=True)
+        
+        if result.returncode != 0:
+            print(f"Error: {result.stderr}")
+            return False
+        
+        print(f"SUCCESS: Audio berhasil dibuat: {file_path}")
+        return True
+        
+    except Exception as e:
+        print(f"ERROR: {str(e)}")
+        return False
+
+def main():
+    """
+    Fungsi utama dengan parameter yang diminta
+    """
+    # Parameter sesuai permintaan
+    text = "Selamat pagi, nama saya Aryo."
+    file_path = "output_id_coqui.wav"
+    
+    print("=" * 60)
+    print("TTS Standalone - Bahasa Indonesia")
+    print("=" * 60)
+    print(f"Teks: {text}")
+    print(f"Output file: {file_path}")
+    print(f"Speaker: {params['speaker']}")
+    print("=" * 60)
+    
+    # Generate TTS
+    success = generate_tts(text, file_path, params["speaker"])
+    
+    if success:
+        print("\nSUCCESS: Proses TTS selesai!")
+        print(f"File audio tersimpan di: {file_path}")
+    else:
+        print("\nERROR: Proses TTS gagal!")
+        print("Pastikan:")
+        print("1. Model checkpoint_1260000-inference.pth tersedia")
+        print("2. File config.json tersedia")
+        print("3. TTS library terinstall (pip install TTS)")
+        print("4. Speaker tersedia dalam model")
+        print("5. Dependencies terinstall: pip install -r requirements.txt")
+
+if __name__ == "__main__":
+    main()