Update app.py

app.py

@@ -10,7 +10,7 @@ from pathlib import Path
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configuration
+# Configuration - Use current directory for model files
 MODEL_DIR = "."
 SUPPORTED_AUDIO_FORMATS = [".mp3", ".mp4", ".wav", ".m4a", ".flac", ".ogg"]
 
@@ -55,9 +55,31 @@ def safe_import_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)
+    
+    if missing_files:
+        logger.error(f"Missing model files: {missing_files}")
+        return False, missing_files
+    
+    logger.info("✓ All required model files found")
+    return True, []
+
 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 {
@@ -118,13 +140,15 @@ def process_audio_input(audio_file):
         if audio_file is None:
             return "❌ Error: No audio file uploaded"
         
+        # Check if pipeline is available
         if not all(MODULES.values()):
             return "❌ Error: Audio processing pipeline not available. Missing required modules."
         
-        # Get file path
-        file_path = audio_file.name if hasattr(audio_file, 'name') else str(audio_file)
-        
         # Check file format
+        file_path = audio_file
+        if hasattr(audio_file, 'name'):
+            file_path = audio_file.name
+        
         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)}"
@@ -160,7 +184,8 @@ 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}
@@ -182,9 +207,11 @@ def process_audio_input(audio_file):
 📊 **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."
             
@@ -193,12 +220,124 @@ def process_audio_input(audio_file):
         logger.error(traceback.format_exc())
         return f"❌ Processing Error: {str(e)}\n\nPlease check the logs for more details."
 
-# Create simple interface
-def create_simple_interface():
-    """Create simplified Gradio interface"""
+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
+        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 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
     
-    # Create interface with basic components only
-    iface = gr.Interface(
+    return is_cloud, localhost_accessible
+
+def create_interface():
+    """Create Gradio interface with proper configuration"""
+    
+    # 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**"
+    
+    if not model_available:
+        status_message += f"\n❌ 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)}"
+    
+    # Create interface using simple Interface instead of Blocks to avoid JSON schema issues
+    audio_interface = gr.Interface(
         fn=process_audio_input,
         inputs=gr.File(
             label="Upload Audio File (MP3, MP4, WAV, M4A, FLAC, OGG)",
@@ -211,23 +350,48 @@ def create_simple_interface():
         ),
         title="🧠 Aphasia Classification System",
         description="Upload audio files to analyze speech patterns and classify aphasia types",
-        article="<p><strong>About:</strong> This system uses advanced NLP and acoustic analysis to classify different types of aphasia.</p><p><em>For research and clinical assessment purposes.</em></p>"
+        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>
+        """
     )
     
-    return iface
+    return audio_interface
 
 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_simple_interface()
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,  # Set to False to avoid the share warning
-            show_error=True
-        )
+        demo = create_interface()
+        
+        # Configure launch parameters based on environment
+        launch_kwargs = {
+            "server_name": "0.0.0.0",
+            "server_port": 7860,
+            "show_error": True,
+            "quiet": False,
+        }
+        
+        # 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)
         
     except Exception as e:
         logger.error(f"Failed to launch app: {e}")