app.py

import spaces
from kokoro import KModel, KPipeline
import gradio as gr
import os
import random
import torch
import openai

# Check if running in a duplicate space
IS_DUPLICATE = not os.getenv('SPACE_ID', '').startswith('hexgrad/')
CHAR_LIMIT = None if IS_DUPLICATE else 5000

# Check if CUDA is available
CUDA_AVAILABLE = torch.cuda.is_available()

# Load the models (GPU and CPU versions)
models = {gpu: KModel().to('cuda' if gpu else 'cpu').eval() for gpu in [False] + ([True] if CUDA_AVAILABLE else [])}
pipelines = {lang_code: KPipeline(lang_code=lang_code, model=False) for lang_code in 'abefhijpz'}
pipelines['a'].g2p.lexicon.golds['kokoro'] = 'kˈOkəɹO'
pipelines['b'].g2p.lexicon.golds['kokoro'] = 'kˈQkəɹQ'

# GPU function to generate audio
@spaces.GPU(duration=10)
def forward_gpu(ps, ref_s, speed):
    return models[True](ps, ref_s, speed)

# Function to generate first output
def generate_first(text, voice='af_heart', speed=1, use_gpu=CUDA_AVAILABLE):
    text = text if CHAR_LIMIT is None else text.strip()[:CHAR_LIMIT]
    pipeline = pipelines[voice[0]]
    pack = pipeline.load_voice(voice)
    use_gpu = use_gpu and CUDA_AVAILABLE
    for _, ps, _ in pipeline(text, voice, speed):
        ref_s = pack[len(ps)-1]
        try:
            if use_gpu:
                audio = forward_gpu(ps, ref_s, speed)
            else:
                audio = models[False](ps, ref_s, speed)
        except gr.exceptions.Error as e:
            if use_gpu:
                gr.Warning(str(e))
                gr.Info('Retrying with CPU. To avoid this error, change Hardware to CPU.')
                audio = models[False](ps, ref_s, speed)
            else:
                raise gr.Error(e)
        return (24000, audio.numpy()), ps
    return None, ''

# Function to tokenize first
def tokenize_first(text, voice='af_heart'):
    words = text.split()  # This splits the text into words based on spaces
    return words  # Return a list of words

# Function to get random text for the "Random Text" button
random_texts = {}
for lang in ['en']:
    with open(f'{lang}.txt', 'r') as r:
        random_texts[lang] = [line.strip() for line in r]

def get_random_text(voice):
    lang = dict(a='en', b='en')[voice[0]]
    return random.choice(random_texts[lang])

# OpenAI GPT-4 translation function
def translate_to_english(text, model="gpt-4"):
    try:
        response = openai.Completion.create(
            model=model,
            prompt=f"Translate the following text to English:\n\n{text}",
            temperature=0.5,
            max_tokens=500,
        )
        return response.choices[0].text.strip()
    except Exception as e:
        return str(e)

# Function to handle generation for translated text
def translate_and_generate(text, voice, speed):
    translated_text = translate_to_english(text)
    audio, tokens = generate_first(translated_text, voice, speed, use_gpu=CUDA_AVAILABLE)
    return audio, tokens, translated_text

# Predefined voices for the dropdown menu
CHOICES = {
    '🇺🇸 🚺 Heart ❤️': 'af_heart',
    '🇺🇸 🚺 Bella 🔥': 'af_bella',
    '🇺🇸 🚺 Nicole 🎧': 'af_nicole',
    '🇺🇸 🚺 Aoede': 'af_aoede',
    '🇺🇸 🚺 Kore': 'af_kore',
    '🇺🇸 🚺 Sarah': 'af_sarah',
    '🇺🇸 🚺 Nova': 'af_nova',
    '🇺🇸 🚺 Sky': 'af_sky',
    '🇺🇸 🚺 Alloy': 'af_alloy',
    '🇺🇸 🚺 Jessica': 'af_jessica',
    '🇺🇸 🚺 River': 'af_river',
    
    '🇺🇸 🚹 Michael': 'am_michael',
    '🇺🇸 🚹 Fenrir': 'am_fenrir',
    '🇺🇸 🚹 Puck': 'am_puck',
    '🇺🇸 🚹 Echo': 'am_echo',
    '🇺🇸 🚹 Eric': 'am_eric',
    '🇺🇸 🚹 Liam': 'am_liam',
    '🇺🇸 🚹 Onyx': 'am_onyx',
    '🇺🇸 🚹 Santa': 'am_santa',
    '🇺🇸 🚹 Adam': 'am_adam',
    
    '🇬🇧 🚺 Emma': 'bf_emma',
    '🇬🇧 🚺 Isabella': 'bf_isabella',
    '🇬🇧 🚺 Alice': 'bf_alice',
    '🇬🇧 🚺 Lily': 'bf_lily',
    
    '🇬🇧 🚹 George': 'bm_george',
    '🇬🇧 🚹 Fable': 'bm_fable',
    '🇬🇧 🚹 Lewis': 'bm_lewis',
    '🇬🇧 🚹 Daniel': 'bm_daniel',
    
    '🇪🇸 🚺 Dora': 'ef_dora',
    
    '🇪🇸 🚹 Alex': 'em_alex',
    '🇪🇸 🚹 Santa': 'em_santa',
    
    '🇫🇷 🚺 Siwis': 'ff_siwis',
    
    '🇮🇳 🚹 Alpha': 'hf_alpha',
    '🇮🇳 🚹 Beta': 'hf_beta',
    
    '🇮🇳 🚹 Omega': 'hm_omega',
    '🇮🇳 🚹 Psi': 'hm_psi',
    
    '🇮🇹 🚺 Sara': 'if_sara',
    
    '🇮🇹 🚺 Nicola': 'im_nicola',
    
    '🇯🇵 🚹 Alpha': 'jf_alpha',
    '🇯🇵 🚹 Gongitsune': 'jf_gongitsune',
    '🇯🇵 🚹 Nezumi': 'jf_nezumi',
    '🇯🇵 🚹 Tebukuro': 'jf_tebukuro',
    
    '🇯🇵 🚹 Kumo': 'jm_kumo',
    
    '🇧🇷 🚺 Dora': 'pf_dora',
    
    '🇧🇷 🚹 Alex': 'pm_alex',
    '🇧🇷 🚹 Santa': 'pm_santa',
    
    '🇨🇳 🚺 Xiaobei': 'zf_xiaobei',
    '🇨🇳 🚺 Xiaoni': 'zf_xiaoni',
    '🇨🇳 🚺 Xiaoxiao': 'zf_xiaoxiao',
    '🇨🇳 🚺 Xiaoyi': 'zf_xiaoyi',

    '🇨🇳 🚹 Yunjian': 'zm_yunjian',
    '🇨🇳 🚹 Yunxi': 'zm_yunxi',
    '🇨🇳 🚹 Yunxia': 'zm_yunxia',
    '🇨🇳 🚹 Yunyang': 'zm_yunyang',
}

