Update modules/supply_failure.py

modules/supply_failure.py

@@ -1,12 +1,6 @@
-from flask import Blueprint, render_template, request, jsonify, redirect, url_for, flash, session
+from flask import Blueprint, render_template, request, jsonify, redirect, url_for, flash
 import pandas as pd
 import numpy as np
-import plotly.express as px
-import plotly.utils
-import json
-import os
-import joblib
-from datetime import datetime
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler, LabelEncoder
 from sklearn.ensemble import RandomForestClassifier
@@ -15,20 +9,18 @@ import random
 
 supply_failure_bp = Blueprint('supply_failure', __name__, url_prefix='/predict/supply_failure')
 
-UPLOAD_FOLDER = 'temp_uploads'
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+# --- Global variables for supply module (simple logic) ---
+_current_df_supply = None
+_model_supply = None
+_scaler_supply = None
+_encoders_supply = None
+_feature_names_supply = None
+_original_cols_supply = None
+_target_col_supply = 'failure_flag' # This is fixed for the supply module
 
-def get_current_df_supply():
-    try:
-        csv_path = session.get('supply_csv_path')
-        if csv_path and os.path.exists(csv_path):
-            return pd.read_csv(csv_path)
-        return None
-    except Exception as e:
-        print(f"Error in get_current_df_supply: {str(e)}")
-        return None
 
 def get_summary_stats_supply(df):
+    """Helper function to get summary statistics."""
     return {
         'total_rows': len(df),
         'total_columns': len(df.columns),
@@ -39,76 +31,50 @@ def get_summary_stats_supply(df):
     }
 
 def preprocess_data_supply(df, for_prediction=False, label_encoders=None):
+    """Helper function to preprocess supply chain data."""
     df_processed = df.copy()
-
-    # Identify date columns based on known names
-    date_cols = ['order_date', 'promised_delivery_date', 'actual_delivery_date']
     
-    # Process date columns: extract features and drop original
+    date_cols = ['order_date', 'promised_delivery_date', 'actual_delivery_date']
+    categorical_columns = [col for col in df_processed.columns if df_processed[col].dtype == 'object' and col not in date_cols]
+
     for col in date_cols:
         if col in df_processed.columns:
-            # Convert to datetime, coercing errors to NaT
             df_processed[col] = pd.to_datetime(df_processed[col], errors='coerce')
-            
-            # Extract features only if there are valid datetime values
-            if not df_processed[col].isnull().all():
-                df_processed[f'{col}_day_of_week'] = df_processed[col].dt.dayofweek.fillna(-1) # -1 for NaN dates
-                df_processed[f'{col}_month'] = df_processed[col].dt.month.fillna(-1)
-                df_processed[f'{col}_year'] = df_processed[col].dt.year.fillna(-1)
-                df_processed[f'{col}_day'] = df_processed[col].dt.day.fillna(-1)
-            else: # If all dates are NaT, add dummy columns filled with -1
-                df_processed[f'{col}_day_of_week'] = -1
-                df_processed[f'{col}_month'] = -1
-                df_processed[f'{col}_year'] = -1
-                df_processed[f'{col}_day'] = -1
+            df_processed[f'{col}_day_of_week'] = df_processed[col].dt.dayofweek.fillna(-1)
+            df_processed[f'{col}_month'] = df_processed[col].dt.month.fillna(-1)
             df_processed = df_processed.drop(columns=[col])
 
-    # Identify numerical and categorical columns after date processing
-    categorical_columns = []
-    numerical_columns = []
-    
-    for column in df_processed.columns:
-        if pd.api.types.is_numeric_dtype(df_processed[column]):
-            numerical_columns.append(column)
-        else:
-            try:
-                # Attempt to convert to numeric, if successful, it's numeric
-                if pd.to_numeric(df_processed[column].dropna()).notna().all():
-                    numerical_columns.append(column)
-                else:
-                    categorical_columns.append(column)
-            except ValueError:
-                categorical_columns.append(column)
-
-    # Encode categorical variables
     current_label_encoders = {}
-    if not for_prediction: # During training, fit and save encoders
+    if not for_prediction:
         for col in categorical_columns:
             if col in df_processed.columns:
                 le = LabelEncoder()
