Upload folder using huggingface_hub

app.py

@@ -1,36 +1,36 @@
-import os
-import joblib
-from flask import Flask, request, jsonify
-import pandas as pd
-import numpy as np
-import warnings
-import logging
-warnings.filterwarnings("ignore")
+import os                                                                        # Provides access to operating system functionalities like reading files, interacting with directories, and managing environment variable
+import joblib                                                                    # Used for saving and loading models efficiently. It allows serialization of Python objects, especially machine learning models.
+from flask import Flask, request, jsonify                                        # Imports Flask framework for building a web API. Flask initializes the app, request handles incoming data, and jsonify converts responses to JSON format.
+import pandas as pd                                                              # Loads pandas, a powerful library for data analysis and manipulation, allowing structured data handling through DataFrames.
+import numpy as np                                                               # Imports numpy, which provides support for numerical computations, including arrays, mathematical functions, and statistical operations.
+import warnings                                                                  # Enables control over Python warning messages that may arise due to deprecated features or ignored exceptions.
+import logging                                                                   # Helps in tracking events and errors within the application by logging messages systematically.
+warnings.filterwarnings("ignore")                                                # Suppresses warning messages to ensure cleaner output during execution.
 
 # Initialize flask app with a name
-sales_prediction = Flask(__name__)
+sales_prediction = Flask(__name__)                                               # Creates Flask application
 
 # Configure logging
-logging.basicConfig(level=logging.DEBUG)
+logging.basicConfig(level=logging.DEBUG)                                         # Configures logging to display debug messages.
 
 # Load the trained model pipeline
 try:
-    model = joblib.load("SuperKart_Sales_Prediction_Model.joblib")
-    logging.info("Model loaded successfully.")
-except Exception as e:
-    logging.error(f"Error loading model: {e}")
-    raise
+    model = joblib.load("SuperKart_Sales_Prediction_Model.joblib")               # Loads saved model
+    logging.info("Model loaded successfully.")                                   # Logs a success message     
+except Exception as e:                                                           # To log any exception during handling                                                              
+    logging.error(f"Error loading model: {e}")                                   # Logs an error message if loading fails
+    raise                                                                        # Raises the error for troubleshooting.
 
-# Define an endpoint for making predictions
-@sales_prediction.get('/')
+# Define an endpoint for making predictions                                      # Returns a welcome message when accessed:
+@sales_prediction.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 App!"
+    return "Welcome to the SuperKart Sales Prediction App!"           
 
-# Define an endpoint for single property prediction (POST request)
+# Define an endpoint for single property prediction (POST request)              # Handles single prediction requests and returns JSON response:
 @sales_prediction.post('/v1/predict')
 def predict_sales():
     """
@@ -40,53 +40,53 @@ def predict_sales():
     """
     # Get the JSON data from the request body
     try:
-        business_data = request.get_json()
-        logging.debug(f"Received data: {business_data}")
-    except Exception as e:
-        logging.error(f"Error decoding JSON: {e}")
-        return jsonify({'error': f'Invalid JSON: {e}'}), 400
+        business_data = request.get_json()                                       # Extracts JSON data from request body
+        logging.debug(f"Received data: {business_data}")                         # Logs the received data for debugging purposes
+    except Exception as e:                                                       # To log any exception during handling                             
+        logging.error(f"Error decoding JSON: {e}")                               # Logs an error if JSON decoding fails
+        return jsonify({'error': f'Invalid JSON: {e}'}), 400                     # Returns a JSON-formatted error response with a 400 (Bad Request) status code. This informs the client that there was an issue with their request.                        
 
     # Extract relevant features from the JSON data
     try:
         business_data_sample = {
-            'Product_Weight': business_data['Product_Weight'],
-            'Product_Sugar_Content': business_data['Product_Sugar_Content'],
-            'Product_Type': business_data['Product_Type'],
-            'Product_Allocated_Area': business_data['Product_Allocated_Area'],
-            'Product_MRP': business_data['Product_MRP'],
-            'Store_Size': business_data['Store_Size'],
-            'Store_Location_City_Type': business_data['Store_Location_City_Type'],
-            'Store_Type': business_data['Store_Type'],
-            'Store_Current_Age': business_data['Store_Current_Age']  # Keep Store_Current_Age
+            'Product_Weight': business_data['Product_Weight'],                  # Extracts the weight of the product from the JSON data, which can be a crucial feature for predicting sales
+            'Product_Sugar_Content': business_data['Product_Sugar_Content'],    # Retrieves the sugar content classification (e.g., low sugar, regular) of the product, which might influence customer preferences
+            'Product_Type': business_data['Product_Type'],                      # Identifies the broad category of the product, such as dairy, snacks, or frozen foods, helping in segmentation analysis.
+            'Product_Allocated_Area': business_data['Product_Allocated_Area'],  # Captures the ratio of display space allocated to this product in a store, affecting visibility and sales performance
+            'Product_MRP': business_data['Product_MRP'],                        # Extracts the Maximum Retail Price of the product, a key factor influencing purchasing decisions.
+            'Store_Size': business_data['Store_Size'],                          # Retrieves the store's size classification (e.g., small, medium, large), which affects inventory and foot traffic.
+            'Store_Location_City_Type': business_data['Store_Location_City_Type'],# Identifies whether the store is in a Tier 1, Tier 2, or Tier 3 city, which impacts customer demographics and purchasing power
+            'Store_Type': business_data['Store_Type'],                            # Specifies the store format (e.g., supermarket, food mart, or departmental store), affecting pricing strategy and sales
+            'Store_Current_Age': business_data['Store_Current_Age']              # Calculates the store’s age based on its establishment year, potentially relevant for analyzing store performance over time.  
         }
-    except KeyError as e:
-        logging.error(f"Missing key in JSON data: {e}")
-        return jsonify({'error': f'Missing key: {e}'}), 400
-    except TypeError as e:
-        logging.error(f"Error with data types: {e}")
-        return jsonify({'error': f'Incorrect data type: {e}'}), 400
+    except KeyError as e:                                                      
+        logging.error(f"Missing key in JSON data: {e}")                         # Handles missing keys in JSON data                           
+        return jsonify({'error': f'Missing key: {e}'}), 400                     # Logs an error message and returns a JSON response with an HTTP 400 status code (Bad Request)
+    except TypeError as e:                                                      # Handles TypeError, which occurs when the data received is in an unexpected format
+        logging.error(f"Error with data types: {e}")                            # Logs an error message
+        return jsonify({'error': f'Incorrect data type: {e}'}), 400             # Logs the issue and returns an error response with HTTP status 400.
 
     # Convert the extracted data into a Pandas DataFrame
     try:
-        business_df = pd.DataFrame(business_data_sample, index=[0])
-        logging.debug(f"DataFrame: {business_df.head().to_string()}")
-    except Exception as e:
-        logging.error(f"Error creating DataFrame: {e}")
-        return jsonify({'error': f'Error creating DataFrame: {e}'}), 500
+        business_df = pd.DataFrame(business_data_sample, index=[0])             # Transforms the extracted business data sample into a single-row Pandas DataFrame for structured analysis and model predictions.          
+        logging.debug(f"DataFrame: {business_df.head().to_string()}")           # Logs the first few rows of the DataFrame in a formatted string for clearer debugging output
+    except Exception as e:                                                      # To log any exception during handling    
+        logging.error(f"Error creating DataFrame: {e}")                         # Logs an error message if DataFrame creation fails
+        return jsonify({'error': f'Error creating DataFrame: {e}'}), 500        # Returns a JSON-formatted error message with a 500 Internal Server Error status, signaling a failure in DataFrame processing.       
 
     # Make predictions using the loaded model
