Upload folder using huggingface_hub

app.py

@@ -1,13 +1,11 @@
-# Import necessary libraries
 import numpy as np
-import joblib  # For loading the serialized model
-import pandas as pd  # For data manipulation
-from flask import Flask, request, jsonify  # For creating the Flask API
+import joblib
+import pandas as pd
+from flask import Flask, request, jsonify
 
-# Initialize the Flask application
 sales_revenue_predictor_api = Flask("Superkart sales Revenue Predictor")
 
-# Load the trained machine learning model
+# Load trained model
 model = joblib.load("Sales_revenue_prediction_model_v1_0.joblib")
 
 # Define the expected columns (based on your dataset)
@@ -18,87 +16,45 @@ EXPECTED_COLUMNS = [
     'Store_Location_City_Type', 'Store_Type'
 ]
 
-
-
-# Define a route for the home page (GET request)
 @sales_revenue_predictor_api.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 revenue Prediction API!"
+    return "Welcome to the SuperKart Sales Prediction API!"
 
-# Define an endpoint for single property prediction (POST request)
 @sales_revenue_predictor_api.post('/v1/sales')
-def predict_product_sales():
-    """
-    This function handles POST requests to the '/v1/sales' endpoint.
-    It expects a JSON payload containing property details and returns
-    the predicted product total sales revenue as a JSON response.
-    """
-    # Get the JSON data from the request body
+def predict_sales():
     sales_data = request.get_json()
 
-    # Extract relevant features from the JSON data
-    sample = {
-        'Product_Weight': sales_data['Product_Weight'],
-        'Product_Sugar_Content': sales_data['Product_Sugar_Content'],
-        '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 data into a Pandas DataFrame
-    input_data = pd.DataFrame([sample])
-
-    # Make prediction (get product sales)
-    predicted_Sales = model.predict(input_data)[0]
+    # Manually build DataFrame with missing/default values
+    input_data = pd.DataFrame([sales_data])
 
-    # Calculate actual product sales
-    predicted_product_sales = np.exp(predicted_Sales)
+    # Add missing expected columns if any
+    missing_cols = set(EXPECTED_COLUMNS) - set(input_data.columns)
+    if missing_cols:
+        return jsonify({"error": f"columns are missing: {missing_cols}"}), 400
 
-    # Convert predicted_product_sales to Python float
-    predicted_product_sales = round(float(predicted_product_sales), 2)
-    # The conversion above is needed as we convert the model prediction (predicted_Sales) to actual sales using np.exp, which returns predictions as NumPy float32 values.
-    # When we send this value directly within a JSON response, Flask's jsonify function encounters a datatype error
+    # Predict
+    prediction = model.predict(input_data)[0]
+    return jsonify({"Sales": round(float(prediction), 2)})
 
-    # Return the actual product sales total
-    return jsonify({'Predicted total product sales': predicted_product_sales})
-
-
-# Define an endpoint for batch prediction (POST request)
 @sales_revenue_predictor_api.post('/v1/salesbatch')
-def predict_product_sales_batch():
-    """
-    This function handles POST requests to the '/v1/salesbatch' endpoint.
-    It expects a CSV file containing property details for multiple properties
-    and returns the predicted total product sales revenue as a dictionary in the JSON response.
-    """
-    # Get the uploaded CSV file from the request
+def predict_sales_batch():
     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 predicted_Sales)
-    predicted_Sales = model.predict(input_data).tolist()
+    # Check for missing columns
+    missing_cols = set(EXPECTED_COLUMNS) - set(input_data.columns)
+    if missing_cols:
+        return jsonify({"error": f"columns are missing: {missing_cols}"}), 400
 
-    # Calculate actual sales
-    predicted_Sales = [round(float(np.exp(Product_Store_Sales_Total)), 2) for Product_Store_Sales_Total in predicted_Sales]
+    # Predict
+    predictions = model.predict(input_data).tolist()
+    predictions = [round(float(p), 2) for p in predictions]
 
-    # Create a dictionary of predictions with property IDs as keys
-    Product_Ids = input_data['Product_Id'].tolist()  # Assuming 'Product_Id' is the product ID column
-    output_dict = dict(zip(Product_Ids, predicted_Sales))  # Use actual sales
+    # Use ID column or row index
+    ids = input_data['Product_Id'].tolist() if 'Product_Id' in input_data.columns else list(range(1, len(predictions) + 1))
 
-    # Return the predictions dictionary as a JSON response
-    return output_dict
+    return jsonify(dict(zip(ids, predictions)))
 
-# Run the Flask application in debug mode if this script is executed directly
 if __name__ == '__main__':
     sales_revenue_predictor_api.run(debug=True)
+