initial commit

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,31 @@
+from flask import Flask, render_template
+from modules.sales_perdiction import sales_prediction_bp
+from modules.campaign_analysis import campaign_analysis_bp
+from modules.inventory_optimization import inventory_optimization_bp
+from modules.pricing_intelligence import pricing_intelligence_bp
+from modules.underperformance import underperformance_bp
+from modules.machine_failure import machine_failure_bp
+from modules.supply_failure import supply_failure_bp
+
+app = Flask(__name__)
+app.secret_key = "secret_key"
+app.config['SESSION_TYPE'] = 'filesystem'
+
+app.register_blueprint(sales_prediction_bp)
+app.register_blueprint(campaign_analysis_bp)
+app.register_blueprint(inventory_optimization_bp)
+app.register_blueprint(pricing_intelligence_bp)
+app.register_blueprint(underperformance_bp)
+app.register_blueprint(machine_failure_bp)
+app.register_blueprint(supply_failure_bp)
+
+@app.route('/')
+def index():
+    return render_template('index.html', title="Home - Predictive Analytics Tool")
+
+# if __name__ == '__main__':
+#     app.run(debug=True)
+
+if __name__ == "__main__":
+    port = 7860
+    app.run(debug=True, host="0.0.0.0", port=port)

modules/campaign_analysis.py

@@ -0,0 +1,162 @@
+from flask import Blueprint, render_template, request, flash, redirect, url_for
+import pandas as pd
+import numpy as np
+import json
+
+campaign_analysis_bp = Blueprint('campaign_analysis', __name__, url_prefix='/campaign')
+
+_current_sales_df = None
+_current_campaign_df = None
+
+def normalize(s):
+    return str(s).strip().lower()
+
+# OPTIONAL: channel mapping between campaign and sales if desired
+CHANNEL_MAP = {
+    'whatsapp': 'online',
+    'email': 'online',
+    'mobile app': 'online',
+    'tv': 'offline',
+    # add more as needed
+}
+
+@campaign_analysis_bp.route('/', methods=['GET'])
+def show_campaign_analysis():
+    return render_template('campaign_analysis.html', title="Campaign Analysis Engine")
+
+@campaign_analysis_bp.route('/upload', methods=['POST'])
+def upload_files():
+    global _current_sales_df, _current_campaign_df
+
+    sales_file = request.files.get('sales_file')
+    campaign_file = request.files.get('campaign_file')
+    if not sales_file or not campaign_file:
+        flash('Please upload both sales and campaign CSV files.')
+        return redirect(url_for('campaign_analysis.show_campaign_analysis'))
+
+    try:
+        _current_sales_df = pd.read_csv(sales_file, parse_dates=['date'], dayfirst=True)
+        _current_campaign_df = pd.read_csv(campaign_file, parse_dates=['start_date', 'end_date'], dayfirst=True)
+    except Exception as e:
+        flash(f'Error reading CSVs: {e}')
+        return redirect(url_for('campaign_analysis.show_campaign_analysis'))
+
+    try:
+        analysis = analyze_campaigns(_current_sales_df, _current_campaign_df)
+        plot_data = make_plot_data(analysis['campaigns'])
+    except Exception as e:
+        flash(f'Error during analysis: {e}')
+        return redirect(url_for('campaign_analysis.show_campaign_analysis'))
+
+    return render_template('campaign_analysis.html',
+        title="Campaign Analysis Engine",
+        campaigns=analysis['campaigns'],
+        summary=analysis['summary'],
+        columns=_current_campaign_df.columns.tolist(),
+        plot_data=plot_data  # <--- DO NOT json.dumps here!
+    )
+
+def make_plot_data(campaigns):
+    # For bar and line charts
+    names = [c['name'] if c['name'] else c['id'] for c in campaigns]
+    roi = [c['roi'] if c['roi']==c['roi'] else 0 for c in campaigns]
+    uplift = [c['uplift_pct'] if c['uplift_pct']==c['uplift_pct'] else 0 for c in campaigns]
+    revenue = [c['total_revenue'] for c in campaigns]
+    start_dates = [str(c['start_date']) for c in campaigns]
+    types = [c['name'] for c in campaigns]
+    regions = [c['region'] for c in campaigns]
+
+    # Pie chart of types
+    from collections import Counter
+    type_counts = Counter(types)
+    region_counts = Counter(regions)
+
+    return {
+        "bar_uplift": {"x": names, "y": uplift},
+        "bar_roi": {"x": names, "y": roi},
+        "line_revenue": {"x": start_dates, "y": revenue, "names": names},
+        "pie_type": {"labels": list(type_counts.keys()), "values": list(type_counts.values())},
+        "pie_region": {"labels": list(region_counts.keys()), "values": list(region_counts.values())}
+    }
+
+def map_campaign_channel_to_sales(campaign_channel):
+    # Normalize and map campaign channel to sales channel if needed
+    ch = normalize(campaign_channel)
+    return CHANNEL_MAP.get(ch, ch)
+
+def analyze_campaigns(sales_df, campaign_df):
+    """
+    For each campaign, compute total units/revenue during the campaign period,
+    estimate uplift vs. pre-campaign, and simple ROI.
+    """
+    sales_df['channel'] = sales_df['channel'].astype(str)
+    campaign_results = []
+    for _, camp in campaign_df.iterrows():
+        # Split target_skus and iterate
+        target_skus = [sku.strip() for sku in str(camp['target_skus']).split(',')]
+        region = camp['region']
+        # Map campaign channel to sales channel if needed
+        campaign_channel = camp['channel']
+        mapped_channel = map_campaign_channel_to_sales(campaign_channel)
+        start_date = camp['start_date']
+        end_date = camp['end_date']
+
+        # Filter sales for this campaign
+        sales_mask = (
+            sales_df['sku'].isin(target_skus)
+            & (sales_df['region'] == region)
+            & (sales_df['channel'].str.lower() == mapped_channel)
+            & (sales_df['date'] >= start_date)
+            & (sales_df['date'] <= end_date)
+        )
+        sales_during = sales_df[sales_mask]
+        total_units = int(sales_during['sales_units'].sum())
+        total_revenue = float(sales_during['sales_revenue'].sum())
+
+        # Uplift: compare average daily units in campaign vs. 14 days prior
+        pre_mask = (
+            sales_df['sku'].isin(target_skus)
+            & (sales_df['region'] == region)
+            & (sales_df['channel'].str.lower() == mapped_channel)
+            & (sales_df['date'] >= (start_date - pd.Timedelta(days=14)))
+            & (sales_df['date'] < start_date)
+        )
+        sales_pre = sales_df[pre_mask]
+        days_campaign = (end_date - start_date).days + 1
+        days_pre = (sales_pre['date'].max() - sales_pre['date'].min()).days + 1 if not sales_pre.empty else 1
+        avg_daily_campaign = total_units / days_campaign if days_campaign > 0 else 0
+        avg_daily_pre = sales_pre['sales_units'].sum() / days_pre if days_pre > 0 and not sales_pre.empty else 0
+        uplift_pct = ((avg_daily_campaign - avg_daily_pre) / avg_daily_pre * 100) if avg_daily_pre > 0 else np.nan
+
+        # ROI: (Incremental revenue - budget) / budget
+        budget = camp.get('budget', np.nan)
+        try:
+            budget = float(budget)
+        except Exception:
+            budget = np.nan
+        incremental_revenue = total_revenue - sales_pre['sales_revenue'].sum() if not sales_pre.empty else total_revenue
+        roi = ((incremental_revenue - budget) / budget * 100) if pd.notna(budget) and budget > 0 else np.nan
+
+        campaign_results.append({
+            'id': camp.get('campaign_id', ''),
+            'name': camp.get('type', ''),
+            'sku': ','.join(target_skus),
+            'region': region,
+            'channel': campaign_channel,
+            'start_date': start_date.date() if not pd.isnull(start_date) else '',
+            'end_date': end_date.date() if not pd.isnull(end_date) else '',
+            'budget': budget if not pd.isnull(budget) else '-',
+            'total_units': total_units,
+            'total_revenue': total_revenue,
+            'uplift_pct': uplift_pct,
+            'roi': roi
+        })
+
+    # Simple summary for display
+    summary = {
+        'total_campaigns': len(campaign_results),
+        'total_revenue': float(np.nansum([c['total_revenue'] for c in campaign_results])),
+        'avg_uplift_pct': float(np.nanmean([c['uplift_pct'] for c in campaign_results if not np.isnan(c['uplift_pct'])])) if campaign_results else 0,
+        'avg_roi': float(np.nanmean([c['roi'] for c in campaign_results if not np.isnan(c['roi'])])) if campaign_results else 0,
+    }
+    return {'campaigns': campaign_results, 'summary': summary}

modules/inventory_optimization.py

@@ -0,0 +1,7 @@
+from flask import Blueprint, render_template
+
+inventory_optimization_bp = Blueprint('inventory_optimization', __name__, url_prefix='/inventory')
+
+@inventory_optimization_bp.route('/')
+def show_inventory_optimization():
+    return render_template('inventory_optimization.html', title="Inventory Optimization")

modules/machine_failure.py

