Spaces:
Running
Running
File size: 3,368 Bytes
60bd17d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
import os
import time
import logging
import numpy as np
import soundfile as sf
from typing import Optional, Tuple, Generator
# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# Constants
DEFAULT_SAMPLE_RATE = 24000
# Global client instance (lazy loaded)
_client = None
def _get_client():
"""Lazy-load the Kokoro Space client to avoid loading it until needed"""
global _client
if _client is None:
logger.info("Loading Kokoro Space client...")
try:
# Import gradio client
from gradio_client import Client
# Initialize the client
logger.info("Initializing Kokoro Space client")
_client = Client("Remsky/Kokoro-TTS-Zero")
# Log client details
logger.info("Kokoro Space client loaded successfully")
logger.info(f"Client type: {type(_client).__name__}")
except ImportError as import_err:
logger.error(f"Import error loading Kokoro Space client: {import_err}")
logger.error("This may indicate missing dependencies")
raise
except Exception as e:
logger.error(f"Error loading Kokoro Space client: {e}", exc_info=True)
logger.error(f"Error type: {type(e).__name__}")
raise
return _client
def generate_speech(text: str, language: str = "z", voice: str = "af_nova", speed: float = 1.0) -> str:
"""Public interface for TTS generation using Kokoro Space
This is a legacy function maintained for backward compatibility.
New code should use the factory pattern implementation directly.
Args:
text (str): Input text to synthesize
language (str): Language code (not used in Kokoro Space, kept for API compatibility)
voice (str): Voice ID to use (e.g., 'af_nova', 'af_bella', etc.)
speed (float): Speech speed multiplier (0.5 to 2.0)
Returns:
str: Path to the generated audio file
"""
logger.info(f"Legacy Kokoro Space generate_speech called with text length: {len(text)}")
# Use the new implementation via factory pattern
from utils.tts_engines import KokoroSpaceTTSEngine
try:
# Create a Kokoro Space engine and generate speech
kokoro_space_engine = KokoroSpaceTTSEngine(language)
return kokoro_space_engine.generate_speech(text, voice, speed)
except Exception as e:
logger.error(f"Error in legacy Kokoro Space generate_speech: {str(e)}", exc_info=True)
# Fall back to dummy TTS
from utils.tts_base import DummyTTSEngine
dummy_engine = DummyTTSEngine()
return dummy_engine.generate_speech(text)
def _create_output_dir() -> str:
"""Create output directory for audio files
Returns:
str: Path to the output directory
"""
output_dir = "temp/outputs"
os.makedirs(output_dir, exist_ok=True)
return output_dir
def _generate_output_path(prefix: str = "output") -> str:
"""Generate a unique output path for audio files
Args:
prefix (str): Prefix for the output filename
Returns:
str: Path to the output file
"""
output_dir = _create_output_dir()
timestamp = int(time.time())
return f"{output_dir}/{prefix}_{timestamp}.wav" |