Update app.py

app.py

@@ -1,32 +1,123 @@
-
-from flask import Flask, request, jsonify
-import joblib
-import pandas as pd
-import os
+from flask import Flask, request, jsonify, make_response
+import joblib, pandas as pd, numpy as np, os, sys, time, traceback
+from sklearn.pipeline import Pipeline
 
 app = Flask(__name__)
 
 MODEL_PATH = os.getenv("MODEL_PATH", "best_model_random_forest.joblib")
+PORT = int(os.getenv("PORT", "7860"))
+
+print(f"==> [BOOT] Starting Flask app on port {PORT}")
+print(f"==> [BOOT] MODEL_PATH={MODEL_PATH}", flush=True)
+
+def load_pipeline(path: str):
+    t0 = time.time()
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Model file not found: {path}")
+    print(f"==> [LOAD] Loading model from {path} ...", flush=True)
+    obj = joblib.load(path)
+    if isinstance(obj, dict) and "pipeline" in obj:
+        pipe = obj["pipeline"]
+        print("==> [LOAD] Loaded dict bundle with 'pipeline'", flush=True)
+    else:
+        pipe = obj
+        print("==> [LOAD] Loaded pipeline object (no bundle key)", flush=True)
+    print(f"==> [LOAD] Done in {time.time()-t0:.2f}s", flush=True)
+    return pipe
+
+try:
+    pipe = load_pipeline(MODEL_PATH)
+    MODEL_READY, LOAD_ERROR = True, None
+except Exception as e:
+    pipe, MODEL_READY, LOAD_ERROR = None, False, str(e)
+    print("==> [ERROR] Model load failed:", LOAD_ERROR, file=sys.stderr, flush=True)
+
+def sanitize_inputs(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+    for col in df.select_dtypes(include="object").columns:
+        df[col] = df[col].astype(str).str.strip().str.title()
+    for col in df.columns:
+        if df[col].dtype.kind in "biufc":
+            df[col] = pd.to_numeric(df[col], errors="coerce").fillna(0)
+    return df
+
+def expected_feature_names():
+    names = getattr(pipe, "feature_names_in_", None)
+    if names is not None:
+        return list(names)
+    if isinstance(pipe, Pipeline):
+        first = pipe.steps[0][1]
+        names = getattr(first, "feature_names_in_", None)
+        if names is not None:
+            return list(names)
+    return None
 
-if not os.path.exists(MODEL_PATH):
-    raise FileNotFoundError(f"Model file not found: {MODEL_PATH}. Please ensure it's uploaded to the Space.")
+@app.after_request
+def add_cors_headers(resp):
+    resp.headers["Access-Control-Allow-Origin"] = "*"
+    resp.headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
+    resp.headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
+    return resp
 
-model_bundle = joblib.load(MODEL_PATH)
-if isinstance(model_bundle, dict) and "pipeline" in model_bundle:
-    pipe = model_bundle["pipeline"]
-else:
-    pipe = model_bundle
+@app.get("/")
+def root():
+    return jsonify({
+        "service": "SuperKart Sales Forecast API",
+        "health": "/health",
+        "predict": "/predict",
+        "schema": "/schema",
+        "model_path": MODEL_PATH
+    })
 
-@app.route("/health", methods=["GET"])
+@app.get("/health")
 def health():
-    return jsonify({"status": "ok", "model": MODEL_PATH})
+    return (jsonify({"status": "ok", "model_path": MODEL_PATH}), 200) if MODEL_READY \
+        else (jsonify({"status": "error", "error": LOAD_ERROR, "model_path": MODEL_PATH}), 500)
 
-@app.route("/predict", methods=["POST"])
+@app.get("/schema")
+def schema():
+    return jsonify({
+        "model_ready": MODEL_READY,
+        "model_path": MODEL_PATH,
+        "estimator_type": type(pipe).__name__ if pipe is not None else None,
+        "expected_feature_names": expected_feature_names()
+    }), 200 if MODEL_READY else 500
+
+@app.route("/predict", methods=["OPTIONS"])
+def predict_options():
+    return make_response(("", 204))
+
+@app.post("/predict")
 def predict():
-    data = request.get_json(force=True)
-    df = pd.DataFrame([data]) if isinstance(data, dict) else pd.DataFrame(data)
-    preds = pipe.predict(df)
-    return jsonify({"predictions": [float(p) for p in preds]})
+    if not MODEL_READY or pipe is None:
+        return jsonify({"error": "Model not loaded", "details": LOAD_ERROR}), 503
+    try:
+        payload = request.get_json(force=True)
+        if payload is None:
+            return jsonify({"error": "No JSON received"}), 400
+
+        df = pd.DataFrame([payload]) if isinstance(payload, dict) else pd.DataFrame(payload)
+        df = sanitize_inputs(df)
+
+        expected = expected_feature_names()
+        if expected:
+            missing = [c for c in expected if c not in df.columns]
+            if missing:
+                return jsonify({
+                    "error": "Missing required columns",
+                    "missing": missing,
+                    "expected": expected,
+                    "received": list(df.columns)
+                }), 400
+            df = df[expected]
+
+        preds = pipe.predict(df)
+        preds = [float(p) if isinstance(p, (np.floating, float, int)) else p for p in preds]
+        return jsonify({"predictions": preds, "rows_received": len(df)})
+    except Exception as e:
+        print("==> [ERROR] Prediction failed:\n", traceback.format_exc(), flush=True)
+        return jsonify({"error": "Prediction failed", "details": str(e)}), 500
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=5000)
+    print("==> [RUN] Flask dev server starting...", flush=True)
+    app.run(host="0.0.0.0", port=PORT)