Update app.py

app.py

@@ -4,20 +4,7 @@ import pandas as pd
 from werkzeug.utils import secure_filename
 from joblib import load
 import numpy as np
-from sklearn.preprocessing import OneHotEncoder, LabelEncoder
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import StandardScaler
-from sklearn.decomposition import PCA
-from sklearn.pipeline import Pipeline
-from sklearn.tree import DecisionTreeRegressor
-from sklearn.ensemble import RandomForestRegressor
-from sklearn.linear_model import LinearRegression
-from xgboost import XGBRegressor
-from sklearn.neighbors import KNeighborsRegressor
-from sklearn.model_selection import cross_val_score
-from sklearn.metrics import mean_squared_error
-from sklearn import metrics
-from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.preprocessing import LabelEncoder
 from time import time
 
 app = Flask(__name__)
@@ -29,62 +16,75 @@ app.secret_key = os.urandom(24)
 UPLOAD_FOLDER = "uploads/"
 DATA_FOLDER = "data/"
 
-# Define the model directory (ensuring correct path formatting)
-MODEL_DIR = r"./Model"
-LABEL_ENOCDER_DIR = r'./Label_encoders'
+# Define the model directory and label encoder directory
+MODEL_DIR = r'.\Model'
+LABEL_ENOCDER_DIR = r'.\Label_encoders'
 
-# Define the output file path
-PRED_OUTPUT_FILE = "./data/pred_output.csv"
-CLASS_OUTPUT_FILE = "./data/class_output.csv"
+# Global file names for outputs; these will be updated per prediction.
+PRED_OUTPUT_FILE = "data/pred_output.csv"
+CLASS_OUTPUT_FILE = "data/class_output.csv"
 
 ALLOWED_EXTENSIONS = {'csv', 'xlsx'}
 
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-app.config['DATA_FOLDER'] = DATA_FOLDER
-
-# Ensure the upload folder exists
 os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-os.makedirs(app.config['DATA_FOLDER'], exist_ok=True)
-
-# Load models using os.path.join for better cross-platform compatibility
 
-# linear_regression_model
+# ------------------------------
+# Load Models and Label Encoders
+# ------------------------------
+# (Loading models code remains unchanged)
 gia_model = load(os.path.join(MODEL_DIR, 'linear_regression_model_gia_price.joblib'))
 grade_model = load(os.path.join(MODEL_DIR, 'linear_regression_model_grade_price.joblib'))
 bygrade_model = load(os.path.join(MODEL_DIR, 'linear_regression_model_bygrade_price.joblib'))
 makable_model = load(os.path.join(MODEL_DIR, 'linear_regression_model_makable_price.joblib'))
 
-# classifier_model
 col_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_col.joblib'))
 cts_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_cts.joblib'))
 cut_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_cut.joblib'))
 qua_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_qua.joblib'))
 shp_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_shp.joblib'))
 
-# print("===================================models==================================")
-# print(gia_model)
-# print(grade_model)  
-# print(bygrade_model)
-# print(makable_model)
+blk_eng_to_mkbl_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_mkbl_blk.joblib'))
+wht_eng_to_mkbl_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_mkbl_wht.joblib'))
+open_eng_to_mkbl_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_mkbl_open.joblib'))
+pav_eng_to_mkbl_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_mkbl_pav.joblib'))
+blk_eng_to_grade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_grade_blk.joblib'))
+wht_eng_to_grade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_grade_wht.joblib'))
+open_eng_to_grade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_grade_open.joblib'))
+pav_eng_to_grade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_grade_pav.joblib'))
+blk_eng_to_bygrade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_bygrade_blk.joblib'))
+wht_eng_to_bygrade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_bygrade_wht.joblib'))
+open_eng_to_bygrade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_bygrade_open.joblib'))
+pav_eng_to_bygrade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_bygrade_pav.joblib'))
+blk_eng_to_gia_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_gia_blk.joblib'))
+wht_eng_to_gia_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_gia_wht.joblib'))
+open_eng_to_gia_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_gia_open.joblib'))
+pav_eng_to_gia_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_gia_pav.joblib'))
+
+encoder_list = ['Tag', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol', 'EngSym', 'EngFlo',
+                'EngNts', 'EngMikly', 'EngLab','EngBlk', 'EngWht', 'EngOpen','EngPav',
+                'Change_cts_value', 'Change_shape_value', 'Change_quality_value', 'Change_color_value',
+                'Change_cut_value', 'Change_Blk_Eng_to_Mkbl_value', 'Change_Wht_Eng_to_Mkbl_value',
+                'Change_Open_Eng_to_Mkbl_value', 'Change_Pav_Eng_to_Mkbl_value', 'Change_Blk_Eng_to_Grd_value',
+                'Change_Wht_Eng_to_Grd_value', 'Change_Open_Eng_to_Grd_value', 'Change_Pav_Eng_to_Grd_value',
+                'Change_Blk_Eng_to_ByGrd_value', 'Change_Wht_Eng_to_ByGrd_value', 'Change_Open_Eng_to_ByGrd_value',
+                'Change_Pav_Eng_to_ByGrd_value', 'Change_Blk_Eng_to_Gia_value', 'Change_Wht_Eng_to_Gia_value',
+                'Change_Open_Eng_to_Gia_value', 'Change_Pav_Eng_to_Gia_value']
 
