Upload folder using huggingface_hub

Dockerfile

@@ -13,4 +13,4 @@ RUN pip install --no-cache-dir --upgrade -r requirements.txt
 # - `-w 4`: Uses 4 worker processes for handling requests
 # - `-b 0.0.0.0:7860`: Binds the server to port 7860 on all network interfaces
 # - `app:superkart_api`: Runs the Flask app (Flask app instance is named `superkart_api` inside app.py)
-CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:7860", "app:app"]
+CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:7860", "app:superkart_api"]

app.py

@@ -1,96 +1,80 @@
 
-import os
 import numpy as np
 import pandas as pd
 import joblib
 from flask import Flask, request, jsonify
-from flask_cors import CORS
 
 # ------------------------------------------------------------
-# Flask Application Setup
+# Application Initialization
 # ------------------------------------------------------------
-def create_app(model_path: str):
-    """
-    Factory function to create and configure the Flask app.
-    """
-    app = Flask("superkart_api")
-    CORS(app)
+# Create Flask app instance
+superkart_api = Flask("superkart_sales_prediction_api")
 
-    # Load model once during startup
-    if not os.path.exists(model_path):
-        raise FileNotFoundError(f"Trained model not found at {model_path}")
+# Load the serialized (trained) model
+# Ensure the model file path is correct relative to this script
+MODEL_PATH = "superkart_product_sales_forecasting_model_v1_0.joblib"
+model = joblib.load(MODEL_PATH)
 
-    model = joblib.load(model_path)
-
-    # --------------------------------------------------------
-    # Health check route
-    # --------------------------------------------------------
-    @app.route("/", methods=["GET"])
-    def health_check():
-        """
-        Returns a simple message to verify the API is running.
-        """
-        return jsonify({"status": "ok", "message": "SuperKart Sales Prediction API is active"})
+# ------------------------------------------------------------
+# Routes
+# ------------------------------------------------------------
 
-    # --------------------------------------------------------
-    # Prediction endpoint
-    # --------------------------------------------------------
-    @app.route("/api/v1/predict", methods=["POST"])
-    def predict():
-        """
-        Accepts JSON input, validates fields, runs the model, and returns predictions.
-        """
-        data = request.get_json()
+@superkart_api.route("/", methods=["GET"])
+def home():
+    """
+    Health check or root endpoint.
+    Returns a simple confirmation message.
+    """
+    return "SuperKart Sales Prediction API is running successfully."
 
-        if not data:
-            return jsonify({"error": "No input received"}), 400
 
-        expected_fields = [
-            "Product_Weight",
-            "Product_Sugar_Content",
-            "Product_Allocated_Area",
-            "Product_MRP",
-            "Store_Size",
-            "Store_Location_City_Type",
-            "Store_Type",
-            "Store_Age_Years",
-            "Product_Type_Category"
+@superkart_api.route("/v1/predict", methods=["POST"])
+def predict_sales():
+    """
+    Predicts sales based on product and store attributes.
+    Expects a JSON payload with the required feature fields.
+    """
+    try:
+        # Parse incoming JSON data
+        data = request.get_json(force=True)
+
+        # Define required input fields
+        required_fields = [
+            'Product_Weight',
+            'Product_Sugar_Content',
+            'Product_Allocated_Area',
+            'Product_MRP',
+            'Store_Size',
+            'Store_Location_City_Type',
+            'Store_Type',
+            'Product_Id_char',
+            'Store_Age_Years',
+            'Product_Type_Category'
         ]
 
-        missing = [f for f in expected_fields if f not in data]
+        # Check for missing fields
+        missing = [f for f in required_fields if f not in data]
         if missing:
-            return jsonify({"error": f"Missing required fields: {missing}"}), 400
-
-        try:
-            # Preprocess input data into model format
-            processed = pd.DataFrame([{
-                "Product_Weight": float(data["Product_Weight"]),
-                "Product_Sugar_Content": data["Product_Sugar_Content"],
-                "Product_Allocated_Area_Log": np.log1p(float(data["Product_Allocated_Area"])),
-                "Product_MRP": float(data["Product_MRP"]),
-                "Store_Size": data["Store_Size"],
-                "Store_Location_City_Type": data["Store_Location_City_Type"],
-                "Store_Type": data["Store_Type"],
-                "Store_Age_Years": int(data["Store_Age_Years"]),
-                "Product_Type_Category": data["Product_Type_Category"]
-            }])
+            return jsonify({"error": f"Missing input fields: {missing}"}), 400
 
-            prediction = model.predict(processed)[0]
+        # Prepare input as DataFrame for model
+        input_df = pd.DataFrame([{f: data[f] for f in required_fields}])
 
-            return jsonify({
-                "Predicted_Sales": round(float(prediction), 2),
-                "status": "success"
-            })
+        # Generate prediction
+        prediction = float(model.predict(input_df)[0])
 
-        except Exception as exc:
-            return jsonify({"error": f"Prediction failed: {str(exc)}"}), 500
+        # Return prediction result
+        return jsonify({
+            "Predicted_Sales": round(prediction, 2),
+            "status": "success"
+        })
 
-    return app
+    except Exception as e:
+        return jsonify({"error": f"Prediction failed: {str(e)}"}), 500
 
 
-# Run the Flask app in debug mode
-if __name__ == '__main__':
-
-  MODEL_PATH = "superkart_product_sales_forecasting_model_v1_0.joblib"
-  app = create_app(MODEL_PATH)
-  app.run(debug=True)
+# ------------------------------------------------------------
+# Entry Point
+# ------------------------------------------------------------
+if __name__ == "__main__":
+    superkart_api.run(host="0.0.0.0", port=5000, debug=True)