Update app.py

app.py

@@ -1,429 +1,184 @@
 """
-Streamlit Application for Engine Predictive Maintenance
+DIAGNOSTIC VERSION - Streamlit App for Debugging
+This version has extensive logging to find the exact failure point
 """
 
 import streamlit as st
-import pandas as pd
-import os
 import sys
+import os
 
-# Print to console (will show in HF Space logs)
-print("=" * 70, file=sys.stderr)
-print("APP STARTING - INITIALIZATION", file=sys.stderr)
-print("=" * 70, file=sys.stderr)
+print("=" * 80, file=sys.stderr)
+print("DIAGNOSTIC APP STARTING", file=sys.stderr)
+print("=" * 80, file=sys.stderr)
 
-# Page Configuration MUST be first
-st.set_page_config(
-    page_title="Engine Predictive Maintenance",
-    page_icon="🔧",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
+# Test 1: Page Config
+try:
+    print("\n[TEST 1] Setting page config...", file=sys.stderr)
+    st.set_page_config(
+        page_title="Engine Predictive Maintenance - DIAGNOSTIC",
+        page_icon="🔧",
+        layout="wide"
+    )
+    print("✓ Page config successful", file=sys.stderr)
+except Exception as e:
+    print(f"✗ Page config failed: {e}", file=sys.stderr)
+    import traceback
+    print(traceback.format_exc(), file=sys.stderr)
 
-# Import after page config
+# Test 2: Imports
+print("\n[TEST 2] Testing imports...", file=sys.stderr)
 try:
-    print("Importing huggingface_hub...", file=sys.stderr)
+    print("  Importing pandas...", file=sys.stderr)
+    import pandas as pd
+    print("  ✓ pandas imported", file=sys.stderr)
+    
+    print("  Importing huggingface_hub...", file=sys.stderr)
     from huggingface_hub import hf_hub_download, login
-    print("Importing joblib...", file=sys.stderr)
+    print("  ✓ huggingface_hub imported", file=sys.stderr)
+    
+    print("  Importing joblib...", file=sys.stderr)
     import joblib
+    print("  ✓ joblib imported", file=sys.stderr)
+    
     print("✓ All imports successful", file=sys.stderr)
 except Exception as e:
-    print(f"✗ Import error: {e}", file=sys.stderr)
-    st.error(f"Import failed: {e}")
+    print(f"✗ Import failed: {e}", file=sys.stderr)
+    import traceback
+    print(traceback.format_exc(), file=sys.stderr)
+    st.error(f"Import error: {e}")
     st.stop()
 
-# CRITICAL: Feature columns must EXACTLY match model training
-FEATURE_COLUMNS = [
-    "Engine rpm",
-    "Lub oil pressure",
-    "Fuel pressure",
-    "Coolant pressure",
-    "lub oil temp",
-    "Coolant temp"
-]
-
-# Custom CSS
-st.markdown("""
-<style>
-.main-header {
-    font-size: 42px;
-    font-weight: bold;
-    color: #1f77b4;
-    text-align: center;
-    margin-bottom: 10px;
-}
-.sub-header {
-    font-size: 18px;
-    color: #555;
-    text-align: center;
-    margin-bottom: 30px;
-}
-.prediction-box {
-    padding: 20px;
-    border-radius: 10px;
-    text-align: center;
-    font-size: 24px;
-    font-weight: bold;
-    margin-top: 20px;
-}
-.normal {
-    background-color: #d4edda;
-    color: #155724;
-    border: 2px solid #c3e6cb;
-}
-.maintenance {
-    background-color: #f8d7da;
-    color: #721c24;
-    border: 2px solid #f5c6cb;
-}
-.metric-card {
-    background-color: #f8f9fa;
-    padding: 15px;
-    border-radius: 8px;
-    border-left: 4px solid #1f77b4;
-}
-</style>
-""", unsafe_allow_html=True)
+# Test 3: Environment Variables
+print("\n[TEST 3] Checking environment variables...", file=sys.stderr)
+hf_token = os.environ.get("HF_TOKEN")
+print(f"  HF_TOKEN exists: {hf_token is not None}", file=sys.stderr)
+if hf_token:
+    print(f"  HF_TOKEN length: {len(hf_token)}", file=sys.stderr)
+    print(f"  HF_TOKEN starts with: {hf_token[:7]}...", file=sys.stderr)
+else:
+    print("  ⚠ WARNING: HF_TOKEN not found!", file=sys.stderr)
+
+# Test 4: Hugging Face Authentication
+print("\n[TEST 4] Testing Hugging Face authentication...", file=sys.stderr)
+if hf_token:
+    try:
+        print("  Attempting login...", file=sys.stderr)
+        login(token=hf_token)
+        print("  ✓ Login successful", file=sys.stderr)
+    except Exception as e:
+        print(f"  ✗ Login failed: {e}", file=sys.stderr)
+        import traceback
+        print(traceback.format_exc(), file=sys.stderr)
+else:
+    print("  ⚠ Skipping login (no token)", file=sys.stderr)
 
+# Test 5: Model Download
+print("\n[TEST 5] Testing model download...", file=sys.stderr)
+model = None
+model_error = None
 
-@st.cache_resource
-def load_model():
-    """Load model from Hugging Face with detailed logging and retries"""
-    
-    print("\n" + "=" * 70, file=sys.stderr)
-    print("LOADING MODEL FROM HUGGING FACE", file=sys.stderr)
-    print("=" * 70, file=sys.stderr)
+try:
+    print("  Repository: Quantum9999/xgb-predictive-maintenance", file=sys.stderr)
+    print("  Filename: xgb_tuned_model.joblib", file=sys.stderr)
+    print("  Cache dir: /tmp/hf_cache", file=sys.stderr)
+    print("  Starting download...", file=sys.stderr)
     
-    max_retries = 3
-    retry_count = 0
+    model_path = hf_hub_download(
+        repo_id="Quantum9999/xgb-predictive-maintenance",
+        filename="xgb_tuned_model.joblib",
+        token=hf_token,
+        cache_dir="/tmp/hf_cache"
+    )
     
-    while retry_count < max_retries:
-        try:
-            # CORRECT: Use HF_TOKEN (as configured in your HF Space secrets)
-            hf_token = os.environ.get("HF_TOKEN")
-            print(f"HF_TOKEN found: {hf_token is not None}", file=sys.stderr)
-            
-            if hf_token:
-                print("Authenticating with Hugging Face...", file=sys.stderr)
-                login(token=hf_token)
-                print("✓ Authentication successful", file=sys.stderr)
-            else:
-                print("⚠ No HF_TOKEN - attempting public access", file=sys.stderr)
-            
-            # Download model
-            print("\nDownloading model...", file=sys.stderr)
-            print("  Repo: Quantum9999/xgb-predictive-maintenance", file=sys.stderr)
-            print("  File: xgb_tuned_model.joblib", file=sys.stderr)
-            
-            model_path = hf_hub_download(
-                repo_id="Quantum9999/xgb-predictive-maintenance",
-                filename="xgb_tuned_model.joblib",
-                token=hf_token,
-                cache_dir="/tmp/hf_cache"  # Use tmp for faster access
-            )
-            print(f"✓ Model downloaded: {model_path}", file=sys.stderr)
-            
-            # Load model
-            print("Loading model into memory...", file=sys.stderr)
-            model = joblib.load(model_path)
-            print("✓ Model loaded successfully", file=sys.stderr)
-            
-            # Verify model features
-            if hasattr(model, 'feature_names_in_'):
-                print(f"Model expects features: {model.feature_names_in_}", file=sys.stderr)
-            
-            print("=" * 70 + "\n", file=sys.stderr)
-            
-            return model, None
-            
-        except Exception as e:
-            retry_count += 1
-            error_msg = f"Model loading attempt {retry_count}/{max_retries} failed: {str(e)}"
-            print(f"✗ {error_msg}", file=sys.stderr)
-            
-            if retry_count < max_retries:
-                import time
-                wait_time = 2 * retry_count
-                print(f"Retrying in {wait_time} seconds...", file=sys.stderr)
-                time.sleep(wait_time)
-            else:
-                import traceback
-                print(f"Final traceback:\n{traceback.format_exc()}", file=sys.stderr)
-                print("=" * 70 + "\n", file=sys.stderr)
-                return None, error_msg
-
-
-def main():
-    """Main application"""
+    print(f"  ✓ Download successful!", file=sys.stderr)
+    print(f"  Model path: {model_path}", file=sys.stderr)
     
-    print("Starting main application...", file=sys.stderr)
+    # Test 6: Model Loading
+    print("\n[TEST 6] Testing model loading...", file=sys.stderr)
+    print("  Loading model into memory...", file=sys.stderr)
+    model = joblib.load(model_path)
+    print("  ✓ Model loaded successfully!", file=sys.stderr)
     
-    # Header
-    st.markdown(
-        '<div class="main-header">🔧 Engine Predictive Maintenance System</div>',
-        unsafe_allow_html=True
-    )
-    st.markdown(
-        '<div class="sub-header">AI-powered engine health monitoring & failure prediction</div>',
-        unsafe_allow_html=True
-    )
-
-    # Load model with progress indicator
-    with st.spinner("Loading AI model... This may take a moment."):
-        model, error = load_model()
+    # Test 7: Model Properties
+    print("\n[TEST 7] Checking model properties...", file=sys.stderr)
+    print(f"  Model type: {type(model)}", file=sys.stderr)
+    if hasattr(model, 'feature_names_in_'):
+        print(f"  Expected features: {model.feature_names_in_}", file=sys.stderr)
+    if hasattr(model, 'n_features_in_'):
+        print(f"  Number of features: {model.n_features_in_}", file=sys.stderr)
     
-    if model is None:
-        st.error(f"❌ Failed to load prediction model")
-        st.code(error)
-        
-        with st.expander("🔍 Troubleshooting"):
-            st.write("**Possible Issues:**")
-            st.write("1. HF_TOKEN not set in Space secrets")
-            st.write("2. Model repository is private")
-            st.write("3. Model filename is incorrect")
-            st.write("4. Network connectivity issue")
-            
-            st.write("\n**Current Configuration:**")
-            st.write(f"- HF_TOKEN set: {os.environ.get('HF_TOKEN') is not None}")
-            st.write("- Expected repo: Quantum9999/xgb-predictive-maintenance")
-            st.write("- Expected file: xgb_tuned_model.joblib")
-            
-            st.write("\n**Your Setup (from screenshots):**")
-            st.write("✅ HF Space has HF_TOKEN secret (Image 1)")
-            st.write("✅ GitHub has HF_EN_TOKEN secret (Image 2)")
-            st.write("✅ GitHub token for pushing code (Image 3)")
-            
-            st.write("\n**Next Steps:**")
-            st.write("1. Verify HF_TOKEN secret exists in Space settings")
-            st.write("2. Check Space logs for detailed error messages")
-            st.write("3. Ensure model repo is accessible")
-        
-        st.stop()
-    
-    st.success("✓ Model loaded successfully!")
-
-    # Sidebar
-    with st.sidebar:
-        st.header("ℹ️ About")
-        st.write(
-            "This application predicts engine maintenance needs using "
-            "machine learning analysis of 6 critical sensor parameters."
-        )
-        
-        st.header("📊 Model Information")
-        st.markdown("""
-        - **Algorithm**: XGBoost Classifier
-        - **Features**: 6 sensor readings
-        - **Target Classes**: 
-          - 0: Normal Operation
-          - 1: Maintenance Required
-        - **Training Data**: 19,535 records
-        """)
-        
-        st.header("🎯 How to Use")
-        st.markdown("""
-        1. Enter current sensor readings
-        2. Click 'Predict Engine Condition'
-        3. Review prediction and confidence
-        4. Take action based on results
-        """)
-        
-        st.header("📈 Sensor Ranges")
-        st.markdown("""
-        **Normal Operating Ranges:**
-        - RPM: 161 - 2,239
-        - Lub Oil Pressure: 0.003 - 7.3 bar
-        - Fuel Pressure: 0.003 - 21.1 bar
-        - Coolant Pressure: 0.002 - 7.5 bar
-        - Lub Oil Temp: 71 - 90 °C
-        - Coolant Temp: 62 - 196 °C
-        """)
+except Exception as e:
+    model_error = str(e)
+    print(f"  ✗ Model loading failed: {e}", file=sys.stderr)
+    import traceback
+    print(traceback.format_exc(), file=sys.stderr)
 
-    # Main content
-    st.header("📝 Enter Engine Sensor Readings")
-    st.markdown("---")
+print("\n" + "=" * 80, file=sys.stderr)
+print("DIAGNOSTIC TESTS COMPLETED", file=sys.stderr)
+print("=" * 80 + "\n", file=sys.stderr)
 
-    # Input columns
-    col1, col2 = st.columns(2)
+# Display results to user
+st.title("🔍 Diagnostic Mode")
+st.write("This is a diagnostic version to identify the issue.")
 
-    with col1:
-        st.subheader("⚙️ Speed & Pressure Sensors")
-        
-        engine_rpm = st.number_input(
-            "Engine RPM (Revolutions per Minute)",
-            min_value=100.0,
-            max_value=2500.0,
-            value=791.0,
-            step=10.0,
-            help="Engine speed - Normal range: 161-2,239 RPM"
-        )
-        
-        lub_oil_pressure = st.number_input(
-            "Lubrication Oil Pressure (bar)",
-            min_value=0.0,
-            max_value=10.0,
-            value=3.3,
-            step=0.1,
-            help="Lubricating oil pressure - Normal range: 0.003-7.266 bar"
-        )
-        
-        fuel_pressure = st.number_input(
-            "Fuel Pressure (bar)",
-            min_value=0.0,
-            max_value=25.0,
-            value=6.7,
-            step=0.1,
-            help="Fuel delivery pressure - Normal range: 0.003-21.138 bar"
-        )
+st.header("Test Results:")
 
-    with col2:
-        st.subheader("🌡️ Temperature & Coolant Sensors")
-        
-        coolant_pressure = st.number_input(
-            "Coolant Pressure (bar)",
-            min_value=0.0,
-            max_value=10.0,
-            value=2.3,
-            step=0.1,
-            help="Coolant system pressure - Normal range: 0.002-7.479 bar"
-        )
-        
-        lub_oil_temp = st.number_input(
-            "Lubrication Oil Temperature (°C)",
-            min_value=60.0,
-            max_value=100.0,
-            value=77.6,
-            step=0.5,
-            help="Lubricating oil temperature - Normal range: 71.3-89.6 °C"
-        )
-        
-        coolant_temp = st.number_input(
-            "Coolant Temperature (°C)",
-            min_value=50.0,
-            max_value=200.0,
-            value=78.4,
-            step=0.5,
-            help="Engine coolant temperature - Normal range: 61.7-195.5 °C"
-        )
+st.subheader("1. Environment Variables")
+if hf_token:
+    st.success(f"✓ HF_TOKEN found (length: {len(hf_token)})")
+else:
+    st.error("✗ HF_TOKEN not found in environment")
 
-    # Prediction button
-    st.markdown("---")
+st.subheader("2. Model Loading")
+if model is not None:
+    st.success("✓ Model loaded successfully!")
+    st.write(f"Model type: {type(model)}")
     
-    if st.button("🔍 Predict Engine Condition", use_container_width=True, type="primary"):
-        # Create input DataFrame with exact column names
-        input_df = pd.DataFrame([{
-            "Engine rpm": engine_rpm,
-            "Lub oil pressure": lub_oil_pressure,
-            "Fuel pressure": fuel_pressure,
-            "Coolant pressure": coolant_pressure,
-            "lub oil temp": lub_oil_temp,
-            "Coolant temp": coolant_temp
-        }])
-
-        try:
-            print(f"Making prediction with input: {input_df.to_dict()}", file=sys.stderr)
-            
-            # Make prediction
-            prediction = model.predict(input_df)[0]
-            proba = model.predict_proba(input_df)[0]
-            
-            print(f"Prediction: {prediction}, Probabilities: {proba}", file=sys.stderr)
-
-            # Display results
-            st.markdown("---")
-            st.header("🎯 Prediction Result")
-
-            if prediction == 0:
-                st.markdown(
-                    '<div class="prediction-box normal">✅ Engine Operating Normally</div>',
-                    unsafe_allow_html=True
-                )
-                st.success("✓ No maintenance required at this time. Engine is functioning within normal parameters.")
-            else:
-                st.markdown(
-                    '<div class="prediction-box maintenance">⚠️ Maintenance Required</div>',
-                    unsafe_allow_html=True
-                )
-                st.warning("⚠ Engine shows signs of potential failure. Schedule maintenance as soon as possible to prevent breakdown.")
-
-            # Confidence scores
-            st.subheader("📊 Prediction Confidence")
-            
-            conf_col1, conf_col2 = st.columns(2)
-            
-            with conf_col1:
-                st.markdown('<div class="metric-card">', unsafe_allow_html=True)
-                st.metric(
-                    label="Normal Operation Probability",
-                    value=f"{proba[0]:.2%}",
-                    help="Confidence that engine is operating normally"
-                )
-                st.markdown('</div>', unsafe_allow_html=True)
-            
-            with conf_col2:
-                st.markdown('<div class="metric-card">', unsafe_allow_html=True)
-                st.metric(
-                    label="Maintenance Required Probability",
-                    value=f"{proba[1]:.2%}",
-                    help="Confidence that engine requires maintenance"
-                )
-                st.markdown('</div>', unsafe_allow_html=True)
-
-            # Input summary
-            with st.expander("📋 View Input Summary"):
-                st.dataframe(
-                    input_df.T.rename(columns={0: "Value"}),
-                    use_container_width=True
-                )
-                
-            # Recommendations
-            with st.expander("💡 Recommendations"):
-                if prediction == 0:
-                    st.markdown("""
-                    **Current Status: Healthy**
-                    - Continue regular monitoring
-                    - Maintain current maintenance schedule
-                    - Monitor for any sudden changes in sensor readings
-                    - Schedule next routine inspection as planned
-                    """)
-                else:
-                    st.markdown("""
-                    **Immediate Actions Required:**
-                    - Schedule comprehensive engine inspection
-                    - Check lubrication system
-                    - Inspect cooling system
-                    - Review fuel delivery system
-                    - Monitor engine closely until serviced
-                    - Consider reducing operational load
-                    """)
-        
-        except Exception as e:
-            error_msg = f"Prediction error: {e}"
-            print(f"✗ {error_msg}", file=sys.stderr)
-            import traceback
-            print(f"Traceback:\n{traceback.format_exc()}", file=sys.stderr)
-            
-            st.error(f"❌ {error_msg}")
-            st.info("Please verify all sensor values are within valid ranges and try again.")
+    if hasattr(model, 'feature_names_in_'):
+        st.write("Expected features:")
+        st.code(str(model.feature_names_in_))
     
-    # Footer
-    st.markdown("---")
-    st.markdown(
-        "<p style='text-align: center; color: #666; font-size: 14px;'>"
-        "🤖 Built with XGBoost & Streamlit | 🤗 Model hosted on Hugging Face<br>"
-        "Developed as part of ML Deployment & Automation Project"
-        "</p>",
-        unsafe_allow_html=True
-    )
-
-
-if __name__ == "__main__":
-    print("Entering main()...", file=sys.stderr)
+    # Try a test prediction
+    st.subheader("3. Test Prediction")
     try:
-        main()
-        print("✓ Main completed successfully", file=sys.stderr)
+        import pandas as pd
+        test_input = pd.DataFrame([{
+            "Engine rpm": 791.0,
+            "Lub oil pressure": 3.3,
+            "Fuel pressure": 6.7,
+            "Coolant pressure": 2.3,
+            "lub oil temp": 77.6,
+            "Coolant temp": 78.4
+        }])
+        
+        prediction = model.predict(test_input)[0]
+        proba = model.predict_proba(test_input)[0]
+        
+        st.success("✓ Test prediction successful!")
+        st.write(f"Prediction: {prediction}")
+        st.write(f"Probabilities: {proba}")
+        
     except Exception as e:
-        print(f"✗ FATAL ERROR: {e}", file=sys.stderr)
-        import traceback
-        print(f"Traceback:\n{traceback.format_exc()}", file=sys.stderr)
-        st.error(f"Application error: {e}")
+        st.error(f"✗ Test prediction failed: {e}")
+        st.code(str(e))
+        
+else:
+    st.error("✗ Model loading failed!")
+    if model_error:
+        st.code(model_error)
+    st.warning("Check Container logs for detailed traceback")
+
+st.divider()
+st.info("📝 Check the 'Container' logs tab for detailed diagnostic information")
+
+st.header("Next Steps:")
+if model is not None:
+    st.success("✅ Everything works! The issue might be with the healthcheck timing.")
+    st.write("Recommendation: Just wait longer for the Space to become healthy, or increase healthcheck start-period to 90s")
+else:
+    st.error("There's a real issue with model loading.")
+    st.write("Common causes:")
+    st.write("1. HF_TOKEN is wrong or expired")
+    st.write("2. Model file doesn't exist in the repository")
+    st.write("3. Network/connectivity issue")
+    st.write("4. File permissions issue")