-# Load label encoders
-encoder_list = ['Tag', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol', 'EngSym', 'EngFlo', 'EngNts', 'EngMikly', 'EngLab',
-                'Change_cts_value', 'Change_shape_value', 'Change_quality_value', 'Change_color_value', 'Change_cut_value']
-#loaded_label_encoder = {val: load(f"./Label_encoders/label_encoder_{val}.joblib") for val in encoder_list}
 loaded_label_encoder = {}
 for val in encoder_list:
-    #encoder_path = f"H:/DEV PATEL/2025/AI_In_Diamond_Industry/Label_encoders/label_encoder_{val}.joblib"
     encoder_path = os.path.join(LABEL_ENOCDER_DIR, f"label_encoder_{val}.joblib")
     loaded_label_encoder[val] = load(encoder_path)
-    
-# print(loaded_label_encoder)
-
-# Ensure upload folder exists
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 
+# ------------------------------
+# Utility: Allowed File Check
+# ------------------------------
 def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
+# ------------------------------
+# Routes
+# ------------------------------
 @app.route('/')
 def index():
     return render_template('index.html')
@@ -105,181 +105,175 @@ def predict():
         filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
         file.save(filepath)
         
-        # Convert to DataFrame
+        # Convert file to DataFrame
         if filename.endswith('.csv'):
             df = pd.read_csv(filepath)
         else:
             df = pd.read_excel(filepath)
         
-        # Preprocess DataFrame
-        print("===================================process_dataframe=0==================================")
-        df,dx = process_dataframe(df)
-        print("===================================process_dataframe=5==================================")
-        return render_template('output.html', df=df.to_html(), dx=dx.to_html())
+        # Process the DataFrame and generate predictions and classification analysis.
+        df_pred, dx_class = process_dataframe(df)
+        
+        # Save output files with a timestamp (you can also store in session if needed)
+        current_date = pd.Timestamp.now().strftime("%Y-%m-%d")
+        global PRED_OUTPUT_FILE, CLASS_OUTPUT_FILE
+        PRED_OUTPUT_FILE = f'data/prediction_output_{current_date}.csv'
+        CLASS_OUTPUT_FILE = f'data/classification_output_{current_date}.csv'
+        df_pred.to_csv(PRED_OUTPUT_FILE, index=False)
+        dx_class.to_csv(CLASS_OUTPUT_FILE, index=False)
+        
+        # Redirect to report view; default to prediction report, page 1.
+        return redirect(url_for('report_view', report_type='pred', page=1))
     else:
         flash('Invalid file type. Only CSV and Excel files are allowed.', 'error')
-        print('Invalid file type. Only CSV and Excel files are allowed.')
         return redirect(request.url)
 
 def process_dataframe(df):
     try:
-        print("===================================process_dataframe=1==================================")
-        # 'EngLab' is not in the required columns
-        required_columns = ['Tag', 'EngCts', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol',
-                            'EngSym', 'EngFlo', 'EngNts', 'EngMikly', 'EngAmt']
-        
-        # for prediction
-        df = df[required_columns]
-        df = df.copy()
-        # for classification
+        # Define the columns needed for two parts
+        required_columns = ['Tag', 'EngCts', 'EngShp', 'EngQua', 'EngCol', 'EngCut',
+                            'EngPol', 'EngSym', 'EngFlo', 'EngNts', 'EngMikly', 'EngAmt']
+        required_columns_2 = required_columns + ['EngBlk', 'EngWht', 'EngOpen', 'EngPav']
         
