Upload folder using huggingface_hub

app.py

@@ -1,94 +1,149 @@
-
+import os
 import numpy as np
 import pandas as pd
 import joblib
 from flask import Flask, request, jsonify
+from flask_cors import CORS
 
-#initate flask application
-sales_price_prediction_api = Flask("SuperKart Sales Price Prediction API")
+# Create Flask app
+app = Flask("SuperKart Sales Prediction API")
+CORS(app)  # allow cross-origin requests (useful for frontend calls)
 
-#Load the trained model
-model = joblib.load("superkart_prediction.joblib")
+# Load the trained model (adjust path if different)
+MODEL_PATH = os.environ.get("MODEL_PATH", "superkart_prediction.joblib")
+try:
+    model = joblib.load(MODEL_PATH)
+except Exception as e:
+    # If model can't be loaded, keep model = None and return helpful errors later
+    model = None
+    load_error = str(e)
+else:
+    load_error = None
 
 
-# Define a route for the home page (GET request)
-@SalesPredictionBackend_api.get('/')
+@app.route("/", methods=["GET"])
 def home():
-  """
-  This function handles GET requests to the root URL ('/') of the API.
-  It returns a simple welcome message.
-  """
-  return "Welcome to the SuperKart Sales Prediction API!"
-
-# Define an endpoint for single property prediction (POST request)
-@SalesPredictionBackend_api.post('/v1/sales')
-def predict_rental_prife():
-  """
-  This function handles POST requests to the '/v1/sales' endpoint.
-  It expects a JSON payload containing producr details and returns
-  the predicted sales amount as a JSON response.
-  """
-  # Get the JSON data from the request body
-  sales_data = request.get_json()
-  
-  # Extract relevant features from the JSON data
-  sample = {
-      'Product_Id': sales_data['Product_Id'],
-      'Product_Weight': sales_data['Product_Weight'],
-      'Product_Sugar_Content': sales_data['Product_Sugar_Content'],
-      'Product_Allocated_Area': sales_data['Product_Allocated_Area'],
-      'Product_Allocated_Area': sales_data['Product_Allocated_Area'],
-      'Product_Type': sales_data['Product_Type'],
-      'Product_MRP': sales_data['Product_MRP'],
-      'Store_Id': sales_data['Store_Id'],
-      'Store_Establishment_Year': sales_data['Store_Establishment_Year'],
-      'Store_Size': sales_data['Store_Size'],
-      'Store_Location_City_Type': sales_data['Store_Location_City_Type'],
-      'Store_Type': sales_data['Store_Type']
-      }
-  #Convert the extracted sata into a Panda Dataframe
-  input_data = pd.DataFrame([sample])
-
-  #Make prediction (get sales_prediction)
-  prediction_log_sale = model.predict(input_data)
-  
-  #calculated_sale
-  predicted_sale = np.exp(prediction_log_sale[0])
-  
-  #convert predicted price to Pyton float
-  predicted_sale = round(float(predicted_sale), 2)
-
-  #return the sales
-  return jsonify({'predicted Sales (indollars)': predicted_sale})
-
-#define an endpoint for batch predictions (POST request)
-@SalesPredictionBackend_api.post('/v1/sales/batch')
+    return "Welcome to the SuperKart Sales Prediction API!", 200
+
+
+@app.route("/v1/sales", methods=["POST"])
+def predict_sales_single():
+    """
+    Expects JSON body with the product/store features required by the model.
+    Example JSON:
+    {
+      "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: set true if model predicts log(sales)
+    }
+    """
+    if model is None:
+        return jsonify({"error": "Model not loaded", "details": load_error}), 500
+
+    try:
+        data = request.get_json()
+        if data is None:
+            return jsonify({"error": "Invalid or empty JSON body"}), 400
+
+        # Extract expected features - adapt these keys to your model's expected columns
+        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"
+        ]
+
+        # Build dictionary with available keys, set missing keys to None
+        row = {col: data.get(col, None) for col in expected_cols}
+
+        # Convert to DataFrame
+        input_df = pd.DataFrame([row])
+
+        # Predict
+        pred = model.predict(input_df)
+        # Some models predict log-sales; allow caller to indicate or default to False
+        log_output = bool(data.get("log_output", False))
+        if log_output:
+            sale = float(np.exp(pred[0]))
+        else:
+            sale = float(pred[0])
+
+        sale = round(sale, 2)
+        return jsonify({"predicted_sales": sale}), 200
+
+    except Exception as e:
+        return jsonify({"error": "Prediction failed", "details": str(e)}), 500
+
+
+@app.route("/v1/sales/batch", methods=["POST"])
 def predict_sales_batch():