@@ -0,0 +1,376 @@
+from flask import Blueprint, render_template, request, jsonify, redirect, url_for, flash, session
+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
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+import random 
+
+machine_failure_bp = Blueprint('machine_failure', __name__, url_prefix='/predict/machine_failure')
+
+UPLOAD_FOLDER = 'temp_uploads'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+def get_current_df():
+    try:
+        csv_path = session.get('machine_csv_path')
+        print(f"Debug - CSV Path from session: {csv_path}")
+        
+        if csv_path and os.path.exists(csv_path):
+            print(f"Debug - File exists at path: {csv_path}")
+            return pd.read_csv(csv_path)
+        
+        print("Debug - No valid CSV path found")  
+        return None
+    except Exception as e:
+        print(f"Debug - Error in get_current_df: {str(e)}")  
+        return None
+
+def get_summary_stats(df):
+    return {
+        'total_rows': len(df),
+        'total_columns': len(df.columns),
+        'columns': list(df.columns),
+        'numeric_columns': list(df.select_dtypes(include=[np.number]).columns),
+        'categorical_columns': list(df.select_dtypes(exclude=[np.number]).columns),
+        'missing_values': df.isnull().sum().to_dict()
+    }
+
+def preprocess_data(df, for_prediction=False, label_encoders=None):
+    """Preprocess the dataframe for machine learning
+    
+    Args:
+        df (pd.DataFrame): The input DataFrame.
+        for_prediction (bool): True if preprocessing for a single prediction, False for training.
+        label_encoders (dict): Dictionary of pre-fitted LabelEncoders for single prediction.
+    """
+    df_processed = df.copy()
+
+    categorical_columns = []
+    numerical_columns = []
+    
+    # Dynamically determine column types based on the current DataFrame
+    for column in df_processed.columns:
+        if column in ['timestamp', 'maintenance_timestamp']:
+            continue
+            
+        # Check if column is numeric or can be converted to numeric (after dropping NaNs for check)
+        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)
+
+    # Handle timestamps
+    for time_col in ['timestamp', 'maintenance_timestamp']:
+        if time_col in df_processed.columns:
+            # Convert to datetime, coercing errors
+            df_processed[time_col] = pd.to_datetime(df_processed[time_col], errors='coerce')
+            
+            # Extract features only if the column contains valid datetime values
+            if not df_processed[time_col].isnull().all():
+                df_processed[f'{time_col}_hour'] = df_processed[time_col].dt.hour.fillna(0) # Fill NaN with 0 if time part is missing
+                df_processed[f'{time_col}_day'] = df_processed[time_col].dt.day.fillna(0)
+                df_processed[f'{time_col}_month'] = df_processed[time_col].dt.month.fillna(0)
+            else:
+                df_processed[f'{time_col}_hour'] = 0
+                df_processed[f'{time_col}_day'] = 0
+                df_processed[f'{time_col}_month'] = 0
+            
+            df_processed = df_processed.drop(columns=[time_col])
+
+    # Encode categorical variables
+    current_label_encoders = {}
+    if not for_prediction: # During training, fit and save encoders
+        for col in categorical_columns:
+            if col in df_processed.columns:
+                le = LabelEncoder()
+                df_processed[col] = le.fit_transform(df_processed[col].astype(str))
+                current_label_encoders[col] = le
+    else: 
+        for col, le in label_encoders.items():
+            if col in df_processed.columns:
+                # Use a lambda function to handle unseen labels: map to -1 or a default if not in classes
+                df_processed[col] = df_processed[col].astype(str).apply(
+                    lambda x: le.transform([x])[0] if x in le.classes_ else -1
+                )
+    return df_processed, current_label_encoders
+
+
+@machine_failure_bp.route('/', methods=['GET'])
+def show_machine_failure():
+    return render_template('machine_failure.html', title="Machine Failure Prediction")
+
+@machine_failure_bp.route('/upload', methods=['POST'])
+def upload_file():
+    if 'machine_file' not in request.files:
+        flash('No file selected')
+        return redirect(url_for('machine_failure.show_machine_failure'))
+
+    file = request.files['machine_file']
+    if file.filename == '':
+        flash('No file selected')
+        return redirect(url_for('machine_failure.show_machine_failure'))
+
+    try:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        safe_filename = f"machine_data_{timestamp}.csv"
+        file_path = os.path.join(UPLOAD_FOLDER, safe_filename)
+        
+        file.save(file_path)
+        session['machine_csv_path'] = file_path
+        print(f"Debug - Saved file to: {file_path}")  
+        
+        df = pd.read_csv(file_path)
+        preview_data = df.head().to_dict('records')
+        summary_stats = get_summary_stats(df)
+        
+        session['original_columns'] = df.columns.tolist()
+
+        return render_template('machine_failure.html',
+                             title="Machine Failure Prediction",
+                             preview_data=preview_data,
+                             columns=df.columns.tolist(),
+                             summary_stats=summary_stats)
+
+    except Exception as e:
+        print(f"Debug - Upload error: {str(e)}")  
+        flash(f'Error processing file: {str(e)}')
+        return redirect(url_for('machine_failure.show_machine_failure'))
+    
+@machine_failure_bp.route('/run_prediction', methods=['POST'])
+def run_prediction():
+    try:
+        df = get_current_df()
+        if df is None:
+            return jsonify({'success': False, 'error': 'No data available. Please upload a CSV file first.'})
+
+        target_col = request.form.get('target_col')
+        if not target_col:
+            return jsonify({'success': False, 'error': 'Target column not selected.'})
+
+        # Preprocess the data for training
+        df_processed, label_encoders = preprocess_data(df.copy(), for_prediction=False)
+        
+        encoders_path = os.path.join(UPLOAD_FOLDER, f'encoders_{datetime.now().strftime("%Y%m%d_%H%M%S")}.joblib')
+        joblib.dump(label_encoders, encoders_path)
+        session['encoders_path'] = encoders_path
+
+        # Prepare features and target
+        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."})
+
+        X = df_processed.drop(columns=[target_col])
+        y = df_processed[target_col]
+
+        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] 
+
+        top_features = [{'feature': f, 'importance': float(imp)} for f, imp in feature_importance]
+
+        session['feature_names'] = X.columns.tolist()
+        session['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),
+            'Recall': recall_score(y_test, y_pred, average='weighted', zero_division=0),
+            'F1 Score': f1_score(y_test, y_pred, average='weighted', zero_division=0)
+        }
+
+        model_path = os.path.join(UPLOAD_FOLDER, f'model_{datetime.now().strftime("%Y%m%d_%H%M%S")}.joblib')
+        scaler_path = os.path.join(UPLOAD_FOLDER, f'scaler_{datetime.now().strftime("%Y%m%d_%H%M%S")}.joblib')
+        
+        joblib.dump(clf, model_path)
+        joblib.dump(scaler, scaler_path)
+        
+        session['model_path'] = model_path
+        session['scaler_path'] = scaler_path
+
+        return jsonify({
+            'success': True,
+            'metrics': metrics,
+            'top_features': top_features,
+        })
+
+    except Exception as e:
+        print(f"Error in run_prediction: {e}")
+        return jsonify({'success': False, 'error': str(e)})
+
+@machine_failure_bp.route('/get_form_data', methods=['GET'])
+def get_form_data():
+    try:
+        df = get_current_df()
+        if df is None:
+            return jsonify({'success': False, 'error': 'No data available. Please upload a file first.'})
+
+        target_col = session.get('target_column_name')
+        if not target_col:
+            return jsonify({'success': False, 'error': 'Target column not found in session. Please run prediction first.'})
+
+        exclude_cols = ['error_severity', 'downtime_minutes', 'failure_type', target_col]
+        
+        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 ['timestamp', 'maintenance_timestamp']:
+                    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" # Fallback for invalid dates
+                        else:
+                            default_value = parsed_date.strftime('%Y-%m-%d %H:%M:%S')
+                    except Exception:
+                        default_value = "YYYY-MM-DD HH:MM:SS"
+                else:
+                    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 ['timestamp', 'maintenance_timestamp']: 
+                 form_fields.append({
+                    'name': col,
+                    'type': 'text',
+                    'placeholder': 'YYYY-MM-DD HH:MM:SS (optional)',
+                    'default_value': default_value
+                })
+            else:
+                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: {e}")
+        return jsonify({'success': False, 'error': str(e)})
+
+
+@machine_failure_bp.route('/predict_single', methods=['POST'])
+def predict_single():
+    try:
+        model_path = session.get('model_path')
+        scaler_path = session.get('scaler_path')
+        encoders_path = session.get('encoders_path')
+        feature_names = session.get('feature_names')
+        target_col = session.get('target_column_name')
+        
+        if not all([model_path, scaler_path, encoders_path, feature_names, target_col]):
+            return jsonify({'success': False, 'error': 'Model or preprocessing artifacts not found. 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.'})
+
+        original_uploaded_columns = session.get('original_columns')
+        
+        if not original_uploaded_columns:
+            return jsonify({'success': False, 'error': 'Original dataset column names not found in session. Please upload a file.'})
+        
+        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(full_input_df.copy(), for_prediction=True, label_encoders=label_encoders)
+
+        final_input_features = pd.DataFrame(columns=feature_names)
+        
+        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) 
+
+        input_scaled = scaler.transform(final_input_features)
+        
+        prediction_value = model.predict(input_scaled)[0]
+        
+        prediction_display = prediction_value
+        if target_col in label_encoders:
+            if isinstance(prediction_value, (int, np.integer)) and prediction_value < len(label_encoders[target_col].classes_):
+                prediction_display = str(label_encoders[target_col].inverse_transform([prediction_value])[0])
+            else:
+                prediction_display = str(prediction_value) + " (Unknown Class)"
+        else:
+            if isinstance(prediction_value, np.number):
+                prediction_display = float(prediction_value)
+            else:
+                prediction_display = prediction_value
+        
+        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': prediction_display,
+            'probability': probability
+        })
+    except Exception as e:
+        print(f"Error in predict_single: {e}")
+        return jsonify({'success': False, 'error': str(e)})

modules/pricing_intelligence.py

@@ -0,0 +1,7 @@
+from flask import Blueprint, render_template
+
+pricing_intelligence_bp = Blueprint('pricing_intelligence', __name__, url_prefix='/pricing')
+
+@pricing_intelligence_bp.route('/')
+def show_pricing_intelligence():
+    return render_template('pricing_intelligence.html', title="Pricing Intelligence")

modules/sales_perdiction.py

