#Installing the libraries with the specified versions
!pip install numpy==2.0.2 pandas==2.2.2 scikit-learn==1.6.1 matplotlib==3.10.0 seaborn==0.13.2 joblib==1.4.2 xgboost==2.1.4 requests==2.32.4 huggingface_hub==0.34.0 -q

# import libraries for reading and manipulation of data
import os
import numpy as np
import pandas as pd

# import libraries for data visualization
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib.ticker import ScalarFormatter
from matplotlib.ticker import FuncFormatter

# import libraries to split datasets into training and testing sets
from sklearn.model_selection import train_test_split

# import libraries to import ensemble classifiers
from sklearn.ensemble import (
    BaggingRegressor,
    RandomForestRegressor,
    AdaBoostRegressor,
    GradientBoostingRegressor,
)
from xgboost import XGBRegressor
from sklearn.tree import DecisionTreeRegressor


# import library to compute classification metrics
from sklearn.metrics import (
    confusion_matrix,
    accuracy_score,
    precision_score,
    recall_score,
    f1_score,
    mean_squared_error,
    mean_absolute_error,
    r2_score,
    mean_absolute_percentage_error
)
from sklearn.metrics import mean_squared_error as mse

# import libraries to create the pipeline
from sklearn.compose import make_column_transformer
from sklearn.pipeline import make_pipeline,Pipeline

# import library to tune different models and standardize
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler,OneHotEncoder

# import library to serialize the model
import joblib

# import library for API requests
import requests

# import library for hugging face space authentication to upload files
from huggingface_hub import login, HfApi

# Removes the limit for the number of displayed columns
pd.set_option("display.max_columns", None)
# Sets the limit for the number of displayed rows
pd.set_option("display.max_rows", 100)

# import library to suppress unnecessary warnings
import warnings
warnings.filterwarnings('ignore')

# run the following lines for Google Colab
from google.colab import drive
drive.mount('/content/drive')

# read the dataset from the Google Colab drive Python Course
products = pd.read_csv('/content/drive/MyDrive/Python Course/SuperKart.csv')

# creating a copy of the data
data = products.copy()

# pull the first 5 rows of data from dataset
data.head(5)

# pull the last 5 rows of the data from the dataset
data.tail(5)

# view the number of rows and columns that are present in the data
data.shape

# pull the datatypes for each column and entries for each column in the dataset
data.info()

# check data for any records with no data entered for the column
data.isnull().sum()

# check for duplicate values in the dataset
data.duplicated().sum()

# check the statistical information for each varaiable (column) in the dataset
data.describe().T

# setup function to create combined boxplot and histogram for univariate analysis of numerical variables in dataset
# data - dataframe dataset; feature - column in dataset; figsize - figure size; kde - density curve displayed; bins - interval of groups in the histogram
def histogram_boxplot(data, feature, figsize=(20, 10), kde=False, bins=None):
    # create the subplots
    # nrows - Number of rows in the subplot grid; sharex - x-axis will be shared among all subplots
    f2, (ax_box2, ax_hist2) = plt.subplots(nrows=2, sharex=True, gridspec_kw={"height_ratios": (0.25, 0.75)}, figsize=figsize,)
    # create the boxplot which will display a triangle to indicate the mean value of the variable
    sns.boxplot(data=data, x=feature, ax=ax_box2, showmeans=True, color="aquamarine")
    # create the histogram which will display a straight line for the mean of the variable and dotted line for the median of the variable
    sns.histplot(data=data, x=feature, kde=kde, ax=ax_hist2, bins=bins,
    ) if bins else sns.histplot(
        data=data, x=feature, kde=kde, ax=ax_hist2, color="violet")
    ax_hist2.axvline(data[feature].mean(), color="black", linestyle="--")
    ax_hist2.axvline(data[feature].median(), color="gold", linestyle="-")

