create fallback flow for tts engines

utils/tts_base.py

@@ -28,7 +28,7 @@ class TTSEngineBase(ABC):
         logger.info(f"Initializing {self.__class__.__name__} with language code: {lang_code}")
     
     @abstractmethod
-    def generate_speech(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> str:
+    def generate_speech(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> Optional[str]:
         """Generate speech from text
         
         Args:
@@ -39,7 +39,7 @@ class TTSEngineBase(ABC):
                            Note: Not all engines support speed adjustment
             
         Returns:
-            str: Path to the generated audio file
+            Optional[str]: Path to the generated audio file, or None if generation fails
         """
         pass
     

utils/tts_cascading.py

@@ -0,0 +1,112 @@
+import logging
+from typing import List, Tuple, Generator, Optional
+import numpy as np
+
+from utils.tts_base import TTSEngineBase, DummyTTSEngine
+from utils.tts_engines import create_engine
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class CascadingTTSEngine(TTSEngineBase):
+    """Cascading TTS engine implementation
+    
+    This engine tries multiple TTS engines in order until one succeeds.
+    It provides a fallback mechanism to maximize the chances of getting
+    quality speech output.
+    """
+    
+    def __init__(self, engine_types: List[str], lang_code: str = 'z'):
+        """Initialize the cascading TTS engine
+        
+        Args:
+            engine_types (List[str]): List of engine types to try in order
+            lang_code (str): Language code for the engines
+        """
+        super().__init__(lang_code)
+        self.engine_types = engine_types
+        self.lang_code = lang_code
+        logger.info(f"Initialized cascading TTS engine with engines: {engine_types}")
+    
+    def generate_speech(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> str:
+        """Generate speech by trying multiple engines in order
+        
+        Args:
+            text (str): Input text to synthesize
+            voice (str): Voice ID to use
+            speed (float): Speech speed multiplier
+            
+        Returns:
+            str: Path to the generated audio file
+        """
+        logger.info(f"Generating speech with cascading engine for text length: {len(text)}")
+        
+        # Try each engine in order
+        for engine_type in self.engine_types:
+            try:
+                logger.info(f"Trying TTS engine: {engine_type}")
+                engine = create_engine(engine_type, self.lang_code)
+                
+                # Generate speech with the current engine
+                result = engine.generate_speech(text, voice, speed)
+                
+                # If the engine returned a valid result, return it
+                if result is not None:
+                    logger.info(f"Successfully generated speech with {engine_type}")
+                    return result
+                
+                logger.warning(f"TTS engine {engine_type} failed to generate speech, trying next engine")
+            except Exception as e:
+                logger.error(f"Error with TTS engine {engine_type}: {str(e)}")
+                logger.error(f"Error type: {type(e).__name__}")
+                logger.warning(f"Trying next TTS engine")
+        
+        # If all engines failed, fall back to dummy engine
+        logger.warning("All TTS engines failed, falling back to dummy engine")
+        return DummyTTSEngine(self.lang_code).generate_speech(text, voice, speed)
+    
+    def generate_speech_stream(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> Generator[Tuple[int, np.ndarray], None, None]:
+        """Generate speech stream by trying multiple engines in order
+        
+        Args:
+            text (str): Input text to synthesize
+            voice (str): Voice ID to use
+            speed (float): Speech speed multiplier
+            
+        Yields:
+            tuple: (sample_rate, audio_data) pairs for each segment
+        """
+        logger.info(f"Generating speech stream with cascading engine for text length: {len(text)}")
+        
+        # Try each engine in order
+        for engine_type in self.engine_types:
+            try:
+                logger.info(f"Trying TTS engine for streaming: {engine_type}")
+                engine = create_engine(engine_type, self.lang_code)
+                
+                # Create a generator for the current engine
+                generator = engine.generate_speech_stream(text, voice, speed)
+                
+                # Try to get the first chunk to verify the engine works
+                first_chunk = next(generator, None)
+                if first_chunk is not None:
+                    # Engine produced a valid first chunk, yield it and continue with this engine
+                    logger.info(f"Successfully started speech stream with {engine_type}")
+                    yield first_chunk
+                    
+                    # Yield the rest of the chunks from this engine
+                    for chunk in generator:
+                        yield chunk
+                    
+                    # Successfully streamed all chunks, return
+                    return
+                
+                logger.warning(f"TTS engine {engine_type} failed to generate speech stream, trying next engine")
+            except Exception as e:
+                logger.error(f"Error with TTS engine {engine_type} streaming: {str(e)}")
+                logger.error(f"Error type: {type(e).__name__}")
+                logger.warning(f"Trying next TTS engine for streaming")
+        
+        # If all engines failed, fall back to dummy engine
+        logger.warning("All TTS engines failed for streaming, falling back to dummy engine")
+        yield from DummyTTSEngine(self.lang_code).generate_speech_stream(text, voice, speed)

utils/tts_engines.py

@@ -3,7 +3,7 @@ import time
 import os
 import numpy as np
 import soundfile as sf
-from typing import Dict, List, Optional, Tuple, Generator, Any
+from typing import Dict, List, Optional, Tuple, Generator, Any, Union
 
 from utils.tts_base import TTSEngineBase, DummyTTSEngine
 
@@ -64,7 +64,7 @@ class KokoroTTSEngine(TTSEngineBase):
             logger.error(f"Error type: {type(e).__name__}")
             raise
     
-    def generate_speech(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> str:
+    def generate_speech(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> Optional[str]:
         """Generate speech using Kokoro TTS engine
         
         Args:
@@ -73,7 +73,7 @@ class KokoroTTSEngine(TTSEngineBase):
             speed (float): Speech speed multiplier (0.5 to 2.0)
             
         Returns:
-            str: Path to the generated audio file
+            Optional[str]: Path to the generated audio file or None if generation fails
         """
         logger.info(f"Generating speech with Kokoro for text length: {len(text)}")
         
@@ -126,7 +126,7 @@ class KokoroSpaceTTSEngine(TTSEngineBase):
             logger.error(f"Error type: {type(e).__name__}")
             raise
     
-    def generate_speech(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> str:
+    def generate_speech(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> Optional[str]:
         """Generate speech using Kokoro Space TTS engine
         
         Args:
@@ -135,7 +135,7 @@ class KokoroSpaceTTSEngine(TTSEngineBase):
             speed (float): Speech speed multiplier (0.5 to 2.0)
             
         Returns:
-            str: Path to the generated audio file
+            Optional[str]: Path to the generated audio file or None if generation fails
         """
         logger.info(f"Generating speech with Kokoro Space for text length: {len(text)}")
         logger.info(f"Text to generate speech on is: {text[:50]}..." if len(text) > 50 else f"Text to generate speech on is: {text}")
@@ -156,19 +156,19 @@ class KokoroSpaceTTSEngine(TTSEngineBase):
             )
             logger.info(f"Received audio from Kokoro FastAPI server: {result}")
             
-            # TODO: Process the result and save to output_path
-            # For now, we'll return the result path directly if it's a string
+            # Process the result and save to output_path
+            # Return the result path directly if it's a string
             if isinstance(result, str) and os.path.exists(result):
                 return result
             else:
-                logger.warning("Unexpected result from Kokoro Space, falling back to dummy audio")
-                return DummyTTSEngine().generate_speech(text, voice, speed)
+                logger.warning("Unexpected result from Kokoro Space")
+                return None
             
         except Exception as e:
             logger.error(f"Failed to generate speech from Kokoro FastAPI server: {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)
+            logger.info("Kokoro Space TTS engine failed")
+            return None
 
 
 class DiaTTSEngine(TTSEngineBase):
@@ -182,7 +182,7 @@ class DiaTTSEngine(TTSEngineBase):
         # Dia doesn't need initialization here, it will be lazy-loaded when needed
         logger.info("Dia TTS engine initialized (lazy loading)")
     
-    def generate_speech(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> str:
+    def generate_speech(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> Optional[str]:
         """Generate speech using Dia TTS engine
         
         Args:
@@ -191,7 +191,7 @@ class DiaTTSEngine(TTSEngineBase):
             speed (float): Speech speed multiplier (not used in Dia)
             
         Returns:
-            str: Path to the generated audio file
+            Optional[str]: Path to the generated audio file or None if generation fails
         """
         logger.info(f"Generating speech with Dia for text length: {len(text)}")
         
@@ -201,13 +201,8 @@ class DiaTTSEngine(TTSEngineBase):
             
             # Check if Dia is available
             if not DIA_AVAILABLE:
-                logger.warning("Dia TTS engine is not available, falling back to Dia Space")
-                # Try using Dia Space instead
-                if DIA_SPACE_AVAILABLE:
-                    return DiaSpaceTTSEngine(self.lang_code).generate_speech(text, voice, speed)
-                else:
-                    logger.warning("Dia Space is also not available, falling back to dummy TTS")
-                    return DummyTTSEngine(self.lang_code).generate_speech(text, voice, speed)
+                logger.warning("Dia TTS engine is not available")
+                return None
             
             logger.info("Successfully imported Dia speech generation function")
             
@@ -218,18 +213,13 @@ class DiaTTSEngine(TTSEngineBase):
             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)
-                else:
-                    logger.warning("Dia Space is also not available, falling back to dummy TTS")
-                    return DummyTTSEngine(self.lang_code).generate_speech(text, voice, speed)
+                logger.warning("Dia TTS engine failed due to missing 'dac' module")
+                return None
             raise
         except Exception as e:
             logger.error(f"Error generating speech with Dia: {str(e)}", exc_info=True)
-            logger.warning("Falling back to dummy TTS engine")
-            return DummyTTSEngine(self.lang_code).generate_speech(text, voice, speed)
+            logger.warning("Dia TTS engine failed")
+            return None
 
 
 class DiaSpaceTTSEngine(TTSEngineBase):
@@ -250,7 +240,7 @@ class DiaSpaceTTSEngine(TTSEngineBase):
             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:
+    def generate_speech(self, text: str, voice: str = 'S1', speed: float = 1.0, response_format: str = 'wav') -> Optional[str]:
         """Generate speech using Dia Space TTS engine
         
         Args:
@@ -260,7 +250,7 @@ class DiaSpaceTTSEngine(TTSEngineBase):
             response_format (str): Audio format ('wav', 'mp3', 'opus')
             
         Returns:
-            str: Path to the generated audio file
+            Optional[str]: Path to the generated audio file or None if generation fails
         """
         logger.info(f"Generating speech with Dia Space for text length: {len(text)}")
         
@@ -281,19 +271,19 @@ class DiaSpaceTTSEngine(TTSEngineBase):
         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)
+            logger.info("Dia Space TTS engine failed")
+            return None
             
         except ImportError as import_err:
             logger.error(f"Dia TTS generation failed due to import error: {str(import_err)}")
-            logger.error("Falling back to dummy audio generation")
-            return DummyTTSEngine().generate_speech(text, voice, speed)
+            logger.error("Dia Space TTS engine failed")
+            return None
             
         except Exception as dia_error:
             logger.error(f"Dia TTS generation failed: {str(dia_error)}", exc_info=True)
             logger.error(f"Error type: {type(dia_error).__name__}")
-            logger.error("Falling back to dummy audio generation")
-            return DummyTTSEngine().generate_speech(text, voice, speed)
+            logger.error("Dia Space TTS engine failed")
+            return None
     
     def generate_speech_stream(self, text: str, voice: str = 'af_heart', speed: float = 1.0) -> Generator[Tuple[int, np.ndarray], None, None]:
         """Generate speech stream using Dia TTS engine

utils/tts_factory.py

@@ -6,6 +6,7 @@ logger = logging.getLogger(__name__)
 
 # Import the base class
 from utils.tts_base import TTSEngineBase, DummyTTSEngine
+from utils.tts_cascading import CascadingTTSEngine
 
 class TTSFactory:
     """Factory class for creating TTS engines
@@ -36,17 +37,41 @@ class TTSFactory:
         if engine_type is not None:
             if engine_type in available_engines:
                 logger.info(f"Creating requested engine: {engine_type}")
-                return create_engine(engine_type, lang_code)
+                engine = create_engine(engine_type, lang_code)
+                return engine
             else:
                 logger.warning(f"Requested engine '{engine_type}' is not available")
         
-        # Try to create the best available engine
-        # Priority: kokoro > kokoro_space > dia > dummy
-        for engine in ['kokoro', 'kokoro_space', 'dia']:
-            if engine in available_engines:
-                logger.info(f"Creating best available engine: {engine}")
-                return create_engine(engine, lang_code)
+        # Fall back to dummy engine if no engines are available
+        if not available_engines or (len(available_engines) == 1 and available_engines[0] == 'dummy'):
+            logger.warning("No TTS engines available, falling back to dummy engine")
+            return DummyTTSEngine(lang_code)
+            
+        return TTSFactory.create_cascading_engine(available_engines, lang_code)
+    
+    @staticmethod
+    def create_cascading_engine(available_engines: List[str], lang_code: str = 'z') -> TTSEngineBase:
+        """Create a cascading TTS engine that tries multiple engines in order
+        
+        Args:
+            available_engines (List[str]): List of available engine names
+            lang_code (str): Language code for the engines
+            
+        Returns:
+            TTSEngineBase: A cascading TTS engine instance
+        """
+        from utils.tts_engines import create_engine
+        
+        # Define the priority order for engines
+        priority_order = ['kokoro', 'kokoro_space', 'dia', 'dia_space', 'dummy']
+        
+        # Filter and sort available engines by priority
+        engines_by_priority = [engine for engine in priority_order if engine in available_engines]
+        
+        # Always ensure dummy is the last fallback
+        if 'dummy' not in engines_by_priority:
+            engines_by_priority.append('dummy')
+            
+        logger.info(f"Creating cascading engine with priority: {engines_by_priority}")
         
-        # Fall back to dummy engine
-        logger.warning("No TTS engines available, falling back to dummy engine")
-        return DummyTTSEngine(lang_code)
+        return CascadingTTSEngine(engines_by_priority, lang_code)