-                df_processed[col] = le.fit_transform(df_processed[col].astype(str).fillna('missing_value'))
+                df_processed[col] = le.fit_transform(df_processed[col].astype(str).fillna('missing'))
                 current_label_encoders[col] = le
-    else: # For prediction, use provided encoders
+    else:
         for col, le in label_encoders.items():
             if col in df_processed.columns:
-                df_processed[col] = df_processed[col].astype(str).apply(
-                    lambda x: le.transform([x])[0] if x in le.classes_ else -1
-                )
+                df_processed[col] = df_processed[col].astype(str).fillna('missing').apply(
+                    lambda x: le.transform([x])[0] if x in le.classes_ else -1)
     
-    # Ensure numerical columns are truly numeric and fill any NaNs
-    for col in numerical_columns:
-        if col in df_processed.columns:
-            df_processed[col] = pd.to_numeric(df_processed[col], errors='coerce').fillna(0) # Fill numerical NaNs with 0
+    # Fill any remaining NaNs in numeric columns
+    numeric_cols = df_processed.select_dtypes(include=np.number).columns
+    for col in numeric_cols:
+        df_processed[col] = df_processed[col].fillna(0) # Fill with 0 or another sensible default
 
     return df_processed, current_label_encoders
 
 
 @supply_failure_bp.route('/', methods=['GET'])
 def show_supply_failure():
+    """Renders the main page for the supply failure tool."""
     return render_template('supply_failure.html', title="Supply Failure Prediction")
 
+
 @supply_failure_bp.route('/upload_file_supply', methods=['POST'])
 def upload_file_supply():
+    """Handles file upload and displays data preview."""
+    global _current_df_supply, _original_cols_supply
     if 'supply_file' not in request.files:
         flash('No file selected')
         return redirect(url_for('supply_failure.show_supply_failure'))
@@ -119,71 +85,53 @@ def upload_file_supply():
         return redirect(url_for('supply_failure.show_supply_failure'))
 
     try:
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-        safe_filename = f"supply_data_{timestamp}.csv"
-        file_path = os.path.join(UPLOAD_FOLDER, safe_filename)
-        
-        file.save(file_path)
-        session['supply_csv_path'] = file_path
-        
-        df = pd.read_csv(file_path)
-        preview_data = df.head().to_dict('records')
-        summary_stats = get_summary_stats_supply(df)
-        session['original_columns_supply'] = df.columns.tolist()
+        _current_df_supply = pd.read_csv(file)
+        _original_cols_supply = _current_df_supply.columns.tolist()
+        preview_data = _current_df_supply.head().to_dict('records')
+        summary_stats = get_summary_stats_supply(_current_df_supply)
 
         return render_template('supply_failure.html',
                              title="Supply Failure Prediction",
                              preview_data=preview_data,
-                             columns=df.columns.tolist(),
+                             columns=_current_df_supply.columns.tolist(),
                              summary_stats=summary_stats)
-
     except Exception as e:
         flash(f'Error processing file: {str(e)}')
         return redirect(url_for('supply_failure.show_supply_failure'))
 
+
 @supply_failure_bp.route('/run_prediction', methods=['POST'])
 def run_prediction_supply():
-    try:
-        df = get_current_df_supply()
-        if df is None:
-            return jsonify({'success': False, 'error': 'No data available. Please upload a CSV file first.'})
-
-        target_col = 'failure_flag' # Fixed target column as per definition
+    """Trains the model and returns performance metrics."""
+    global _current_df_supply, _model_supply, _scaler_supply, _encoders_supply, _feature_names_supply, _target_col_supply
+    if _current_df_supply is None:
+        return jsonify({'success': False, 'error': 'No data available. Please upload a CSV file first.'})
 
-        df_processed, label_encoders = preprocess_data_supply(df.copy(), for_prediction=False)
-        
-        encoders_path = os.path.join(UPLOAD_FOLDER, f'supply_encoders_{datetime.now().strftime("%Y%m%d_%H%M%S")}.joblib')
-        joblib.dump(label_encoders, encoders_path)
-        session['supply_encoders_path'] = encoders_path
+    try:
+        df_processed, label_encoders = preprocess_data_supply(_current_df_supply.copy())
+        _encoders_supply = label_encoders
 
