Update app.py

app.py

@@ -1,67 +1,83 @@
 from flask import Flask, request, jsonify
+import os
 import joblib
 import pandas as pd
-import os
+from typing import Any, Optional
 
 app = Flask(__name__)
 
-# Default model path (can be changed via Space environment variable)
 MODEL_PATH = os.getenv("MODEL_PATH", "best_model_random_forest.joblib")
 
-# Load model if it exists
-if not os.path.exists(MODEL_PATH):
-    raise FileNotFoundError(
-        f"❌ Model file not found: {MODEL_PATH}. Please ensure it's uploaded to the Space root directory."
-    )
+_model: Optional[Any] = None  # lazy-loaded
+_pipe: Optional[Any] = None
+_model_error: Optional[str] = None
+
 
-model_bundle = joblib.load(MODEL_PATH)
+def load_model_if_needed():
+    """Load the model/pipeline once, on demand. Keeps the app booting even if loading fails."""
+    global _model, _pipe, _model_error
+    if _pipe is not None or _model_error is not None:
+        return
+
+    try:
+        if not os.path.exists(MODEL_PATH):
+            _model_error = f"Model file not found at '{MODEL_PATH}'. Upload it or set MODEL_PATH."
+            return
+
+        _model = joblib.load(MODEL_PATH)
+        _pipe = _model["pipeline"] if isinstance(_model, dict) and "pipeline" in _model else _model
+
+    except Exception as e:
+        # Capture the error so the app keeps running and can report it on / and /health
+        _model_error = f"Failed to load model from '{MODEL_PATH}': {e}"
 
-# Support both raw model or model dict with a pipeline
-pipe = model_bundle["pipeline"] if isinstance(model_bundle, dict) and "pipeline" in model_bundle else model_bundle
 
 @app.route("/", methods=["GET"])
 def home():
+    load_model_if_needed()
     return jsonify({
         "status": "ok",
-        "message": "Backend Flask API is running successfully 🎉",
-        "model_loaded": True,
-        "model_path": MODEL_PATH
+        "framework": "flask",
+        "model_path": MODEL_PATH,
+        "model_loaded": _pipe is not None and _model_error is None,
+        "model_error": _model_error
     })
 
+
 @app.route("/health", methods=["GET"])
 def health():
-    return jsonify({"status": "ok", "model_path": MODEL_PATH})
+    load_model_if_needed()
+    status = "ok" if _pipe is not None and _model_error is None else "degraded"
+    return jsonify({"status": status, "model_path": MODEL_PATH, "model_error": _model_error})
+
 
 @app.route("/predict", methods=["POST"])
 def predict():
-    """
-    Example input:
-    {
-        "feature1": value1,
-        "feature2": value2,
-        ...
-    }
-    or
-    [
-        {"feature1": value1, "feature2": value2},
-        {"feature1": value3, "feature2": value4}
-    ]
-    """
+    load_model_if_needed()
+    if _pipe is None:
+        return jsonify({"error": f"Model not available. Details: {_model_error}"}), 500
+
     data = request.get_json(force=True)
 
-    # Normalize input to a DataFrame
-    df = pd.DataFrame([data]) if isinstance(data, dict) else pd.DataFrame(data)
+    # Accept single object, list of objects, or {"records":[...]}
+    if isinstance(data, dict) and "records" in data:
+        df = pd.DataFrame(data["records"])
+    elif isinstance(data, list):
+        df = pd.DataFrame(data)
+    elif isinstance(data, dict):
+        df = pd.DataFrame([data])
+    else:
+        return jsonify({"error": "Unsupported payload format"}), 400
 
     try:
-        preds = pipe.predict(df)
-        # Convert numpy types to native Python floats
+        preds = _pipe.predict(df)
         predictions = [float(p) for p in preds]
         return jsonify({"predictions": predictions})
     except Exception as e:
         return jsonify({"error": str(e)}), 400
 
 
-# Entry point for local development; Spaces uses gunicorn automatically
+# Local dev only; Spaces runs gunicorn and ignores this block.
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", 7860))  # HF Spaces use port 7860 by default
+    port = int(os.getenv("PORT", 5000))  # Spaces Server SDK often binds to 5000
     app.run(host="0.0.0.0", port=port, debug=False)