# setup function to create barplot with the percentage on top for univariate analysis of category variables in dataset
# data - dataframe dataset; feature - column in dataset; perc - display of percentages instead of count (set to False);
# n - display the top n category levels (set to display all levels)
def labeled_barplot(data, feature, perc=False, n=None):
    total = len(data[feature])  # length of the column
    count = data[feature].nunique()
    if n is None:
        plt.figure(figsize=(count + 2, 6))
    else:
        plt.figure(figsize=(n + 2, 6))

    plt.xticks(rotation=90, fontsize=15)
    ax = sns.countplot(data=data, x=feature, palette="pastel",
        order=data[feature].value_counts().index[:n],)
    # set percentage of each class of category, count of each category,
    # set width and height of the plot
    for p in ax.patches:
        if perc == True:
            label = "{:.1f}%".format(100 * p.get_height() / total)
        else:
            label = p.get_height()

        x = p.get_x() + p.get_width() / 2
        y = p.get_height()
        # annotate the percentage
        ax.annotate(label, (x, y), ha="center", va="center",
            size=12, xytext=(0, 5), textcoords="offset points",)

    plt.show()

histogram_boxplot(data, "Product_Weight")

histogram_boxplot(data, "Product_Allocated_Area")

histogram_boxplot(data, "Product_MRP")

histogram_boxplot(data, "Product_Store_Sales_Total")

labeled_barplot(data, "Product_Sugar_Content", perc=True)

labeled_barplot(data, "Product_Type", perc=True)

labeled_barplot(data, "Store_Id", perc=True)

labeled_barplot(data, "Store_Size", perc=True)

labeled_barplot(data, "Store_Location_City_Type", perc=True)

labeled_barplot(data, "Store_Type", perc=True)

# setup function to create category counts and plot a stacked bar chart for bivariate analysis of variables in dataset
# data - dataframe dataset; predictor - independent variable, target - target variable
def stacked_barplot(data, predictor, target):
    count = data[predictor].nunique()
    sorter = data[target].value_counts().index[-1]
    tab1 = pd.crosstab(data[predictor], data[target], margins=True).sort_values(
        by=sorter, ascending=False)
    print(tab1)
    print("-" * 120)
    tab = pd.crosstab(data[predictor], data[target], normalize="index").sort_values(
        by=sorter, ascending=False)
    tab.plot(kind="bar", stacked=True, figsize=(count + 5, 5))
    plt.legend(loc="lower left", frameon=False,)
    plt.legend(loc="upper left", bbox_to_anchor=(1, 1))
    plt.show()

# setup function to create scatterplot to see how one variable relates to another and whether the predictor categories show distinct behaviors on the target variable
def scatterplot_distribution(data, predictor, target):
  plt.figure(figsize=(12, 6))
  sns.scatterplot(data, x=predictor, y=target, hue=predictor)
  plt.title(f"Scatterplot for {predictor}  Vs {target}")
  plt.show()

# setup function to create boxplot to show the data's median, spread, range, and outlier points
def boxplot_distribution(data, predictor, target):
  plt.figure(figsize=[12, 6])
  sns.boxplot(data, x=predictor, y=target, hue=predictor)
  plt.xticks(rotation=90)
  plt.title(f"Boxplot for {predictor}  Vs {target}")
  plt.show()

# setup function to create grouped barplot to compare multiple related categories side by side within each main category, revealing patterns, differences, and trends in the dataset.
def grouped_barplot(data, group_cols, value_col, x, y, hue=None,
                     agg_func='sum', figsize=(12, 6), title='Grouped Bar Plot'):

    grouped = data.groupby(group_cols)[value_col].agg(agg_func).reset_index()

    plt.figure(figsize=figsize)
    ax = sns.barplot(data=grouped, x=x, y=y, hue=hue)
    ax.set(xlabel=x, ylabel=y, title=title)
    ax.ticklabel_format(style='plain', axis='y')
    ax.yaxis.set_major_formatter(FuncFormatter(lambda x, _: f'{x:,.0f}'))
    plt.xticks(rotation=90)
    if hue:
        plt.legend(title=hue, loc='upper left')
    plt.tight_layout()
    plt.show()