@@ -0,0 +1,246 @@
+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
+
+sales_prediction_bp = Blueprint('sales_prediction', __name__, url_prefix='/forecast/sales')
+
+_current_df = None
+
+def get_summary_stats(df):
+    return {
+        'total_rows': len(df),
+        'total_columns': len(df.columns),
+        'columns': list(df.columns),
+        'numeric_columns': list(df.select_dtypes(include=[np.number]).columns),
+        'categorical_columns': list(df.select_dtypes(exclude=[np.number]).columns),
+        'missing_values': df.isnull().sum().to_dict()
+    }
+
+@sales_prediction_bp.route('/', methods=['GET'])
+def show_sales_prediction():
+    return render_template('sales_prediction.html', title="Sales Prediction Engine")
+
+@sales_prediction_bp.route('/upload', methods=['POST'])
+def upload_file():
+    if 'sales_file' not in request.files:
+        flash('No file selected')
+        return redirect(url_for('sales_prediction.show_sales_prediction'))
+    
+    file = request.files['sales_file']
+    if file.filename == '':
+        flash('No file selected')
+        return redirect(url_for('sales_prediction.show_sales_prediction'))
+    
+    try:
+        global _current_df
+        _current_df = pd.read_csv(file)
+        preview_data = _current_df.head().to_dict('records')
+        summary_stats = get_summary_stats(_current_df)
+        return render_template('sales_prediction.html',
+                           title="Sales Prediction Engine",
+                           preview_data=preview_data,
+                           columns=_current_df.columns.tolist(),
+                           summary_stats=summary_stats)
+    except Exception as e:
+        flash(f'Error processing file: {str(e)}')
+        return redirect(url_for('sales_prediction.show_sales_prediction'))
+
+@sales_prediction_bp.route('/plot', methods=['POST'])
+def create_plot():
+    try:
+        global _current_df
+        if _current_df is None:
+            return jsonify(success=False,
+                           error="Please upload the CSV first.")
+
+        column    = request.form.get('column')     
+        plot_type = request.form.get('plot_type')
+        NUMERIC      = {'sales_units', 'sales_revenue', 'price'}
+        CATEGORICAL  = {'sku', 'category', 'region', 'channel', 'brand'}
+
+        if column not in NUMERIC.union(CATEGORICAL):
+            return jsonify(success=False,
+                           error=f"Column '{column}' not supported.")
+
+        if column in NUMERIC:
+            _current_df[column] = pd.to_numeric(_current_df[column],
+                                                errors='coerce')
+
+        df = _current_df.dropna(subset=[column])
+        if plot_type == 'histogram' and column in NUMERIC:
+            fig = px.histogram(df, x=column, nbins=40,
+                               title=f'Distribution of {column}')
+
+        elif plot_type == 'box' and column in NUMERIC:
+            fig = px.box(df, y=column,
+                         title=f'Box-plot of {column}')
+
+        elif plot_type == 'bar' and column in CATEGORICAL:
+            agg_df = (df.groupby(column, as_index=False)
+                        ['sales_units'].sum()
+                        .sort_values('sales_units', ascending=False)
+                        .head(25))
+
+            fig = px.bar(agg_df, x=column, y='sales_units',
+                         title=f'{column} – total units sold',
+                         labels={'sales_units': 'Units sold'})
+
+            fig.update_layout(xaxis_categoryorder='total descending')
+
+        else:
+            return jsonify(success=False,
+                           error=f"'{plot_type}' not allowed for '{column}'")
+
+        plot_json = json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
+        return jsonify(success=True, plot=plot_json)
+
+    except Exception as e:
+        return jsonify(success=False, error=str(e))
+        
+@sales_prediction_bp.route('/fix_nulls', methods=['POST'])
+def fix_nulls():
+    try:
+        global _current_df
+        if _current_df is None:
+            return jsonify(success=False, error="No data available. Please upload a CSV file first.")
+        column = request.form.get('column')
+        method = request.form.get('method')
+        if column not in _current_df.columns:
+            return jsonify(success=False, error=f"Column '{column}' not found")
+        nulls_before = int(_current_df[column].isnull().sum())
+        if nulls_before == 0:
+            return jsonify(success=False, error=f"No nulls to fix in '{column}'")
+        if method == 'drop':
+            _current_df = _current_df.dropna(subset=[column])
+        elif method == 'mean':
+            _current_df[column] = _current_df[column].fillna(_current_df[column].mean())
+        elif method == 'median':
+            _current_df[column] = _current_df[column].fillna(_current_df[column].median())
+        elif method == 'mode':
+            _current_df[column] = _current_df[column].fillna(_current_df[column].mode()[0])
+        else:
+            return jsonify(success=False, error="Invalid method")
+        nulls_after = int(_current_df[column].isnull().sum())
+        summary_stats = get_summary_stats(_current_df)
+        preview_data = _current_df.head().to_dict('records')
+        columns = list(_current_df.columns)
+        return jsonify(
+            success=True,
+            message=f"Fixed {nulls_before - nulls_after} nulls in '{column}' using {method}.",
+            summary_stats=summary_stats,
+            preview_data=preview_data,
+            columns=columns
+        )
+    except Exception as e:
+        return jsonify(success=False, error=str(e))
+    
+@sales_prediction_bp.route('/run_forecast', methods=['POST'])
+def run_forecast():
+    try:
+        global _current_df
+        if _current_df is None:
+            return jsonify(success=False, error="No data available. Please upload a CSV file first.")
+        model = request.form.get('model')
+        date_col = request.form.get('date_col')
+        target_col = request.form.get('target_col')
+        horizon = int(request.form.get('horizon', 30))
+
+        if date_col not in _current_df.columns or target_col not in _current_df.columns:
+            return jsonify(success=False, error="Invalid column selection.")
+
+        df = _current_df.copy()
+        df = df[[date_col, target_col]].dropna()
+        # Try to parse date with dayfirst and fallback to default
+        try:
+            df[date_col] = pd.to_datetime(df[date_col], dayfirst=True, errors='coerce')
+        except Exception:
+            df[date_col] = pd.to_datetime(df[date_col], errors='coerce')
+        df = df.dropna(subset=[date_col])
+        df = df.sort_values(date_col)
+        df = df.groupby(date_col)[target_col].sum().reset_index()
+
+        # Only forecast if enough data
+        if len(df) < horizon + 5:
+            return jsonify(success=False, error="Not enough data for the selected forecast horizon.")
+
+        train = df.iloc[:-horizon]
+        test = df.iloc[-horizon:]
+
+        forecast = []
+        conf_int = []
+        trend = []
+        seasonality = []
+        metrics = {}
+
+        if model == "ARIMA":
+            try:
+                from statsmodels.tsa.arima.model import ARIMA
+                ts = train.set_index(date_col)[target_col]
+                arima = ARIMA(ts, order=(1,1,1)).fit()
+                pred = arima.get_forecast(steps=horizon)
+                forecast = pred.predicted_mean.values.tolist()
+                conf_int = pred.conf_int().values.tolist()
+                trend = [np.mean(ts)] * horizon
+                seasonality = [0] * horizon
+                y_true = test[target_col].values
+                y_pred = forecast
+                metrics = {
+                    "MAPE": float(np.mean(np.abs((y_true - y_pred) / y_true)) * 100),
+                    "RMSE": float(np.sqrt(np.mean((y_true - y_pred) ** 2))),
+                    "R2": float(1 - np.sum((y_true - y_pred) ** 2) / np.sum((y_true - np.mean(y_true)) ** 2))
+                }
+            except Exception as e:
+                return jsonify(success=False, error=f"ARIMA error: {e}")
+
+        elif model == "Prophet":
+            try:
+                from prophet import Prophet
+                prophet_df = train.rename(columns={date_col: "ds", target_col: "y"})
+                m = Prophet()
+                m.fit(prophet_df)
+                future = m.make_future_dataframe(periods=horizon)
+                forecast_df = m.predict(future)
+                forecast = forecast_df['yhat'][-horizon:].values.tolist()
+                conf_int = list(zip(forecast_df['yhat_lower'][-horizon:].values, forecast_df['yhat_upper'][-horizon:].values))
+                trend = forecast_df['trend'][-horizon:].values.tolist()
+                seasonality = (forecast_df['seasonal'][-horizon:].values.tolist() if 'seasonal' in forecast_df else [0]*horizon)
+                y_true = test[target_col].values
+                y_pred = forecast
+                metrics = {
+                    "MAPE": float(np.mean(np.abs((y_true - y_pred) / y_true)) * 100),
+                    "RMSE": float(np.sqrt(np.mean((y_true - y_pred) ** 2))),
+                    "R2": float(1 - np.sum((y_true - y_pred) ** 2) / np.sum((y_true - np.mean(y_true)) ** 2))
+                }
+            except Exception as e:
+                return jsonify(success=False, error=f"Prophet error: {e}")
+
+        elif model in ["Random Forest", "XGBoost", "LSTM"]:
+            y_true = test[target_col].values
+            y_pred = [np.mean(train[target_col])] * horizon
+            forecast = y_pred
+            conf_int = [[y-5, y+5] for y in y_pred]
+            trend = [np.mean(train[target_col])] * horizon
+            seasonality = [0] * horizon
+            metrics = {
+                "MAPE": float(np.mean(np.abs((y_true - y_pred) / y_true)) * 100),
+                "RMSE": float(np.sqrt(np.mean((y_true - y_pred) ** 2))),
+                "R2": float(1 - np.sum((y_true - y_pred) ** 2) / np.sum((y_true - np.mean(y_true)) ** 2))
+            }
+
+        forecast_dates = test[date_col].dt.strftime('%Y-%m-%d').tolist()
+
+        return jsonify(
+            success=True,
+            forecast=forecast,
+            conf_int=conf_int,
+            trend=trend,
+            seasonality=seasonality,
+            metrics=metrics,
+            dates=forecast_dates,
+            model=model
+        )
+    except Exception as e:
+        return jsonify(success=False, error=str(e))

modules/supply_failure.py

@@ -0,0 +1,363 @@
+from flask import Blueprint, render_template, request, jsonify, redirect, url_for, flash, session
+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
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+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)
+
+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):
+    return {
+        'total_rows': len(df),
+        'total_columns': len(df.columns),
+        'columns': list(df.columns),
+        'numeric_columns': list(df.select_dtypes(include=[np.number]).columns),
+        'categorical_columns': list(df.select_dtypes(exclude=[np.number]).columns),
+        'missing_values': df.isnull().sum().to_dict()
+    }
+
+def preprocess_data_supply(df, for_prediction=False, label_encoders=None):
+    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
+    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 = 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
+        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'))
+                current_label_encoders[col] = le
+    else: # For prediction, use provided encoders
+        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
+                )
+    
+    # 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
+
+    return df_processed, current_label_encoders
+
+
+@supply_failure_bp.route('/', methods=['GET'])
+def show_supply_failure():
+    return render_template('supply_failure.html', title="Supply Failure Prediction")
+
+@supply_failure_bp.route('/upload', methods=['POST'])
+def upload_file_supply():
+    if 'supply_file' not in request.files:
+        flash('No file selected')
+        return redirect(url_for('supply_failure.show_supply_failure'))
+
+    file = request.files['supply_file']
+    if file.filename == '':
+        flash('No file selected')
+        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()
+
+        return render_template('supply_failure.html',
+                             title="Supply Failure Prediction",
+                             preview_data=preview_data,
+                             columns=df.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
+
+        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
+
+        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."})
+
+        X = df_processed.drop(columns=[target_col])
+        y = df_processed[target_col]
+
+        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] 
+
+        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),
+            'Recall': recall_score(y_test, y_pred, average='weighted', zero_division=0),
+            '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,
+        })
+
+    except Exception as e:
+        print(f"Error in run_prediction_supply: {e}")
+        return jsonify({'success': False, 'error': 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)})
+
+
+@supply_failure_bp.route('/predict_single', methods=['POST'])
+def predict_single_supply():
+    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)
+
+        final_input_features = pd.DataFrame(columns=feature_names)
+        
+        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) 
+
+        input_scaled = scaler.transform(final_input_features)
+        
+        prediction_value = model.predict(input_scaled)[0]
+        
+        # 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 = 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
+        })
+    except Exception as e:
+        print(f"Error in predict_single_supply: {e}")
+        return jsonify({'success': False, 'error': str(e)})

modules/underperformance.py

@@ -0,0 +1,7 @@
+from flask import Blueprint, render_template
+
+underperformance_bp = Blueprint('underperformance', __name__, url_prefix='/underperformance')
+
+@underperformance_bp.route('/')
+def show_underperformance():
+    return render_template('underperformance.html', title="Underperformance Detector")

requirements.txt

@@ -0,0 +1,11 @@
+flask
+jinja2
+scikit-learn
+xgboost
+pandas
+numpy
+flask-session
+flask-cors
+plotly
+matplotlib
+huggingface_hub[CLI]

static/index.js

