Upload folder using huggingface_hub

app.py

@@ -1,27 +1,24 @@
-import os
-import logging
-import numpy as np
-import pandas as pd
-import joblib
+
+%%bash
+cat > app.py <<'PY'
+import os, logging, joblib, numpy as np, pandas as pd
 from flask import Flask, request, jsonify
 
-# try to enable CORS if available (optional)
+# Attempt optional CORS
 try:
     from flask_cors import CORS
-    _CORS_AVAILABLE = True
+    _CORS = True
 except Exception:
-    _CORS_AVAILABLE = False
+    _CORS = False
 
-# Create Flask app (WSGI callable must be named `app`)
+# WSGI callable expected by gunicorn must be named `app`
 app = Flask(__name__)
-if _CORS_AVAILABLE:
+if _CORS:
     CORS(app)
 
-# logging (helps debugging in Spaces)
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Load the trained model (guarded)
 MODEL_PATH = os.environ.get("MODEL_PATH", "superkart_prediction.joblib")
 model = None
 load_error = None
@@ -36,131 +33,66 @@ else:
     load_error = f"Model file not found at {MODEL_PATH}"
     logger.warning(load_error)
 
-
 @app.route("/", methods=["GET"])
 def home():
-    return jsonify({"message": "Welcome to the SuperKart Sales Prediction API!"}), 200
-
+    return jsonify({"message":"API up"}), 200
 
 @app.route("/v1/sales", methods=["POST"])
-def predict_sales_single():
-    """
-    Expects a JSON body with the features required by the model.
-    Example:
-    {
-      "Product_Id": 123,
-      "Product_Weight": 1.23,
-      "Product_Sugar_Content": "Low",
-      "Product_Allocated_Area": 10,
-      "Product_Type": "TypeA",
-      "Product_MRP": 99.99,
-      "Store_Id": "S1",
-      "Store_Establishment_Year": 1998,
-      "Store_Size": "Small",
-      "Store_Location_City_Type": "Tier1",
-      "Store_Type": "Supermarket",
-      "log_output": true  # optional, True if model predicts log(sales)
-    }
-    """
+def predict_single():
     if model is None:
-        return jsonify({"error": "Model not loaded", "details": load_error}), 500
-
+        return jsonify({"error":"Model not loaded","details": load_error}), 500
     try:
         data = request.get_json(force=True)
-        if not data:
-            return jsonify({"error": "Invalid or empty JSON body"}), 400
-
-        # expected columns (adapt to your model's expected features/order)
         expected_cols = [
-            "Product_Id", "Product_Weight", "Product_Sugar_Content", "Product_Allocated_Area",
-            "Product_Type", "Product_MRP", "Store_Id", "Store_Establishment_Year",
-            "Store_Size", "Store_Location_City_Type", "Store_Type"
+            "Product_Id","Product_Weight","Product_Sugar_Content","Product_Allocated_Area",
+            "Product_Type","Product_MRP","Store_Id","Store_Establishment_Year",
+            "Store_Size","Store_Location_City_Type","Store_Type"
         ]
-
-        # build a row dict with missing keys set to None
-        row = {col: data.get(col, None) for col in expected_cols}
-
-        # convert to DataFrame and predict
-        input_df = pd.DataFrame([row])
-        pred = model.predict(input_df)
-
-        # handle log-output option
-        log_output = bool(data.get("log_output", False))
-        sale = float(np.exp(pred[0])) if log_output else float(pred[0])
-        sale = round(sale, 2)
-
-        return jsonify({"predicted_sales": sale}), 200
-
+        row = {c: data.get(c, None) for c in expected_cols}
+        df = pd.DataFrame([row])
+        pred = model.predict(df)
+        log_out = bool(data.get("log_output", False))
+        val = float(np.exp(pred[0])) if log_out else float(pred[0])
+        return jsonify({"predicted_sales": round(val,2)}), 200
     except Exception as e:
-        logger.exception("Single prediction failed")
-        return jsonify({"error": "Prediction failed", "details": str(e)}), 500
-
+        logger.exception("predict_single failed")
+        return jsonify({"error":"prediction failed","details": str(e)}), 500
 
 @app.route("/v1/sales/batch", methods=["POST"])
-def predict_sales_batch():
-    """
-    Accepts:
-      - multipart/form-data file upload with key 'file' (CSV), OR
-      - JSON body with key 'data' (list of records) OR
-      - JSON body as a list of records
-    Returns JSON mapping of IDs (if present) or indices to predicted sales.
-    """
+def predict_batch():
     if model is None:
-        return jsonify({"error": "Model not loaded", "details": load_error}), 500
-
+        return jsonify({"error":"Model not loaded","details": load_error}), 500
     try:
-        # 1) CSV upload
         if "file" in request.files:
-            file = request.files["file"]
-            df = pd.read_csv(file)
+            df = pd.read_csv(request.files["file"])
         else:
-            # 2) JSON body
-            json_body = request.get_json(force=True)
-            if json_body is None:
-                return jsonify({"error": "No file uploaded and no JSON body provided"}), 400
-
-            if isinstance(json_body, dict) and "data" in json_body:
-                df = pd.DataFrame(json_body["data"])
-            elif isinstance(json_body, list):
-                df = pd.DataFrame(json_body)
+            jb = request.get_json(force=True)
+            if isinstance(jb, dict) and "data" in jb:
+                df = pd.DataFrame(jb["data"])
+            elif isinstance(jb, list):
+                df = pd.DataFrame(jb)
             else:
-                return jsonify({"error": "JSON must be a list of records or contain 'data' key"}), 400
-
+                return jsonify({"error":"No file or JSON data provided"}), 400
         if df.empty:
-            return jsonify({"error": "Input data is empty"}), 400
-
-        # Predict (model should accept DataFrame columns as provided)
+            return jsonify({"error":"Input empty"}), 400
         preds = model.predict(df).tolist()
-
-        # Handle optional query param or JSON flag for log output (default False)
-        log_output_flag = request.args.get("log_output", "false").lower() == "true"
-        if log_output_flag:
-            preds = [float(round(np.exp(p), 2)) for p in preds]
+        log_flag = request.args.get("log_output","false").lower() == "true"
+        if log_flag:
+            preds = [round(float(np.exp(p)),2) for p in preds]
         else:
-            preds = [float(round(p, 2)) for p in preds]
-
-        # map back to ID column if present
-        id_col = None
-        for candidate in ("id", "ID", "Product_Id"):
-            if candidate in df.columns:
-                id_col = candidate
-                break
-
+            preds = [round(float(p),2) for p in preds]
+        id_col = next((c for c in ("id","ID","Product_Id") if c in df.columns), None)
         if id_col:
-            ids = df[id_col].astype(str).tolist()
-            out = dict(zip(ids, preds))
+            keys = df[id_col].astype(str).tolist()
+            out = dict(zip(keys, preds))
         else:
             out = {str(i): preds[i] for i in range(len(preds))}
-
         return jsonify({"predictions": out}), 200
-
     except Exception as e:
-        logger.exception("Batch prediction failed")
-        return jsonify({"error": "Batch prediction failed", "details": str(e)}), 500
-
+        logger.exception("predict_batch failed")
+        return jsonify({"error":"batch prediction failed","details": str(e)}), 500
 
-# local debug server; in Spaces/Gunicorn we expose 'app' as WSGI callable
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
-    logger.info(f"Starting local Flask server on port {port}")
     app.run(host="0.0.0.0", port=port, debug=True)
+PY