Update app.py

app.py

@@ -1,17 +1,16 @@
 import gradio as gr
-import json
+from flask import Flask
 import os
 import tempfile
 import logging
-import traceback
-from pathlib import Path
-print("Gradio version:", gr.__version__)
+import threading
+import time
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configuration - Use current directory for model files
+# Configuration
 MODEL_DIR = "."
 SUPPORTED_AUDIO_FORMATS = [".mp3", ".mp4", ".wav", ".m4a", ".flac", ".ogg"]
 
@@ -70,12 +69,7 @@ def check_model_files():
         if not os.path.exists(os.path.join(MODEL_DIR, file)):
             missing_files.append(file)
     
-    if missing_files:
-        logger.error(f"Missing model files: {missing_files}")
-        return False, missing_files
-    
-    logger.info("✓ All required model files found")
-    return True, []
+    return len(missing_files) == 0, missing_files
 
 def run_complete_pipeline(audio_file_path: str) -> dict:
     """Complete pipeline: Audio → WAV → CHA → JSON → Model Prediction"""
@@ -128,7 +122,8 @@ def run_complete_pipeline(audio_file_path: str) -> dict:
         
     except Exception as e:
         logger.error(f"Pipeline error: {str(e)}")
-        logger.error(traceback.format_exc())
+        import traceback
+        traceback.print_exc()
         return {
             "success": False,
             "error": str(e),
@@ -143,13 +138,15 @@ def process_audio_input(audio_file):
         
         # Check if pipeline is available
         if not all(MODULES.values()):
-            return "❌ Error: Audio processing pipeline not available. Missing required modules."
+            missing_modules = [k for k, v in MODULES.items() if v is None]
+            return f"❌ Error: Audio processing pipeline not available. Missing required modules: {', '.join(missing_modules)}"
         
         # Check file format
         file_path = audio_file
         if hasattr(audio_file, 'name'):
             file_path = audio_file.name
         
+        from pathlib import Path
         file_ext = Path(file_path).suffix.lower()
         if file_ext not in SUPPORTED_AUDIO_FORMATS:
             return f"❌ Error: Unsupported file format {file_ext}. Supported: {', '.join(SUPPORTED_AUDIO_FORMATS)}"
@@ -185,8 +182,7 @@ def process_audio_input(audio_file):
             prob_dist = first_pred["probability_distribution"]
             top_3 = list(prob_dist.items())[:3]
             
-            result_text = f"""
-🧠 **APHASIA CLASSIFICATION RESULTS**
+            result_text = f"""🧠 **APHASIA CLASSIFICATION RESULTS**
 
 🎯 **Primary Classification:** {predicted_class}
 📊 **Confidence:** {confidence}
@@ -218,7 +214,8 @@ def process_audio_input(audio_file):
             
     except Exception as e:
         logger.error(f"Processing error: {str(e)}")
-        logger.error(traceback.format_exc())
+        import traceback
+        traceback.print_exc()
         return f"❌ Processing Error: {str(e)}\n\nPlease check the logs for more details."
 
 def process_text_input(text_input):
@@ -232,6 +229,7 @@ def process_text_input(text_input):
             return "❌ Error: Text analysis not available. Missing prediction module."
         
         # Create a simple JSON structure for text-only input
+        import json
         temp_json = {
             "sentences": [{
                 "sentence_id": "S1",
@@ -274,8 +272,7 @@ def process_text_input(text_input):
             severity = first_pred["additional_predictions"]["predicted_severity_level"]
             fluency = first_pred["additional_predictions"]["fluency_rating"]
             
-            return f"""
-🧠 **TEXT ANALYSIS RESULTS**
+            return f"""🧠 **TEXT ANALYSIS RESULTS**
 
 🎯 **Predicted:** {predicted_class}
 📊 **Confidence:** {confidence}
@@ -294,107 +291,159 @@ def process_text_input(text_input):
         logger.error(f"Text processing error: {str(e)}")
         return f"❌ Error: {str(e)}"
 
-def detect_environment():
-    """Detect if we're running in a cloud environment"""
-    # Check for common cloud environment indicators
-    cloud_indicators = [
-        'SPACE_ID',  # Hugging Face Spaces
-        'PAPERSPACE_NOTEBOOK_REPO_ID',  # Paperspace
-        'COLAB_GPU',  # Google Colab
-        'KAGGLE_KERNEL_RUN_TYPE',  # Kaggle
-        'AWS_LAMBDA_FUNCTION_NAME',  # AWS Lambda
-    ]
-    
-    is_cloud = any(os.getenv(indicator) for indicator in cloud_indicators)
-    
-    # Also check if we can access localhost
-    import socket
-    localhost_accessible = False
-    try:
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(1)
-        result = sock.connect_ex(('127.0.0.1', 7860))
-        localhost_accessible = (result == 0)
-        sock.close()
-    except:
-        localhost_accessible = False
-    
-    return is_cloud, localhost_accessible
-
-def create_interface():
-    """Create Gradio interface with proper configuration"""
+def create_gradio_app():
+    """Create the Gradio interface"""
     
     # Check system status
     model_available, missing_files = check_model_files()
     pipeline_available = all(MODULES.values())
     
-    status_message = "🟢 **System Status: Ready**" if model_available and pipeline_available else "🔴 **System Status: Issues Detected**"
+    status_message = "🟢 System Ready" if model_available and pipeline_available else "🔴 System Issues"
     
+    status_details = []
     if not model_available:
-        status_message += f"\n❌ Missing model files: {', '.join(missing_files)}"
-    
+        status_details.append(f"Missing model files: {', '.join(missing_files)}")
     if not pipeline_available:
         missing_modules = [k for k, v in MODULES.items() if v is None]
-        status_message += f"\n❌ Missing modules: {', '.join(missing_modules)}"
+        status_details.append(f"Missing modules: {', '.join(missing_modules)}")
     
-    # Create interface using simple Interface instead of Blocks to avoid JSON schema issues
-    audio_interface = gr.Interface(
+    # Create simple interfaces to avoid JSON schema issues
+    audio_demo = gr.Interface(
         fn=process_audio_input,
-        inputs=gr.File(
-            label="Upload Audio File (MP3, MP4, WAV, M4A, FLAC, OGG)",
-            file_types=["audio"]
-        ),
-        outputs=gr.Textbox(
-            label="Analysis Results",
-            lines=25,
-            max_lines=50
-        ),
+        inputs=gr.File(label="Upload Audio File", file_types=["audio"]),
+        outputs=gr.Textbox(label="Analysis Results", lines=25),
+        title="🎵 Audio Analysis",
+        description="Upload MP3, MP4, WAV, M4A, FLAC, or OGG files"
+    )
+    
+    text_demo = gr.Interface(
+        fn=process_text_input,
+        inputs=gr.Textbox(label="Enter Text", lines=5, placeholder="Enter speech transcription..."),
+        outputs=gr.Textbox(label="Analysis Results", lines=15),
+        title="📝 Text Analysis", 
+        description="Enter text for direct analysis (less accurate than audio)"
+    )
+    
+    # Combine interfaces using TabbedInterface
+    demo = gr.TabbedInterface(
+        [audio_demo, text_demo],
+        ["Audio Analysis", "Text Analysis"],
         title="🧠 Aphasia Classification System",
-        description="Upload audio files to analyze speech patterns and classify aphasia types",
-        article=f"""
-        <div style="margin-top: 20px;">
-            <h3>System Status</h3>
-            <p>{status_message}</p>
-            <h3>About</h3>
-            <p><strong>Pipeline:</strong> Audio → WAV → CHA → JSON → Classification</p>
-            <p><strong>Supported formats:</strong> MP3, MP4, WAV, M4A, FLAC, OGG</p>
-            <p><em>For research and clinical assessment purposes.</em></p>
-        </div>
-        """
+        theme=gr.themes.Soft()
     )
     
-    return audio_interface
+    return demo
 
-if __name__ == "__main__":
-    try:
-        logger.info("Starting Aphasia Classification System...")
-        
-        # Detect environment
-        is_cloud, localhost_accessible = detect_environment()
-        logger.info(f"Environment - Cloud: {is_cloud}, Localhost accessible: {localhost_accessible}")
-        
-        # Create and launch interface
-        demo = create_interface()
+def create_flask_app():
+    """Create Flask app that serves Gradio"""
+    
+    # Create Flask app
+    flask_app = Flask(__name__)
+    
+    # Create Gradio app
+    gradio_app = create_gradio_app()
+    
+    # Mount Gradio app on Flask
+    gradio_app.queue()  # Enable queuing for better performance
+    
+    # Get the underlying FastAPI app from Gradio
+    gradio_fastapi_app = gradio_app.app
+    
+    # Add a health check endpoint
+    @flask_app.route('/health')
+    def health_check():
+        model_available, missing_files = check_model_files()
+        pipeline_available = all(MODULES.values())
         
-        # Configure launch parameters based on environment
-        launch_kwargs = {
-            "server_name": "0.0.0.0",
-            "server_port": 7860,
-            "show_error": True,
-            "quiet": False,
+        return {
+            "status": "healthy" if model_available and pipeline_available else "unhealthy",
+            "model_available": model_available,
+            "pipeline_available": pipeline_available,
+            "missing_files": missing_files if not model_available else [],
+            "missing_modules": [k for k, v in MODULES.items() if v is None] if not pipeline_available else []
         }
-        
-        # Set share parameter based on environment
-        if is_cloud or not localhost_accessible:
-            launch_kwargs["share"] = True
-            logger.info("Running in cloud environment or localhost not accessible - enabling share")
-        else:
-            launch_kwargs["share"] = False
-            logger.info("Running locally - share disabled")
-        
-        demo.launch(**launch_kwargs)
-        
+    
+    # Add info endpoint
+    @flask_app.route('/info')
+    def info():
+        return {
+            "title": "Aphasia Classification System",
+            "description": "AI-powered aphasia type classification from audio",
+            "supported_formats": SUPPORTED_AUDIO_FORMATS,
+            "endpoints": {
+                "/": "Main Gradio interface",
+                "/health": "Health check",
+                "/info": "System information"
+            }
+        }
+    
+    return flask_app, gradio_app
+
+def run_gradio_on_flask():
+    """Run Gradio app mounted on Flask"""
+    
+    logger.info("Starting Aphasia Classification System with Flask + Gradio...")
+    
+    # Create Flask and Gradio apps
+    flask_app, gradio_app = create_flask_app()
+    
+    # Detect environment
+    port = int(os.environ.get('PORT', 7860))
+    host = os.environ.get('HOST', '0.0.0.0')
+    
+    # Check if we're in a cloud environment
+    is_cloud = any(os.getenv(indicator) for indicator in [
+        'SPACE_ID', 'PAPERSPACE_NOTEBOOK_REPO_ID', 
+        'COLAB_GPU', 'KAGGLE_KERNEL_RUN_TYPE'
+    ])
+    
+    logger.info(f"Environment - Cloud: {is_cloud}, Host: {host}, Port: {port}")
+    
+    def run_gradio():
+        """Run Gradio in a separate thread"""
+        try:
+            gradio_app.launch(
+                server_name=host,
+                server_port=port,
+                share=is_cloud,  # Auto-enable share in cloud environments
+                show_error=True,
+                quiet=False,
+                prevent_thread_lock=True  # Important for running with Flask
+            )
+        except Exception as e:
+            logger.error(f"Failed to start Gradio: {e}")
+    
+    # Start Gradio in background thread
+    gradio_thread = threading.Thread(target=run_gradio, daemon=True)
+    gradio_thread.start()
+    
+    # Give Gradio time to start
+    time.sleep(2)
+    
+    logger.info(f"✓ Gradio app started on {host}:{port}")
+    logger.info("✓ Flask health endpoints available at /health and /info")
+    
+    # Keep the main thread alive
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        logger.info("Shutting down...")
+
+if __name__ == "__main__":
+    try:
+        run_gradio_on_flask()
     except Exception as e:
-        logger.error(f"Failed to launch app: {e}")
-        logger.error(traceback.format_exc())
-        print(f"❌ Application startup failed: {e}")
+        logger.error(f"Failed to start application: {e}")
+        import traceback
+        traceback.print_exc()
+        
+        # Fallback to basic Gradio if Flask setup fails
+        logger.info("Falling back to basic Gradio interface...")
+        demo = create_gradio_app()
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            show_error=True
+        )