@@ -0,0 +1,690 @@
+document.addEventListener('DOMContentLoaded', () => {
+    console.log('Landing page loaded.');
+    
+    // Animate elements on scroll using Intersection Observer
+    const animatedElements = document.querySelectorAll('.animate-on-scroll');
+    const observer = new IntersectionObserver(entries => {
+        entries.forEach(entry => {
+            if (entry.isIntersecting) {
+                entry.target.classList.add('animate-fadeIn');
+                observer.unobserve(entry.target);
+            }
+        });
+    }, { threshold: 0.2 });
+    
+    animatedElements.forEach(el => observer.observe(el));
+
+    // Plotly initial plot (if present)
+    const initialPlotDiv = document.getElementById('initialPlot');
+    if (initialPlotDiv) {
+        const plotData = JSON.parse(initialPlotDiv.dataset.plot);
+        Plotly.newPlot('plotDiv', plotData.data, plotData.layout);
+    }
+
+    // Initialize toast notifications
+    if (!document.getElementById('toast-container')) {
+        const toastContainer = document.createElement('div');
+        toastContainer.id = 'toast-container';
+        toastContainer.className = 'fixed top-4 right-4 z-50';
+        document.body.appendChild(toastContainer);
+    }
+});
+
+function showToast(message, type = 'success') {
+    const toast = document.createElement('div');
+    toast.className = `p-4 mb-4 rounded shadow-lg ${type === 'success' ? 'bg-green-500' : 'bg-red-500'} text-white`;
+    toast.textContent = message;
+    
+    const container = document.getElementById('toast-container');
+    container.appendChild(toast);
+    
+    setTimeout(() => {
+        toast.remove();
+    }, 3000);
+}
+
+window.createPlot = function() {
+    const column = document.getElementById('plotColumn').value;
+    const plotType = document.getElementById('plotType').value;
+    
+    fetch('/forecast/sales/plot', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: `column=${column}&plot_type=${plotType}`
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            const plotData = JSON.parse(data.plot);
+            Plotly.newPlot('plotDiv', plotData.data, plotData.layout);
+            showToast(`Generated ${plotType} for ${column}`);
+        } else {
+            showToast(data.error, 'error');
+        }
+    })
+    .catch(error => {
+        console.error('Error:', error);
+        showToast(error.message, 'error');
+    });
+}
+
+window.fixNulls = function(column) {
+    const method = document.getElementById('method-' + column).value;
+    fetch('/forecast/sales/fix_nulls', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/x-www-form-urlencoded'},
+        body: `column=${column}&method=${method}`
+    })
+    .then(response => response.json())
+    .then(data => {
+        const msgDiv = document.getElementById('null-fix-message');
+        if (data.success) {
+            msgDiv.textContent = data.message;
+            msgDiv.classList.remove('text-red-700');
+            msgDiv.classList.add('text-green-700');
+            showToast(data.message);
+
+            // Update summary stats
+            updateSummaryStats(data.summary_stats);
+
+            // Update preview table
+            updatePreviewTable(data.columns, data.preview_data);
+
+            // Update nulls UI
+            updateNullsUI(data.summary_stats.missing_values);
+
+        } else {
+            msgDiv.textContent = data.error;
+            msgDiv.classList.remove('text-green-700');
+            msgDiv.classList.add('text-red-700');
+            showToast(data.error, 'error');
+        }
+    });
+}
+
+// Helper to update summary stats
+function updateSummaryStats(stats) {
+    document.querySelectorAll('.summary-total-rows').forEach(el => el.textContent = stats.total_rows);
+    document.querySelectorAll('.summary-total-cols').forEach(el => el.textContent = stats.total_columns);
+    document.querySelectorAll('.summary-numeric-cols').forEach(el => el.textContent = stats.numeric_columns.join(', '));
+    document.querySelectorAll('.summary-categorical-cols').forEach(el => el.textContent = stats.categorical_columns.join(', '));
+}
+
+// Helper to update preview table
+function updatePreviewTable(columns, previewData) {
+    const table = document.getElementById('preview-table');
+    if (!table) return;
+    // Update header
+    let thead = table.querySelector('thead');
+    let tbody = table.querySelector('tbody');
+    thead.innerHTML = '<tr>' + columns.map(col => `<th class="px-4 py-2 bg-gray-100">${col}</th>`).join('') + '</tr>';
+    // Update body
+    tbody.innerHTML = previewData.map(row =>
+        '<tr>' + columns.map(col => `<td class="border px-4 py-2">${row[col]}</td>`).join('') + '</tr>'
+    ).join('');
+}
+
+// Helper to update nulls UI
+function updateNullsUI(missingValues) {
+    const nullList = document.getElementById('null-list');
+    if (!nullList) return;
+    let html = '';
+    let hasNulls = false;
+    for (const [col, count] of Object.entries(missingValues)) {
+        if (count > 0) {
+            hasNulls = true;
+            html += `
+                <li>
+                    <span>${col}: ${count} missing values</span>
+                    <select id="method-${col}" class="border rounded p-1 mx-2">
+                        <option value="drop">Drop Rows</option>
+                        <option value="mean">Fill Mean</option>
+                        <option value="median">Fill Median</option>
+                        <option value="mode">Fill Mode</option>
+                    </select>
+                    <button class="btn-learn-more" onclick="fixNulls('${col}')">Fix</button>
+                </li>
+            `;
+        }
+    }
+    nullList.innerHTML = html;
+    // If no nulls left, show a message
+    if (!hasNulls) {
+        nullList.innerHTML = '<li class="text-green-700 font-semibold">No missing values remaining!</li>';
+    }
+}
+window.runForecast = function() {
+    const dateCol = document.getElementById('forecastDateCol').value;
+    const targetCol = document.getElementById('forecastTargetCol').value;
+    const model = document.getElementById('forecastModel').value;
+    const horizon = document.getElementById('forecastHorizon').value;
+    const metricsDiv = document.getElementById('forecast-metrics');
+    const plotDiv = document.getElementById('forecast-plot');
+    const errorDiv = document.getElementById('forecast-error');
+    metricsDiv.innerHTML = '';
+    plotDiv.innerHTML = '';
+    errorDiv.textContent = '';
+
+    fetch('/forecast/sales/run_forecast', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/x-www-form-urlencoded'},
+        body: `date_col=${dateCol}&target_col=${targetCol}&model=${model}&horizon=${horizon}`
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            // Show metrics
+            metricsDiv.innerHTML = `
+                <div class="mb-2">
+                    <strong>Model:</strong> ${data.model}
+                </div>
+                <div class="mb-2">
+                    <strong>MAPE:</strong> ${data.metrics.MAPE.toFixed(2)}%
+                    <strong class="ml-4">RMSE:</strong> ${data.metrics.RMSE.toFixed(2)}
+                    <strong class="ml-4">R²:</strong> ${data.metrics.R2.toFixed(3)}
+                </div>
+            `;
+            // Plot forecast with confidence intervals
+            const trace = {
+                x: data.dates,
+                y: data.forecast,
+                mode: 'lines+markers',
+                name: 'Forecast'
+            };
+            const lower = data.conf_int.map(ci => ci[0]);
+            const upper = data.conf_int.map(ci => ci[1]);
+            const ciTrace = {
+                x: [...data.dates, ...data.dates.slice().reverse()],
+                y: [...upper, ...lower.reverse()],
+                fill: 'toself',
+                fillcolor: 'rgba(0,100,80,0.2)',
+                line: {color: 'transparent'},
+                name: 'Confidence Interval',
+                showlegend: true,
+                type: 'scatter'
+            };
+            const layout = {
+                title: 'Forecasted Sales',
+                xaxis: {title: 'Date'},
+                yaxis: {title: 'Forecast'},
+                showlegend: true
+            };
+            Plotly.newPlot(plotDiv, [trace, ciTrace], layout);
+            showToast('Forecast generated!');
+        } else {
+            errorDiv.textContent = data.error;
+            showToast(data.error, 'error');
+        }
+    })
+    .catch(error => {
+        errorDiv.textContent = error.message;
+        showToast(error.message, 'error');
+    });
+}
+
+// Machine Failure Prediction
+
+function runPrediction() {
+    // Show loading state
+    const metricsDiv = document.getElementById('predict-metrics');
+    const errorDiv = document.getElementById('predict-error');
+    const singlePredictionSection = document.getElementById('single-prediction-section');
+    
+    metricsDiv.innerHTML = '<p>Running prediction...</p>';
+    errorDiv.textContent = '';
+    singlePredictionSection.classList.add('hidden'); // Hide form until model is ready
+    
+    // Get selected values
+    const targetCol = document.getElementById('predictTargetCol').value;
+    const model = document.getElementById('predictModel').value; // Model is currently fixed to RF in backend, but UI allows selection
+    
+    // Create form data
+    const formData = new FormData();
+    formData.append('target_col', targetCol);
+    formData.append('model', model);
+
+    // Make API call
+    fetch('/predict/machine_failure/run_prediction', {
+        method: 'POST',
+        body: formData
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+          // Display metrics in a grid
+          let metricsHtml =
+            '<div class="grid grid-cols-2 md:grid-cols-4 gap-4">';
+          for (const [key, value] of Object.entries(data.metrics)) {
+            metricsHtml += `
+                    <div class="p-4 bg-blue-50 rounded">
+                        <p class="font-semibold">${key}</p>
+                        <p class="text-xl">${value.toFixed(4)}</p>
+                    </div>
+                `;
+          }
+          metricsHtml += "</div>";
+          metricsDiv.innerHTML = metricsHtml;
+
+          // --- Feature Importance ---
+          if (data.top_features && Array.isArray(data.top_features)) {
+            const fiDiv = document.getElementById("feature-importance");
+            const fiList = document.getElementById("feature-importance-list");
+            fiDiv.classList.remove("hidden");
+            fiList.innerHTML = `
+                    <table class="min-w-full table-auto">
+                        <thead>
+                            <tr>
+                                <th class="px-4 py-2 bg-gray-100">Feature</th>
+                                <th class="px-4 py-2 bg-gray-100">Importance</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            ${data.top_features
+                              .map(
+                                (f) =>
+                                  `<tr>
+                                    <td class="border px-4 py-2">${
+                                      f.feature
+                                    }</td>
+                                    <td class="border px-4 py-2">${f.importance.toFixed(
+                                      4
+                                    )}</td>
+                                </tr>`
+                              )
+                              .join("")}
+                        </tbody>
+                    </table>
+                `;
+          }
+
+          showToast("Model trained successfully");
+
+          // Now that the model is trained, fetch form data and display the single prediction form
+          fetchSinglePredictionForm();
+        } else {
+            errorDiv.textContent = data.error || 'An error occurred';
+            showToast(data.error || 'An error occurred', 'error');
+        }
+    })
+    .catch(error => {
+        errorDiv.textContent = 'Error: ' + error.message;
+        showToast('Error: ' + error.message, 'error');
+    });
+}
+
+window.runPrediction = runPrediction;
+
+// Function to fetch data for and generate the single prediction form
+function fetchSinglePredictionForm() {
+    fetch('/predict/machine_failure/get_form_data')
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                generatePredictionForm(data.form_fields);
+                document.getElementById('single-prediction-section').classList.remove('hidden');
+            } else {
+                showToast(data.error, 'error');
+                document.getElementById('single-prediction-error').textContent = data.error;
+            }
+        })
+        .catch(error => {
+            console.error('Error fetching form data:', error);
+            showToast('Error fetching form data: ' + error.message, 'error');
+            document.getElementById('single-prediction-error').textContent = 'Error fetching form data: ' + error.message;
+        });
+}
+
+// Function to dynamically generate the prediction form
+function generatePredictionForm(formFields) {
+    const formContainer = document.getElementById('single-prediction-form');
+    formContainer.innerHTML = ''; // Clear previous fields
+
+    formFields.forEach(field => {
+        const div = document.createElement('div');
+        div.className = 'mb-4';
+
+        const label = document.createElement('label');
+        label.className = 'block text-gray-700 text-sm font-bold mb-2';
+        label.textContent = field.name.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase()); // Capitalize and replace underscores
+
+        div.appendChild(label);
+
+        if (field.type === 'select') {
+            const select = document.createElement('select');
+            select.id = `input-${field.name}`;
+            select.name = field.name;
+            select.className = 'shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline';
+            
+            field.options.forEach(option => {
+                const optionElement = document.createElement('option');
+                optionElement.value = option;
+                optionElement.textContent = option;
+                // Set default selected option
+                if (field.default_value !== undefined && String(field.default_value) === String(option)) { // Compare as strings
+                    optionElement.selected = true;
+                }
+                select.appendChild(optionElement);
+            });
+            div.appendChild(select);
+        } else if (field.type === 'number') {
+            const input = document.createElement('input');
+            input.id = `input-${field.name}`;
+            input.name = field.name;
+            input.type = 'number';
+            input.className = 'shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline';
+            input.placeholder = `Enter ${field.name.replace(/_/g, ' ')}`;
+            if (field.default_value !== undefined) {
+                input.value = field.default_value;
+            }
+            div.appendChild(input);
+        } else { // Default to text for other types, including timestamps
+            const input = document.createElement('input');
+            input.id = `input-${field.name}`;
+            input.name = field.name;
+            input.type = 'text';
+            input.className = 'shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline';
+            input.placeholder = field.placeholder || `Enter ${field.name.replace(/_/g, ' ')}`;
+            if (field.default_value !== undefined) {
+                input.value = field.default_value;
+            }
+            div.appendChild(input);
+        }
+        formContainer.appendChild(div);
+    });
+}
+
+// Function to handle single instance prediction submission
+window.predictSingleInstance = function() {
+    const form = document.getElementById('single-prediction-form');
+    const formData = {};
+    const inputs = form.querySelectorAll('input, select');
+
+    inputs.forEach(input => {
+        formData[input.name] = input.value;
+    });
+
+    const resultDiv = document.getElementById('single-prediction-result');
+    const predictionOutput = document.getElementById('prediction-output');
+    const probabilityOutput = document.getElementById('probability-output');
+    const errorDiv = document.getElementById('single-prediction-error');
+
+    resultDiv.classList.add('hidden');
+    errorDiv.textContent = '';
+    predictionOutput.textContent = 'Predicting...';
+    probabilityOutput.innerHTML = '';
+
+    fetch('/predict/machine_failure/predict_single', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(formData)
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            let displayPrediction = 'Unknown';
+            if (data.prediction === 0 || data.prediction === '0') {
+                displayPrediction = 'No Failure';
+            } else if (data.prediction === 1 || data.prediction === '1') {
+                displayPrediction = 'Failure';
+            } else {
+                 displayPrediction = data.prediction; // Fallback for other values if backend sends different strings
+            }
+            predictionOutput.textContent = displayPrediction;
+
+            if (data.probability && Array.isArray(data.probability)) {
+                if (data.probability.length === 2) { // Binary classification
+                    const probNoFailure = data.probability[0];
+                    const probFailure = data.probability[1];
+                    probabilityOutput.innerHTML = `Probability of No Failure: ${(probNoFailure * 100).toFixed(2)}%<br>
+                                                 Probability of Failure: ${(probFailure * 100).toFixed(2)}%`;
+                } else { // Multi-class classification
+                    probabilityOutput.innerHTML = 'Probabilities: ' + data.probability.map((p, i) => `Class ${i}: ${(p * 100).toFixed(2)}%`).join(', ');
+                }
+            } else {
+                 probabilityOutput.innerHTML = 'Probability: N/A (not a classification model)';
+            }
+            resultDiv.classList.remove('hidden');
+            showToast('Single prediction successful!');
+        } else {
+            errorDiv.textContent = data.error || 'An error occurred during single prediction.';
+            showToast(data.error || 'An error occurred', 'error');
+        }
+    })
+    .catch(error => {
+        console.error('Error during single prediction:', error);
+        errorDiv.textContent = 'Error: ' + error.message;
+        showToast('Error: ' + error.message, 'error');
+    });
+};
+
+
+// Supply Failure Prediction (New functions similar to Machine Failure)
+
+window.runSupplyPrediction = function() {
+    const metricsDiv = document.getElementById('predict-metrics-supply');
+    const errorDiv = document.getElementById('predict-error-supply');
+    const singlePredictionSection = document.getElementById('single-prediction-section-supply');
+    
+    metricsDiv.innerHTML = '<p>Running prediction...</p>';
+    errorDiv.textContent = '';
+    singlePredictionSection.classList.add('hidden');
+    
+    // Target column is fixed to 'failure_flag'
+    const targetCol = 'failure_flag'; 
+    const model = document.getElementById('predictModelSupply').value; 
+    
+    const formData = new FormData();
+    formData.append('target_col', targetCol);
+    formData.append('model', model);
+
+    fetch('/predict/supply_failure/run_prediction', {
+        method: 'POST',
+        body: formData
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+          let metricsHtml =
+            '<div class="grid grid-cols-2 md:grid-cols-4 gap-4">';
+          for (const [key, value] of Object.entries(data.metrics)) {
+            metricsHtml += `
+                    <div class="p-4 bg-blue-50 rounded">
+                        <p class="font-semibold">${key}</p>
+                        <p class="text-xl">${value.toFixed(4)}</p>
+                    </div>
+                `;
+          }
+          metricsHtml += "</div>";
+          metricsDiv.innerHTML = metricsHtml;
+
+          // --- Feature Importance ---
+          if (data.top_features && Array.isArray(data.top_features)) {
+            const fiDiv = document.getElementById("feature-importance");
+            const fiList = document.getElementById("feature-importance-list");
+            fiDiv.classList.remove("hidden");
+            fiList.innerHTML = `
+                    <table class="min-w-full table-auto">
+                        <thead>
+                            <tr>
+                                <th class="px-4 py-2 bg-gray-100">Feature</th>
+                                <th class="px-4 py-2 bg-gray-100">Importance</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            ${data.top_features
+                              .map(
+                                (f) =>
+                                  `<tr>
+                                    <td class="border px-4 py-2">${
+                                      f.feature
+                                    }</td>
+                                    <td class="border px-4 py-2">${f.importance.toFixed(
+                                      4
+                                    )}</td>
+                                </tr>`
+                              )
+                              .join("")}
+                        </tbody>
+                    </table>
+                `;
+          }
+
+          showToast("Supply Model trained successfully");
+          fetchSupplySinglePredictionForm();
+        } else {
+            errorDiv.textContent = data.error || 'An error occurred';
+            showToast(data.error || 'An error occurred', 'error');
+        }
+    })
+    .catch(error => {
+        errorDiv.textContent = 'Error: ' + error.message;
+        showToast('Error: ' + error.message, 'error');
+    });
+}
+
+function fetchSupplySinglePredictionForm() {
+    fetch('/predict/supply_failure/get_form_data')
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                generateSupplyPredictionForm(data.form_fields);
+                document.getElementById('single-prediction-section-supply').classList.remove('hidden');
+            } else {
+                showToast(data.error, 'error');
+                document.getElementById('single-prediction-error-supply').textContent = data.error;
+            }
+        })
+        .catch(error => {
+            console.error('Error fetching supply form data:', error);
+            showToast('Error fetching supply form data: ' + error.message, 'error');
+            document.getElementById('single-prediction-error-supply').textContent = 'Error fetching supply form data: ' + error.message;
+        });
+}
+
+function generateSupplyPredictionForm(formFields) {
+    const formContainer = document.getElementById('single-prediction-form-supply');
+    formContainer.innerHTML = '';
+
+    formFields.forEach(field => {
+        const div = document.createElement('div');
+        div.className = 'mb-4';
+
+        const label = document.createElement('label');
+        label.className = 'block text-gray-700 text-sm font-bold mb-2';
+        label.textContent = field.name.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+
+        div.appendChild(label);
+
+        if (field.type === 'select') {
+            const select = document.createElement('select');
+            select.id = `input-supply-${field.name}`;
+            select.name = field.name;
+            select.className = 'shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline';
+            
+            field.options.forEach(option => {
+                const optionElement = document.createElement('option');
+                optionElement.value = option;
+                optionElement.textContent = option;
+                if (field.default_value !== undefined && String(field.default_value) === String(option)) {
+                    optionElement.selected = true;
+                }
+                select.appendChild(optionElement);
+            });
+            div.appendChild(select);
+        } else if (field.type === 'number') {
+            const input = document.createElement('input');
+            input.id = `input-supply-${field.name}`;
+            input.name = field.name;
+            input.type = 'number';
+            input.className = 'shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline';
+            input.placeholder = `Enter ${field.name.replace(/_/g, ' ')}`;
+            if (field.default_value !== undefined) {
+                input.value = field.default_value;
+            }
+            div.appendChild(input);
+        } else { // Default to text for other types, including timestamps
+            const input = document.createElement('input');
+            input.id = `input-supply-${field.name}`;
+            input.name = field.name;
+            input.type = 'text';
+            input.className = 'shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline';
+            input.placeholder = field.placeholder || `Enter ${field.name.replace(/_/g, ' ')}`;
+            if (field.default_value !== undefined) {
+                input.value = field.default_value;
+            }
+            div.appendChild(input);
+        }
+        formContainer.appendChild(div);
+    });
+}
+
+window.predictSupplySingleInstance = function() {
+    const form = document.getElementById('single-prediction-form-supply');
+    const formData = {};
+    const inputs = form.querySelectorAll('input, select');
+
+    inputs.forEach(input => {
+        formData[input.name] = input.value;
+    });
+
+    const resultDiv = document.getElementById('single-prediction-result-supply');
+    const predictionOutput = document.getElementById('prediction-output-supply');
+    const probabilityOutput = document.getElementById('probability-output-supply');
+    const errorDiv = document.getElementById('single-prediction-error-supply');
+
+    resultDiv.classList.add('hidden');
+    errorDiv.textContent = '';
+    predictionOutput.textContent = 'Predicting...';
+    probabilityOutput.innerHTML = '';
+
+    fetch('/predict/supply_failure/predict_single', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(formData)
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            // User-friendly mapping for Supply Failure
+            let displayPrediction = 'Unknown';
+            if (data.prediction === "Delivery Successful") { // Backend sends "Delivery Successful" or "Delivery Failed"
+                displayPrediction = 'Delivery Successful';
+            } else if (data.prediction === "Delivery Failed") {
+                displayPrediction = 'Delivery Failed';
+            } else {
+                 displayPrediction = data.prediction; // Fallback
+            }
+            predictionOutput.textContent = displayPrediction;
+
+            if (data.probability && Array.isArray(data.probability)) {
+                if (data.probability.length === 2) {
+                    // Assuming data.probability[0] corresponds to 'Delivery Successful' and data.probability[1] to 'Delivery Failed'
+                    const probSuccessful = data.probability[0];
+                    const probFailed = data.probability[1];
+                    probabilityOutput.innerHTML = `Probability of Delivery Successful: ${(probSuccessful * 100).toFixed(2)}%<br>
+                                                 Probability of Delivery Failed: ${(probFailed * 100).toFixed(2)}%`;
+                } else {
+                    probabilityOutput.innerHTML = 'Probabilities: ' + data.probability.map((p, i) => `Class ${i}: ${(p * 100).toFixed(2)}%`).join(', ');
+                }
+            } else {
+                 probabilityOutput.innerHTML = 'Probability: N/A (not a classification model)';
+            }
+            resultDiv.classList.remove('hidden');
+            showToast('Single prediction successful!');
+        } else {
+            errorDiv.textContent = data.error || 'An error occurred during single prediction.';
+            showToast(data.error || 'An error occurred', 'error');
+        }
+    })
+    .catch(error => {
+        console.error('Error during single prediction:', error);
+        errorDiv.textContent = 'Error: ' + error.message;
+        showToast('Error: ' + error.message, 'error');
+    });
+};

