enhance logging

utils/tts.py

@@ -28,12 +28,43 @@ except ImportError:
 # Try to import Dia as fallback
 if not KOKORO_AVAILABLE:
     try:
-        from utils.tts_dia import _get_model as get_dia_model
-        DIA_AVAILABLE = True
-        logger.info("Dia TTS engine is available as fallback")
+        logger.info("Attempting to import Dia TTS engine as fallback")
+        try:
+            # Check if required dependencies for Dia are available
+            import torch
+            logger.info("PyTorch is available for Dia TTS")
+        except ImportError as torch_err:
+            logger.error(f"PyTorch dependency for Dia TTS is missing: {str(torch_err)}")
+            raise ImportError(f"PyTorch dependency required for Dia TTS: {str(torch_err)}") from torch_err
+            
+        # Try to import the Dia module
+        try:
+            from utils.tts_dia import _get_model as get_dia_model
+            logger.info("Successfully imported Dia TTS module")
+            
+            # Verify the model can be accessed
+            logger.info("Verifying Dia model can be accessed")
+            model_info = get_dia_model.__module__
+            logger.info(f"Dia model module: {model_info}")
+            
+            DIA_AVAILABLE = True
+            logger.info("Dia TTS engine is available as fallback")
+        except ImportError as module_err:
+            logger.error(f"Failed to import Dia TTS module: {str(module_err)}")
+            logger.error(f"Module path: {module_err.__traceback__.tb_frame.f_globals.get('__file__', 'unknown')}")
+            raise
+        except AttributeError as attr_err:
+            logger.error(f"Dia TTS module attribute error: {str(attr_err)}")
+            logger.error(f"This may indicate the module exists but has incorrect structure")
+            raise
     except ImportError as e:
-        logger.warning(f"Dia TTS engine is not available: {str(e)}")
+        logger.error(f"Dia TTS engine is not available due to import error: {str(e)}")
+        logger.error(f"Import path attempted: {e.__traceback__.tb_frame.f_globals.get('__name__', 'unknown')}")
         logger.warning("Will use dummy TTS implementation as fallback")
+    except Exception as e:
+        logger.error(f"Unexpected error initializing Dia TTS: {str(e)}")
+        logger.error(f"Error type: {type(e).__name__}")
+        logger.error("Will use dummy TTS implementation as fallback")
 
 class TTSEngine:
     def __init__(self, lang_code='z'):
