use Gradio

app.py

@@ -1,6 +1,6 @@
 """
 Main entry point for the Audio Translation Web Application
-Handles file upload, processing pipeline, and UI rendering using DDD architecture
+Handles file upload, processing pipeline, and UI rendering using DDD architecture with Gradio
 """
 
 import logging
@@ -14,9 +14,10 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-import streamlit as st
+import gradio as gr
 import os
-from typing import Optional
+import json
+from typing import Optional, Tuple, Dict, Any
 
 # Import application services and DTOs
 from src.application.services.audio_processing_service import AudioProcessingApplicationService
@@ -32,39 +33,43 @@ from src.infrastructure.config.container_setup import initialize_global_containe
 os.makedirs("temp/uploads", exist_ok=True)
 os.makedirs("temp/outputs", exist_ok=True)
 
-def configure_page():
-    """Set up Streamlit page configuration"""
-    logger.info("Configuring Streamlit page")
-    st.set_page_config(
-        page_title="Audio Translator",
-        page_icon="🎧",
-        layout="wide",
-        initial_sidebar_state="expanded"
-    )
-    st.markdown("""
-        <style>
-            .reportview-container {margin-top: -2em;}
-            #MainMenu {visibility: hidden;}
-            .stDeployButton {display:none;}
-            .stAlert {padding: 20px !important;}
-        </style>
-    """, unsafe_allow_html=True)
+# Global container initialization
+container_initialized = False
 
-def create_audio_upload_dto(uploaded_file) -> AudioUploadDto:
+def initialize_application():
+    """Initialize the application with dependency injection container"""
+    global container_initialized
+    if not container_initialized:
+        try:
+            logger.info("Initializing application container")
+            initialize_global_container()
+            container_initialized = True
+            logger.info("Application container initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize application: {e}")
+            raise RuntimeError(f"Application initialization failed: {str(e)}")
+
+def create_audio_upload_dto(audio_file_path: str) -> AudioUploadDto:
     """
-    Create AudioUploadDto from Streamlit uploaded file.
+    Create AudioUploadDto from audio file path.
 
     Args:
-        uploaded_file: Streamlit UploadedFile object
+        audio_file_path: Path to the uploaded audio file
 
     Returns:
         AudioUploadDto: DTO containing upload information
     """
     try:
-        content = uploaded_file.getbuffer().tobytes()
+        if not audio_file_path or not os.path.exists(audio_file_path):
+            raise ValueError("No audio file provided or file does not exist")
+
+        filename = os.path.basename(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(uploaded_file.name.lower())[1]
+        file_ext = os.path.splitext(filename.lower())[1]
         content_type_map = {
             '.wav': 'audio/wav',
             '.mp3': 'audio/mpeg',
@@ -75,7 +80,7 @@ def create_audio_upload_dto(uploaded_file) -> AudioUploadDto:
         content_type = content_type_map.get(file_ext, 'audio/wav')
 
         return AudioUploadDto(
-            filename=uploaded_file.name,
+            filename=filename,
             content=content,
             content_type=content_type,
             size=len(content)
@@ -84,33 +89,65 @@ def create_audio_upload_dto(uploaded_file) -> AudioUploadDto:
         logger.error(f"Failed to create AudioUploadDto: {e}")
         raise ValueError(f"Invalid audio file: {str(e)}")
 
-def handle_file_processing(
-    audio_upload: AudioUploadDto,
+def get_supported_configurations() -> dict:
+    """
+    Get supported configurations from application service.
+
+    Returns:
+        dict: Supported configurations
+    """
+    try:
+        logger.info("Getting global container...")
+        container = get_global_container()
+        logger.info("Resolving AudioProcessingApplicationService...")
+        audio_service = container.resolve(AudioProcessingApplicationService)
+        logger.info("Getting supported configurations from service...")
+        config = audio_service.get_supported_configurations()
+        logger.info(f"Retrieved configurations: {config}")
+        return config
+    except Exception as e:
+        logger.error(f"Failed to get configurations: {e}", exc_info=True)
+        # Return fallback configurations
+        return {
+            'asr_models': ['whisper-small', 'parakeet'],
+            'voices': ['kokoro', 'dia', 'cosyvoice2', 'dummy'],
+            'languages': ['en', 'zh', 'es', 'fr', 'de'],
+            'audio_formats': ['wav', 'mp3'],
+            'max_file_size_mb': 100,
+            'speed_range': {'min': 0.5, 'max': 2.0}
+        }
+
+def process_audio_pipeline(
+    audio_file,
     asr_model: str,
     target_language: str,
     voice: str,
     speed: float,
-    source_language: Optional[str] = None
-) -> ProcessingResultDto:
+    source_language: str = "en"
+) -> Tuple[str, str, str, str, str]:
     """
     Execute the complete processing pipeline using application services.
 
     Args:
-        audio_upload: Audio upload DTO
+        audio_file: Gradio audio file input
         asr_model: ASR model to use
         target_language: Target language for translation
         voice: Voice for TTS
         speed: Speech speed
-        source_language: Source language (optional)
+        source_language: Source language
 
     Returns:
-        ProcessingResultDto: Processing result
+        Tuple: (status_message, original_text, translated_text, audio_output_path, processing_details)
     """
-    logger.info(f"Starting processing for: {audio_upload.filename} using {asr_model} model")
-    progress_bar = st.progress(0)
-    status_text = st.empty()
-
     try:
+        if not audio_file:
+            return "❌ No audio file provided", "", "", None, ""
+
+        logger.info(f"Starting processing for: {audio_file} using {asr_model} model")
+
+        # Create audio upload DTO
+        audio_upload = create_audio_upload_dto(audio_file)
+
         # Get application service from container
         container = get_global_container()
         audio_service = container.resolve(AudioProcessingApplicationService)
@@ -125,274 +162,213 @@ def handle_file_processing(
             source_language=source_language
         )
 
-        # Update progress and status
-        status_text.markdown("🔍 **Performing Speech Recognition...**")
-        progress_bar.progress(10)
-
         # Process through application service
-        with st.spinner("Processing audio pipeline..."):
-            result = audio_service.process_audio_pipeline(request)
+        result = audio_service.process_audio_pipeline(request)
 
         if result.success:
-            progress_bar.progress(100)
-            status_text.success("✅ Processing Complete!")
+            status_message = f"✅ Processing Complete! ({result.processing_time:.2f}s)"
             logger.info(f"Processing completed successfully in {result.processing_time:.2f}s")
+            
+            # Prepare processing details
+            details = {
+                "processing_time": f"{result.processing_time:.2f}s",
+                "asr_model": asr_model,
+                "target_language": target_language,
+                "voice": voice,
+                "speed": speed
+            }
+            if result.metadata:
+                details.update(result.metadata)
+            
+            processing_details = json.dumps(details, indent=2)
+            
+            return (
+                status_message,
+                result.original_text or "",
+                result.translated_text or "",
+                result.audio_path if result.has_audio_output else None,
+                processing_details
+            )
         else:
-            status_text.error(f"❌ Processing Failed: {result.error_message}")
+            error_msg = f"❌ Processing Failed: {result.error_message}"
             logger.error(f"Processing failed: {result.error_message}")
-
-        return result
+            return error_msg, "", "", None, f"Error: {result.error_message}"
 
     except Exception as e:
         logger.error(f"Processing failed: {str(e)}", exc_info=True)
-        status_text.error(f"❌ Processing Failed: {str(e)}")
-        st.exception(e)
-
-        # Return error result
-        return ProcessingResultDto.error_result(
-            error_message=str(e),
-            error_code='SYSTEM_ERROR'
-        )
-
-def render_results(result: ProcessingResultDto):
-    """
-    Display processing results using ProcessingResultDto.
-
-    Args:
-        result: Processing result DTO
-    """
-    logger.info("Rendering results")
-    st.divider()
-
-    if not result.success:
-        st.error(f"Processing failed: {result.error_message}")
-        if result.error_code:
-            st.code(f"Error Code: {result.error_code}")
-        return
-
-    col1, col2 = st.columns([2, 1])
-
-    with col1:
-        # Display original text if available
-        if result.original_text:
-            st.subheader("Recognition Results")
-            st.code(result.original_text, language="text")
-
-        # Display translated text if available
-        if result.translated_text:
-            st.subheader("Translation Results")
-            st.code(result.translated_text, language="text")
-
-        # Display processing metadata
-        if result.metadata:
-            with st.expander("Processing Details"):
-                st.json(result.metadata)
-
-    with col2:
-        # Display audio output if available
-        if result.has_audio_output and result.audio_path:
-            st.subheader("Audio Output")
-
-            # Check if file exists and is accessible
-            if os.path.exists(result.audio_path):
-                # Standard audio player
-                st.audio(result.audio_path)
-
-                # Download button
-                try:
-                    with open(result.audio_path, "rb") as f:
-                        st.download_button(
-                            label="Download Audio",
-                            data=f,
-                            file_name="translated_audio.wav",
-                            mime="audio/wav"
-                        )
-                except Exception as e:
-                    st.warning(f"Download not available: {str(e)}")
-            else:
-                st.warning("Audio file not found or not accessible")
-
-        # Display processing time
-        st.metric("Processing Time", f"{result.processing_time:.2f}s")
-
-def get_supported_configurations() -> dict:
-    """
-    Get supported configurations from application service.
-
-    Returns:
-        dict: Supported configurations
-    """
-    try:
-        logger.info("Getting global container...")
-        container = get_global_container()
-        logger.info("Resolving AudioProcessingApplicationService...")
-        audio_service = container.resolve(AudioProcessingApplicationService)
-        logger.info("Getting supported configurations from service...")
-        config = audio_service.get_supported_configurations()
-        logger.info(f"Retrieved configurations: {config}")
-        return config
-    except Exception as e:
-        logger.error(f"Failed to get configurations: {e}", exc_info=True)
-        # Return fallback configurations
-        return {
-            'asr_models': ['whisper-small', 'parakeet'],
-            'voices': ['kokoro', 'dia', 'cosyvoice2', 'dummy'],
-            'languages': ['en', 'zh', 'es', 'fr', 'de'],
-            'audio_formats': ['wav', 'mp3'],
-            'max_file_size_mb': 100,
-            'speed_range': {'min': 0.5, 'max': 2.0}
+        error_msg = f"❌ Processing Failed: {str(e)}"
+        return error_msg, "", "", None, f"System Error: {str(e)}"
+
+def create_interface():
+    """Create and configure the Gradio interface"""
+    
+    # Initialize application
+    initialize_application()
+    
+    # Get supported configurations
+    config = get_supported_configurations()
+    
+    # Voice options mapping
+    voice_options = ["kokoro", "dia", "cosyvoice2", "dummy"]
+    
+    # Language options mapping
+    language_options = {
+        "Chinese (Mandarin)": "zh",
+        "Spanish": "es", 
+        "French": "fr",
+        "German": "de",
+        "English": "en"
+    }
+    
+    # Create the interface
+    with gr.Blocks(
+        title="🎧 High-Quality Audio Translation System",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 1200px !important;
         }
-
-def initialize_session_state():
-    """Initialize session state variables"""
-    if 'processing_result' not in st.session_state:
-        st.session_state.processing_result = None
-    if 'container_initialized' not in st.session_state:
-        st.session_state.container_initialized = False
-
-def initialize_application():
-    """Initialize the application with dependency injection container"""
-    if not st.session_state.get('container_initialized', False):
-        try:
-            logger.info("Initializing application container")
-            initialize_global_container()
-            st.session_state.container_initialized = True
-            logger.info("Application container initialized successfully")
-        except Exception as e:
-            logger.error(f"Failed to initialize application: {e}")
-            st.error(f"Application initialization failed: {str(e)}")
-            st.stop()
-
-def main():
-    """Main application workflow"""
-    logger.info("Starting application")
-
-    try:
-        # Configure page
-        configure_page()
-
-        # Initialize session state first
-        initialize_session_state()
-
-        # Initialize application
-        initialize_application()
-
-        st.title("🎧 High-Quality Audio Translation System")
-        st.markdown("Upload English Audio → Get Chinese Speech Output")
-
-        # Get supported configurations with error handling
-        try:
-            config = get_supported_configurations()
-            logger.info("Successfully retrieved configurations")
-        except Exception as e:
-            logger.error(f"Failed to get configurations: {e}")
-            st.error(f"Configuration error: {str(e)}")
-            # Use fallback configuration
-            config = {
-                'asr_models': ['parakeet', 'whisper-small'],
-                'voices': ['kokoro', 'dia', 'cosyvoice2', 'dummy'],
-                'languages': ['en', 'zh', 'es', 'fr', 'de'],
-                'audio_formats': ['wav', 'mp3'],
-                'max_file_size_mb': 100,
-                'speed_range': {'min': 0.5, 'max': 2.0}
-            }
-
-        # Voice selection in sidebar
-        st.sidebar.header("TTS Settings")
-
-        # Map voice display names to internal IDs
-        voice_options = {
-            "Kokoro": "kokoro",
-            "Dia": "dia",
-            "CosyVoice2": "cosyvoice2",
-            "Dummy (Test)": "dummy"
+        .audio-player {
+            width: 100%;
         }
-
-        selected_voice_display = st.sidebar.selectbox(
-            "Select Voice",
-            list(voice_options.keys()),
-            index=0
-        )
-        selected_voice = voice_options[selected_voice_display]
-
-        speed = st.sidebar.slider(
-            "Speech Speed",
-            config['speed_range']['min'],
-            config['speed_range']['max'],
-            1.0,
-            0.1
-        )
-
-        # Model selection
-        asr_model = st.selectbox(
-            "Select Speech Recognition Model",
-            options=config['asr_models'],
-            index=0,
-            help="Choose the ASR model for speech recognition"
+        """
+    ) as interface:
+        
+        gr.Markdown("# 🎧 High-Quality Audio Translation System")
+        gr.Markdown("Upload English Audio → Get Chinese Speech Output")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Audio input
+                audio_input = gr.Audio(
+                    label=f"Upload Audio File ({', '.join(config['audio_formats']).upper()})",
+                    type="filepath",
+                    format="wav"
+                )
+                
+                # Model selection
+                asr_model = gr.Dropdown(
+                    choices=config['asr_models'],
+                    value=config['asr_models'][0] if config['asr_models'] else "parakeet",
+                    label="Speech Recognition Model",
+                    info="Choose the ASR model for speech recognition"
+                )
+                
+                # Language selection
+                target_language = gr.Dropdown(
+                    choices=list(language_options.keys()),
+                    value="Chinese (Mandarin)",
+                    label="Target Language",
+                    info="Select the target language for translation"
+                )
+                
+            with gr.Column(scale=1):
+                # TTS Settings
+                gr.Markdown("### TTS Settings")
+                
+                voice = gr.Dropdown(
+                    choices=voice_options,
+                    value="kokoro",
+                    label="Voice"
+                )
+                
+                speed = gr.Slider(
+                    minimum=config['speed_range']['min'],
+                    maximum=config['speed_range']['max'],
+                    value=1.0,
+                    step=0.1,
+                    label="Speech Speed"
+                )
+        
+        # Process button
+        process_btn = gr.Button("🚀 Process Audio", variant="primary", size="lg")
+        
+        # Status message
+        status_output = gr.Markdown(label="Status")
+        
+        # Results section
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Text outputs
+                original_text = gr.Textbox(
+                    label="Recognition Results",
+                    lines=4,
+                    max_lines=8,
+                    interactive=False
+                )
+                
+                translated_text = gr.Textbox(
+                    label="Translation Results", 
+                    lines=4,
+                    max_lines=8,
+                    interactive=False
+                )
+                
+                # Processing details
+                with gr.Accordion("Processing Details", open=False):
+                    processing_details = gr.Code(
+                        label="Metadata",
+                        language="json",
+                        interactive=False
+                    )
+            
+            with gr.Column(scale=1):
+                # Audio output
+                audio_output = gr.Audio(
+                    label="Audio Output",
+                    interactive=False
+                )
+        
+        # Wire up the processing function
+        def process_wrapper(audio_file, asr_model_val, target_lang_val, voice_val, speed_val):
+            # Map display language to code
+            target_lang_code = language_options.get(target_lang_val, "zh")
+            
+            return process_audio_pipeline(
+                audio_file=audio_file,
+                asr_model=asr_model_val,
+                target_language=target_lang_code,
+                voice=voice_val,
+                speed=speed_val,
+                source_language="en"
+            )
+        
+        process_btn.click(
+            fn=process_wrapper,
+            inputs=[audio_input, asr_model, target_language, voice, speed],
+            outputs=[status_output, original_text, translated_text, audio_output, processing_details]
         )
-
-        # Language selection
-        language_options = {
-            "Chinese (Mandarin)": "zh",
-            "Spanish": "es",
-            "French": "fr",
-            "German": "de",
-            "English": "en"
-        }
-
-        selected_language_display = st.selectbox(
-            "Target Language",
-            list(language_options.keys()),
-            index=0,
-            help="Select the target language for translation"
+        
+        # Add examples if needed
+        gr.Examples(
+            examples=[],
+            inputs=[audio_input, asr_model, target_language, voice, speed],
+            label="Example Configurations"
         )
-        target_language = language_options[selected_language_display]
+    
+    return interface
 
-        # File upload
-        uploaded_file = st.file_uploader(
-            f"Select Audio File ({', '.join(config['audio_formats']).upper()})",
-            type=config['audio_formats'],
-            accept_multiple_files=False,
-            help=f"Maximum file size: {config['max_file_size_mb']}MB"
+def main():
+    """Main application entry point"""
+    logger.info("Starting Gradio application")
+    
+    try:
+        # Create interface
+        interface = create_interface()
+        
+        # Launch the interface
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            debug=False,
+            show_error=True,
+            quiet=False
         )
-
-        if uploaded_file:
-            logger.info(f"File uploaded: {uploaded_file.name}")
-
-            try:
-                # Create audio upload DTO
-                audio_upload = create_audio_upload_dto(uploaded_file)
-
-                # Display file information
-                st.info(f"📁 **File:** {audio_upload.filename} ({audio_upload.size / 1024:.1f} KB)")
-
-                # Process button
-                if st.button("🚀 Process Audio", type="primary"):
-                    # Process the audio
-                    result = handle_file_processing(
-                        audio_upload=audio_upload,
-                        asr_model=asr_model,
-                        target_language=target_language,
-                        voice=selected_voice,
-                        speed=speed,
-                        source_language="en"  # Assume English source for now
-                    )
-
-                    # Store result in session state
-                    st.session_state.processing_result = result
-
-                # Display results if available
-                if st.session_state.processing_result:
-                    render_results(st.session_state.processing_result)
-
-            except Exception as e:
-                st.error(f"Error processing file: {str(e)}")
-                logger.error(f"File processing error: {e}")
-
+        
     except Exception as e:
-        logger.error(f"Main application error: {str(e)}", exc_info=True)
-        st.error(f"Application error: {str(e)}")
-        st.exception(e)
+        logger.error(f"Failed to start application: {str(e)}", exc_info=True)
+        raise
 
 if __name__ == "__main__":
     main()

pyproject.toml

@@ -25,8 +25,7 @@ dependencies = [
     "ordered-set>=4.1.0",
     "phonemizer-fork>=3.3.2",
     "nemo_toolkit[asr]",
-    "faster-whisper>=1.1.1",
-    "descript-audio-codec>=0.0.5"
+    "faster-whisper>=1.1.1"
 ]
 
 [project.optional-dependencies]

requirements.txt

@@ -14,5 +14,4 @@ kokoro>=0.7.9
 ordered-set>=4.1.0
 phonemizer-fork>=3.3.2
 nemo_toolkit[asr]
-faster-whisper>=1.1.1
-descript-audio-codec>=0.0.5
+faster-whisper>=1.1.1