static/styles.css

@@ -0,0 +1,99 @@
+/* Base typography and container */
+body {
+    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+}
+
+/* Container max width override */
+.container {
+    max-width: 1200px;
+}
+
+/* Custom keyframes for fade in */
+@keyframes fadeIn {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+/* Animation helper */
+.animate-fadeIn {
+    animation: fadeIn 1s ease-out forwards;
+}
+
+/* Hero section background and overlay */
+.hero-bg {
+    background-image: url('https://source.unsplash.com/1600x900/?business,analytics');
+    background-size: cover;
+    background-position: center;
+    position: relative;
+    height: 80vh;
+}
+.hero-overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+}
+
+/* Button styles */
+.btn-learn-more {
+    display: inline-block;
+    padding: 0.75rem 1.5rem;
+    font-size: 0.875rem;
+    font-weight: 600;
+    border-radius: 0.5rem;
+    transition: background-color 0.3s ease;
+    background-color: #3b82f6; /* Tailwind blue-500 */
+    color: #ffffff;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+.btn-learn-more:hover {
+    background-color: #2563eb; /* Tailwind blue-600 */
+}
+.btn-custom {
+    transition: transform 0.3s ease;
+}
+.btn-custom:hover {
+    transform: scale(1.05);
+}
+
+/* ----- Module Base Styles (Reusable for all modules) ----- */
+.module {
+    padding: 1rem;
+}
+.module-title {
+    font-size: 1.875rem; /* 30px equivalent */
+    font-weight: 700;
+    color: #1f2937; /* Tailwind gray-800 */
+}
+.module-intro {
+    font-size: 1.125rem;
+    color: #4b5563; /* Tailwind gray-600 */
+}
+.module-section {
+    background-color: #ffffff;
+    padding: 1.5rem;
+    border-radius: 0.5rem;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    margin-bottom: 1.5rem;
+}
+.module-section-header {
+    font-size: 1.5rem; /* 24px equivalent */
+    font-weight: 700;
+    color: #374151; /* Tailwind gray-700 */
+    margin-bottom: 0.5rem;
+}
+.module-section-content {
+    font-size: 1rem;
+    color: #4b5563;
+}
+.module-list li {
+    margin-bottom: 0.5rem;
+}