@@ -45,20 +76,34 @@ class TTSEngine:
                            Note: lang_code is only used for Kokoro, not for Dia
         """
         logger.info("Initializing TTS Engine")
+        logger.info(f"Available engines - Kokoro: {KOKORO_AVAILABLE}, Dia: {DIA_AVAILABLE}")
         self.engine_type = None
         
         if KOKORO_AVAILABLE:
-            self.pipeline = KPipeline(lang_code=lang_code)
-            self.engine_type = "kokoro"
-            logger.info("TTS engine initialized with Kokoro")
-        elif DIA_AVAILABLE:
+            logger.info(f"Using Kokoro as primary TTS engine with language code: {lang_code}")
+            try:
+                self.pipeline = KPipeline(lang_code=lang_code)
+                self.engine_type = "kokoro"
+                logger.info("TTS engine successfully initialized with Kokoro")
+            except Exception as kokoro_err:
+                logger.error(f"Failed to initialize Kokoro pipeline: {str(kokoro_err)}")
+                logger.error(f"Error type: {type(kokoro_err).__name__}")
+                logger.info("Will try to fall back to Dia TTS engine")
+                # Fall through to try Dia
+        
+        # Try Dia if Kokoro is not available or failed to initialize
+        if self.engine_type is None and DIA_AVAILABLE:
+            logger.info("Using Dia as fallback TTS engine")
             # For Dia, we don't need to initialize anything here
             # The model will be lazy-loaded when needed
             self.pipeline = None
             self.engine_type = "dia"
             logger.info("TTS engine initialized with Dia (lazy loading)")
-        else:
+        
+        # Use dummy if no TTS engines are available
+        if self.engine_type is None:
             logger.warning("Using dummy TTS implementation as no TTS engines are available")
+            logger.warning("Check logs above for specific errors that prevented Kokoro or Dia initialization")
             self.pipeline = None
             self.engine_type = "dummy"
 
@@ -95,13 +140,29 @@ class TTSEngine:
             elif self.engine_type == "dia":
                 # Use Dia for TTS generation
                 try:
+                    logger.info("Attempting to use Dia TTS for speech generation")
                     # Import here to avoid circular imports
-                    from utils.tts_dia import generate_speech as dia_generate_speech
+                    try:
+                        logger.info("Importing Dia speech generation module")
+                        from utils.tts_dia import generate_speech as dia_generate_speech
+                        logger.info("Successfully imported Dia speech generation function")
+                    except ImportError as import_err:
+                        logger.error(f"Failed to import Dia speech generation function: {str(import_err)}")
+                        logger.error(f"Import path: {import_err.__traceback__.tb_frame.f_globals.get('__name__', 'unknown')}")
+                        raise
+                    
                     # Call Dia's generate_speech function
+                    logger.info("Calling Dia's generate_speech function")
                     output_path = dia_generate_speech(text)
                     logger.info(f"Generated audio with Dia: {output_path}")
+                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 self._generate_dummy_audio(output_path)
                 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")
                     # Fall back to dummy audio if Dia fails
                     return self._generate_dummy_audio(output_path)
             else:
@@ -157,14 +218,36 @@ class TTSEngine:
                 # Dia doesn't support streaming natively, so we generate the full audio
                 # and then yield it as a single chunk
                 try:
+                    logger.info("Attempting to use Dia TTS for speech streaming")
                     # Import here to avoid circular imports
-                    import torch
-                    from utils.tts_dia import _get_model, DEFAULT_SAMPLE_RATE
+                    try:
+                        logger.info("Importing required modules for Dia streaming")
+                        import torch
+                        logger.info("PyTorch successfully imported for Dia streaming")
+                        
+                        try:
+                            from utils.tts_dia import _get_model, DEFAULT_SAMPLE_RATE
+                            logger.info("Successfully imported Dia model and sample rate")
+                        except ImportError as import_err:
+                            logger.error(f"Failed to import Dia model for streaming: {str(import_err)}")
+                            logger.error(f"Import path: {import_err.__traceback__.tb_frame.f_globals.get('__name__', 'unknown')}")
+                            raise
+                    except ImportError as torch_err:
+                        logger.error(f"PyTorch import failed for Dia streaming: {str(torch_err)}")
+                        raise
                     
                     # Get the Dia model
-                    model = _get_model()
+                    logger.info("Getting Dia model instance")
+                    try:
+                        model = _get_model()
+                        logger.info("Successfully obtained Dia model instance")
+                    except Exception as model_err:
+                        logger.error(f"Failed to get Dia model instance: {str(model_err)}")
+                        logger.error(f"Error type: {type(model_err).__name__}")
+                        raise
                     
                     # Generate audio
+                    logger.info("Generating audio with Dia model")
                     with torch.inference_mode():
                         output_audio_np = model.generate(
                             text,
@@ -178,12 +261,22 @@ class TTSEngine:
                         )
                     
                     if output_audio_np is not None:
+                        logger.info(f"Successfully generated audio with Dia (length: {len(output_audio_np)})")
                         yield DEFAULT_SAMPLE_RATE, output_audio_np
                     else:
+                        logger.warning("Dia model returned None for audio output")
+                        logger.warning("Falling back to dummy audio stream")
                         # Fall back to dummy audio if Dia fails
                         yield from self._generate_dummy_audio_stream()
+                except ImportError as import_err:
+                    logger.error(f"Dia TTS streaming failed due to import error: {str(import_err)}")
+                    logger.error("Falling back to dummy audio stream")
+                    # Fall back to dummy audio if Dia fails
+                    yield from self._generate_dummy_audio_stream()
                 except Exception as dia_error:
                     logger.error(f"Dia TTS streaming failed: {str(dia_error)}", exc_info=True)
+                    logger.error(f"Error type: {type(dia_error).__name__}")
+                    logger.error("Falling back to dummy audio stream")
                     # Fall back to dummy audio if Dia fails
                     yield from self._generate_dummy_audio_stream()
             else:
@@ -221,14 +314,25 @@ def get_tts_engine(lang_code='a'):
     Returns:
         TTSEngine: Initialized TTS engine instance
     """
+    logger.info(f"Requesting TTS engine with language code: {lang_code}")
     try:
         import streamlit as st
+        logger.info("Streamlit detected, using cached TTS engine")
         @st.cache_resource
         def _get_engine():
-            return TTSEngine(lang_code)
-        return _get_engine()
+            logger.info("Creating cached TTS engine instance")
+            engine = TTSEngine(lang_code)
+            logger.info(f"Cached TTS engine created with type: {engine.engine_type}")
+            return engine
+        
+        engine = _get_engine()
+        logger.info(f"Retrieved TTS engine from cache with type: {engine.engine_type}")
+        return engine
     except ImportError:
-        return TTSEngine(lang_code)
+        logger.info("Streamlit not available, creating direct TTS engine instance")
+        engine = TTSEngine(lang_code)
+        logger.info(f"Direct TTS engine created with type: {engine.engine_type}")
+        return engine
 
 def generate_speech(text: str, voice: str = 'af_heart', speed: float = 1.0) -> str:
     """Public interface for TTS generation
@@ -241,5 +345,24 @@ def generate_speech(text: str, voice: str = 'af_heart', speed: float = 1.0) -> s
     Returns:
         str: Path to generated audio file
     """