-        if target_col not in df_processed.columns:
-            return jsonify({'success': False, 'error': f"Target column '{target_col}' not found after preprocessing. Check if it was dropped or transformed incorrectly."})
+        if _target_col_supply not in df_processed.columns:
+            return jsonify({'success': False, 'error': f"Target column '{_target_col_supply}' not found after preprocessing."})
 
-        X = df_processed.drop(columns=[target_col])
-        y = df_processed[target_col]
+        X = df_processed.drop(columns=[_target_col_supply])
+        y = df_processed[_target_col_supply]
+        _feature_names_supply = X.columns.tolist()
 
         X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-        scaler = StandardScaler()
-        X_train_scaled = scaler.fit_transform(X_train)
-        X_test_scaled = scaler.transform(X_test)
-
-        clf = RandomForestClassifier(random_state=42)
-        clf.fit(X_train_scaled, y_train)
-        y_pred = clf.predict(X_test_scaled)
-
-        importances = clf.feature_importances_
-        feature_names = X.columns
-        feature_importance = sorted(
-            zip(feature_names, importances),
-            key=lambda x: x[1],
-            reverse=True
-        )[:5] 
-
+        
+        _scaler_supply = StandardScaler()
+        X_train_scaled = _scaler_supply.fit_transform(X_train)
+        X_test_scaled = _scaler_supply.transform(X_test)
+        
+        _model_supply = RandomForestClassifier(random_state=42)
+        _model_supply.fit(X_train_scaled, y_train)
+        y_pred = _model_supply.predict(X_test_scaled)
+        
+        importances = _model_supply.feature_importances_
+        feature_importance = sorted(zip(_feature_names_supply, importances), key=lambda x: x[1], reverse=True)[:5]
         top_features = [{'feature': f, 'importance': float(imp)} for f, imp in feature_importance]
 
-        session['supply_feature_names'] = X.columns.tolist()
-        session['supply_target_column_name'] = target_col
-
         metrics = {
             'Accuracy': accuracy_score(y_test, y_pred),
             'Precision': precision_score(y_test, y_pred, average='weighted', zero_division=0),
@@ -191,173 +139,68 @@ def run_prediction_supply():
             'F1 Score': f1_score(y_test, y_pred, average='weighted', zero_division=0)
         }
 
-        model_path = os.path.join(UPLOAD_FOLDER, f'supply_model_{datetime.now().strftime("%Y%m%d_%H%M%S")}.joblib')
-        scaler_path = os.path.join(UPLOAD_FOLDER, f'supply_scaler_{datetime.now().strftime("%Y%m%d_%H%M%S")}.joblib')
-        
-        joblib.dump(clf, model_path)
-        joblib.dump(scaler, scaler_path)
-        
-        session['supply_model_path'] = model_path
-        session['supply_scaler_path'] = scaler_path
-
-        return jsonify({
-            'success': True,
-            'metrics': metrics,
-            'top_features': top_features,
-        })
-
+        return jsonify({'success': True, 'metrics': metrics, 'top_features': top_features})
     except Exception as e:
-        print(f"Error in run_prediction_supply: {e}")
-        return jsonify({'success': False, 'error': str(e)})
+        return jsonify({'success': False, 'error': f'An error occurred: {str(e)}'})
 
 @supply_failure_bp.route('/get_form_data', methods=['GET'])
 def get_form_data_supply():