templates/base.html

@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ title | default("Predictive Analytics Tool") }}</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }}">
+    <script src="{{ url_for('static', filename='index.js') }}" defer></script>
+</head>
+<body class="bg-gray-100 text-gray-900">
+    <header class="bg-white shadow">
+        <div class="container mx-auto px-4 py-6 flex justify-between items-center">
+            <div class="text-2xl font-bold">Predictive Analytics Tool</div>
+            <nav>
+                <ul class="flex space-x-4">
+                    <li><a href="/" class="hover:text-blue-500 transition">Home</a></li>
+                    <li><a href="/forecast/sales" class="hover:text-blue-500 transition">Sales Prediction</a></li>
+                    <li><a href="/campaign" class="hover:text-blue-500 transition">Campaign Analysis</a></li>
+                    <li><a href="/inventory" class="hover:text-blue-500 transition">Inventory Optimization</a></li>
+                    <li><a href="/pricing" class="hover:text-blue-500 transition">Pricing Intelligence</a></li>
+                    <li><a href="/underperformance" class="hover:text-blue-500 transition">Underperformance</a></li>
+                    <li><a href="/predict/machine_failure" class="hover:text-blue-500 transition">Machine Failure</a></li>
+                    <li><a href="/predict/supply_failure" class="hover:text-blue-500 transition">Supply Failure</a></li>
+                </ul>
+            </nav>
+        </div>
+    </header>
+    <main>
+        {% block content %}{% endblock %}
+    </main>
+    <footer class="bg-white border-t">
+        <div class="container mx-auto px-4 py-4 text-center text-sm">
+            &copy; 2025 Predictive Analytics Tool. All rights reserved.
+        </div>
+    </footer>
+</body>
+</html>

templates/campaign_analysis.html

@@ -0,0 +1,105 @@
+{% extends 'base.html' %}
+{% block content %}
+<section class="container mx-auto py-8">
+  <h1 class="text-3xl font-bold mb-4">Campaign Analysis</h1>
+  <p class="mb-6">Analyze the performance of your promotions and campaigns to calculate uplift, ROI, and customer engagement.</p>
+  <form method="POST" action="{{ url_for('campaign_analysis.upload_files') }}" enctype="multipart/form-data" class="mb-8 bg-white p-6 rounded shadow flex flex-col gap-4">
+    <div class="flex flex-col gap-2">
+      <label class="font-semibold">Sales Data CSV</label>
+      <input type="file" name="sales_file" accept=".csv" required class="file:border file:rounded file:px-3 file:py-1">
+    </div>
+    <div class="flex flex-col gap-2">
+      <label class="font-semibold">Campaign Data CSV</label>
+      <input type="file" name="campaign_file" accept=".csv" required class="file:border file:rounded file:px-3 file:py-1">
+    </div>
+    <button type="submit" class="bg-blue-500 text-white px-4 py-2 rounded hover:bg-blue-600 transition">Analyze Campaigns</button>
+  </form>
+
+  {% if summary %}
+  <div class="bg-white p-6 rounded shadow mb-8">
+    <h2 class="text-xl font-bold mb-2">Summary</h2>
+    <ul class="list-disc pl-5">
+      <li><b>Total Campaigns:</b> {{ summary.total_campaigns }}</li>
+      <li><b>Total Campaign Revenue:</b> ${{ "%.2f"|format(summary.total_revenue) }}</li>
+      <li><b>Average Campaign Uplift:</b> {{ "%.2f"|format(summary.avg_uplift_pct) }}%</li>
+      <li><b>Average ROI:</b> {{ "%.2f"|format(summary.avg_roi) }}%</li>
+    </ul>
+  </div>
+  {% endif %}
+
+  {% if plot_data %}
+  <div class="bg-white p-6 rounded shadow mb-8">
+    <h2 class="text-xl font-bold mb-4">Campaign Visualizations</h2>
+    <div class="flex flex-col gap-8 w-full">
+      <div class="w-full">
+        <h3 class="font-semibold mb-2 text-blue-600">Uplift % by Campaign</h3>
+        <div id="uplift_chart" class="w-full" style="min-height:350px;"></div>
+      </div>
+      <div class="w-full">
+        <h3 class="font-semibold mb-2 text-blue-600">ROI % by Campaign</h3>
+        <div id="roi_chart" class="w-full" style="min-height:350px;"></div>
+      </div>
+      <div class="w-full">
+        <h3 class="font-semibold mb-2 text-blue-600">Campaign Revenue Over Time</h3>
+        <div id="revenue_chart" class="w-full" style="min-height:350px;"></div>
+      </div>
+      <div class="w-full">
+        <h3 class="font-semibold mb-2 text-blue-600">Campaign Types</h3>
+        <div id="type_pie" class="w-full" style="min-height:350px;"></div>
+      </div>
+      <div class="w-full">
+        <h3 class="font-semibold mb-2 text-blue-600">Top Regions</h3>
+        <div id="region_pie" class="w-full" style="min-height:350px;"></div>
+      </div>
+    </div>
+  </div>
+  <script src="https://cdn.plot.ly/plotly-2.31.1.min.js"></script>
+  <script>
+    const plots = {{ plot_data|tojson }};
+    if (plots && plots.bar_uplift && plots.bar_uplift.x && plots.bar_uplift.x.length) {
+      Plotly.newPlot('uplift_chart', [{
+        x: plots.bar_uplift.x,
+        y: plots.bar_uplift.y,
+        type: 'bar',
+        marker: {color: '#3b82f6'},
+        text: plots.bar_uplift.y.map(v=>v.toFixed(2)+'%')
+      }], {title: 'Uplift % by Campaign', margin: {t:30}, width: 900, height: 350});
+    }
+    if (plots && plots.bar_roi && plots.bar_roi.x && plots.bar_roi.x.length) {
+      Plotly.newPlot('roi_chart', [{
+        x: plots.bar_roi.x,
+        y: plots.bar_roi.y,
+        type: 'bar',
+        marker: {color: '#10b981'},
+        text: plots.bar_roi.y.map(v=>v.toFixed(2)+'%')
+      }], {title: 'ROI % by Campaign', margin: {t:30}, width: 900, height: 350});
+    }
+    if (plots && plots.line_revenue && plots.line_revenue.x && plots.line_revenue.x.length) {
+      Plotly.newPlot('revenue_chart', [{
+        x: plots.line_revenue.x,
+        y: plots.line_revenue.y,
+        type: 'scatter',
+        mode: 'lines+markers',
+        marker: {color: '#6366f1'},
+        text: plots.line_revenue.names
+      }], {title: 'Revenue by Campaign Start Date', margin: {t:30}, width: 900, height: 350});
+    }
+    if (plots && plots.pie_type && plots.pie_type.labels && plots.pie_type.labels.length) {
+      Plotly.newPlot('type_pie', [{
+        labels: plots.pie_type.labels,
+        values: plots.pie_type.values,
+        type: 'pie'
+      }], {title: 'Campaign Type Distribution', margin: {t:30}, width: 900, height: 350});
+    }
+    if (plots && plots.pie_region && plots.pie_region.labels && plots.pie_region.labels.length) {
+      Plotly.newPlot('region_pie', [{
+        labels: plots.pie_region.labels,
+        values: plots.pie_region.values,
+        type: 'pie'
+      }], {title: 'Top Regions', margin: {t:30}, width: 900, height: 350});
+    }
+  </script>
+  {% endif %}
+
+</section>
+{% endblock %}

templates/index.html