-    try:
-        prediction = model.predict(business_df)
-        logging.debug(f"Prediction: {prediction}")
-    except Exception as e:
-        logging.error(f"Error during prediction: {e}")
-        return jsonify({'error': f'Prediction error: {e}'}), 500
+    try:                                                                          
+        prediction = model.predict(business_df)                                 # Uses the loaded model to make predictions on the business data
+        logging.debug(f"Prediction: {prediction}")                              # Logs an error message
+    except Exception as e:                                                      # To log any exception during handling                                 
+        logging.error(f"Error during prediction: {e}")                          # Logs an error message if DataFrame creation fails                         
+        return jsonify({'error': f'Prediction error: {e}'}), 500                # Returning an error code 500 if any issue with JSON
 
     # Return the prediction as a JSON response
-    return jsonify({'prediction': list(prediction)})
+    return jsonify({'prediction': list(prediction)})                            # Returns the prediction as a JSON response
 
 # Define an endpoint for batch prediction (POST request)
-@sales_prediction.post('/v1/batch_predict')
+@sales_prediction.post('/v1/batch_predict')                                     
 def batch_predict():
     """
     This function handles POST requests to the '/v1/batch_predict' endpoint.
@@ -95,31 +95,31 @@ def batch_predict():
     """
     # Get the uploaded CSV file from the request
     try:
-        file = request.files['file']
-        logging.debug(f"Received file: {file.filename}")
-    except Exception as e:
-        logging.error(f"Error getting file: {e}")
-        return jsonify({'error': f'Error getting file: {e}'}), 400
+        file = request.files['file']                                            # Retrieves the uploaded file from the request
+        logging.debug(f"Received file: {file.filename}")                        # Logs the received file for debugging purposes           
+    except Exception as e:                                                      # To log any exception during handling                                                              
+        logging.error(f"Error getting file: {e}")                               # Logs an error if file retrieval fails
+        return jsonify({'error': f'Error getting file: {e}'}), 400              # Logs the issue and returns an error response with HTTP status 400.          
 
     # Read the CSV file into a Pandas DataFrame
     try:
-        df = pd.read_csv(file)
-        logging.debug(f"DataFrame shape: {df.shape}")
-    except Exception as e:
-        logging.error(f"Error reading CSV: {e}")
-        return jsonify({'error': f'Error reading CSV file: {e}'}), 400
+        df = pd.read_csv(file)                                                  # creating a variable to store the csv file
+        logging.debug(f"DataFrame shape: {df.shape}")                           # Logs the shape of the DataFrame for debugging purposes
+    except Exception as e:                                                      # To log any exception during handling    
+        logging.error(f"Error reading CSV: {e}")                                # Logs an error if CSV reading fails
+        return jsonify({'error': f'Error reading CSV file: {e}'}), 400          # Logs the issue and returns an error response with HTTP status 400. 
 
     # Make preductions using the loaded model
     try:
-        prediction = model.predict(df)
-        logging.debug(f"Prediction: {prediction}")
-    except Exception as e:
-        logging.error(f"Error during prediction: {e}")
-        return jsonify({'error': f'Prediction error: {e}'}), 500
+        prediction = model.predict(df)                                          # Fit the model to variable 'prediction'
+        logging.debug(f"Prediction: {prediction}")                              # Logs the prediction for debugging purposes
+    except Exception as e:                                                      # To log any exception during handling  
+        logging.error(f"Error during prediction: {e}")                          # Logs an error if prediction fails
+        return jsonify({'error': f'Prediction error: {e}'}), 500                # Returning an error code 500 if any issue with JSON
 
     # Return the prediction as a JSON response
-    return jsonify({'prediction': list(prediction)})
+    return jsonify({'prediction': list(prediction)})                            # Returns the prediction as a JSON response
 
 # Run the Flask app if this script is executed
-if __name__ == '_main_':
-    sales_prediction.run(debug=True)
+if __name__ == '_main_':                                                        # Checks if the script is executed directly.
+    sales_prediction.run(debug=True)                                            # Display the sales predicted and handle any debug issue