-    try:
-        df = get_current_df_supply()
-        if df is None:
-            return jsonify({'success': False, 'error': 'No data available. Please upload a file first.'})
-
-        target_col = 'failure_flag' # Fixed target column for supply chain
-        if not target_col: # Should not happen if fixed, but good for robustness
-            return jsonify({'success': False, 'error': 'Target column not found in session. Please run prediction first.'})
-
-        # Columns to exclude from the form as requested by the user
-        exclude_cols = ['delivery_delay_days', 'delivered_quantity', 'return_reason', 'delivery_status', 'failure_type', target_col, 'order_id', 'component_id', 'po_approval_delay_days', 'customs_clearance_days', 'actual_delivery_date'] 
-        
-        form_fields = []
-        for col in df.columns:
-            if col.lower() in [ec.lower() for ec in exclude_cols]:
-                continue 
-
-            default_value = None
-            if not df[col].dropna().empty:
-                if pd.api.types.is_numeric_dtype(df[col]):
-                    min_val = df[col].min()
-                    max_val = df[col].max()
-                    if pd.isna(min_val) or pd.isna(max_val):
-                         default_value = 0.0
-                    else:
-                        default_value = round(random.uniform(float(min_val), float(max_val)), 2) 
-                elif col in ['order_date', 'promised_delivery_date', 'actual_delivery_date']:
-                    sample_date = random.choice(df[col].dropna().tolist())
-                    try:
-                        parsed_date = pd.to_datetime(sample_date)
-                        if pd.isna(parsed_date):
-                             default_value = "YYYY-MM-DD HH:MM:SS"
-                        else:
-                            default_value = parsed_date.strftime('%Y-%m-%d %H:%M:%S')
-                    except Exception:
-                        default_value = "YYYY-MM-DD HH:MM:SS"
-                else: # Categorical or other types
-                    unique_vals_str = [str(x) for x in df[col].dropna().unique()]
-                    if unique_vals_str:
-                        default_value = random.choice(unique_vals_str)
-                    else:
-                        default_value = ""
-
-            if pd.api.types.is_numeric_dtype(df[col]):
-                form_fields.append({
-                    'name': col,
-                    'type': 'number',
-                    'default_value': default_value
-                })
-            elif col in ['order_date', 'promised_delivery_date', 'actual_delivery_date']:
-                 form_fields.append({
-                    'name': col,
-                    'type': 'text',
-                    'placeholder': 'YYYY-MM-DD HH:MM:SS',
-                    'default_value': default_value
-                })
-            else: # Categorical
-                unique_values = [str(x) for x in df[col].dropna().unique().tolist()]
-                form_fields.append({
-                    'name': col,
-                    'type': 'select',
-                    'options': unique_values,
-                    'default_value': default_value
-                })
-                
-        return jsonify({'success': True, 'form_fields': form_fields})
-
-    except Exception as e:
-        print(f"Error in get_form_data_supply: {e}")
-        return jsonify({'success': False, 'error': str(e)})
+    """Generates the fields for the single prediction form."""
+    if _current_df_supply is None:
+        return jsonify({'success': False, 'error': 'No data available. Please upload a file first.'})
+
+    df = _current_df_supply
+    exclude_cols = [
+        'delivery_delay_days', 'delivered_quantity', 'return_reason', 
+        'delivery_status', 'failure_type', _target_col_supply, 'order_id', 
+        'component_id', 'po_approval_delay_days', 'customs_clearance_days', 
+        'actual_delivery_date'
+    ]
+    form_fields = []
+    
+    for col in df.columns:
+        if col.lower() in [ec.lower() for ec in exclude_cols]:
+            continue
+
+        field_info = {'name': col}
+        if pd.api.types.is_numeric_dtype(df[col]):
+            field_info['type'] = 'number'
+            field_info['default_value'] = round(df[col].mean(), 2) if not df[col].empty else 0
+        elif col in ['order_date', 'promised_delivery_date']:
+            field_info['type'] = 'text'
+            field_info['placeholder'] = 'YYYY-MM-DD'
+            field_info['default_value'] = pd.to_datetime(df[col].mode()[0]).strftime('%Y-%m-%d') if not df[col].mode().empty else ''
+        else:
+            field_info['type'] = 'select'
+            field_info['options'] = [str(x) for x in df[col].dropna().unique().tolist()]
+            field_info['default_value'] = df[col].mode()[0] if not df[col].mode().empty else ''
+        form_fields.append(field_info)
+            
+    return jsonify({'success': True, 'form_fields': form_fields})
 
 
 @supply_failure_bp.route('/predict_single', methods=['POST'])
 def predict_single_supply():
+    """Makes a prediction for a single instance of data."""
+    if not all([_model_supply, _scaler_supply, _encoders_supply, _feature_names_supply, _original_cols_supply]):
+        return jsonify({'success': False, 'error': 'Model or configuration not ready. Please run a prediction first.'})
+
     try:
