Aphasia_Classificifier

Sleeping

App Files Files Community

Ellie5757575757 commited on Aug 9, 2025

Commit

28fc64c

verified ·

1 Parent(s): 63d2b83

Update app.py

Browse files

Files changed (1) hide show

app.py +444 -364

app.py CHANGED Viewed

@@ -1,449 +1,529 @@
-import gradio as gr
-from flask import Flask
 import os
 import tempfile
 import logging
-import threading
-import time
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-# Configuration
-MODEL_DIR = "."
-SUPPORTED_AUDIO_FORMATS = [".mp3", ".mp4", ".wav", ".m4a", ".flac", ".ogg"]
 def safe_import_modules():
-    """Safely import pipeline modules with error handling"""
     modules = {}
     try:
         from utils_audio import convert_to_wav
         modules['convert_to_wav'] = convert_to_wav
-        logger.info("✓ utils_audio imported successfully")
     except Exception as e:
-        logger.error(f"✗ Failed to import utils_audio: {e}")
         modules['convert_to_wav'] = None
     try:
         from to_cha import to_cha_from_wav
         modules['to_cha_from_wav'] = to_cha_from_wav
-        logger.info("✓ to_cha imported successfully")
     except Exception as e:
-        logger.error(f"✗ Failed to import to_cha: {e}")
         modules['to_cha_from_wav'] = None
     try:
         from cha_json import cha_to_json_file
         modules['cha_to_json_file'] = cha_to_json_file
-        logger.info("✓ cha_json imported successfully")
     except Exception as e:
-        logger.error(f"✗ Failed to import cha_json: {e}")
         modules['cha_to_json_file'] = None
     try:
         from output import predict_from_chajson
         modules['predict_from_chajson'] = predict_from_chajson
-        logger.info("✓ output imported successfully")
     except Exception as e:
-        logger.error(f"✗ Failed to import output: {e}")
         modules['predict_from_chajson'] = None
     return modules
 # Import modules
 MODULES = safe_import_modules()
-def check_model_files():
-    """Check if required model files exist"""
-    required_files = [
-        "pytorch_model.bin",
-        "config.json",
-        "tokenizer.json",
-        "tokenizer_config.json"
-    ]
-    missing_files = []
-    for file in required_files:
-        if not os.path.exists(os.path.join(MODEL_DIR, file)):
-            missing_files.append(file)
-    return len(missing_files) == 0, missing_files
-def run_complete_pipeline(audio_file_path: str) -> dict:
-    """Complete pipeline: Audio → WAV → CHA → JSON → Model Prediction"""
-    # Check if all modules are available
-    if not all(MODULES.values()):
-        missing = [k for k, v in MODULES.items() if v is None]
-        return {
-            "success": False,
-            "error": f"Missing required modules: {missing}",
-            "message": "Pipeline modules not available"
         }
-    try:
-        logger.info(f"Starting pipeline for: {audio_file_path}")
-        # Step 1: Convert to WAV
-        logger.info("Step 1: Converting audio to WAV...")
-        wav_path = MODULES['convert_to_wav'](audio_file_path, sr=16000, mono=True)
-        logger.info(f"WAV conversion completed: {wav_path}")
-        # Step 2: Generate CHA file using Batchalign
-        logger.info("Step 2: Generating CHA file...")
-        cha_path = MODULES['to_cha_from_wav'](wav_path, lang="eng")
-        logger.info(f"CHA generation completed: {cha_path}")
-        # Step 3: Convert CHA to JSON
-        logger.info("Step 3: Converting CHA to JSON...")
-        chajson_path, json_data = MODULES['cha_to_json_file'](cha_path)
-        logger.info(f"JSON conversion completed: {chajson_path}")
-        # Step 4: Run aphasia classification
-        logger.info("Step 4: Running aphasia classification...")
-        results = MODULES['predict_from_chajson'](MODEL_DIR, chajson_path, output_file=None)
-        logger.info("Classification completed")
-        # Cleanup temporary files
-        try:
-            os.unlink(wav_path)
-            os.unlink(cha_path)
-            os.unlink(chajson_path)
-        except Exception as cleanup_error:
-            logger.warning(f"Cleanup error: {cleanup_error}")
-        return {
-            "success": True,
-            "results": results,
-            "message": "Pipeline completed successfully"
         }
