handle dia model not available

utils/tts_dia_space.py

@@ -0,0 +1,154 @@
+import os
+import time
+import logging
+import requests
+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 = 44100
+DEFAULT_API_URL = "https://droolingpanda-dia-tts-server.hf.space"
+DEFAULT_MODEL = "dia-1.6b"
+
+# Global client instance (lazy loaded)
+_client = None
+
+
+def _get_client():
+    """Lazy-load the Dia Space client to avoid loading it until needed"""
+    global _client
+    if _client is None:
+        logger.info("Loading Dia Space client...")
+        try:
+            # Import requests if not already imported
+            import requests
+            
+            # Initialize the client (just a session for now)
+            logger.info("Initializing Dia Space client")
+            _client = requests.Session()
+            
+            # Test connection to the API
+            response = _client.get(f"{DEFAULT_API_URL}/docs")
+            if response.status_code == 200:
+                logger.info("Dia Space client loaded successfully")
+                logger.info(f"Client type: {type(_client).__name__}")
+            else:
+                logger.warning(f"Dia Space API returned status code {response.status_code}")
+        except ImportError as import_err:
+            logger.error(f"Import error loading Dia Space client: {import_err}")
+            logger.error("This may indicate missing dependencies")
+            raise
+        except Exception as e:
+            logger.error(f"Error loading Dia Space client: {e}", exc_info=True)
+            logger.error(f"Error type: {type(e).__name__}")
+            raise
+    return _client
+
+
+def generate_speech(text: str, language: str = "zh", voice: str = "S1", response_format: str = "wav", speed: float = 1.0) -> str:
+    """Public interface for TTS generation using Dia Space API
+    
+    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 Dia Space, kept for API compatibility)
+        voice (str): Voice mode to use ('S1', 'S2', 'dialogue', or filename for clone)
+        response_format (str): Audio format ('wav', 'mp3', 'opus')
+        speed (float): Speech speed multiplier
+        
+    Returns:
+        str: Path to the generated audio file
+    """
+    logger.info(f"Legacy Dia Space generate_speech called with text length: {len(text)}")
+    
+    # Use the new implementation via factory pattern
+    from utils.tts_engines import DiaSpaceTTSEngine
+    
+    try:
+        # Create a Dia Space engine and generate speech
+        dia_space_engine = DiaSpaceTTSEngine(language)
+        return dia_space_engine.generate_speech(text, voice, speed, response_format)
+    except Exception as e:
+        logger.error(f"Error in legacy Dia 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", extension: str = "wav") -> str:
+    """Generate a unique output path for audio files
+    
+    Args:
+        prefix (str): Prefix for the output filename
+        extension (str): File extension for the output file
+        
+    Returns:
+        str: Path to the output file
+    """
+    output_dir = _create_output_dir()
+    timestamp = int(time.time())
+    return f"{output_dir}/{prefix}_{timestamp}.{extension}"
+
+
+def _call_dia_api(text: str, voice: str = "S1", response_format: str = "wav", speed: float = 1.0) -> bytes:
+    """Call the Dia Space API to generate speech
+    
+    Args:
+        text (str): Input text to synthesize
+        voice (str): Voice mode to use ('S1', 'S2', 'dialogue', or filename for clone)
+        response_format (str): Audio format ('wav', 'mp3', 'opus')
+        speed (float): Speech speed multiplier
+        
+    Returns:
+        bytes: Audio data
+    """
+    client = _get_client()
+    
+    # Prepare the request payload
+    payload = {
+        "model": DEFAULT_MODEL,
+        "input": text,
+        "voice": voice,
+        "response_format": response_format,
+        "speed": speed
+    }
+    
+    # Make the API request
+    logger.info(f"Calling Dia Space API with voice: {voice}, format: {response_format}, speed: {speed}")
+    try:
+        response = client.post(
+            f"{DEFAULT_API_URL}/v1/audio/speech",
+            json=payload,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Check for successful response
+        if response.status_code == 200:
+            logger.info("Dia Space API call successful")
+            return response.content
+        else:
+            logger.error(f"Dia Space API returned error: {response.status_code}")
+            logger.error(f"Response: {response.text}")
+            raise Exception(f"Dia Space API error: {response.status_code}")
+    except Exception as e:
+        logger.error(f"Error calling Dia Space API: {str(e)}", exc_info=True)
+        raise

utils/tts_engines.py

@@ -14,6 +14,7 @@ logger = logging.getLogger(__name__)
 KOKORO_AVAILABLE = False
 KOKORO_SPACE_AVAILABLE = True
 DIA_AVAILABLE = False
+DIA_SPACE_AVAILABLE = True
 
 # Try to import Kokoro
 try:
@@ -39,6 +40,12 @@ try:
     logger.info("Dia TTS engine is available")
 except ImportError:
     logger.warning("Dia TTS engine is not available")
+except ModuleNotFoundError as e:
+    if "dac" in str(e):
+        logger.warning("Dia TTS engine is not available due to missing 'dac' module")
+    else:
+        logger.warning(f"Dia TTS engine is not available: {str(e)}")
+    DIA_AVAILABLE = False
 
 
 class KokoroTTSEngine(TTSEngineBase):
@@ -198,6 +205,66 @@ class DiaTTSEngine(TTSEngineBase):
             output_path = dia_generate_speech(text, language=self.lang_code)
             logger.info(f"Generated audio with Dia: {output_path}")
             return output_path
+        except ModuleNotFoundError as e:
+            if "dac" in str(e):
+                logger.warning("Dia TTS engine failed due to missing 'dac' module, falling back to Dia Space")
+                # Try using Dia Space instead
+                if DIA_SPACE_AVAILABLE:
+                    return DiaSpaceTTSEngine(self.lang_code).generate_speech(text, voice, speed)
+            raise
+
+
+class DiaSpaceTTSEngine(TTSEngineBase):
+    """Dia Space TTS engine implementation
+    
+    This engine uses the Dia TTS Server API for speech generation.
+    """
+    
+    def __init__(self, lang_code: str = 'z'):
+        super().__init__(lang_code)
+        try:
+            # Import here to avoid circular imports
+            from utils.tts_dia_space import _get_client
+            self.client = _get_client()
+            logger.info("Dia Space TTS engine successfully initialized")
+        except Exception as e:
+            logger.error(f"Failed to initialize Dia Space client: {str(e)}")
+            logger.error(f"Error type: {type(e).__name__}")
+            raise
+    
+    def generate_speech(self, text: str, voice: str = 'S1', speed: float = 1.0, response_format: str = 'wav') -> str:
+        """Generate speech using Dia Space TTS engine
+        
+        Args:
+            text (str): Input text to synthesize
+            voice (str): Voice mode to use ('S1', 'S2', 'dialogue', or filename for clone)
+            speed (float): Speech speed multiplier
+            response_format (str): Audio format ('wav', 'mp3', 'opus')
+            
+        Returns:
+            str: Path to the generated audio file
+        """
+        logger.info(f"Generating speech with Dia Space for text length: {len(text)}")
+        
+        try:
+            # Import here to avoid circular imports
+            from utils.tts_dia_space import _call_dia_api, _generate_output_path
+            
+            # Call the Dia Space API
+            audio_data = _call_dia_api(text, voice, response_format, speed)
+            
+            # Save the audio data to a file
+            output_path = _generate_output_path(prefix="dia_space", extension=response_format)
+            with open(output_path, 'wb') as f:
+                f.write(audio_data)
+            
+            logger.info(f"Generated audio with Dia Space: {output_path}")
+            return output_path
+        except Exception as e:
+            logger.error(f"Failed to generate speech from Dia Space API: {str(e)}")
+            logger.error(f"Error type: {type(e).__name__}")
+            logger.info("Falling back to dummy audio generation")
+            return DummyTTSEngine().generate_speech(text, voice, speed)
             
         except ImportError as import_err:
             logger.error(f"Dia TTS generation failed due to import error: {str(import_err)}")