# Load voices
for v in CHOICES.values():
    pipelines[v[0]].load_voice(v)

# Build the interface
with gr.Blocks() as generate_tab:
    out_audio = gr.Audio(label='Output Audio', interactive=False, streaming=False, autoplay=True)
    generate_btn = gr.Button('Generate', variant='primary')
    with gr.Accordion('Output Tokens', open=True):
        out_ps = gr.Textbox(interactive=False, show_label=False, info='Tokens used to generate the audio, up to 510 context length.')
        tokenize_btn = gr.Button('Tokenize', variant='secondary')
        predict_btn = gr.Button('Predict', variant='secondary', visible=False)

# Translator Tab
with gr.Blocks() as translator_tab:
    trans_out_audio = gr.Audio(label='Translated Audio Output', interactive=False, streaming=False, autoplay=True)
    trans_out_tokens = gr.Textbox(interactive=False, show_label=False, info='Tokens used to generate the translated audio')
    translate_btn = gr.Button('Translate & Generate Audio', variant='primary')
    
    translate_btn.click(fn=translate_and_generate, inputs=[text, voice, speed], outputs=[trans_out_audio, trans_out_tokens, text], api_name=None)

# Main Interface
with gr.Blocks() as app:
    with gr.Row():
        gr.Markdown('''[***Kokoro*** **is an open-weight TTS model with 82 million parameters.**](https://huggingface.co/hexgrad/Kokoro-82M)
        As of January 31st, 2025, Kokoro was the most-liked [**TTS model**](https://huggingface.co/models?pipeline_tag=text-to-speech&sort=likes) and the most-liked [**TTS space**](https://huggingface.co/spaces?sort=likes&search=tts) on Hugging Face.
        This demo only showcases English, but you can directly use the model to access other languages.''', container=True)
    
    with gr.Row():
        with gr.Column():
            text = gr.Textbox(label='Input Text', info=f"Up to ~500 characters per Generate, or {'∞' if CHAR_LIMIT is None else CHAR_LIMIT} characters per Stream")
            with gr.Row():
                voice = gr.Dropdown(list(CHOICES.items()), value='af_heart', label='Voice', info='Quality and availability vary by language')
                use_gpu = gr.Dropdown(
                    [('ZeroGPU 🚀', True), ('CPU 🐌', False)],
                    value=CUDA_AVAILABLE,
                    label='Hardware',
                    info='GPU is usually faster, but has a usage quota',
                    interactive=CUDA_AVAILABLE
                )
            speed = gr.Slider(minimum=0.5, maximum=2, value=1, step=0.1, label='Speed')
            random_btn = gr.Button('Random Text', variant='secondary')
        with gr.Column():
            gr.TabbedInterface([generate_tab, translator_tab], ['Generate', 'Translator'])
    
    random_btn.click(fn=get_random_text, inputs=[voice], outputs=[text])
    generate_btn.click(fn=generate_first, inputs=[text, voice, speed, use_gpu], outputs=[out_audio, out_ps])
    tokenize_btn.click(fn=tokenize_first, inputs=[text, voice], outputs=[out_ps])
    predict_btn.click(fn=predict, inputs=[text, voice, speed], outputs=[out_audio])

if __name__ == '__main__':
    app.queue().launch(show_api=True)