-    except Exception as e:
-        logger.error(f"Pipeline error: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return {
-            "success": False,
-            "error": str(e),
-            "message": f"Pipeline failed: {str(e)}"
         }
-def process_audio_input(audio_file):
-    """Process audio file and return formatted results"""
-    try:
-        if audio_file is None:
-            return "❌ Error: No audio file uploaded"
-        # Check if pipeline is available
-        if not all(MODULES.values()):
-            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)}"
-        # Run the complete pipeline
-        pipeline_result = run_complete_pipeline(file_path)
-        if not pipeline_result["success"]:
-            return f"❌ Pipeline Error: {pipeline_result['message']}\n\nDetails: {pipeline_result.get('error', '')}"
-        # Format results
-        results = pipeline_result["results"]
-        if "predictions" in results and len(results["predictions"]) > 0:
-            first_pred = results["predictions"][0]
-            if "error" in first_pred:
-                return f"❌ Classification Error: {first_pred['error']}"
-            # Format main result
-            predicted_class = first_pred["prediction"]["predicted_class"]
-            confidence = first_pred["prediction"]["confidence_percentage"]
-            class_name = first_pred["class_description"]["name"]
-            description = first_pred["class_description"]["description"]
-            # Additional metrics
-            additional_info = first_pred["additional_predictions"]
-            severity_level = additional_info["predicted_severity_level"]
-            fluency_score = additional_info["fluency_score"]
-            fluency_rating = additional_info["fluency_rating"]
-            # Format probability distribution (top 3)
-            prob_dist = first_pred["probability_distribution"]
-            top_3 = list(prob_dist.items())[:3]
-            result_text = f"""🧠 **APHASIA CLASSIFICATION RESULTS**
-🎯 **Primary Classification:** {predicted_class}
-📊 **Confidence:** {confidence}
-📋 **Type:** {class_name}
-📈 **Additional Metrics:**
-• Severity Level: {severity_level}/3
-• Fluency Score: {fluency_score:.3f} ({fluency_rating})
-📊 **Top 3 Probability Rankings:**
-"""
-            for i, (aphasia_type, info) in enumerate(top_3, 1):
-                result_text += f"{i}. {aphasia_type}: {info['percentage']}\n"
-            result_text += f"""
-📝 **Clinical Description:**
-{description}
-📊 **Processing Summary:**
-• Total sentences analyzed: {results.get('total_sentences', 'N/A')}
-• Average confidence: {results.get('summary', {}).get('average_confidence', 'N/A')}
-• Average fluency: {results.get('summary', {}).get('average_fluency_score', 'N/A')}
-"""
-            return result_text
-        else:
-            return "❌ No predictions generated. The audio file may not contain analyzable speech."
-    except Exception as e:
-        logger.error(f"Processing error: {str(e)}")
-        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):
-    """Process text input directly (fallback option)"""
     try:
-        if not text_input or not text_input.strip():
-            return "❌ Error: Please enter some text for analysis"
-        # Check if prediction module is available
-        if MODULES['predict_from_chajson'] is None:
-            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",
-                "aphasia_type": "UNKNOWN",
-                "dialogues": [{
-                    "INV": [],
-                    "PAR": [{
-                        "tokens": text_input.split(),
-                        "word_pos_ids": [0] * len(text_input.split()),
-                        "word_grammar_ids": [[0, 0, 0]] * len(text_input.split()),
-                        "word_durations": [0.0] * len(text_input.split()),
-                        "utterance_text": text_input
-                    }]
-                }]
-            }],
-            "text_all": text_input
-        }
-        # Save to temporary file
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
-            json.dump(temp_json, f, ensure_ascii=False, indent=2)
-            temp_json_path = f.name
-        # Run prediction
-        results = MODULES['predict_from_chajson'](MODEL_DIR, temp_json_path, output_file=None)
-        # Cleanup
-        try:
-            os.unlink(temp_json_path)
-        except:
-            pass
-        # Format results
-        if "predictions" in results and len(results["predictions"]) > 0:
-            first_pred = results["predictions"][0]
-            predicted_class = first_pred["prediction"]["predicted_class"]
-            confidence = first_pred["prediction"]["confidence_percentage"]
-            description = first_pred["class_description"]["description"]
-            severity = first_pred["additional_predictions"]["predicted_severity_level"]
-            fluency = first_pred["additional_predictions"]["fluency_rating"]
-            return f"""🧠 **TEXT ANALYSIS RESULTS**
-🎯 **Predicted:** {predicted_class}
-📊 **Confidence:** {confidence}
-📈 **Severity:** {severity}/3
-🗣️ **Fluency:** {fluency}
-📝 **Description:**
 {description}
-ℹ️ **Note:** Text-based analysis provides limited accuracy compared to audio analysis.
 """
-        else:
-            return "❌ No predictions generated from text input"
     except Exception as e:
-        logger.error(f"Text processing error: {str(e)}")
-        return f"❌ Error: {str(e)}"
-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 Ready" if model_available and pipeline_available else "🔴 System Issues"
-    status_details = []
-    if not model_available:
-        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_details.append(f"Missing modules: {', '.join(missing_modules)}")
-    # Create simple interfaces to avoid JSON schema issues
-    audio_demo = gr.Interface(
-        fn=process_audio_input,
-        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",
-        theme=gr.themes.Soft()
-    )
-    return demo
-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())
-        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 []
-        }
-    # 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 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
-        )

+#!/usr/bin/env python3
+"""
+Pure Flask App for Aphasia Classification
+No Gradio dependency - works anywhere!
+"""
+from flask import Flask, request, render_template_string, jsonify, send_from_directory
 import os
 import tempfile
 import logging
+import json
+from pathlib import Path
+import traceback
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
+app = Flask(__name__)
+app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100MB max
+print("🚀 Starting Aphasia Classification System (Flask)")
 def safe_import_modules():
+    """Import pipeline modules safely"""
     modules = {}
     try:
         from utils_audio import convert_to_wav
         modules['convert_to_wav'] = convert_to_wav
+        logger.info("✓ utils_audio imported")
     except Exception as e:
+        logger.error(f"✗ utils_audio failed: {e}")
         modules['convert_to_wav'] = None
     try:
         from to_cha import to_cha_from_wav
         modules['to_cha_from_wav'] = to_cha_from_wav
+        logger.info("✓ to_cha imported")
     except Exception as e:
+        logger.error(f"✗ to_cha failed: {e}")
         modules['to_cha_from_wav'] = None
     try:
         from cha_json import cha_to_json_file
         modules['cha_to_json_file'] = cha_to_json_file
+        logger.info("✓ cha_json imported")
     except Exception as e:
+        logger.error(f"✗ cha_json failed: {e}")
         modules['cha_to_json_file'] = None
     try:
         from output import predict_from_chajson
         modules['predict_from_chajson'] = predict_from_chajson
+        logger.info("✓ output imported")
     except Exception as e:
+        logger.error(f"✗ output failed: {e}")
         modules['predict_from_chajson'] = None
     return modules
 # Import modules
 MODULES = safe_import_modules()
+MODEL_DIR = "."
+# HTML Template
+HTML_TEMPLATE = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>🧠 Aphasia Classification System</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
         }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 60px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+        .header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 40px 30px;
+            text-align: center;
+        }
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+            font-weight: 700;
+        }
+        .header p {
+            font-size: 1.1em;
+            opacity: 0.9;
+        }
+        .content {
+            padding: 40px 30px;
         }
+        .status {
+            background: #f8f9fa;
+            border-radius: 10px;
+            padding: 20px;
+            margin-bottom: 30px;
+            border-left: 4px solid #28a745;
         }