# setup function to create barplot to compare the sum of the revenue to other variables
def revenue_barplot(data, predictor, target):
  group_cols = [predictor]
  agg_data = data.groupby(group_cols)[target].sum().reset_index()
  plt.figure(figsize=(12, 6))
  ax = sns.barplot(data=agg_data, x=predictor, y=target)
  ax.set(xlabel=predictor, ylabel=f'Total {target}', title=f'Total {target} by {predictor}')
  ax.ticklabel_format(style='plain', axis='y')
  ax.yaxis.set_major_formatter(FuncFormatter(lambda x, _: f'{x:,.0f}'))
  plt.xticks(rotation=90)
  plt.tight_layout()
  plt.show()

# create a heatmap for the correlation of the numeric features
cols_list = data.select_dtypes(include=np.number).columns.tolist()
cols_list.remove('Store_Establishment_Year')
plt.figure(figsize=(20, 10))
sns.heatmap(
    data[cols_list].corr(), annot=True, vmin=-1, vmax=1, fmt=".2f", cmap='coolwarm'
)
plt.show()

scatterplot_distribution(data, 'Product_Weight', 'Product_Store_Sales_Total')

scatterplot_distribution(data, 'Product_Allocated_Area', 'Product_Store_Sales_Total')

scatterplot_distribution(data, 'Product_MRP', 'Product_Store_Sales_Total')

boxplot_distribution(data, 'Product_Sugar_Content', 'Product_Store_Sales_Total')

boxplot_distribution(data, 'Product_Type', 'Product_Store_Sales_Total')

boxplot_distribution(data, 'Store_Id', 'Product_Store_Sales_Total')

boxplot_distribution(data, 'Store_Size', 'Product_Store_Sales_Total')

boxplot_distribution(data, 'Store_Location_City_Type', 'Product_Store_Sales_Total')

boxplot_distribution(data, 'Store_Type', 'Product_Store_Sales_Total')

plt.figure(figsize=(12, 6))
sns.boxplot(data=data, x='Product_Sugar_Content', y='Product_Weight', hue='Product_Sugar_Content')
plt.xticks(rotation=90)
plt.title('Boxplot of Product Weight vs Product Sugar Content')
plt.show()

plt.figure(figsize=(12, 6))
sns.boxplot(data=data, x='Product_Type', y='Product_Weight', hue='Product_Type')
plt.xticks(rotation=90)
plt.title('Boxplot of Product Weight vs Product Type')
plt.show()

store_ids = ['OUT001', 'OUT002', 'OUT003', 'OUT004']

cols_list = ['Store_Establishment_Year', 'Store_Size', 'Store_Location_City_Type', 'Store_Type']
for store in store_ids:
    print(f'\n**** Statistics for Store ID: {store} ****')
    display(data.loc[data['Store_Id'] == store, cols_list].describe(include='all').T)

store_revenue = (
    data.groupby('Store_Id')['Product_Store_Sales_Total']
    .sum()
    .loc[store_ids]
)

for store, revenue in store_revenue.items():
    print(f'Store ID: {store}, Total Revenue: ${revenue:,.2f}')

revenue_barplot(data, 'Store_Id', 'Product_Store_Sales_Total')

revenue_barplot(data, 'Store_Size', 'Product_Store_Sales_Total')

revenue_barplot(data, 'Store_Location_City_Type', 'Product_Store_Sales_Total')

revenue_barplot(data, 'Store_Type', 'Product_Store_Sales_Total')

revenue_barplot(data, 'Product_Sugar_Content', 'Product_Store_Sales_Total')

revenue_product = data.groupby('Product_Type')['Product_Store_Sales_Total'].sum().reset_index()

plt.figure(figsize=(12, 6))
sns.barplot(data=revenue_product, x='Product_Type', y='Product_Store_Sales_Total')
plt.xticks(rotation=90)
plt.xlabel('Product Types')
plt.ylabel('Product Store Sales Total')
plt.title('Revenue by Product Type')
plt.show()

grouped_barplot(
   data=data,
    group_cols=['Store_Id', 'Product_Type'],
    value_col='Product_Store_Sales_Total',
    x='Store_Id',
    y='Product_Store_Sales_Total',
    hue='Product_Type',
    title='Revenue generated by each Store ID for each Product Type'
)