-    engine = get_tts_engine()
-    return engine.generate_speech(text, voice, speed)
+    logger.info(f"Public generate_speech called with text length: {len(text)}, voice: {voice}, speed: {speed}")
+    try:
+        # Get the TTS engine
+        logger.info("Getting TTS engine instance")
+        engine = get_tts_engine()
+        logger.info(f"Using TTS engine type: {engine.engine_type}")
+        
+        # Generate speech
+        logger.info("Calling engine.generate_speech")
+        output_path = engine.generate_speech(text, voice, speed)
+        logger.info(f"Speech generation complete, output path: {output_path}")
+        return output_path
+    except Exception as e:
+        logger.error(f"Error in public generate_speech function: {str(e)}", exc_info=True)
+        logger.error(f"Error type: {type(e).__name__}")
+        if hasattr(e, '__traceback__'):
+            tb = e.__traceback__
+            while tb.tb_next:
+                tb = tb.tb_next
+            logger.error(f"Error occurred in file: {tb.tb_frame.f_code.co_filename}, line {tb.tb_lineno}")
+        raise

utils/tts_dia.py

@@ -27,10 +27,36 @@ def _get_model() -> Dia:
     if _model is None:
         logger.info("Loading Dia model...")
         try:
+            # Check if torch is available with correct version
+            logger.info(f"PyTorch version: {torch.__version__}")
+            logger.info(f"CUDA available: {torch.cuda.is_available()}")
+            if torch.cuda.is_available():
+                logger.info(f"CUDA version: {torch.version.cuda}")
+                logger.info(f"GPU device: {torch.cuda.get_device_name(0)}")
+            
+            # Check if model path exists
+            logger.info(f"Attempting to load model from: {DEFAULT_MODEL_NAME}")
+            
+            # Load the model with detailed logging
+            logger.info("Initializing Dia model...")
             _model = Dia.from_pretrained(DEFAULT_MODEL_NAME, compute_dtype="float16")
-            logger.info("Dia model loaded successfully")
+            
+            # Log model details
+            logger.info(f"Dia model loaded successfully")
+            logger.info(f"Model type: {type(_model).__name__}")
+            logger.info(f"Model device: {next(_model.parameters()).device}")
+        except ImportError as import_err:
+            logger.error(f"Import error loading Dia model: {import_err}")
+            logger.error(f"This may indicate missing dependencies")
+            raise
+        except FileNotFoundError as file_err:
+            logger.error(f"File not found error loading Dia model: {file_err}")
+            logger.error(f"Model path may be incorrect or inaccessible")
+            raise
         except Exception as e:
             logger.error(f"Error loading Dia model: {e}", exc_info=True)
+            logger.error(f"Error type: {type(e).__name__}")
+            logger.error(f"This may indicate incompatible versions or missing CUDA support")
             raise
     return _model
 