+        .status h3 {
+            color: #28a745;
+            margin-bottom: 10px;
+        }
+        .upload-section {
+            background: #f8f9fa;
+            border-radius: 15px;
+            padding: 30px;
+            margin-bottom: 30px;
+            border: 2px dashed #dee2e6;
+            text-align: center;
+            transition: all 0.3s ease;
+        }
+        .upload-section:hover {
+            border-color: #667eea;
+            background: #f0f4ff;
+        }
+        .file-input {
+            display: none;
+        }
+        .file-label {
+            display: inline-block;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 15px 30px;
+            border-radius: 50px;
+            cursor: pointer;
+            font-size: 1.1em;
+            font-weight: 600;
+            transition: transform 0.2s ease;
+        }
+        .file-label:hover {
+            transform: translateY(-2px);
+        }
+        .analyze-btn {
+            background: #28a745;
+            color: white;
+            border: none;
+            padding: 15px 40px;
+            border-radius: 50px;
+            font-size: 1.1em;
+            font-weight: 600;
+            cursor: pointer;
+            margin-top: 20px;
+            transition: all 0.2s ease;
+        }
+        .analyze-btn:hover {
+            background: #218838;
+            transform: translateY(-2px);
+        }
+        .analyze-btn:disabled {
+            background: #6c757d;
+            cursor: not-allowed;
+            transform: none;
+        }
+        .results {
+            background: #f8f9fa;
+            border-radius: 15px;
+            padding: 30px;
+            margin-top: 30px;
+            display: none;
+        }
+        .results.success {
+            border-left: 4px solid #28a745;
+        }
+        .results.error {
+            border-left: 4px solid #dc3545;
+            background: #fff5f5;
+        }
+        .loading {
+            text-align: center;
+            padding: 40px;
+            display: none;
+        }
+        .spinner {
+            border: 4px solid #f3f3f3;
+            border-top: 4px solid #667eea;
+            border-radius: 50%;
+            width: 50px;
+            height: 50px;
+            animation: spin 1s linear infinite;
+            margin: 0 auto 20px;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+        .supported-formats {
+            text-align: center;
+            color: #6c757d;
+            margin-top: 15px;
+            font-size: 0.9em;
+        }
+        .about {
+            background: #fff;
+            border-radius: 15px;
+            padding: 30px;
+            margin-top: 30px;
+            border: 1px solid #dee2e6;
+        }
+        .about h3 {
+            color: #333;
+            margin-bottom: 15px;
+        }
+        .about p {
+            color: #666;
+            line-height: 1.6;
+            margin-bottom: 10px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🧠 Aphasia Classification</h1>
+            <p>Advanced AI-powered speech analysis for aphasia type identification</p>
+        </div>
+        <div class="content">
+            <div class="status">
+                <h3>{{ status_title }}</h3>
+                <div>{{ status_details | safe }}</div>
+            </div>
+            <div class="upload-section">
+                <h3>📁 Upload Audio File</h3>
+                <p>Select an audio file containing speech for analysis</p>
+                <form id="uploadForm" enctype="multipart/form-data">
+                    <input type="file" id="audioFile" name="audio" class="file-input" accept="audio/*" required>
+                    <label for="audioFile" class="file-label">
+                        🎵 Choose Audio File
+                    </label>
+                    <br>
+                    <button type="submit" class="analyze-btn" id="analyzeBtn">
+                        🔍 Analyze Speech
+                    </button>
+                </form>
+                <div class="supported-formats">
+                    Supported: MP3, WAV, MP4, M4A, FLAC, OGG
+                </div>
+            </div>
+            <div class="loading" id="loading">
+                <div class="spinner"></div>
+                <h3>🔄 Analyzing Audio...</h3>
+                <p>This may take 1-3 minutes depending on file size</p>
+            </div>
+            <div class="results" id="results">
+                <div id="resultsContent"></div>
+            </div>
+            <div class="about">
+                <h3>About This System</h3>
+                <p>This AI system analyzes speech patterns to classify different types of aphasia, including:</p>
+                <p><strong>• Broca's Aphasia:</strong> Non-fluent speech with preserved comprehension</p>
+                <p><strong>• Wernicke's Aphasia:</strong> Fluent but often meaningless speech</p>
+                <p><strong>• Anomic Aphasia:</strong> Word-finding difficulties</p>
+                <p><strong>• Conduction Aphasia:</strong> Fluent speech with poor repetition</p>
+                <p><strong>• Global Aphasia:</strong> Severe impairment in all language areas</p>
+                <br>
+                <p><em>Note: This tool is for research and educational purposes. Always consult healthcare professionals for clinical decisions.</em></p>
+            </div>
+        </div>
+    </div>
+    <script>
+        document.getElementById('uploadForm').addEventListener('submit', async function(e) {
+            e.preventDefault();
+            const fileInput = document.getElementById('audioFile');
+            const analyzeBtn = document.getElementById('analyzeBtn');
+            const loading = document.getElementById('loading');
+            const results = document.getElementById('results');
+            const resultsContent = document.getElementById('resultsContent');
+            if (!fileInput.files[0]) {
+                alert('Please select an audio file first');
+                return;
+            }
+            // Show loading
+            loading.style.display = 'block';
+            results.style.display = 'none';
+            analyzeBtn.disabled = true;
+            analyzeBtn.textContent = '🔄 Processing...';
+            try {
+                const formData = new FormData();
+                formData.append('audio', fileInput.files[0]);
+                const response = await fetch('/analyze', {
+                    method: 'POST',
+                    body: formData
+                });
+                const data = await response.json();
+                // Hide loading
+                loading.style.display = 'none';
+                if (data.success) {
+                    resultsContent.innerHTML = '<pre style="white-space: pre-wrap; font-family: inherit;">' + data.result + '</pre>';
+                    results.className = 'results success';
+                } else {
+                    resultsContent.innerHTML = '<h3 style="color: #dc3545;">❌ Error</h3><p>' + data.error + '</p>';
+                    results.className = 'results error';
+                }
+                results.style.display = 'block';
+            } catch (error) {
+                loading.style.display = 'none';
+                resultsContent.innerHTML = '<h3 style="color: #dc3545;">❌ Network Error</h3><p>Failed to process request: ' + error.message + '</p>';
+                results.className = 'results error';
+                results.style.display = 'block';
+            }
+            // Reset button
+            analyzeBtn.disabled = false;
+            analyzeBtn.textContent = '🔍 Analyze Speech';
+        });
+        // Update file label when file is selected
+        document.getElementById('audioFile').addEventListener('change', function(e) {
+            const label = document.querySelector('.file-label');
+            if (e.target.files[0]) {
+                label.textContent = '✓ ' + e.target.files[0].name;
+            } else {
+                label.textContent = '🎵 Choose Audio File';
+            }
+        });
+    </script>
+</body>
+</html>
+"""
+@app.route('/')
+def index():
+    """Main page"""
+    # Check system status
+    modules_ready = all(MODULES.values())
+    missing_modules = [k for k, v in MODULES.items() if v is None]
+    if modules_ready:
+        status_title = "🟢 System Ready"
+        status_details = "All components loaded successfully. Ready to process audio files."
+    else:
+        status_title = "🟡 System Loading"
+        status_details = f"Missing modules: {', '.join(missing_modules)}<br>Some features may not be available."
+    return render_template_string(HTML_TEMPLATE,
+                                status_title=status_title,
+                                status_details=status_details)
+@app.route('/analyze', methods=['POST'])
+def analyze_audio():
+    """Process uploaded audio file"""
     try:
+        # Check if file was uploaded
+        if 'audio' not in request.files:
+            return jsonify({'success': False, 'error': 'No audio file uploaded'})
+        audio_file = request.files['audio']
+        if audio_file.filename == '':
+            return jsonify({'success': False, 'error': 'No file selected'})
+        # Check if modules are available
+        if not all(MODULES.values()):
+            missing = [k for k, v in MODULES.items() if v is None]
+            return jsonify({'success': False, 'error': f'System not ready. Missing: {", ".join(missing)}'})
+        # Save uploaded file temporarily
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(audio_file.filename)[1]) as tmp_file:
+            audio_file.save(tmp_file.name)
+            temp_audio_path = tmp_file.name
+        try:
+            logger.info("🎵 Starting audio processing pipeline...")
+            # Step 1: Convert to WAV
+            wav_path = MODULES['convert_to_wav'](temp_audio_path, sr=16000, mono=True)
+            logger.info("✓ Audio converted to WAV")
+            # Step 2: Generate CHA file
+            cha_path = MODULES['to_cha_from_wav'](wav_path, lang="eng")
+            logger.info("✓ CHA file generated")
+            # Step 3: Convert CHA to JSON
+            json_path, _ = MODULES['cha_to_json_file'](cha_path)
+            logger.info("✓ JSON conversion completed")
+            # Step 4: Run classification
+            results = MODULES['predict_from_chajson'](MODEL_DIR, json_path, output_file=None)
+            logger.info("✓ Classification completed")
+            # Clean up temporary files
+            for temp_file in [temp_audio_path, wav_path, cha_path, json_path]:
+                try:
+                    os.unlink(temp_file)
+                except:
+                    pass
+            # Format results
+            if "predictions" in results and results["predictions"]:
+                pred = results["predictions"][0]
+                if "error" in pred:
+                    return jsonify({'success': False, 'error': f'Classification error: {pred["error"]}'})
+                # Format the result text
+                classification = pred["prediction"]["predicted_class"]
+                confidence = pred["prediction"]["confidence_percentage"]
+                type_name = pred["class_description"]["name"]
+                description = pred["class_description"]["description"]
+                severity = pred["additional_predictions"]["predicted_severity_level"]
+                fluency = pred["additional_predictions"]["fluency_rating"]
+                result_text = f"""🧠 APHASIA CLASSIFICATION RESULTS
+🎯 Primary Classification: {classification}
+📊 Confidence: {confidence}
+📋 Type: {type_name}
+📈 Severity Level: {severity}/3
+🗣️ Fluency Rating: {fluency}
+📊 Top 3 Probability Rankings:"""
+                # Add probability distribution
+                prob_dist = pred["probability_distribution"]
+                for i, (atype, info) in enumerate(list(prob_dist.items())[:3], 1):
+                    result_text += f"\n{i}. {atype}: {info['percentage']}"
+                result_text += f"""
+📝 Clinical Description:
 {description}
+📊 Processing Summary:
+• Total sentences analyzed: {results.get('total_sentences', 'N/A')}
+• Average confidence: {results.get('summary', {}).get('average_confidence', 'N/A')}
+• Processing completed successfully
 """
+                return jsonify({'success': True, 'result': result_text})
+            else:
+                return jsonify({'success': False, 'error': 'No predictions generated from the audio file'})
+        except Exception as e:
+            # Clean up temp file on error
+            try:
+                os.unlink(temp_audio_path)
+            except:
+                pass
+            raise e
     except Exception as e:
+        logger.error(f"Processing error: {e}")
+        traceback.print_exc()
+        return jsonify({'success': False, 'error': f'Processing failed: {str(e)}'})
+@app.route('/health')
+def health_check():
+    """Health check endpoint"""
+    modules_ready = all(MODULES.values())
+    return jsonify({
+        'status': 'healthy' if modules_ready else 'degraded',
+        'modules': {k: v is not None for k, v in MODULES.items()},
+        'ready': modules_ready
+    })
+if __name__ == '__main__':
+    # Get port from environment (for Hugging Face Spaces)
     port = int(os.environ.get('PORT', 7860))
     host = os.environ.get('HOST', '0.0.0.0')
+    print(f"🚀 Starting Flask app on {host}:{port}")
+    print("📋 Modules status:")
+    for name, module in MODULES.items():
+        status = "✓" if module else "❌"
+        print(f"   {status} {name}")
+    app.run(host=host, port=port, debug=False)