grouped_barplot(
    data=data,
    group_cols=['Product_Sugar_Content', 'Store_Id'],
    value_col='Product_Store_Sales_Total',
    x='Product_Sugar_Content',
    y='Product_Store_Sales_Total',
    hue='Store_Id',
    title='Revenue generated by each Store Type for each Product Type'
)

# updating the product sugar content to move reg to Regular
data.Product_Sugar_Content.replace(to_replace=['reg'], value='Regular', inplace=True)
data.Product_Sugar_Content.value_counts()

# create a variable for number of years that store has been in operation
data['Store_Years_In_Operation'] = 2025 - data.Store_Establishment_Year
data.head()

# create a variable for product codes to reduce number of product ids for model
data['Product_Code'] = data['Product_Id'].str[:2]
data['Product_Code'].unique()

# print product code arrays
codes = ['FD', 'NC', 'DR']
for code in codes:
    types = data.loc[data['Product_Code'] == code, 'Product_Type'].unique()
    print(f'{code}: {types}')

# create a variable for product categories to reduce number of product types for model
food = [
    'Frozen Foods', 'Dairy', 'Canned', 'Baking Goods', 'Snack Foods', 'Meat', 'Fruits and Vegetables', 'Breads', 'Breakfast', 'Starchy Foods', 'Seafood'
]
data['Product_Category'] = np.where(data['Product_Type'].isin(food), 'Food', 'Non Food')
data.head()

# outlier detection using boxplot
numeric_columns = data.select_dtypes(include=np.number).columns.tolist()
numeric_columns.remove('Store_Establishment_Year')
numeric_columns.remove('Store_Years_In_Operation')

plt.figure(figsize=(15, 10))

for i, variable in enumerate(numeric_columns):
    plt.subplot(4, 4, i + 1)
    plt.boxplot(data[variable], whis=1.5)
    plt.tight_layout()
    plt.title(variable)

plt.show()

# drop some of the categorical features for modeling as new concise variables have been created
data = data.drop(columns=['Product_Id', 'Product_Type', 'Store_Id', 'Store_Establishment_Year'])
data.shape

data.head()

# define the independent and dependent variables
X = data.drop(['Product_Store_Sales_Total'], axis=1)
y = data['Product_Store_Sales_Total']

# splitting data into training and test set

# split data into 2 parts: Train + Temp (80%) and Test (20%)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, shuffle=True)

# print the number of rows of each dataset
print("Number of rows in train data =", X_train.shape[0])
print("Number of rows in test data =", X_test.shape[0])

# create a categorical feature that stores a list of the categorical column names
categorical_features = data.select_dtypes(include=['object', 'category']).columns.tolist()
categorical_features

# create a preprocessing pipeline for the categorical features
preprocessor = make_column_transformer(
    (Pipeline([('encoder', OneHotEncoder(handle_unknown='ignore'))]), categorical_features)
)

# function to compute adjusted R-squared
def adj_r2_score(predictors, targets, predictions):
    r2 = r2_score(targets, predictions)
    n = predictors.shape[0]
    k = predictors.shape[1]
    return 1 - ((1 - r2) * (n - 1) / (n - k - 1))


# function to compute different metrics to check performance of a regression model
def model_performance_regression(model, predictors, target):
    """
    Function to compute different metrics to check regression model performance

    model: regressor
    predictors: independent variables
    target: dependent variable
    """

    # predicting using the independent variables
    pred = model.predict(predictors)

    r2 = r2_score(target, pred)  # to compute R-squared
    adjr2 = adj_r2_score(predictors, target, pred)  # to compute adjusted R-squared
    rmse = np.sqrt(mean_squared_error(target, pred))  # to compute RMSE
    mae = mean_absolute_error(target, pred)  # to compute MAE
    mape = mean_absolute_percentage_error(target, pred)  # to compute MAPE

    # creating a dataframe of metrics
    df_perf = pd.DataFrame(
        {
            "RMSE": rmse,
            "MAE": mae,
            "R-squared": r2,
            "Adj. R-squared": adjr2,
            "MAPE": mape,
        },
        index=[0],
    )

    return df_perf

# fitting the random forest model
rf_estimator = RandomForestRegressor(random_state=42)
rf_estimator = make_pipeline(preprocessor, rf_estimator)
rf_estimator.fit(X_train, y_train)