+        # Create two DataFrames: one for prediction and one for classification.
+        df_pred = df[required_columns].copy()
+        df_class = df[required_columns_2].fillna("NA").copy()
         
-        # df[col] = df[col].map(lambda x: loaded_label_encoder[col].transform([x])[0] if x in loaded_label_encoder[col].classes_ else np.nan)
-
-        # Transform categorical features using loaded label encoders
-        df["Tag"] = loaded_label_encoder['Tag'].transform(df["Tag"])
-        df["EngShp"] = loaded_label_encoder['EngShp'].transform(df["EngShp"]) 
-        df["EngQua"] = loaded_label_encoder['EngQua'].transform(df["EngQua"])
-        df["EngCol"] = loaded_label_encoder['EngCol'].transform(df["EngCol"])
-        df["EngCut"] = loaded_label_encoder['EngCut'].transform(df["EngCut"])
-        df["EngPol"] = loaded_label_encoder['EngPol'].transform(df["EngPol"])
-        df["EngSym"] = loaded_label_encoder['EngSym'].transform(df["EngSym"])
-        df["EngFlo"] = loaded_label_encoder['EngFlo'].transform(df["EngFlo"])
-        df["EngNts"] = loaded_label_encoder['EngNts'].transform(df["EngNts"])
-        df["EngMikly"] = loaded_label_encoder['EngMikly'].transform(df["EngMikly"])
-        #EngLab = loaded_label_encoder['EngLab'].transform(df[EngLab])
-        
-        df=df.astype(float)
-        print(df.head())  
-          
-        dx = df.copy()
+        # Transform categorical columns for prediction DataFrame using the label encoders.
+        for col in ['Tag', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol', 'EngSym', 'EngFlo', 'EngNts', 'EngMikly']:
+            df_pred[col] = loaded_label_encoder[col].transform(df_pred[col])
         
-        print(df.columns)
-        x= df.copy()
+        # Update the classification DataFrame with the transformed prediction columns.
+        for col in ['Tag', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol', 'EngSym', 'EngFlo', 'EngNts', 'EngMikly']:
+            df_class[col] = df_pred[col]
         
-        # print("Model expects", gia_model.n_features_in_, "features.")
-        # print("X_features shape:", x.shape)
+        # Transform the extra columns in the classification DataFrame.
+        for col in ['EngBlk', 'EngWht', 'EngOpen', 'EngPav']:
+            df_class[col] = loaded_label_encoder[col].transform(df_class[col])
         
-        print("===================================process_dataframe=2==================================")
+        # Convert both DataFrames to float (or handle as needed).
+        df_pred = df_pred.astype(float)
+        df_class = df_class.astype(float)
         
-        # ================================================================================================
-        # Prediction report
-        # ================================================================================================
+        # -------------------------
+        # Prediction Report Section
+        # -------------------------
+        # Use the prediction DataFrame for price predictions.
+        x = df_pred.copy()
+        df_pred['GIA_Predicted'] = gia_model.predict(x)
+        df_pred['Grade_Predicted'] = grade_model.predict(x)
+        df_pred['ByGrade_Predicted'] = bygrade_model.predict(x)
+        df_pred['Makable_Predicted'] = makable_model.predict(x)
+        df_pred['GIA_Diff'] = df_pred['EngAmt'] - df_pred['GIA_Predicted']
+        df_pred['Grade_Diff'] = df_pred['EngAmt'] - df_pred['Grade_Predicted']
+        df_pred['ByGrade_Diff'] = df_pred['EngAmt'] - df_pred['ByGrade_Predicted']
+        df_pred['Makable_Diff'] = df_pred['EngAmt'] - df_pred['Makable_Predicted']
         
-        # Predict prices
-        df['GIA_Predicted'] = gia_model.predict(x)
-        df['Grade_Predicted'] = grade_model.predict(x)
-        df['ByGrade_Predicted'] = bygrade_model.predict(x)
-        df['Makable_Predicted'] = makable_model.predict(x)
-                            
-        
-        # Compute differences
-        df['GIA_Diff'] = df['EngAmt'] - df['GIA_Predicted']
-        df['Grade_Diff'] = df['EngAmt'] - df['Grade_Predicted']
-        df['ByGrade_Diff'] = df['EngAmt'] - df['ByGrade_Predicted']
-        df['Makable_Diff'] = df['EngAmt'] - df['Makable_Predicted']
-        
-        print(df.head())
-        
-        predictions = df.to_dict(orient='records')
-        analysis = df.describe().to_html()
-        #print(analysis)
-        #print(predictions)
-        print("===================================process_dataframe=3==================================")
-        
-        # ================================================================================================
-        # Classification report
-        # ================================================================================================      
-                      
+        # -------------------------
+        # Classification Report Section
+        # -------------------------
+        # For classification, use df_class (which has extra columns).
+        x2 = df_class.copy()
+        dx = df_pred.copy()  # Start with the prediction data.
         dx['col_change'] = col_model.predict(x)
         dx['cts_change'] = cts_model.predict(x)
         dx['cut_change'] = cut_model.predict(x)
         dx['qua_change'] = qua_model.predict(x)
         dx['shp_change'] = shp_model.predict(x)
+        dx['Change_Blk_Eng_to_Mkbl_value'] = blk_eng_to_mkbl_model.predict(x2)
+        dx['Change_Wht_Eng_to_Mkbl_value'] = wht_eng_to_mkbl_model.predict(x2)
+        dx['Change_Open_Eng_to_Mkbl_value'] = open_eng_to_mkbl_model.predict(x2)
+        dx['Change_Pav_Eng_to_Mkbl_value'] = pav_eng_to_mkbl_model.predict(x2)
+        dx['Change_Blk_Eng_to_Grd_value'] = blk_eng_to_grade_model.predict(x2)
+        dx['Change_Wht_Eng_to_Grd_value'] = wht_eng_to_grade_model.predict(x2)
+        dx['Change_Open_Eng_to_Grd_value'] = open_eng_to_grade_model.predict(x2)
+        dx['Change_Pav_Eng_to_Grd_value'] = pav_eng_to_grade_model.predict(x2)
+        dx['Change_Blk_Eng_to_ByGrd_value'] = blk_eng_to_bygrade_model.predict(x2)
+        dx['Change_Wht_Eng_to_ByGrd_value'] = wht_eng_to_bygrade_model.predict(x2)
+        dx['Change_Open_Eng_to_ByGrd_value'] = open_eng_to_bygrade_model.predict(x2)
+        dx['Change_Pav_Eng_to_ByGrd_value'] = pav_eng_to_bygrade_model.predict(x2)
+        dx['Change_Blk_Eng_to_Gia_value'] = blk_eng_to_gia_model.predict(x2)
+        dx['Change_Wht_Eng_to_Gia_value'] = wht_eng_to_gia_model.predict(x2)
+        dx['Change_Open_Eng_to_Gia_value'] = open_eng_to_gia_model.predict(x2)
+        dx['Change_Pav_Eng_to_Gia_value'] = pav_eng_to_gia_model.predict(x2)
         
-        # Inverse transform the predictions
+        # Inverse transform classification predictions.
         dx['col_change'] = loaded_label_encoder['Change_color_value'].inverse_transform(dx['col_change'])
         dx['cts_change'] = loaded_label_encoder['Change_cts_value'].inverse_transform(dx['cts_change'])
         dx['cut_change'] = loaded_label_encoder['Change_cut_value'].inverse_transform(dx['cut_change'])
         dx['qua_change'] = loaded_label_encoder['Change_quality_value'].inverse_transform(dx['qua_change'])
-        dx['shp_change'] = loaded_label_encoder['Change_shape_value'].inverse_transform(dx['shp_change'])   
-        
-        print(dx.head())     
-        
-        print("===================================process_dataframe=4==================================")
-        
-        # Save output file with date and time
-        time = str(pd.Timestamp.now().strftime("%Y-%m-%d"))
-        
-        #saving the output file
-        global PRED_OUTPUT_FILE
-        PRED_OUTPUT_FILE = f'data/prediction_output_{time}.csv'
-        df.to_csv(PRED_OUTPUT_FILE, index=False)
-        
-        #saving the output file
-        global CLASS_OUTPUT_FILE
-        CLASS_OUTPUT_FILE = f'data/classification_output_{time}.csv'
-        dx.to_csv(CLASS_OUTPUT_FILE, index=False)
+        dx['shp_change'] = loaded_label_encoder['Change_shape_value'].inverse_transform(dx['shp_change'])
+        dx['Change_Blk_Eng_to_Mkbl_value'] = loaded_label_encoder['Change_Blk_Eng_to_Mkbl_value'].inverse_transform(dx['Change_Blk_Eng_to_Mkbl_value'])
+        dx['Change_Wht_Eng_to_Mkbl_value'] = loaded_label_encoder['Change_Wht_Eng_to_Mkbl_value'].inverse_transform(dx['Change_Wht_Eng_to_Mkbl_value'])
+        dx['Change_Open_Eng_to_Mkbl_value'] = loaded_label_encoder['Change_Open_Eng_to_Mkbl_value'].inverse_transform(dx['Change_Open_Eng_to_Mkbl_value'])
+        dx['Change_Pav_Eng_to_Mkbl_value'] = loaded_label_encoder['Change_Pav_Eng_to_Mkbl_value'].inverse_transform(dx['Change_Pav_Eng_to_Mkbl_value'])
+        dx['Change_Blk_Eng_to_Grd_value'] = loaded_label_encoder['Change_Blk_Eng_to_Grd_value'].inverse_transform(dx['Change_Blk_Eng_to_Grd_value'])
+        dx['Change_Wht_Eng_to_Grd_value'] = loaded_label_encoder['Change_Wht_Eng_to_Grd_value'].inverse_transform(dx['Change_Wht_Eng_to_Grd_value'])
+        dx['Change_Open_Eng_to_Grd_value'] = loaded_label_encoder['Change_Open_Eng_to_Grd_value'].inverse_transform(dx['Change_Open_Eng_to_Grd_value'])
+        dx['Change_Pav_Eng_to_Grd_value'] = loaded_label_encoder['Change_Pav_Eng_to_Grd_value'].inverse_transform(dx['Change_Pav_Eng_to_Grd_value'])
+        dx['Change_Blk_Eng_to_ByGrd_value'] = loaded_label_encoder['Change_Blk_Eng_to_ByGrd_value'].inverse_transform(dx['Change_Blk_Eng_to_ByGrd_value'])
+        dx['Change_Wht_Eng_to_ByGrd_value'] = loaded_label_encoder['Change_Wht_Eng_to_ByGrd_value'].inverse_transform(dx['Change_Wht_Eng_to_ByGrd_value'])
+        dx['Change_Open_Eng_to_ByGrd_value'] = loaded_label_encoder['Change_Open_Eng_to_ByGrd_value'].inverse_transform(dx['Change_Open_Eng_to_ByGrd_value'])
+        dx['Change_Pav_Eng_to_ByGrd_value'] = loaded_label_encoder['Change_Pav_Eng_to_ByGrd_value'].inverse_transform(dx['Change_Pav_Eng_to_ByGrd_value'])
+        dx['Change_Blk_Eng_to_Gia_value'] = loaded_label_encoder['Change_Blk_Eng_to_Gia_value'].inverse_transform(dx['Change_Blk_Eng_to_Gia_value'])
+        dx['Change_Wht_Eng_to_Gia_value'] = loaded_label_encoder['Change_Wht_Eng_to_Gia_value'].inverse_transform(dx['Change_Wht_Eng_to_Gia_value'])
+        dx['Change_Open_Eng_to_Gia_value'] = loaded_label_encoder['Change_Open_Eng_to_Gia_value'].inverse_transform(dx['Change_Open_Eng_to_Gia_value'])
+        dx['Change_Pav_Eng_to_Gia_value'] = loaded_label_encoder['Change_Pav_Eng_to_Gia_value'].inverse_transform(dx['Change_Pav_Eng_to_Gia_value'])
         
-        print("===================================Output file saved as output.csv===================================")
-        
-        return df.head(), dx.head()
+        return df_pred, dx.head(len(df_pred))  # Return full DataFrames for pagination later.
     except Exception as e:
-        print(f'Error processing file: {e}')
         flash(f'Error processing file: {e}', 'error')
         return pd.DataFrame(), pd.DataFrame()
-    
-def classification_report(df):
-    try:
-        classifcation_data = df[["EngGraphCts","EngCts","EngShp","EngQua","EngCol","EngCut","EngPol","EngSym","EngFlo","EngNts","EngMikly","EngLab","EngAmt",
-                                 "MkblCts","MkblShp","MkblQua","MkblCol","MkblCut","MkblPol","MkblSym","MkblFlo","MkblNts","MkblMikly","MkblLab","MkblAmt"]] 
-        
-        # Make predictions
-        classifcation_data["Cts_diff_eng_mkbl"] = round(classifcation_data["EngCts"] - classifcation_data["MkblCts"],2)
 
-        # Create a new column 'Change_Label' based on the values in 'Cts_diff_eng_mkbl'
-        classifcation_data['Change_cts_value'] = classifcation_data['Cts_diff_eng_mkbl'].apply(
-            lambda x: str(x)+' negative change' if x < 0 else (str(x)+' positive change' if x > 0 else 'no change')
-        )
-        
-        # Create a new column 'Shape_Change' based on the values in 'EngShp' and 'MkblShp'
-        classifcation_data['Change_shape_value'] = classifcation_data.apply(
-            lambda row: str(row['EngShp'])+' to '+str(row['MkblShp'])+' shape change' if row['EngShp'] != row['MkblShp'] else 'shape not change', axis=1
-        )
-        
-        # Create a new column 'quality_Change' based on the values in 'EngQua' and 'MkblQua'
-        classifcation_data['Change_quality_value'] = classifcation_data.apply(
-            lambda row: str(row['EngQua'])+' to '+str(row['MkblQua'])+' quality change' if row['EngQua'] != row['MkblQua'] else 'quality not change', axis=1
-        )
-        
-        # Create a new column 'color_Change' based on the values in 'EngCol' and 'MkblCol'
-        classifcation_data['Change_color_value'] = classifcation_data.apply(
-            lambda row: str(row['EngCol'])+' to '+str(row['MkblCol'])+' color change' if row['EngCol'] != row['MkblCol'] else 'color not change', axis=1
-        )
-        
-        # Create a new column 'cut_Change' based on the values in 'EngCut' and 'MkblCut'
-        classifcation_data['Change_cut_value'] = classifcation_data.apply(
-            lambda row: str(row['EngCut'])+' to '+str(row['MkblCut'])+' cut change' if row['EngCut'] != row['MkblCut'] else 'cut not change', axis=1
-        )
-        
-        # Generate classification report
-        
-        
-        return classifcation_data
-    except Exception as e:
-        flash(f'Error generating classification report: {e}', 'error')
-        print(f'Error generating classification report: {e}')
-        return None
+# ------------------------------
+# Report View Route with Pagination & Toggle
+# ------------------------------
+@app.route('/report')
+def report_view():
+    # Get query parameters: report_type (pred or class) and page number.
+    report_type = request.args.get('report_type', 'pred')
+    try:
+        page = int(request.args.get('page', 1))
+    except ValueError:
+        page = 1
+    per_page = 15  # records per page
+    
+    # Read the appropriate CSV file.
+    if report_type == 'pred':
+        df = pd.read_csv(PRED_OUTPUT_FILE)
+    else:
+        df = pd.read_csv(CLASS_OUTPUT_FILE)
     
+    # Calculate pagination indices.
+    start_idx = (page - 1) * per_page
+    end_idx = start_idx + per_page
+    total_records = len(df)
+    
+    # Slice the DataFrame for the current page.
+    df_page = df.iloc[start_idx:end_idx]
+    table_html = df_page.to_html(classes="data-table", index=False)
+    
+    # Determine if previous/next pages exist.
+    has_prev = page > 1
+    has_next = end_idx < total_records
+    
+    return render_template('output.html',
+                           table_html=table_html,
+                           report_type=report_type,
+                           page=page,
+                           has_prev=has_prev,
+                           has_next=has_next)
+
+# ------------------------------
+# Download Routes (remain unchanged)
+# ------------------------------
 @app.route('/download_pred', methods=['GET'])
 def download_pred():
-    """Serve the output.csv file for download."""
-    return send_file(PRED_OUTPUT_FILE, as_attachment=True)  
+    return send_file(PRED_OUTPUT_FILE, as_attachment=True)
 
 @app.route('/download_class', methods=['GET'])
 def download_class():
-    """Serve the output.csv file for download."""
-    return send_file(CLASS_OUTPUT_FILE, as_attachment=True)   
+    return send_file(CLASS_OUTPUT_FILE, as_attachment=True)
 
 if __name__ == "__main__":
-    app.run(debug=True)
+    app.run(debug=True)