Upload folder using huggingface_hub

Dockerfile

@@ -18,5 +18,5 @@ EXPOSE 7860
 
 # Start the Flask app using gunicorn
 # - app: refers to app.py
-# - rental_price_predictor_api: the Flask app object in app.py
-CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:7860", "app:rental_price_predictor_api"]
+# - app: the Flask app object in app.py (corrected from rental_price_predictor_api)
+CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:7860", "app:app"]

app.py

@@ -1,45 +1,120 @@
 
 # Import necessary libraries
 import numpy as np
-import joblib  
-import pandas as pd  
-from flask import Flask, request, jsonify  
+import joblib
+import pandas as pd
+from flask import Flask, request, jsonify
+import traceback # Import traceback to print detailed error info
+
+# Define the path where the model is saved
+# NOTE: This path should be accessible within the Docker container.
+# When you upload the deployment_files folder to the Space,
+# the .joblib file will be at the root of the container's /app directory.
+# Adjust the path accordingly. Assuming the model file is at the root of the
+# uploaded directory within the container.
+# If saved_model_path was defined as "/content/drive/MyDrive/...", that path
+# is not valid inside the Docker container.
+# Let's assume the model is in the same directory as app.py inside the container.
+# The model file was saved as "SuperKart_v1_0.joblib" in
+# "/content/drive/MyDrive/Colab Notebooks/ModelDeployment_SuperKart/deployment_files/"
+# When uploading "deployment_files" to the space, the contents are placed in the root.
+# So, the model file inside the container should be just the filename.
+model_file_name = "SuperKart_v1_0.joblib"
+try:
+    # Load the trained machine learning model
+    model = joblib.load(model_file_name)
+    print(f"Model loaded successfully from {model_file_name}")
+except FileNotFoundError:
+    print(f"Error: Model file not found at {model_file_name}")
+    model = None # Set model to None if loading fails
+except Exception as e:
+    print(f"Error loading model: {e}")
+    traceback.print_exc()
+    model = None # Set model to None if loading fails
 
-# Initialize the Flask application
-superkart_salesprice_predictor_api = Flask("Super Kart Product Sales Price Predictor")
 
-# Load the trained machine learning model
-model = joblib.load(saved_model_path)
+# Initialize the Flask application
+# Use the name 'app' which is convention for Gunicorn
+app = Flask(__name__)
 
 # Define a route for the home page (GET request)
-@superkart_salesprice_predictor_api.get('/')
+@app.route('/')
 def home():
     return "Welcome to the Super Kart Product Sales Price Prediction API!"
 
 # Endpoint for single property prediction
-@superkart_salesprice_predictor_api.post('/v1/salesprice')
+@app.route('/v1/salesprice', methods=['POST'])
 def predict_sales_price():
-    property_data = request.get_json()
+    # Check if the model was loaded successfully
+    if model is None:
+        return jsonify({"error": "Model not loaded. Cannot make predictions."}), 500
+
+    try:
+        property_data = request.get_json(force=True) # force=True to handle requests without content-type set
+
+        # Validate incoming JSON data structure
+        expected_keys = [
+            'Product_Weight', 'Product_Sugar_Content', 'Product_Allocated_Area',
+            'Product_Type', 'Product_MRP', 'Store_Size',
+            'Store_Location_City_Type', 'Store_Type', 'Store_Age'
+        ]
+        if not all(key in property_data for key in expected_keys):
+             missing_keys = [key for key in expected_keys if key not in property_data]
+             return jsonify({"error": f"Missing keys in input data: {missing_keys}"}), 400
+
+        # Create a sample dictionary with the expected keys and data types
+        sample = {
+            'Product_Weight': property_data.get('Product_Weight'),
+            'Product_Sugar_Content': property_data.get('Product_Sugar_Content'),
+            'Product_Allocated_Area': property_data.get('Product_Allocated_Area'),
+            'Product_Type': property_data.get('Product_Type'),
+            'Product_MRP': property_data.get('Product_MRP'),
+            'Store_Size': property_data.get('Store_Size'),
+            'Store_Location_City_Type': property_data.get('Store_Location_City_Type'),
+            'Store_Type': property_data.get('Store_Type'),
+            'Store_Age': property_data.get('Store_Age')
+        }
+
+        # Convert to DataFrame
+        # It's crucial that the column names here match the features expected by your pipeline
+        # after the initial data processing (like dropping IDs and adding Store_Age).
+        # Also ensure the data types match. Your payload sends Store_Size and Store_Location_City_Type
+        # as "Medium" and "Tier 2", but your preprocessing maps these to numerical values (1, 2, 3).
+        # The frontend also sends 1, 2, 3. The backend should probably expect the mapped numerical values
+        # consistent with the trained model's expectation after preprocessing.
+        # Let's adjust the payload expectation to match the numerical mapping done during training.
+        # The payload should send 1, 2, or 3 for Store_Size and Store_Location_City_Type.
+        # If you want to send "Medium", "Tier 2" etc., you need to apply the mapping in the backend Flask app before prediction.
+
+        # Assuming the *input payload* for Store_Size and Store_Location_City_Type is already the mapped numerical value (1, 2, or 3)
+        # This aligns with the frontend Streamlit app code.
+        input_data = pd.DataFrame([sample])
+
+
+        # Perform prediction
+        predicted_sales_price = model.predict(input_data)
 
-    sample = {
-        'Product_Weight': property_data['Product_Weight'],
-        'Product_Sugar_Content': property_data['Product_Sugar_Content'],
-        'Product_Allocated_Area': property_data['Product_Allocated_Area'],
-        'Product_Type': property_data['Product_Type'],
-        'Product_MRP': property_data['Product_MRP'],
-        'Store_Size': property_data['Store_Size'],
-        'Store_Location_City_Type': property_data['Store_Location_City_Type'],
-        'Store_Type': property_data['Store_Type'],
-        'Store_Age': property_data['Store_Age']
-    }
+        # Your original code applied np.exp to the prediction.
+        # This implies your model was trained on log-transformed target variable.
+        # Ensure this is consistent with how your model was trained.
+        # If your model predicts the original scale, remove np.exp.
+        # Assuming log transformation was used:
+        predicted_price = round(float(np.exp(predicted_sales_price[0])), 2) # prediction returns an array, take the first element
 
-    input_data = pd.DataFrame([sample])
+        return jsonify({'Predicted Price': predicted_price}), 200 # Return 200 status code for success
 
-    predicted_sales_price = model.predict(input_data)[0]
-    predicted_price = round(float(np.exp(predicted_sales_price)), 2)
+    except Exception as e:
+        # Log the error on the server side
+        print(f"An error occurred during prediction: {e}")
+        traceback.print_exc() # Print traceback to logs for detailed error info
+        # Return an error response to the client
+        return jsonify({"error": "An internal server error occurred during prediction.", "details": str(e)}), 500
 
-    return jsonify({'Predicted Price': predicted_price})
 
-# Run the Flask application in debug mode if this script is executed directly
+# Run the Flask application using Gunicorn (as defined in Dockerfile CMD)
+# The if __name__ == '__main__': block is not strictly necessary when using Gunicorn
+# but can be useful for local testing.
 if __name__ == '__main__':
-    superkart_salesprice_predictor_api.run(debug=True)
+    # For local testing, uncomment the line below and run this script directly
+    # superkart_salesprice_predictor_api.run(debug=True, host='0.0.0.0', port=7860)
+    pass # Do nothing when run by Gunicorn