# calculating the training metric
rf_estimator_model_train_perf = model_performance_regression(rf_estimator, X_train,y_train)
print("Training performance \n",rf_estimator_model_train_perf)

# calculating the testing metric
rf_estimator_model_test_perf = model_performance_regression(rf_estimator, X_test,y_test)
print("Testing performance \n", rf_estimator_model_test_perf)

# fitting the XGBoost model
xgb_estimator = XGBRegressor(random_state=42)
xgb_estimator = make_pipeline(preprocessor, xgb_estimator)
xgb_estimator.fit(X_train, y_train)

# calculating the training metric
xgb_estimator_model_train_perf = model_performance_regression(xgb_estimator, X_train,y_train)
print("Training performance \n",xgb_estimator_model_train_perf)

# calculating the testing metric
xgb_estimator_model_test_perf = model_performance_regression(xgb_estimator, X_test,y_test)
print("Testing performance \n", xgb_estimator_model_test_perf)

# initialize the Random Forest regressor model
rf_tuned = RandomForestRegressor(random_state=42)
rf_tuned = make_pipeline(preprocessor, rf_tuned)

# set grid of parameters to choose from
param_grid = {
    'randomforestregressor__n_estimators': [80, 90, 100, 110],
    'randomforestregressor__max_depth': [4, 6, 8, None],
    'randomforestregressor__max_features': ['sqrt', 'log2', None],
    'randomforestregressor__min_samples_split': [2, 5, 10],
}

# running the grid search
grid_search_rf = GridSearchCV(rf_tuned, param_grid, scoring=r2_score, cv=3, n_jobs=-1)
grid_search_rf = grid_search_rf.fit(X_train, y_train)

# printing the best combination of parameters
print(f"Best parameters for Random Forest: {grid_search_rf.best_params_}")
rf_tuned = grid_search_rf.best_estimator_

# calculating the training metric
rf_tuned_model_train_perf = model_performance_regression(rf_tuned, X_train, y_train)
print("Training performance \n", rf_tuned_model_train_perf)

# calculating the testing metric
rf_tuned_model_test_perf = model_performance_regression(rf_tuned, X_test, y_test)
print("Testing performance \n", rf_tuned_model_test_perf)

# initialize the XGBoost regressor model
xgb_tuned = XGBRegressor(random_state=42)
xgb_tuned = make_pipeline(preprocessor, xgb_tuned)

# set grid of parameters to choose from
param_grid = {
    'xgbregressor__n_estimators': [75, 100, 125],
    'xgbregressor__subsample': [0.7, 0.8, 0.9],
    'xgbregressor__gamma': [0, 1, 3],
    'xgbregressor__colsample_bytree':[0.7, 0.8, 0.9],
    'xgbregressor__colsample_bylevel':[0.7, 0.8, 0.9]
}

# running the grid search
grid_search_xgb = GridSearchCV(xgb_tuned, param_grid, scoring=r2_score, cv=3, n_jobs=-1)
grid_search_xgb = grid_search_xgb.fit(X_train, y_train)

# printing the best combination of parameters
print(f"Best parameters for XGBoost: {grid_search_xgb.best_params_}")
xgb_tuned = grid_search_xgb.best_estimator_

# calculating the training metric
xgb_tuned_model_train_perf = model_performance_regression(xgb_tuned, X_train, y_train)
print("Training performance \n", xgb_tuned_model_train_perf)

# calculating the testing metric
xgb_tuned_model_test_perf = model_performance_regression(xgb_tuned, X_test, y_test)
print("Testing performance \n", xgb_tuned_model_test_perf)

# calculating the training model performance comparison
models_train_comp_df = pd.concat(
    [
        rf_tuned_model_train_perf.T,
        xgb_tuned_model_train_perf.T
    ],
    axis=1,
)
models_train_comp_df.columns = ['Random Forest', 'XGBoost']
print('Training performance comparison:')
models_train_comp_df

