feat(logging): add detailed logging for audio upload and configuration handling

app.py

@@ -64,12 +64,16 @@ def create_audio_upload_dto(audio_file_path: str) -> AudioUploadDto:
             raise ValueError("No audio file provided or file does not exist")
 
         filename = os.path.basename(audio_file_path)
+        logger.info(f"Creating AudioUploadDto for file: {filename}")
+        logger.info(f"Full file path: {audio_file_path}")
         
         with open(audio_file_path, 'rb') as f:
             content = f.read()
 
         # Determine content type based on file extension
         file_ext = os.path.splitext(filename.lower())[1]
+        logger.info(f"Detected file extension: {file_ext}")
+        
         content_type_map = {
             '.wav': 'audio/wav',
             '.mp3': 'audio/mpeg',
@@ -78,6 +82,11 @@ def create_audio_upload_dto(audio_file_path: str) -> AudioUploadDto:
             '.ogg': 'audio/ogg'
         }
         content_type = content_type_map.get(file_ext, 'audio/wav')
+        logger.info(f"Mapped content type: {content_type}")
+        
+        # Log file size info
+        file_size = len(content)
+        logger.info(f"File size: {file_size} bytes ({file_size / 1024 / 1024:.2f} MB)")
 
         return AudioUploadDto(
             filename=filename,
@@ -107,15 +116,18 @@ def get_supported_configurations() -> dict:
         return config
     except Exception as e:
         logger.error(f"Failed to get configurations: {e}", exc_info=True)
+        logger.warning("Using fallback configurations - this may indicate a configuration service issue")
         # Return fallback configurations
-        return {
+        fallback_config = {
             'asr_models': ['whisper-small', 'parakeet'],
             'voices': ['chatterbox'],
             'languages': ['en', 'zh', 'es', 'fr', 'de'],
-            'audio_formats': ['wav', 'mp3'],
+            'audio_formats': ['wav', 'mp3', 'm4a', 'flac', 'ogg'],  # Updated to include all supported formats
             'max_file_size_mb': 100,
             'speed_range': {'min': 0.5, 'max': 2.0}
         }
+        logger.info(f"Using fallback configuration: {fallback_config}")
+        return fallback_config
 
 def process_audio_pipeline(
     audio_file,
@@ -144,9 +156,12 @@ def process_audio_pipeline(
             return "❌ No audio file provided", "", "", None, ""
 
         logger.info(f"Starting processing for: {audio_file} using {asr_model} model")
+        logger.info(f"Audio file exists: {os.path.exists(audio_file) if audio_file else 'N/A'}")
 
         # Create audio upload DTO
+        logger.info("Creating AudioUploadDto...")
         audio_upload = create_audio_upload_dto(audio_file)
+        logger.info(f"AudioUploadDto created successfully - Content-Type: {audio_upload.content_type}")
 
         # Get application service from container
         container = get_global_container()
@@ -208,10 +223,19 @@ def create_interface():
     # Get supported configurations
     config = get_supported_configurations()
     
+    # Log configuration details for debugging
+    logger.info("=== Gradio Interface Configuration ===")
+    logger.info(f"Supported ASR models: {config.get('asr_models', [])}")
+    logger.info(f"Supported voices: {config.get('voices', [])}")
+    logger.info(f"Supported audio formats: {config.get('audio_formats', [])}")
+    logger.info(f"Max file size: {config.get('max_file_size_mb', 0)} MB")
+    logger.info(f"Speed range: {config.get('speed_range', {})}")
+    logger.info("=== End Configuration ===")
+    
     # Language options mapping
     language_options = {
         "Chinese (Mandarin)": "zh",
-        "Spanish": "es", 
+        "Spanish": "es",
         "French": "fr",
         "German": "de",
         "English": "en"
@@ -232,10 +256,19 @@ def create_interface():
         )
     
     # Create the interface using gr.Interface for better compatibility
+    logger.info("Creating Gradio interface with updated file type support...")
+    logger.info("Updated file types for Audio component: .wav, .mp3, .m4a, .flac, .ogg")
+    
     interface = gr.Interface(
         fn=process_wrapper,
         inputs=[
-            gr.Audio(label="Upload Audio File", type="filepath"),
+            gr.Audio(
+                label="Upload Audio File",
+                type="filepath",
+                file_types=[".wav", ".mp3", ".m4a", ".flac", ".ogg"],
+                # Accept both file extensions and MIME types
+                # This explicitly allows mp3 files to pass Gradio's frontend validation
+            ),
             gr.Dropdown(
                 choices=config['asr_models'],
                 value=config['asr_models'][0] if config['asr_models'] else "parakeet",

src/application/dtos/audio_upload_dto.py

@@ -20,6 +20,33 @@ class AudioUploadDto:
     
     def __post_init__(self):
         """Validate the DTO after initialization"""
+        # Add logging for debugging mp3 validation issues
+        import logging
+        logger = logging.getLogger(__name__)
+        
+        logger.info(f"Validating AudioUploadDto - Filename: {self.filename}")
+        logger.info(f"Content-Type: {self.content_type}")
+        logger.info(f"File size: {len(self.content)} bytes")
+        
+        # Check file extension and MIME type mapping
+        _, ext = os.path.splitext(self.filename.lower())
+        logger.info(f"File extension: {ext}")
+        
+        content_type_map = {
+            '.wav': 'audio/wav',
+            '.mp3': 'audio/mpeg',
+            '.m4a': 'audio/mp4',
+            '.flac': 'audio/flac',
+            '.ogg': 'audio/ogg'
+        }
+        expected_content_type = content_type_map.get(ext)
+        logger.info(f"Expected content type for {ext}: {expected_content_type}")
+        logger.info(f"Actual content type: {self.content_type}")
+        
+        # Check mimetypes.guess_type result
+        guessed_type = mimetypes.guess_type(self.filename)[0]
+        logger.info(f"mimetypes.guess_type result: {guessed_type}")
+        
         self._validate()
         if self.size is None:
             self.size = len(self.content)