@@ -46,58 +72,127 @@ def generate_speech(text: str, language: str = "zh") -> str:
         str: Path to the generated audio file
     """
     logger.info(f"Generating speech for text length: {len(text)}")
+    logger.info(f"Text content (first 50 chars): {text[:50]}...")
     
     try:
         # Create output directory if it doesn't exist
-        os.makedirs("temp/outputs", exist_ok=True)
+        output_dir = "temp/outputs"
+        logger.info(f"Ensuring output directory exists: {output_dir}")
+        try:
+            os.makedirs(output_dir, exist_ok=True)
+            logger.info(f"Output directory ready: {output_dir}")
+        except PermissionError as perm_err:
+            logger.error(f"Permission error creating output directory: {perm_err}")
+            raise
+        except Exception as dir_err:
+            logger.error(f"Error creating output directory: {dir_err}")
+            raise
         
         # Generate unique output path
-        output_path = f"temp/outputs/output_{int(time.time())}.wav"
+        timestamp = int(time.time())
+        output_path = f"{output_dir}/output_{timestamp}.wav"
+        logger.info(f"Output will be saved to: {output_path}")
         
         # Get the model
-        model = _get_model()
+        logger.info("Retrieving Dia model instance")
+        try:
+            model = _get_model()
+            logger.info("Successfully retrieved Dia model instance")
+        except Exception as model_err:
+            logger.error(f"Failed to get Dia model: {model_err}")
+            logger.error(f"Error type: {type(model_err).__name__}")
+            raise
         
         # Generate audio
+        logger.info("Starting audio generation with Dia model")
         start_time = time.time()
         
-        with torch.inference_mode():
-            output_audio_np = model.generate(
-                text,
-                max_tokens=None,  # Use default from model config
-                cfg_scale=3.0,
-                temperature=1.3,
-                top_p=0.95,
-                cfg_filter_top_k=35,
-                use_torch_compile=False,  # Keep False for stability
-                verbose=False
-            )
+        try:
+            with torch.inference_mode():
+                logger.info("Calling model.generate() with inference_mode")
+                output_audio_np = model.generate(
+                    text,
+                    max_tokens=None,  # Use default from model config
+                    cfg_scale=3.0,
+                    temperature=1.3,
+                    top_p=0.95,
+                    cfg_filter_top_k=35,
+                    use_torch_compile=False,  # Keep False for stability
+                    verbose=False
+                )
+                logger.info("Model.generate() completed")
+        except RuntimeError as rt_err:
+            logger.error(f"Runtime error during generation: {rt_err}")
+            if "CUDA out of memory" in str(rt_err):
+                logger.error("CUDA out of memory error - consider reducing batch size or model size")
+            raise
+        except Exception as gen_err:
+            logger.error(f"Error during audio generation: {gen_err}")
+            logger.error(f"Error type: {type(gen_err).__name__}")
+            raise
         
         end_time = time.time()
-        logger.info(f"Generation finished in {end_time - start_time:.2f} seconds")
+        generation_time = end_time - start_time
+        logger.info(f"Generation finished in {generation_time:.2f} seconds")
         
         # Process the output
         if output_audio_np is not None:
+            logger.info(f"Generated audio array shape: {output_audio_np.shape}, dtype: {output_audio_np.dtype}")
+            logger.info(f"Audio stats - min: {output_audio_np.min():.4f}, max: {output_audio_np.max():.4f}, mean: {output_audio_np.mean():.4f}")
+            
             # Apply a slight slowdown for better quality (0.94x speed)
             speed_factor = 0.94
             original_len = len(output_audio_np)
             target_len = int(original_len / speed_factor)
             
+            logger.info(f"Applying speed adjustment factor: {speed_factor}")
             if target_len != original_len and target_len > 0:
-                x_original = np.arange(original_len)
-                x_resampled = np.linspace(0, original_len - 1, target_len)
-                output_audio_np = np.interp(x_resampled, x_original, output_audio_np)
-                logger.info(f"Resampled audio from {original_len} to {target_len} samples for {speed_factor:.2f}x speed")
+                try:
+                    x_original = np.arange(original_len)
+                    x_resampled = np.linspace(0, original_len - 1, target_len)
+                    output_audio_np = np.interp(x_resampled, x_original, output_audio_np)
+                    logger.info(f"Resampled audio from {original_len} to {target_len} samples for {speed_factor:.2f}x speed")
+                except Exception as resample_err:
+                    logger.error(f"Error during audio resampling: {resample_err}")
+                    logger.warning("Using original audio without resampling")
             
             # Save the audio file
-            sf.write(output_path, output_audio_np, DEFAULT_SAMPLE_RATE)
-            logger.info(f"Audio saved to {output_path}")
+            logger.info(f"Saving audio to file: {output_path}")
+            try:
+                sf.write(output_path, output_audio_np, DEFAULT_SAMPLE_RATE)
+                logger.info(f"Audio successfully saved to {output_path}")
+            except Exception as save_err:
+                logger.error(f"Error saving audio file: {save_err}")
+                logger.error(f"Error type: {type(save_err).__name__}")
+                raise
             
             return output_path
         else:
-            logger.warning("Generation produced no output, returning dummy audio")
-            return "temp/outputs/dummy.wav"
+            logger.warning("Generation produced no output (None returned from model)")
+            logger.warning("This may indicate a model configuration issue or empty input text")
+            dummy_path = f"{output_dir}/dummy_{timestamp}.wav"
+            logger.warning(f"Returning dummy audio path: {dummy_path}")
+            return dummy_path
             
     except Exception as e:
         logger.error(f"TTS generation failed: {str(e)}", exc_info=True)
+        logger.error(f"Error type: {type(e).__name__}")
+        
+        # Log additional diagnostic information based on error type
+        if isinstance(e, ImportError):
+            logger.error(f"Import error - missing dependency: {e.__class__.__module__}.{e.__class__.__name__}")
+            logger.error("Check if all required packages are installed correctly")
+        elif isinstance(e, RuntimeError) and "CUDA" in str(e):
+            logger.error("CUDA-related runtime error - check GPU compatibility and memory")
+        elif isinstance(e, AttributeError):
+            logger.error(f"Attribute error - likely API incompatibility or incorrect module version")
+            if hasattr(e, '__traceback__'):
+                tb = e.__traceback__
+                while tb.tb_next:
+                    tb = tb.tb_next
+                logger.error(f"Error occurred in file: {tb.tb_frame.f_code.co_filename}, line {tb.tb_lineno}")
+        elif isinstance(e, FileNotFoundError):
+            logger.error(f"File not found - check if model files exist and are accessible")
+        
         # Return dummy path in case of error
         return "temp/outputs/dummy.wav"