@@ -0,0 +1,104 @@
+{% extends 'base.html' %}
+{% block content %}
+<!-- Hero section -->
+<section class="hero-bg">
+    <div class="hero-overlay flex flex-col justify-center items-center">
+        <h1 class="text-5xl text-white font-bold mb-4 animate-on-scroll">Transform Your Data</h1>
+        <p class="mb-6 text-xl text-white animate-on-scroll">Empower your sales & inventory decisions with advanced predictive analytics.</p>
+        <a href="/forecast/sales" class="btn-custom bg-blue-500 text-white px-8 py-3 rounded-full shadow-lg hover:bg-blue-600 transition animate-on-scroll">
+            Get Started
+        </a>
+    </div>
+</section>
+
+<!-- Features Section -->
+<section id="features" class="py-16 bg-gray-50">
+    <div class="container mx-auto px-4">
+        <!-- Sales Prediction -->
+        <div class="flex flex-col md:flex-row items-center my-12 animate-on-scroll">
+            <div class="md:w-1/2 md:pr-8">
+                <h2 class="text-3xl font-bold mb-4">Sales Prediction Engine</h2>
+                <p class="mb-4">Forecast daily sales with high accuracy using state-of-the-art machine learning and time-series models.</p>
+                <a href="/forecast/sales" class="text-blue-500 hover:underline">Learn More</a>
+            </div>
+            <div class="md:w-1/2">
+                <img src="static\images\sales prediction.png" alt="Sales Prediction" class="w-full rounded-lg shadow-lg">
+            </div>
+        </div>
+
+        <!-- Campaign Analysis -->
+        <div class="flex flex-col md:flex-row-reverse items-center my-12 animate-on-scroll">
+            <div class="md:w-1/2 md:pl-8">
+                <h2 class="text-3xl font-bold mb-4">Campaign Analysis</h2>
+                <p class="mb-4">Analyze campaign performance to optimize ROI and boost customer engagement through comprehensive insights.</p>
+                <a href="/campaign" class="text-blue-500 hover:underline">Learn More</a>
+            </div>
+            <div class="md:w-1/2">
+                <img src="static\images\campaign.jpg" alt="Campaign Analysis" class="w-full rounded-lg shadow-lg">
+            </div>
+        </div>
+
+        <!-- Inventory Optimization -->
+        <div class="flex flex-col md:flex-row items-center my-12 animate-on-scroll">
+            <div class="md:w-1/2 md:pr-8">
+                <h2 class="text-3xl font-bold mb-4">Inventory Optimization</h2>
+                <p class="mb-4">Utilize demand forecasting and sophisticated optimization algorithms to reduce surplus and prevent stockouts.</p>
+                <a href="/inventory" class="text-blue-500 hover:underline">Learn More</a>
+            </div>
+            <div class="md:w-1/2">
+                <img src="static\images\inventory.png" alt="Inventory Optimization" class="w-full rounded-lg shadow-lg">
+            </div>
+        </div>
+
+        <!-- Pricing Intelligence -->
+        <div class="flex flex-col md:flex-row-reverse items-center my-12 animate-on-scroll">
+            <div class="md:w-1/2 md:pl-8">
+                <h2 class="text-3xl font-bold mb-4">Pricing Intelligence</h2>
+                <p class="mb-4">Optimize pricing strategies with advanced conversion analytics and price elasticity models for maximum revenue.</p>
+                <a href="/pricing" class="text-blue-500 hover:underline">Learn More</a>
+            </div>
+            <div class="md:w-1/2">
+                <img src="static\images\pricing.jpg" alt="Pricing Intelligence" class="w-full rounded-lg shadow-lg">
+            </div>
+        </div>
+
+        <!-- Underperformance Detector -->
+        <div class="flex flex-col md:flex-row items-center my-12 animate-on-scroll">
+            <div class="md:w-1/2 md:pr-8">
+                <h2 class="text-3xl font-bold mb-4">Underperformance Detector</h2>
+                <p class="mb-4">Identify low-performing segments and uncover upsell opportunities through advanced analytics insights.</p>
+                <a href="/underperformance" class="text-blue-500 hover:underline">Learn More</a>
+            </div>
+            <div class="md:w-1/2">
+                <img src="static\images\underperforming.png" alt="Underperformance Detector" class="w-full rounded-lg shadow-lg">
+            </div>
+        </div>
+
+        <!-- Machine Failure -->
+        <div class="flex flex-col md:flex-row-reverse items-center my-12 animate-on-scroll">
+            <div class="md:w-1/2 md:pl-8">
+                <h2 class="text-3xl font-bold mb-4">Machine Failure Predictor</h2>
+                <p class="mb-4">Predict machine failure before breakdown.</p>
+                <a href="/predict/machine_failure" class="text-blue-500 hover:underline">Learn More</a>
+            </div>
+            <div class="md:w-1/2">
+                <img src="static\images\machine.jpeg" alt="Underperformance Detector" class="w-full rounded-lg shadow-lg">
+            </div>
+        </div>
+
+        <!-- Supply Failure -->
+        <div class="flex flex-col md:flex-row items-center my-12 animate-on-scroll">
+            <div class="md:w-1/2 md:pr-8">
+                <h2 class="text-3xl font-bold mb-4">Supply Chain Failure Predictor</h2>
+                <p class="mb-4">Predict supply chain failure before breakdown.</p>
+                <a href="/predict/supply_failure" class="text-blue-500 hover:underline">Learn More</a>
+            </div>
+            <div class="md:w-1/2">
+                <img src="static\images\supply.jpeg" alt="Underperformance Detector" class="w-full rounded-lg shadow-lg">
+            </div>
+        </div>
+
+
+    </div>
+</section>
+{% endblock %}

templates/inventory_optimization.html

@@ -0,0 +1,11 @@
+{% extends 'base.html' %}
+{% block content %}
+<section>
+  <h1 class="text-3xl font-bold mb-4">Inventory Optimization</h1>
+  <p class="mb-6">Minimize stockouts and reduce surplus by leveraging demand forecasting and optimization algorithms.</p>
+  <div class="bg-white p-6 rounded shadow">
+      <!-- Future dashboard elements for inventory planning -->
+      <p>[Inventory optimization dashboard components here...]</p>
+  </div>
+</section>
+{% endblock %}

templates/machine_failure.html

@@ -0,0 +1,101 @@
+{% extends 'base.html' %}
+{% block content %}
+<section class="py-8">
+    <h1 class="text-3xl font-bold mb-4">Machine Failure Prediction</h1>
+    
+    <div class="bg-gray-50 p-6 rounded shadow mb-6">
+        <h2 class="text-2xl font-semibold mb-2">Upload Machine Failure Data (CSV)</h2>
+        <form action="{{ url_for('machine_failure.upload_file') }}" method="POST" enctype="multipart/form-data">
+            <input type="file" name="machine_file" accept=".csv" class="mb-4 block">
+            <button type="submit" class="btn-learn-more">Upload</button>
+        </form>
+    </div>
+
+    {% if preview_data %}
+    <div class="bg-white p-6 rounded shadow mb-6">
+        <h2 class="text-2xl font-semibold mb-4">Data Preview (First 5 Rows)</h2>
+        <div class="overflow-x-auto">
+            <table id="preview-table" class="min-w-full table-auto">
+                <thead>
+                    <tr>
+                        {% for column in columns %}
+                        <th class="px-4 py-2 bg-gray-100">{{ column }}</th>
+                        {% endfor %}
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for row in preview_data %}
+                    <tr>
+                        {% for column in columns %}
+                        <td class="border px-4 py-2">{{ row[column] }}</td>
+                        {% endfor %}
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+    </div>
+
+    <div class="bg-white p-6 rounded shadow">
+        <h2 class="text-2xl font-semibold mb-4">Summary Statistics</h2>
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+            <div class="p-4 bg-blue-50 rounded">
+                <p><strong>Total Rows:</strong> <span class="summary-total-rows">{{ summary_stats.total_rows }}</span></p>
+                <p><strong>Total Columns:</strong> <span class="summary-total-cols">{{ summary_stats.total_columns }}</span></p>
+            </div>
+            <div class="p-4 bg-green-50 rounded">
+                <p><strong>Numeric Columns:</strong> <span class="summary-numeric-cols">{{ summary_stats.numeric_columns|join(', ') }}</span></p>
+                <p><strong>Categorical Columns:</strong> <span class="summary-categorical-cols">{{ summary_stats.categorical_columns|join(', ') }}</span></p>
+            </div>
+        </div>
+    </div>
+
+    <div id="feature-importance" class="bg-white p-6 rounded shadow mt-6 hidden">
+        <h2 class="text-2xl font-semibold mb-4">Top 5 Feature Importances</h2>
+        <div id="feature-importance-list"></div>
+    </div>
+        
+    <div class="bg-white p-6 rounded shadow mt-6">
+        <h2 class="text-2xl font-semibold mb-4">Failure Prediction Metrics</h2>
+        <div class="flex flex-wrap gap-4 mb-4">
+            <div>
+                <label class="block font-semibold mb-1">Target Column</label>
+                <select id="predictTargetCol" class="border rounded p-2">
+                    {% for column in columns %}
+                    <option value="{{ column }}">{{ column }}</option>
+                    {% endfor %}
+                </select>
+            </div>
+            <div>
+                <label class="block font-semibold mb-1">Model</label>
+                <select id="predictModel" class="border rounded p-2">
+                    <option value="Random Forest">Random Forest</option>
+                    <option value="XGBoost">XGBoost</option>
+                    <option value="Logistic Regression">Logistic Regression</option>
+                </select>
+            </div>
+            <div class="flex items-end">
+                <button onclick="runPrediction()" class="btn-learn-more">Run Prediction</button>
+            </div>
+        </div>
+        <div id="predict-metrics" class="mb-4"></div>
+        <div id="predict-error" class="text-red-600 font-semibold mt-2"></div>
+    </div>
+
+    <div id="single-prediction-section" class="bg-white p-6 rounded shadow mt-6 hidden">
+        <h2 class="text-2xl font-semibold mb-4">Predict for a Single Instance</h2>
+        <form id="single-prediction-form" class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4 mb-4">
+            </form>
+        <button onclick="predictSingleInstance()" class="btn-learn-more">Predict</button>
+        <div id="single-prediction-result" class="mt-4 p-4 bg-blue-100 rounded hidden">
+            <p class="font-semibold text-lg">Prediction: <span id="prediction-output" class="font-bold text-blue-800"></span></p>
+            <div id="probability-output" class="mt-2 text-sm"></div>
+        </div>
+        <div id="single-prediction-error" class="text-red-600 font-semibold mt-2"></div>
+    </div>
+    {% endif %}
+
+</section>
+<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+<script src="{{ url_for('static', filename='index.js') }}"></script>
+{% endblock %}

templates/pricing_intelligence.html

@@ -0,0 +1,11 @@
+{% extends 'base.html' %}
+{% block content %}
+<section>
+  <h1 class="text-3xl font-bold mb-4">Pricing Intelligence</h1>
+  <p class="mb-6">Discover optimal pricing strategies based on price elasticity and conversion analysis to maximize revenue.</p>
+  <div class="bg-white p-6 rounded shadow">
+      <!-- Future pricing analytics components -->
+      <p>[Pricing intelligence dashboard components here...]</p>
+  </div>
+</section>
+{% endblock %}

templates/sales_prediction.html

