Upload app.py with huggingface_hub

app.py

@@ -1,148 +1,42 @@
-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__)
-
-# -----------------------------
-# Config & Model Loading
-# -----------------------------
-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)
+from flask import Flask, request, jsonify
+import joblib
+import pandas as pd
+import numpy as np
 
-# -----------------------------
-# Utils
-# -----------------------------
-def sanitize_inputs(df: pd.DataFrame) -> pd.DataFrame:
-    df = df.copy()
-    # Strings → Title-case (fixes 'low sugar' vs 'Low Sugar'), trimmed
-    for col in df.select_dtypes(include="object").columns:
-        df[col] = df[col].astype(str).str.strip().str.title()
-    # Numerics → coerce
-    for col in df.columns:
-        if df[col].dtype.kind in "biufc":  # numeric-like
-            df[col] = pd.to_numeric(df[col], errors="coerce").fillna(0)
-    return df
-
-def expected_feature_names():
-    # scikit-learn >=1.0 usually exposes this on the fitted estimator or pipeline
-    names = getattr(pipe, "feature_names_in_", None)
-    if names is not None:
-        return list(names)
-    # Fallback: try to infer from first step if it’s a Pipeline
-    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  # unknown
-
-# -----------------------------
-# CORS (no dependency)
-# -----------------------------
-@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
-
-# -----------------------------
-# Basic routes
-# -----------------------------
-@app.get("/")
-def root():
-    return jsonify({"service": "SuperKart Sales Forecast API",
-                    "health": "/health", "predict": "/predict", "schema": "/schema",
-                    "model_path": MODEL_PATH})
+app = Flask(__name__)
 
-@app.get("/health")
-def health():
-    if MODEL_READY:
-        return jsonify({"status": "ok", "model_path": MODEL_PATH}), 200
-    return jsonify({"status": "error", "error": LOAD_ERROR, "model_path": MODEL_PATH}), 500
+# Load the serialized model bundle
+BUNDLE_FILENAME = 'best_model_random_forest.joblib'
+bundle = joblib.load(BUNDLE_FILENAME)
+model = bundle['model']
+feature_cols = bundle['feature_cols']
 
-@app.get("/schema")
-def schema():
-    info = {
-        "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()
-    }
-    return jsonify(info), 200 if MODEL_READY else 500
 
-@app.route("/predict", methods=["OPTIONS"])
-def predict_options():
-    return make_response(("", 204))
+@app.route('/')
+def home():
+    return "Sales Forecasting Backend is running!"
 
-# -----------------------------
-# Predict
-# -----------------------------
-@app.post("/predict")
+@app.route('/predict', methods=['POST'])
 def predict():
-    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
+        data = request.get_json(force=True)
+        # Convert the incoming data to a pandas DataFrame
+        # Assuming the incoming data is a list of dictionaries, where each dictionary is a data point
+        input_data = pd.DataFrame(data)
 
-        df = pd.DataFrame([payload]) if isinstance(payload, dict) else pd.DataFrame(payload)
-        df = sanitize_inputs(df)
+        # Align columns with the training data, adding missing columns with a default value (e.g., 0 or NaN)
+        input_data_processed = input_data.reindex(columns=feature_cols, fill_value=0)
 
-        # If the estimator exposes expected input feature names, validate quickly
-        expected = expected_feature_names()
-        if expected:
-            missing = [c for c in expected if c not in df.columns]
-            extra   = [c for c in df.columns if c not in expected]
-            if missing:
-                return jsonify({
-                    "error": "Missing required columns",
-                    "missing": missing,
-                    "expected": expected,
-                    "received": list(df.columns)
-                }), 400
-            if extra:
-                # Not fatal, but good to know
-                print(f"==> [WARN] Extra columns received that model does not expect: {extra}", flush=True)
-            # Align column order if needed
-            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)})
+        # Make predictions
+        predictions = model.predict(input_data_processed)
 
+        # Return predictions as a JSON response
+        return jsonify(predictions.tolist())
     except Exception as e:
-        print("==> [ERROR] Prediction failed:\n", traceback.format_exc(), flush=True)
-        return jsonify({"error": "Prediction failed", "details": str(e)}), 500
+        return jsonify({'error': str(e)})
 
-if __name__ == "__main__":
-    print("==> [RUN] Flask dev server starting...", flush=True)
-    app.run(host="0.0.0.0", port=PORT)
+if __name__ == '__main__':
+    # Running on 0.0.0.0 makes it accessible externally, useful for deployment
+    app.run(host='0.0.0.0', port=5000)