Upload folder using huggingface_hub

app.py

@@ -1,110 +1,108 @@
 
-cat > app.py <<'PY'
-import os
-import logging
-import joblib
 import numpy as np
 import pandas as pd
+import joblib
 from flask import Flask, request, jsonify
 
-# optional CORS
-try:
-    from flask_cors import CORS
-    _CORS = True
-except Exception:
-    _CORS = False
-
-# WSGI callable must be named `app`
-app = Flask(__name__)
-if _CORS:
-    CORS(app)
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-MODEL_PATH = os.environ.get("MODEL_PATH", "superkart_prediction.joblib")
-model = None
-load_error = None
-if os.path.exists(MODEL_PATH):
-    try:
-        model = joblib.load(MODEL_PATH)
-        logger.info(f"Loaded model from {MODEL_PATH}")
-    except Exception as e:
-        load_error = str(e)
-        logger.exception("Failed to load model")
-else:
-    load_error = f"Model file not found at {MODEL_PATH}"
-    logger.warning(load_error)
+# initiate flask application
+sales_price_prediction_api = Flask("SuperKart Sales Price Prediction API")
 
+# Load the trained model
+model = joblib.load("superkart_prediction.joblib")
 
-@app.route("/", methods=["GET"])
+
+# -------------------- HOME ROUTE --------------------
+@sales_price_prediction_api.get("/")
 def home():
-    return jsonify({"message": "API up"}), 200
+    return "Welcome to the SuperKart Sales Prediction API!"
+
 
+# -------------------- SINGLE SALES PREDICTION --------------------
+@sales_price_prediction_api.post("/v1/sales")
+def predict_sales_single():
+    """
+    Handles POST requests to predict sales for a single product.
+    Expects JSON input with required features.
+    """
 
-@app.route("/v1/sales", methods=["POST"])
-def predict_single():
-    if model is None:
-        return jsonify({"error": "Model not loaded", "details": load_error}), 500
     try:
-        data = request.get_json(force=True)
-        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"
-        ]
-        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
+        sales_data = request.get_json()
+
+        # Extract features
+        sample = {
+            'Product_Id': sales_data.get('Product_Id'),
+            'Product_Weight': sales_data.get('Product_Weight'),
+            'Product_Sugar_Content': sales_data.get('Product_Sugar_Content'),
+            'Product_Allocated_Area': sales_data.get('Product_Allocated_Area'),
+            'Product_Type': sales_data.get('Product_Type'),
+            'Product_MRP': sales_data.get('Product_MRP'),
+            'Store_Id': sales_data.get('Store_Id'),
+            'Store_Establishment_Year': sales_data.get('Store_Establishment_Year'),
+            'Store_Size': sales_data.get('Store_Size'),
+            'Store_Location_City_Type': sales_data.get('Store_Location_City_Type'),
+            'Store_Type': sales_data.get('Store_Type')
+        }
+
+        # Convert into DataFrame
+        input_df = pd.DataFrame([sample])
+
+        # Predict log-sales
+        log_pred = model.predict(input_df)[0]
+
+        # Convert log prediction to actual sales
+        predicted_sale = round(float(np.exp(log_pred)), 2)
+
+        return jsonify({"predicted_sales_in_dollars": predicted_sale})
+
     except Exception as e:
-        logger.exception("predict_single failed")
-        return jsonify({"error": "prediction failed", "details": str(e)}), 500
+        return jsonify({"error": str(e)}), 400
+
 
+# -------------------- BATCH SALES PREDICTION --------------------
+@sales_price_prediction_api.post("/v1/sales/batch")
+def predict_sales_batch():
+    """
+    Handles batch prediction using uploaded CSV.
+    Returns a dict of ID → predicted_sales.
+    """
 
-@app.route("/v1/sales/batch", methods=["POST"])
-def predict_batch():
-    if model is None:
-        return jsonify({"error": "Model not loaded", "details": load_error}), 500
     try:
-        if "file" in request.files:
-            df = pd.read_csv(request.files["file"])
-        else:
-            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": "No file or JSON data provided"}), 400
-
-        if df.empty:
-            return jsonify({"error": "Input empty"}), 400
-
-        preds = model.predict(df).tolist()
-        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 = [round(float(p), 2) for p in preds]
+        # Get uploaded CSV file
+        file = request.files.get("file")
+        if file is None:
+            return jsonify({"error": "No CSV file uploaded under key 'file'"}), 400
+
+        df = pd.read_csv(file)
+
+        # Predict log-sales
+        log_preds = model.predict(df).tolist()
+
+        # Convert log values to sales
+        predictions = [round(float(np.exp(p)), 2) for p in log_preds]
+
+        # Determine ID column
+        id_col = None
+        for col in ["id", "ID", "Product_Id"]:
+            if col in df.columns:
+                id_col = col
+                break
 
-        id_col = next((c for c in ("id", "ID", "Product_Id") if c in df.columns), None)
         if id_col:
-            keys = df[id_col].astype(str).tolist()
-            out = dict(zip(keys, preds))
+            ids = df[id_col].astype(str).tolist()
+            result = dict(zip(ids, predictions))
         else:
-            out = {str(i): preds[i] for i in range(len(preds))}
+            # fallback to index-based prediction
+            result = {str(i): predictions[i] for i in range(len(predictions))}
+
+        return jsonify({"predictions": result})
 
-        return jsonify({"predictions": out}), 200
     except Exception as e:
-        logger.exception("predict_batch failed")
-        return jsonify({"error": "batch prediction failed", "details": str(e)}), 500
+        return jsonify({"error": str(e)}), 400
+
 
+# -------------------- RUN APP LOCALLY --------------------
+# Hugging Face uses gunicorn to run "app", so we expose the variable below:
+app = sales_price_prediction_api
 
 if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
-    logger.info("Starting local Flask server on port %s", port)
-    app.run(host="0.0.0.0", port=port, debug=True)
-PY
+    sales_price_prediction_api.run(host="0.0.0.0", port=7860, debug=True)