-  """
-  This function handles POST requests to the '/v1/rentalbatch' endpoint.
-  It expects a CSV file containing property details for multiple properties
-  and returns the predicted rental prices as a dictionary in the JSON response.
-  """
-
-  # Get the uploaded CSV file from the requqst
-  file = request. files['file']
-  
-  # Read the CSV file into a Pandas DataFrame
-  input_data = pd.read_csv(file)
-  
-  # Make predictions for all properties in the DataFrame (get log_prices)
-  predicted_log_sales = model.predict(input_data).tolist()
-
-  #calculate actual prices
-  predicted_prices = [round(float(np.exp(log_price)), 2) for log_price in predicted_log_prices]
-  
-  # Create a dictionary of predictions with property IDs as keys
-  property_ids = input_data['id'].tolist() # Assuming 'id' is the property ID column
-  output_dict = dict(zip(property_ids, predicted_prices) ) # Use actual prices
-  # Return the predictions dictionary as
-  return output_dict
-
-# Run the Flask application in debug mode if this script is executed directly
-if __name__ == '_main_':
-  sales_price_prediction_api.run(debug=True)
-  
+    """
+    Accepts a CSV file upload under the key 'file' (multipart/form-data) or JSON list under key 'data'.
+    Returns a JSON mapping of row index (or ID column if present) to predicted sales.
+    """
+    if model is None:
+        return jsonify({"error": "Model not loaded", "details": load_error}), 500
+
+    try:
+        # 1) CSV upload via form-data
+        if "file" in request.files:
+            file = request.files["file"]
+            df = pd.read_csv(file)
+        else:
+            # 2) JSON body with 'data' key: list of records
+            json_body = request.get_json()
+            if not json_body:
+                return jsonify({"error": "No file uploaded and no JSON body provided"}), 400
+            if "data" in json_body:
+                df = pd.DataFrame(json_body["data"])
+            else:
+                # maybe user sent a list directly
+                if isinstance(json_body, list):
+                    df = pd.DataFrame(json_body)
+                else:
+                    return jsonify({"error": "JSON must be a list of records or contain 'data' key"}), 400
+
+        if df.empty:
+            return jsonify({"error": "Input dataframe is empty"}), 400
+
+        # Keep track of an ID column if present to map predictions back
+        id_col = None
+        for candidate in ("id", "ID", "product_id", "Product_Id"):
+            if candidate in df.columns:
+                id_col = candidate
+                break
+
+        # Predict (model must accept the dataframe columns as-is)
+        preds = model.predict(df).tolist()
+
+        # Handle whether model output is in log-space or not.
+        # Optionally accept a query param `log_output=true`
+        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]
+        else:
+            preds = [float(round(p, 2)) for p in preds]
+
+        if id_col:
+            ids = df[id_col].astype(str).tolist()
+            out = dict(zip(ids, preds))
+        else:
+            out = {str(i): preds[i] for i in range(len(preds))}
+
+        return jsonify({"predictions": out}), 200
+
+    except Exception as e:
+        return jsonify({"error": "Batch prediction failed", "details": str(e)}), 500
+
+
+if __name__ == "__main__":
+    # For local debugging only. In production (gunicorn) the app object must be importable as 'app'
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)), debug=True)