# calculating the training model performance comparison
models_test_comp_df = pd.concat(
    [
        rf_tuned_model_test_perf.T,
        xgb_tuned_model_test_perf.T
    ],
    axis=1,
)
models_test_comp_df.columns = ['Random Forest', 'XGBoost']
print('Testing performance comparison:')
models_test_comp_df

# calculating the difference in the training model performance comparison
(models_train_comp_df - models_test_comp_df).iloc[2]

# create a folder to store the files that will be used for the backend server deployment
import os
os.makedirs("backend_files", exist_ok=True)

# define the file path to save (serialize) the trained regression model
model_path = "backend_files/sales_prediction_model_v1_0.joblib"

# save the trained regression model and preprocessor using joblibe
joblib.dump(xgb_tuned, model_path)

print(f'Model saved successfully at {model_path}')

saved_model = joblib.load('backend_files/sales_prediction_model_v1_0.joblib')

print('Model loaded successfully.')

saved_model

saved_model.predict(X_test)

# import the login function from the huggingface_hub library
from huggingface_hub import login, HfApi

# import the create_repo function from the huggingface_hub library
from huggingface_hub import create_repo

# access the secret key in Python
from google.colab import userdata
secret_value = userdata.get('BE_Token')

# login to HuggingFace with access token
login(token=secret_value)

# create the repository for the HuggingFace Space
try:
    create_repo("BigGnTX/superkart_backend",
        repo_type="space",
        space_sdk="docker",
        private=False
    )
except Exception as e:
    # handle any potential errors
    if "RepositoryAlreadyExistsError" in str(e):
        print("Repository already exists. Respository not created.")
    else:
        print(f"Error: {e}")

# create the app.py file in the backend_files folder
%%writefile backend_files/app.py
import numpy as np
import joblib
import pandas as pd
from flask import Flask, request, jsonify

# initialize the flask with a name
sales_forecast_api = Flask("Sales Forecast Predictor")

# load the trained sales forecast model
model = joblib.load("sales_prediction_model_v1_0.joblib")

# define the route for the home page
@sales_forecast_api.get('/')
def home():
    return "Welcome to the Sales Forecast Prediction API!"

# define the endpoint to predict sales forecast
@sales_forecast_api.post('/v1/predict')
def predict_sales():
    # get the JSON data from the request
    predict_data = request.get_json()


    # extract relevant features from the input data.
    sample = {
        'Product_Weight': predict_data['Product_Weight'],
        'Product_Sugar_Content': predict_data['Product_Sugar_Content'],
        'Product_Allocated_Area': predict_data['Product_Allocated_Area'],
        'Product_MRP': predict_data['Product_MRP'],
        'Store_Size': predict_data['Store_Size'],
        'Store_Location_City_Type': predict_data['Store_Location_City_Type'],
        'Store_Type': predict_data['Store_Type'],
        'Store_Years_In_Operation': predict_data['Store_Years_In_Operation'],
        'Product_Code': predict_data['Product_Code'],
        'Product_Category': predict_data['Product_Category']

    }

    # convert the extracted data into a DataFrame
    input_data = pd.DataFrame([sample])

    # make a sales forecast prediction using the trained model
    prediction = model.predict(input_data).tolist()[0]

    # return the prediction as a JSON response
    return jsonify({'Sales': prediction})

# Run the Flask app in debug mode
if __name__ == '__main__':
    sales_forecast_api.run(debug=True)

# create the requirements.txt file in the backend_files folder
%%writefile backend_files/requirements.txt
pandas==2.2.2
numpy==2.0.2
scikit-learn==1.6.1
seaborn==0.13.2
joblib==1.4.2
xgboost==2.1.4
Werkzeug==2.2.2
flask==2.2.2
gunicorn==20.1.0
requests==2.32.4

# create the Dockerfile in the backend_files folder
%%writefile backend_files/Dockerfile
FROM python:3.9-slim

# Set the working directory inside the container
WORKDIR /app

# Copy all files from the current directory to the container's working directory
COPY . .

# Install dependencies from the requirements file without using cache to reduce image size
RUN pip install --no-cache-dir --upgrade -r requirements.txt

# Define the command to start the application using Gunicorn with 4 worker processes
# - `-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:app`: Runs the Flask app (assuming `app.py` contains the Flask instance named `app`)
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:7860", "app:sales_forecast_api"]