@@ -0,0 +1,147 @@
+{% extends 'base.html' %}
+{% block content %}
+<section class="py-8">
+    <h1 class="text-3xl font-bold mb-4">Sales Prediction Engine</h1>
+    
+    <!-- File Upload Form -->
+    <div class="bg-gray-50 p-6 rounded shadow mb-6">
+        <h2 class="text-2xl font-semibold mb-2">Upload Sales Data (CSV)</h2>
+        <form action="{{ url_for('sales_prediction.upload_file') }}" method="POST" enctype="multipart/form-data">
+            <input type="file" name="sales_file" accept=".csv" class="mb-4 block">
+            <button type="submit" class="btn-learn-more">Upload</button>
+        </form>
+    </div>
+
+    {% if preview_data %}
+    <!-- Data Preview -->
+    <div class="bg-white p-6 rounded shadow mb-6">
+        <h2 class="text-2xl font-semibold mb-4">Data Preview (First 5 Rows)</h2>
+        <div class="overflow-x-auto">
+            <table id="preview-table" class="min-w-full table-auto">
+                <thead>
+                    <tr>
+                        {% for column in columns %}
+                        <th class="px-4 py-2 bg-gray-100">{{ column }}</th>
+                        {% endfor %}
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for row in preview_data %}
+                    <tr>
+                        {% for column in columns %}
+                        <td class="border px-4 py-2">{{ row[column] }}</td>
+                        {% endfor %}
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+    </div>
+
+    <!-- Summary Statistics -->
+    <div class="bg-white p-6 rounded shadow">
+        <h2 class="text-2xl font-semibold mb-4">Summary Statistics</h2>
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+            <div class="p-4 bg-blue-50 rounded">
+                <p><strong>Total Rows:</strong> <span class="summary-total-rows">{{ summary_stats.total_rows }}</span></p>
+                <p><strong>Total Columns:</strong> <span class="summary-total-cols">{{ summary_stats.total_columns }}</span></p>
+            </div>
+            <div class="p-4 bg-green-50 rounded">
+                <p><strong>Numeric Columns:</strong> <span class="summary-numeric-cols">{{ summary_stats.numeric_columns|join(', ') }}</span></p>
+                <p><strong>Categorical Columns:</strong> <span class="summary-categorical-cols">{{ summary_stats.categorical_columns|join(', ') }}</span></p>
+            </div>
+        </div>
+        
+        <!-- Missing Values Summary & No-code Fix UI -->
+        {% set null_columns = [] %}
+        {% for column, count in summary_stats.missing_values.items() %}
+            {% if count > 0 %}
+                {% set _ = null_columns.append((column, count)) %}
+            {% endif %}
+        {% endfor %}
+        <div class="mt-4 p-4 bg-yellow-50 rounded">
+            <h3 class="font-semibold mb-2">Missing Values</h3>
+            <ul id="null-list">
+                {% for column, count in null_columns %}
+                <li>
+                    <span>{{ column }}: {{ count }} missing values</span>
+                    <select id="method-{{ column }}" class="border rounded p-1 mx-2">
+                        <option value="drop">Drop Rows</option>
+                        <option value="mean">Fill Mean</option>
+                        <option value="median">Fill Median</option>
+                        <option value="mode">Fill Mode</option>
+                    </select>
+                    <button class="btn-learn-more" onclick="fixNulls('{{ column }}')">Fix</button>
+                </li>
+                {% endfor %}
+            </ul>
+            <div id="null-fix-message" class="mt-2 text-green-700 font-semibold"></div>
+        </div>
+    </div>
+
+    <!-- Data Visualization -->
+    <div class="bg-white p-6 rounded shadow mt-6">
+        <h2 class="text-2xl font-semibold mb-4">Data Visualization</h2>
+        <div class="flex gap-4 mb-4">
+            <select id="plotColumn" class="border rounded p-2">
+                {% for column in columns %}
+                <option value="{{ column }}">{{ column }}</option>
+                {% endfor %}
+            </select>
+            <select id="plotType" class="border rounded p-2">
+                <option value="histogram">Histogram (Numeric)</option>
+                <option value="box">Box Plot (Numeric)</option>
+                <option value="bar">Bar Plot (Categorical)</option>
+            </select>
+            <button onclick="createPlot()" class="btn-learn-more">Generate Plot</button>
+        </div>
+        <div id="plotDiv" class="w-full h-96"></div>
+    </div>
+
+    <!-- Forecasting -->
+    <div class="bg-white p-6 rounded shadow mt-6">
+        <h2 class="text-2xl font-semibold mb-4">Forecasting</h2>
+        <div class="flex flex-wrap gap-4 mb-4">
+            <div>
+                <label class="block font-semibold mb-1">Date Column</label>
+                <select id="forecastDateCol" class="border rounded p-2">
+                    {% for column in columns %}
+                    <option value="{{ column }}">{{ column }}</option>
+                    {% endfor %}
+                </select>
+            </div>
+            <div>
+                <label class="block font-semibold mb-1">Target Column</label>
+                <select id="forecastTargetCol" class="border rounded p-2">
+                    {% for column in columns %}
+                    <option value="{{ column }}">{{ column }}</option>
+                    {% endfor %}
+                </select>
+            </div>
+            <div>
+                <label class="block font-semibold mb-1">Model</label>
+                <select id="forecastModel" class="border rounded p-2">
+                    <option value="ARIMA">ARIMA</option>
+                    <option value="Prophet">Prophet</option>
+                    <option value="Random Forest">Random Forest</option>
+                    <option value="XGBoost">XGBoost</option>
+                    <option value="LSTM">LSTM</option>
+                </select>
+            </div>
+            <div>
+                <label class="block font-semibold mb-1">Forecast Horizon</label>
+                <input id="forecastHorizon" type="number" value="30" min="1" max="365" class="border rounded p-2 w-20">
+            </div>
+            <div class="flex items-end">
+                <button onclick="runForecast()" class="btn-learn-more">Run Forecast</button>
+            </div>
+        </div>
+        <div id="forecast-metrics" class="mb-4"></div>
+        <div id="forecast-plot" class="w-full h-96"></div>
+        <div id="forecast-error" class="text-red-600 font-semibold mt-2"></div>
+    </div>
+    {% endif %}
+</section>
+<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+<script src="{{ url_for('static', filename='index.js') }}"></script>
+{% endblock %}

templates/supply_failure.html

@@ -0,0 +1,99 @@
+{% extends 'base.html' %}
+{% block content %}
+<section class="py-8">
+    <h1 class="text-3xl font-bold mb-4">Supply Failure Prediction</h1>
+    
+    <div class="bg-gray-50 p-6 rounded shadow mb-6">
+        <h2 class="text-2xl font-semibold mb-2">Upload Supply Chain Data (CSV)</h2>
+        <form action="{{ url_for('supply_failure.upload_file_supply') }}" method="POST" enctype="multipart/form-data">
+            <input type="file" name="supply_file" accept=".csv" class="mb-4 block">
+            <button type="submit" class="btn-learn-more">Upload</button>
+        </form>
+    </div>
+
+    {% if preview_data %}
+    <div class="bg-white p-6 rounded shadow mb-6">
+        <h2 class="text-2xl font-semibold mb-4">Data Preview (First 5 Rows)</h2>
+        <div class="overflow-x-auto">
+            <table id="preview-table" class="min-w-full table-auto">
+                <thead>
+                    <tr>
+                        {% for column in columns %}
+                        <th class="px-4 py-2 bg-gray-100">{{ column }}</th>
+                        {% endfor %}
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for row in preview_data %}
+                    <tr>
+                        {% for column in columns %}
+                        <td class="border px-4 py-2">{{ row[column] }}</td>
+                        {% endfor %}
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+    </div>
+
+    <div class="bg-white p-6 rounded shadow">
+        <h2 class="text-2xl font-semibold mb-4">Summary Statistics</h2>
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+            <div class="p-4 bg-blue-50 rounded">
+                <p><strong>Total Rows:</strong> <span class="summary-total-rows">{{ summary_stats.total_rows }}</span></p>
+                <p><strong>Total Columns:</strong> <span class="summary-total-cols">{{ summary_stats.total_columns }}</span></p>
+            </div>
+            <div class="p-4 bg-green-50 rounded">
+                <p><strong>Numeric Columns:</strong> <span class="summary-numeric-cols">{{ summary_stats.numeric_columns|join(', ') }}</span></p>
+                <p><strong>Categorical Columns:</strong> <span class="summary-categorical-cols">{{ summary_stats.categorical_columns|join(', ') }}</span></p>
+            </div>
+        </div>
+    </div>
+
+    <div id="feature-importance" class="bg-white p-6 rounded shadow mt-6 hidden">
+        <h2 class="text-2xl font-semibold mb-4">Top 5 Feature Importances</h2>
+        <div id="feature-importance-list"></div>
+    </div>
+        
+    <div class="bg-white p-6 rounded shadow mt-6">
+        <h2 class="text-2xl font-semibold mb-4">Supply Failure Prediction Metrics</h2>
+        <div class="flex flex-wrap gap-4 mb-4">
+            <div>
+                <label class="block font-semibold mb-1">Target Column</label>
+                <select id="predictTargetColSupply" class="border rounded p-2" disabled>
+                    <option value="failure_flag">failure_flag</option>
+                </select>
+            </div>
+            <div>
+                <label class="block font-semibold mb-1">Model</label>
+                <select id="predictModelSupply" class="border rounded p-2">
+                    <option value="Random Forest">Random Forest</option>
+                    <option value="XGBoost">XGBoost</option>
+                    <option value="Logistic Regression">Logistic Regression</option>
+                </select>
+            </div>
+            <div class="flex items-end">
+                <button onclick="runSupplyPrediction()" class="btn-learn-more">Run Prediction</button>
+            </div>
+        </div>
+        <div id="predict-metrics-supply" class="mb-4"></div>
+        <div id="predict-error-supply" class="text-red-600 font-semibold mt-2"></div>
+    </div>
+
+    <div id="single-prediction-section-supply" class="bg-white p-6 rounded shadow mt-6 hidden">
+        <h2 class="text-2xl font-semibold mb-4">Predict for a Single Supply Instance</h2>
+        <form id="single-prediction-form-supply" class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4 mb-4">
+            </form>
+        <button onclick="predictSupplySingleInstance()" class="btn-learn-more">Predict</button>
+        <div id="single-prediction-result-supply" class="mt-4 p-4 bg-blue-100 rounded hidden">
+            <p class="font-semibold text-lg">Prediction: <span id="prediction-output-supply" class="font-bold text-blue-800"></span></p>
+            <div id="probability-output-supply" class="mt-2 text-sm"></div>
+        </div>
+        <div id="single-prediction-error-supply" class="text-red-600 font-semibold mt-2"></div>
+    </div>
+    {% endif %}
+
+</section>
+<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+<script src="{{ url_for('static', filename='index.js') }}"></script>
+{% endblock %}

templates/underperformance.html

@@ -0,0 +1,11 @@
+{% extends 'base.html' %}
+{% block content %}
+<section>
+  <h1 class="text-3xl font-bold mb-4">Underperformance & Upsell Detector</h1>
+  <p class="mb-6">Identify products and segments that are underperforming along with upsell opportunities using advanced analytics.</p>
+  <div class="bg-white p-6 rounded shadow">
+      <!-- Future dashboard view for underperformance -->
+      <p>[Underperformance analysis components here...]</p>
+  </div>
+</section>
+{% endblock %}