-        model_path = session.get('supply_model_path')
-        scaler_path = session.get('supply_scaler_path')
-        encoders_path = session.get('supply_encoders_path')
-        feature_names = session.get('supply_feature_names')
-        target_col = session.get('supply_target_column_name')
-        original_uploaded_columns = session.get('original_columns_supply')
-        
-        if not all([model_path, scaler_path, encoders_path, feature_names, target_col, original_uploaded_columns]):
-            return jsonify({'success': False, 'error': 'Model or preprocessing artifacts not found for supply chain. Please train a model first.'})
-        
-        model = joblib.load(model_path)
-        scaler = joblib.load(scaler_path)
-        label_encoders = joblib.load(encoders_path)
-        
         input_data = request.json
-        if not input_data:
-            return jsonify({'success': False, 'error': 'No input data provided.'})
-
-        full_input_df = pd.DataFrame(columns=original_uploaded_columns)
-        single_row_input_df = pd.DataFrame([input_data])
-        
-        for col in original_uploaded_columns:
-            if col in single_row_input_df.columns:
-                full_input_df.loc[0, col] = single_row_input_df.loc[0, col]
-            else:
-                full_input_df.loc[0, col] = np.nan
-
-        preprocessed_input_df, _ = preprocess_data_supply(full_input_df.copy(), for_prediction=True, label_encoders=label_encoders)
+        input_df = pd.DataFrame([input_data], columns=_original_cols_supply)
 
-        final_input_features = pd.DataFrame(columns=feature_names)
+        preprocessed_df, _ = preprocess_data_supply(input_df.copy(), for_prediction=True, label_encoders=_encoders_supply)
         
-        for col in feature_names:
-            if col in preprocessed_input_df.columns:
-                final_input_features[col] = pd.to_numeric(preprocessed_input_df[col], errors='coerce').values
-            else:
-                final_input_features[col] = 0.0
-
-        final_input_features = final_input_features.fillna(0.0) 
+        final_features = pd.DataFrame(columns=_feature_names_supply)
+        final_features = pd.concat([final_features, preprocessed_df], ignore_index=True).fillna(0)
 
-        input_scaled = scaler.transform(final_input_features)
+        input_scaled = _scaler_supply.transform(final_features[_feature_names_supply])
         
-        prediction_value = model.predict(input_scaled)[0]
+        prediction = _model_supply.predict(input_scaled)[0]
+        prediction_display = "Delivery Failed" if prediction == 1 else "Delivery Successful"
         
-        # Convert prediction_value to standard Python int/float/str
-        prediction_display = prediction_value
-        if target_col in label_encoders and prediction_value in label_encoders[target_col].classes_: # Check if target was encoded and value is in classes
-            prediction_display = str(label_encoders[target_col].inverse_transform([prediction_value])[0])
-        else:
-            if isinstance(prediction_value, np.number):
-                prediction_display = float(prediction_value)
-            else:
-                prediction_display = prediction_value # Keep as is if not np.number
-
-        # Convert 0/1 to "No Failure"/"Failure" based on the definition for failure_flag
-        if prediction_display == 0 or prediction_display == "0":
-            user_friendly_prediction = "Delivery Successful"
-        elif prediction_display == 1 or prediction_display == "1":
-            user_friendly_prediction = "Delivery Failed"
-        else:
-            user_friendly_prediction = str(prediction_display) # Fallback if target is something else
+        probability = _model_supply.predict_proba(input_scaled)[0].tolist()
 
-        probability = None
-        if hasattr(model, 'predict_proba'):
-            probability = model.predict_proba(input_scaled)[0].tolist()
-            probability = [float(p) for p in probability]
-        
-        return jsonify({
-            'success': True,
-            'prediction': user_friendly_prediction,
-            'probability': probability
-        })
+        return jsonify({'success': True, 'prediction': prediction_display, 'probability': probability})
     except Exception as e:
-        print(f"Error in predict_single_supply: {e}")
-        return jsonify({'success': False, 'error': str(e)})
+        return jsonify({'success': False, 'error': f'An error occurred during prediction: {str(e)}'})