# for hugging face space authentication to upload files
from huggingface_hub import HfApi

repo_id = "BigGnTX/superkart_backend"

# initialize the API
api = HfApi()

# upload Streamlit app files stored in the folder called backend_files
api.upload_folder(
    folder_path="backend_files",
    repo_id=repo_id,
    repo_type="space"
)

# Create a folder for storing the files needed for frontend UI deployment
os.makedirs('frontend_files', exist_ok=True)

#create the app.py file in the frontend_files folder
%%writefile frontend_files/app.py
import requests
import streamlit as st
import pandas as pd

st.title('Sales Forecast Prediction')

# input fields for store and product data
Product_Weight = st.slider('Product Weight', min_value=0.0, max_value=30.0, value=12.66)
Product_Sugar_Content = st.selectbox('Product Sugar Content', ['Low Sugar', 'Regular', 'No Sugar'])
Product_Allocated_Area = st.slider('Product Allocated Area', min_value=0.0, max_value=1.0, value = 0.027)
Product_MRP = st.slider('Product MRP', min_value=0.0, max_value=300.0, value = 117.08)
Store_Size = st.selectbox('Store Size', ['Small', 'Medium', 'High'])
Store_Location_City_Type = st.selectbox('Store Location City Type', ['Tier 1', 'Tier 2', 'Tier 3'])
Store_Type = st.selectbox('Store Type', ['Supermarket Type 1', 'Supermarket Type 2', 'Departmental Store', 'Food Mart'])
Store_Years_In_Operation = st.slider('Store Years In Operation', min_value=1, max_value=50, value = 20)
Product_Code = st.selectbox('Product Code', ['FD', 'NC', 'DR'])
Product_Category = st.selectbox('Product Category', ['Food', 'Non Food'])

# converting user input into a DataFrame
forecast_data = {
    'Product_Weight': Product_Weight,
    'Product_Sugar_Content': Product_Sugar_Content,
    'Product_Allocated_Area': Product_Allocated_Area,
    'Product_MRP': Product_MRP,
    'Store_Size': Store_Size,
    'Store_Location_City_Type': Store_Location_City_Type,
    'Store_Type': Store_Type,
    'Store_Years_In_Operation': Store_Years_In_Operation,
    'Product_Code': Product_Code,
    'Product_Category': Product_Category
}

# making prediction when the "Predict" button is clicked
if st.button('Predict', type='primary'):
  response = requests.post('https://biggntx-superkart-backend.hf.space/v1/predict', json=forecast_data)
  if response.status_code == 200:
    result = response.json()
    sales_prediction = result['Sales']
    st.write(f'The Predicted Product Store Sales Total is: ${sales_prediction:.2f}.')
  else:
    st.error(f"Error in API request: Status code {response.status_code}\n{response.text}")

#create the requirements.txt file in the frontend_files folder
%%writefile frontend_files/requirements.txt
pandas==2.2.2
requests==2.32.4
streamlit==1.45.0

#create a Dockerfile in the frontend_files folder
%%writefile frontend_files/Dockerfile
# Use a minimal base image with Python 3.9 installed
FROM python:3.9-slim

# set the working directory inside the container to /app
WORKDIR /app

# copy all files from the current directory on the host to the container's /app directory
COPY . .

# install Python dependencies listed in requirements.txt
RUN pip3 install -r requirements.txt

# define the command to run the Streamlit app on port 8501 and make it accessible externally
CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0", "--server.enableXsrfProtection=false"]

# NOTE: Disable XSRF protection for easier external access in order to make batch predictions

# setting access key and repo_id of the front end HuggingFace app
# access the front end forecast at https://huggingface.co/spaces/BigGnTX/superkart_forecast
repo_id = "BigGnTX/superkart_forecast"
access_key = "HF_Token"


# login to HuggingFace with access token
login(token=access_key)

# initialize the API
api = HfApi()

# uploading Streamlit app files stored in the folder called frontend_files
api.upload_folder(
    folder_path='/content/frontend_files',
    repo_id=repo_id,
    repo_type='space',
)