Create app.py

app.py

@@ -0,0 +1,1275 @@
+import pandas as pd
+import numpy as np
+import pulp as pl
+import matplotlib.pyplot as plt
+import gradio as gr
+from itertools import product
+import io
+import base64
+import tempfile
+import os
+from datetime import datetime
+import plotly.express as px
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+import seaborn as sns
+from ortools.sat.python import cp_model
+import random
+from deap import base, creator, tools, algorithms
+import time
+
+def am_pm(hour):
+    """Converts 24-hour time to AM/PM format."""
+    period = "AM"
+    if hour >= 12:
+        period = "PM"
+    if hour > 12:
+        hour -= 12
+    elif hour == 0:
+        hour = 12  # Midnight
+    return f"{int(hour):02d}:00 {period}"
+
+def show_dataframe(csv_path):
+    """Reads a CSV file and returns a Pandas DataFrame."""
+    try:
+        df = pd.read_csv(csv_path)
+        return df
+    except Exception as e:
+        return f"Error loading CSV: {e}"
+
+def optimize_staffing(csv_file, beds_per_staff, max_hours_per_staff, overlap_time):
+    try:
+        # Load data
+        data = pd.read_csv(csv_file)
+        num_days = len(data)
+        
+        # Define cycles and their hours
+        cycles = {
+            'cycle_1': range(7, 12),   # 7 AM - 12 PM
+            'cycle_2': range(12, 17),  # 12 PM - 5 PM
+            'cycle_3': range(17, 22),  # 5 PM - 10 PM
+            'cycle_4': range(22, 24) + range(0, 3),  # 10 PM - 3 AM
+        }
+        
+        # Calculate hourly demand
+        hourly_demand = {}
+        for d in range(num_days):
+            cycle_demands = {}
+            for col in data.columns:
+                if col.startswith('cycle'):
+                    # Handle NaN values by filling with 0
+                    beds = float(data.iloc[d][col]) if not pd.isna(data.iloc[d][col]) else 0
+                    cycle_demands[col] = int(np.ceil(beds / beds_per_staff))
+            
+            for h in range(24):
+                for cycle, hours in cycles.items():
+                    if h in hours:
+                        hourly_demand[(d,h)] = cycle_demands.get(cycle, 0)
+                        break
+                else:
+                    hourly_demand[(d,h)] = 0  # No demand for hours not in any cycle
+
+        # Check for NaN in hourly_demand
+        if any(pd.isna(value) for value in hourly_demand.values()):
+            raise ValueError("Hourly demand calculation resulted in NaN values.")
+
+        min_staff = max(hourly_demand.values()) + 1
+        
+        # Create model
+        model = cp_model.CpModel()
+        
+        # Variables
+        x = {}        # x[s,d,h] = 1 if staff s works hour h on day d
+        working = {}  # working[s,d] = 1 if staff s works on day d
+        start = {}    # start[s,d] = start hour for staff s on day d
+        
+        for s in range(min_staff):
+            for d in range(num_days):
+                working[s,d] = model.NewBoolVar(f'working_{s}_{d}')
+                start[s,d] = model.NewIntVar(0, 23, f'start_{s}_{d}')
+                for h in range(24):
+                    x[s,d,h] = model.NewBoolVar(f'x_{s}_{d}_{h}')
+
+        # 1. Coverage constraints
+        for (d,h), demand in hourly_demand.items():
+            if demand > 0:
+                model.Add(sum(x[s,d,h] for s in range(min_staff)) >= demand)
+
+        # 2. Shift constraints (6-12 hours)
+        for s in range(min_staff):
+            for d in range(num_days):
+                # Link working to shifts
+                model.Add(sum(x[s,d,h] for h in range(24)) >= 6).OnlyEnforceIf(working[s,d])
+                model.Add(sum(x[s,d,h] for h in range(24)) <= 12).OnlyEnforceIf(working[s,d])
+                model.Add(sum(x[s,d,h] for h in range(24)) == 0).OnlyEnforceIf(working[s,d].Not())
+
+                # Link start hour to shift start
+                for h in range(24):
+                    model.Add(start[s,d] == h).OnlyEnforceIf([x[s,d,h], working[s,d]])
+                    if h > 0:
+                        model.Add(x[s,d,h-1] == 0).OnlyEnforceIf([x[s,d,h], working[s,d]])
+
+        # 3. Consecutive days timing (±1 hour)
+        for s in range(min_staff):
+            for d in range(num_days-1):
+                model.Add(start[s,d+1] - start[s,d] >= -1).OnlyEnforceIf([working[s,d], working[s,d+1]])
+                model.Add(start[s,d+1] - start[s,d] <= 1).OnlyEnforceIf([working[s,d], working[s,d+1]])
+
+        # 4. Weekly rest day
+        for s in range(min_staff):
+            for w in range((num_days + 6) // 7):
+                week_start = w * 7
+                week_end = min((w + 1) * 7, num_days)
+                model.Add(sum(working[s,d] for d in range(week_start, week_end)) <= 6)
+
+        # 5. Monthly hours limit
+        for s in range(min_staff):
+            model.Add(sum(x[s,d,h] for d in range(num_days) for h in range(24)) <= max_hours_per_staff)
+
+        # Solve
+        solver = cp_model.CpSolver()
+        solver.parameters.max_time_in_seconds = 300
+        solver.parameters.num_search_workers = 8
+        
+        status = solver.Solve(model)
+        
+        if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
+            solution = np.zeros((min_staff, num_days, 24))
+            for s in range(min_staff):
+                for d in range(num_days):
+                    for h in range(24):
+                        if solver.Value(x[s,d,h]) == 1:
+                            solution[s,d,h] = 1
+            return process_solution(solution, min_staff, num_days)
+            
+        return None
+
+    except Exception as e:
+        print(f"Optimization error: {str(e)}")
+        return None
+
+def convert_to_24h(time_str):
+    """Converts AM/PM time string to 24-hour format."""
+    try:
+        time_obj = datetime.strptime(time_str, "%I:00 %p")
+        return time_obj.hour
+    except ValueError:
+        return None
+
+def gradio_wrapper(
+    csv_file, beds_per_staff, max_hours_per_staff, hours_per_cycle,
+    rest_days_per_week, clinic_start_ampm, clinic_end_ampm, overlap_time, max_start_time_change,
+    exact_staff_count=None, overtime_percent=100
+):
+    try:
+        # Convert AM/PM times to 24-hour format
+        clinic_start = convert_to_24h(clinic_start_ampm)
+        clinic_end = convert_to_24h(clinic_end_ampm)
+        
+        # Call the optimization function
+        results, staff_assignment_df, gantt_path, schedule_df, plot_path, schedule_csv_path, staff_assignment_csv_path = optimize_staffing(
+            csv_file, beds_per_staff, max_hours_per_staff, overlap_time
+        )
+        
+        # Return the results
+        return staff_assignment_df, gantt_path, schedule_df, plot_path, staff_assignment_csv_path, schedule_csv_path
+    except Exception as e:
+        # If there's an error in the optimization process, return a meaningful error message
+        empty_staff_df = pd.DataFrame(columns=["Day"])
+        error_message = f"Error during optimization: {str(e)}\n\nPlease try with different parameters or a simpler dataset."
+        # Return error in the first output
+        return empty_staff_df, None, None, None, None, None
+
+# Create a Gantt chart with advanced visuals and alternating labels - only showing active staff
+def create_gantt_chart(schedule_df, num_days, staff_count):
+    # Get the list of active staff IDs (staff who have at least one shift)
+    active_staff_ids = sorted(schedule_df['staff_id'].unique())
+    active_staff_count = len(active_staff_ids)
+    
+    # Create a mapping from original staff ID to position in the chart
+    staff_position = {staff_id: i+1 for i, staff_id in enumerate(active_staff_ids)}
+    
+    # Create a larger figure with higher DPI
+    plt.figure(figsize=(max(30, num_days * 1.5), max(12, active_staff_count * 0.8)), dpi=200)
+    
+    # Use a more sophisticated color palette - only for active staff
+    colors = plt.cm.viridis(np.linspace(0.1, 0.9, active_staff_count))
+    
+    # Set a modern style
+    plt.style.use('seaborn-v0_8-whitegrid')
+    
+    # Create a new axis with a slight background color
+    
+    ax = plt.gca()
+    ax.set_facecolor('#f8f9fa')
+    
+    # Sort by staff then day
+    schedule_df = schedule_df.sort_values(['staff_id', 'day'])
+    
+    # Plot Gantt chart - only for active staff
+    for i, staff_id in enumerate(active_staff_ids):
+        staff_shifts = schedule_df[schedule_df['staff_id'] == staff_id]
+        
+        y_pos = active_staff_count - i  # Position based on index in active staff list
+        
+        # Add staff label with a background box
+        ax.text(-0.7, y_pos, f"Staff {staff_id}", fontsize=12, fontweight='bold', 
+                ha='right', va='center', bbox=dict(facecolor='white', edgecolor='gray', 
+                                                  boxstyle='round,pad=0.5', alpha=0.9))
+        
+        # Add a subtle background for each staff row
+        ax.axhspan(y_pos-0.4, y_pos+0.4, color='white', alpha=0.4, zorder=-5)
+        
+        # Track shift positions to avoid label overlap
+        shift_positions = []
+        
+        for idx, shift in enumerate(staff_shifts.iterrows()):
+            _, shift = shift
+            day = shift['day']
+            start_hour = shift['start']
+            end_hour = shift['end']
+            duration = shift['duration']
+            
+            # Format times for display
+            start_ampm = am_pm(start_hour)
+            end_ampm = am_pm(end_hour)
+            
+            # Calculate shift position
+            shift_start_pos = day-1+start_hour/24
+            
+            # Handle overnight shifts
+            if end_hour < start_hour:  # Overnight shift
+                # First part of shift (until midnight)
+                rect1 = ax.barh(y_pos, (24-start_hour)/24, left=shift_start_pos, 
+                       height=0.6, color=colors[i], alpha=0.9, 
+                       edgecolor='black', linewidth=1, zorder=10)
+                
+                # Add gradient effect
+                for r in rect1:
+                    r.set_edgecolor('black')
+                    r.set_linewidth(1)
+                
+                # Second part of shift (after midnight)
+                rect2 = ax.barh(y_pos, end_hour/24, left=day, 
+                       height=0.6, color=colors[i], alpha=0.9,
+                       edgecolor='black', linewidth=1, zorder=10)
+                
+                # Add gradient effect
+                for r in rect2:
+                    r.set_edgecolor('black')
+                    r.set_linewidth(1)
+                
+                # For overnight shifts, we'll place the label in the first part if it's long enough
+                shift_width = (24-start_hour)/24
+                if shift_width >= 0.1:  # Only add label if there's enough space
+                    label_pos = shift_start_pos + shift_width/2
+                    
+                    # Alternate labels above and below
+                    y_offset = 0.35 if idx % 2 == 0 else -0.35
+                    
+                    # Add label with background for better readability
+                    label = f"{start_ampm}-{end_ampm}"
+                    text = ax.text(label_pos, y_pos + y_offset, label, 
+                           ha='center', va='center', fontsize=9, fontweight='bold',
+                           color='black', bbox=dict(facecolor='white', alpha=0.9, pad=3, 
+                                                   boxstyle='round,pad=0.3', edgecolor='gray'),
+                           zorder=20)
+                    
+                    shift_positions.append(label_pos)
+            else:
+                # Regular shift
+                shift_width = duration/24
+                rect = ax.barh(y_pos, shift_width, left=shift_start_pos, 
+                       height=0.6, color=colors[i], alpha=0.9,
+                       edgecolor='black', linewidth=1, zorder=10)
+                
+                # Add gradient effect
+                for r in rect:
+                    r.set_edgecolor('black')
+                    r.set_linewidth(1)
+                
+                # Only add label if there's enough space
+                if shift_width >= 0.1:
+                    label_pos = shift_start_pos + shift_width/2
+                    
+                    # Alternate labels above and below
+                    y_offset = 0.35 if idx % 2 == 0 else -0.35
+                    
+                    # Add label with background for better readability
+                    label = f"{start_ampm}-{end_ampm}"
+                    text = ax.text(label_pos, y_pos + y_offset, label, 
+                           ha='center', va='center', fontsize=9, fontweight='bold',
+                           color='black', bbox=dict(facecolor='white', alpha=0.9, pad=3, 
+                                                   boxstyle='round,pad=0.3', edgecolor='gray'),
+                           zorder=20)
+                    
+                    shift_positions.append(label_pos)
+    
+    # Add weekend highlighting with a more sophisticated look
+    for day in range(1, num_days + 1):
+        # Determine if this is a weekend (assuming day 1 is Monday)
+        is_weekend = (day % 7 == 0) or (day % 7 == 6)  # Saturday or Sunday
+        
+        if is_weekend:
+            ax.axvspan(day-1, day, alpha=0.15, color='#ff9999', zorder=-10)
+            day_label = "Saturday" if day % 7 == 6 else "Sunday"
+            ax.text(day-0.5, 0.2, day_label, ha='center', fontsize=10, color='#cc0000',
+                   fontweight='bold', bbox=dict(facecolor='white', alpha=0.7, pad=2, boxstyle='round'))
+    
+    # Set x-axis ticks for each day with better formatting
+    ax.set_xticks(np.arange(0.5, num_days, 1))
+    day_labels = [f"Day {d}" for d in range(1, num_days+1)]
+    ax.set_xticklabels(day_labels, rotation=0, ha='center', fontsize=10)
+    
+    # Add vertical lines between days with better styling
+    for day in range(1, num_days):
+        ax.axvline(x=day, color='#aaaaaa', linestyle='-', alpha=0.5, zorder=-5)
+    
+    # Set y-axis ticks for each staff
+    ax.set_yticks(np.arange(1, active_staff_count+1))
+    ax.set_yticklabels([])  # Remove default labels as we've added custom ones
+    
+    # Set axis limits with some padding
+    ax.set_xlim(-0.8, num_days)
+    ax.set_ylim(0.5, active_staff_count + 0.5)
+    
+    # Add grid for hours (every 6 hours) with better styling
+    for day in range(num_days):
+        for hour in [6, 12, 18]:
+            ax.axvline(x=day + hour/24, color='#cccccc', linestyle=':', alpha=0.5, zorder=-5)
+            # Add small hour markers at the bottom
+            hour_label = "6AM" if hour == 6 else "Noon" if hour == 12 else "6PM"
+            ax.text(day + hour/24, 0, hour_label, ha='center', va='bottom', fontsize=7, 
+                   color='#666666', rotation=90, alpha=0.7)
+    
+    # Add title and labels with more sophisticated styling
+    plt.title(f'Staff Schedule ({active_staff_count} Active Staff)', fontsize=24, fontweight='bold', pad=20, color='#333333')
+    plt.xlabel('Day', fontsize=16, labelpad=10, color='#333333')
+    
+    # Add a legend for time reference with better styling
+    time_box = plt.figtext(0.01, 0.01, "Time Reference:", ha='left', fontsize=10, 
+                          fontweight='bold', color='#333333')
+    time_markers = ['6 AM', 'Noon', '6 PM', 'Midnight']
+    for i, time in enumerate(time_markers):
+        plt.figtext(0.08 + i*0.06, 0.01, time, ha='left', fontsize=9, color='#555555')
+    
+    # Remove spines
+    for spine in ['top', 'right', 'left']:
+        ax.spines[spine].set_visible(False)
+    
+    # Add a note about weekends with better styling
+    weekend_note = plt.figtext(0.01, 0.97, "Red areas = Weekends", fontsize=12, 
+                              color='#cc0000', fontweight='bold',
+                              bbox=dict(facecolor='white', alpha=0.7, pad=5, boxstyle='round'))
+    
+    # Add a subtle border around the entire chart
+    plt.box(False)
+    
+    # Save the Gantt chart with high quality
+    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f:
+        plt.tight_layout()
+        plt.savefig(f.name, dpi=200, bbox_inches='tight', facecolor='white')
+        plt.close()
+        return f.name
+
+# Define Gradio UI
+am_pm_times = [f"{i:02d}:00 AM" for i in range(1, 13)] + [f"{i:02d}:00 PM" for i in range(1, 13)]
+
+# Add CSS for chart containers
+css = """
+.chart-container {
+    height: 800px !important;
+    width: 100% !important;
+    margin: 20px 0;
+    padding: 20px;
+    border: 1px solid #ddd;
+    border-radius: 8px;
+    background: white;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.weekly-chart-container {
+    height: 1000px !important;
+    width: 100% !important;
+    margin: 20px 0;
+    padding: 20px;
+    border: 1px solid #ddd;
+    border-radius: 8px;
+    background: white;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+/* Ensure plotly charts are visible */
+.js-plotly-plot {
+    width: 100% !important;
+    height: 100% !important;
+}
+
+/* Improve visibility of chart titles */
+.gtitle {
+    font-weight: bold !important;
+    font-size: 20px !important;
+}
+"""
+
+with gr.Blocks(title="Staff Scheduling Optimizer", css=css) as iface:
+    
+    gr.Markdown("# Staff Scheduling Optimizer")
+    gr.Markdown("Upload a CSV file with cycle data and configure parameters to generate an optimal staff schedule.")
+    
+    with gr.Row():
+        # LEFT PANEL - Inputs
+        with gr.Column(scale=1):
+            gr.Markdown("### Input Parameters")
+            
+            # Input parameters
+            csv_input = gr.File(label="Upload CSV")
+            beds_per_staff = gr.Number(label="Beds per Staff", value=3)
+            max_hours_per_staff = gr.Number(label="Maximum monthly hours", value=160)
+            hours_per_cycle = gr.Number(label="Hours per Cycle", value=4)
+            rest_days_per_week = gr.Number(label="Rest Days per Week", value=2)
+            clinic_start_ampm = gr.Dropdown(label="Clinic Start Hour (AM/PM)", choices=am_pm_times, value="08:00 AM")
+            clinic_end_ampm = gr.Dropdown(label="Clinic End Hour (AM/PM)", choices=am_pm_times, value="08:00 PM")
+            overlap_time = gr.Number(label="Overlap Time", value=0)
+            max_start_time_change = gr.Number(label="Max Start Time Change", value=2)
+            exact_staff_count = gr.Number(label="Exact Staff Count (optional)", value=None)
+            overtime_percent = gr.Slider(label="Overtime Allowed (%)", minimum=0, maximum=100, value=100, step=10)
+            
+            optimize_btn = gr.Button("Optimize Schedule", variant="primary", size="lg")
+        
+        # RIGHT PANEL - Outputs
+        with gr.Column(scale=2):
+            gr.Markdown("### Results")
+            
+            # Tabs for different outputs - reordered
+            with gr.Tabs():
+                with gr.TabItem("Detailed Schedule"):
+                    with gr.Row():
+                        csv_schedule = gr.Dataframe(label="Detailed Schedule", elem_id="csv_schedule")
+                    
+                    with gr.Row():
+                        schedule_download_file = gr.File(label="Download Detailed Schedule", visible=True)
+                
+                with gr.TabItem("Gantt Chart"):
+                    gantt_chart = gr.Image(label="Staff Schedule Visualization", elem_id="gantt_chart")
+                
+                with gr.TabItem("Staff Coverage by Cycle"):
+                    with gr.Row():
+                        staff_assignment_table = gr.Dataframe(label="Staff Count in Each Cycle (Staff May Overlap)", elem_id="staff_assignment_table")
+                    
+                    with gr.Row():
+                        staff_download_file = gr.File(label="Download Coverage Table", visible=True)
+                
+                with gr.TabItem("Constraints and Analytics"):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            gr.Markdown("### Applied Constraints")
+                            constraints_text = gr.TextArea(
+                                label="", 
+                                interactive=False,
+                                show_label=False
+                            )
+                        
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Monthly Distribution")
+                                monthly_chart = gr.HTML(
+                                    label="Monthly Hours Distribution",
+                                    show_label=False,
+                                    elem_classes="chart-container"
+                                )
+                        
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Weekly Distribution")
+                                weekly_charts = gr.HTML(
+                                    label="Weekly Hours Distribution",
+                                    show_label=False,
+                                    elem_classes="weekly-chart-container"
+                                )
+                
+                with gr.TabItem("Staff Overlap"):
+                    with gr.Row():
+                        overlap_chart = gr.HTML(
+                            label="Staff Overlap Visualization",
+                            show_label=False
+                        )
+                    with gr.Row():
+                        gr.Markdown("""
+                        This heatmap shows the number of staff members working simultaneously throughout each day.
+                        - Darker colors indicate more staff overlap
+                        - The x-axis shows time of day in 30-minute intervals
+                        - The y-axis shows each day of the schedule
+                        """)
+                
+                with gr.TabItem("Staff Absence Handler"):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### Handle Staff Absence")
+                            absent_staff = gr.Number(label="Staff ID to be absent", precision=0)
+                            absence_start = gr.Number(label="Start Day", precision=0)
+                            absence_end = gr.Number(label="End Day", precision=0)
+                            handle_absence_btn = gr.Button("Redistribute Shifts", variant="primary")
+                        
+                        with gr.Column():
+                            absence_result = gr.TextArea(label="Redistribution Results", interactive=False)
+                            updated_schedule = gr.DataFrame(label="Updated Schedule")
+                            absence_gantt_chart = gr.Image(label="Absence Schedule Visualization", elem_id="absence_gantt_chart")
+    
+    # Define download functions
+    def create_download_link(df, filename="data.csv"):
+        """Create a CSV download link for a dataframe"""
+        if df is None or df.empty:
+            return None
+        
+        csv_data = df.to_csv(index=False)
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv') as f:
+            f.write(csv_data)
+            return f.name
+
+    # Update the optimize_and_display function
+    def optimize_and_display(csv_file, beds_per_staff, max_hours_per_staff, hours_per_cycle,
+                            rest_days_per_week, clinic_start_ampm, clinic_end_ampm, 
+                            overlap_time, max_start_time_change, exact_staff_count, overtime_percent):
+        try:
+            print(f"Starting optimization with parameters: beds={beds_per_staff}, hours={max_hours_per_staff}")
+            
+            # Convert AM/PM times to 24-hour format
+            clinic_start = convert_to_24h(clinic_start_ampm)
+            clinic_end = convert_to_24h(clinic_end_ampm)
+            
+            # Call optimization with proper error handling
+            result = optimize_staffing(csv_file, beds_per_staff, max_hours_per_staff, overlap_time)
+            
+            if result is None:
+                return (
+                    pd.DataFrame({"Error": ["No feasible solution found"]}),
+                    None,
+                    None,
+                    None,
+                    "Optimization failed to find a valid schedule",
+                    "<div>No solution found</div>",
+                    "<div>No solution found</div>",
+                    "<div>No solution found</div>"
+                )
+            
+            staff_assignment_df, gantt_path, schedule_df, plot_path, schedule_csv, staff_csv = result
+            
+            # Generate additional visualizations
+            constraints_info = get_constraints_summary(max_hours_per_staff, rest_days_per_week, overtime_percent)
+            monthly_html = create_monthly_distribution_chart(schedule_df)
+            weekly_html = create_weekly_distribution_charts(schedule_df)
+            overlap_html = create_overlap_visualization(schedule_df)
+            
+            return (
+                staff_assignment_df,
+                gantt_path,
+                schedule_df,
+                schedule_csv,
+                constraints_info,
+                monthly_html,
+                weekly_html,
+                overlap_html
+            )
+            
+        except Exception as e:
+            print(f"Error: {str(e)}")
+            return (
+                pd.DataFrame({"Error": [str(e)]}),
+                None,
+                None,
+                None,
+                "Error occurred during optimization",
+                "<div>Error</div>",
+                "<div>Error</div>",
+                "<div>Error</div>"
+            )
+    
+    def get_constraints_summary(max_hours, rest_days, overtime_percent):
+        """Generate a summary of all applied constraints from actual parameters"""
+        constraints = [
+            "Applied Scheduling Constraints:",
+            "----------------------------",
+            f"1. Maximum Hours per Month: {max_hours} hours",
+            f"2. Required Rest Days per Week: {rest_days} days",
+            f"3. Maximum Weekly Hours: 60 hours per staff member",
+            "4. Minimum Rest Period: 11 hours between shifts",
+            "5. Maximum Consecutive Days: 6 working days",
+            f"6. Overtime Allowance: {overtime_percent}% of standard hours",
+            "7. Coverage Requirements:",
+            "   - All cycles must be fully staffed",
+            "   - No understaffing allowed",
+            "   - Staff assigned based on required beds/staff ratio",
+            "8. Shift Constraints:",
+            "   - Available shift durations: 5, 10 hours",
+            "   - Shifts must align with cycle times",
+            "9. Staff Scheduling Rules:",
+            "   - Equal distribution of workload when possible",
+            "   - Consistent shift patterns preferred",
+            "   - Weekend rotations distributed fairly"
+        ]
+        return "\n".join(constraints)
+    
+    def create_monthly_distribution_chart(schedule_df):
+        """Create Seaborn pie chart for monthly hours distribution"""
+        if schedule_df is None or schedule_df.empty:
+            return "<div>No data available for visualization</div>"
+        
+        try:
+            # Calculate total hours per staff member
+            staff_hours = schedule_df.groupby('staff_id')['duration'].sum()
+            
+            # Create pie chart
+            fig, ax = plt.subplots(figsize=(8, 8))
+            sns.set_palette("pastel")
+            ax.pie(staff_hours, labels=staff_hours.index, autopct='%1.1f%%', startangle=90)
+            ax.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.
+            plt.title("Monthly Hours Distribution")
+            
+            # Convert plot to PNG image
+            img = io.BytesIO()
+            plt.savefig(img, format='png', bbox_inches='tight')  # Added bbox_inches='tight'
+            plt.close(fig)
+            img.seek(0)
+            
+            # Encode to base64
+            img_base64 = base64.b64encode(img.read()).decode('utf-8')
+            img_html = f'<img src="data:image/png;base64,{img_base64}" style="max-width:100%; max-height:600px;">'
+            
+            return img_html
+        except Exception as e:
+            print(f"Error in monthly chart: {e}")
+            return f"<div>Error creating monthly chart: {str(e)}</div>"
+    
+    def create_weekly_distribution_charts(schedule_df):
+        """Create Plotly pie charts for weekly hours distribution"""
+        if schedule_df is None or schedule_df.empty:
+            return "<div>No data available for visualization</div>"
+        
+        try:
+            # Calculate total hours per staff member for each week
+            schedule_df['week'] = schedule_df['day'] // 7  # Assuming each week starts on day 0, 7, 14, etc.
+            weekly_hours = schedule_df.groupby(['week', 'staff_id'])['duration'].sum().reset_index()
+            
+            # Create staff labels
+            weekly_hours['staff_label'] = weekly_hours.apply(
+                lambda x: f"Staff {x['staff_id']} ({x['duration']:.1f}hrs)",
+                axis=1
+            )
+            
+            # Get unique weeks
+            weeks = sorted(weekly_hours['week'].unique())
+            
+            # Define color palette
+            colors = px.colors.qualitative.Set3
+            
+            # Create subplots
+            fig = make_subplots(
+                rows=len(weeks),
+                cols=1,
+                subplot_titles=[f'Week {week}' for week in weeks],
+                specs=[[{'type': 'domain'}] for week in weeks]
+            )
+            
+            # Add pie charts for each week
+            for i, week in enumerate(weeks, start=1):
+                week_data = weekly_hours[weekly_hours['week'] == week]
+                
+                fig.add_trace(
+                    go.Pie(
+                        values=week_data['duration'],
+                        labels=week_data['staff_label'],
+                        name=f'Week {week}',
+                        showlegend=(i == 1),
+                        marker_colors=colors,
+                        textposition='inside',
+                        textinfo='percent+label',
+                        hovertemplate=(
+                            "Staff: %{label}<br>"
+                            "Hours: %{value:.1f}<br>"
+                            "Percentage: %{percent:.1f}%"
+                            "<extra></extra>"
+                        )
+                    ),
+                    row=i,
+                    col=1
+                )
+            
+            fig.update_layout(
+                height=300 * len(weeks),
+                width=800,
+                title_text="Weekly Hours Distribution",
+                title_x=0.5,
+                title_font_size=20,
+                margin=dict(t=50, l=50, r=50, b=50),
+                showlegend=True
+            )
+            
+            return fig.to_html(include_plotlyjs='cdn', full_html=False)
+        except Exception as e:
+            print(f"Error in weekly charts: {e}")
+            return f"<div>Error creating weekly charts: {str(e)}</div>"
+
+    # Add this new function for creating the overlap visualization
+    def create_overlap_visualization(schedule_df):
+        """Create Seaborn heatmap for staff overlap"""
+        if schedule_df is None or schedule_df.empty:
+            return "<div>No data available for visualization</div>"
+        
+        try:
+            # Create 24-hour timeline with 30-minute intervals
+            intervals = 48  # 24 hours * 2 (30-minute intervals)
+            days = sorted(schedule_df['day'].unique())
+            
+            # Initialize overlap matrix
+            overlap_data = np.zeros((len(days), intervals))
+            
+            # Calculate overlaps
+            for day_idx, day in enumerate(days):
+                day_shifts = schedule_df[schedule_df['day'] == day]
+                
+                for i in range(intervals):
+                    time = i * 0.5
+                    staff_working = 0
+                    
+                    for _, shift in day_shifts.iterrows():
+                        start = shift['start']
+                        end = shift['end']
+                        
+                        if end < start:  # Overnight shift
+                            if time >= start or time < end:
+                                staff_working += 1
+                        else:
+                            if start <= time < end:
+                                staff_working += 1
+                
+                overlap_data[day_idx, i] = staff_working
+            
+            # Create time labels
+            time_labels = [f"{int(i//2):02d}:{int((i%2)*30):02d}" for i in range(intervals)]
+            
+            # Create heatmap
+            fig, ax = plt.subplots(figsize=(12, 8))
+            sns.heatmap(overlap_data, cmap="viridis", ax=ax, cbar_kws={'label': 'Staff Count'})
+            
+            # Set labels
+            ax.set_xticks(np.arange(len(time_labels[::4])))
+            ax.set_xticklabels(time_labels[::4], rotation=45, ha="right")
+            ax.set_yticks(np.arange(len(days)))
+            ax.set_yticklabels(days)
+            
+            # Add title
+            ax.set_title("Staff Overlap Throughout the Day")
+            
+            # Ensure layout is tight
+            plt.tight_layout()
+            
+            # Convert plot to PNG image
+            img = io.BytesIO()
+            plt.savefig(img, format='png', bbox_inches='tight')  # Added bbox_inches='tight'
+            plt.close(fig)
+            img.seek(0)
+            
+            # Encode to base64
+            img_base64 = base64.b64encode(img.read()).decode('utf-8')
+            img_html = f'<img src="data:image/png;base64,{img_base64}" style="max-width:100%; max-height:800px;">'
+            
+            return img_html
+        except Exception as e:
+            print(f"Error in overlap visualization: {e}")
+            return f"<div>Error creating overlap visualization: {str(e)}</div>"
+
+    # Connect the button to the optimization function
+    optimize_btn.click(
+        fn=optimize_and_display,
+        inputs=[
+            csv_input, beds_per_staff, max_hours_per_staff, hours_per_cycle,
+            rest_days_per_week, clinic_start_ampm, clinic_end_ampm, 
+            overlap_time, max_start_time_change, exact_staff_count, overtime_percent
+        ],
+        outputs=[
+            staff_assignment_table,  # Staff coverage table
+            gantt_chart,            # Gantt chart
+            csv_schedule,           # Detailed schedule
+            schedule_download_file,   # Download file
+            constraints_text,        # Constraints text
+            monthly_chart,          # Monthly distribution
+            weekly_charts,          # Weekly distribution
+            overlap_chart           # Staff overlap visualization
+        ]
+    )
+
+    # Add the handler function
+    def handle_absence_click(staff_id, start_day, end_day, current_schedule, max_hours_per_staff, overtime_percent):
+        if current_schedule is None or current_schedule.empty:
+            return "No current schedule loaded.", None, None
+        
+        absence_dates = list(range(int(start_day), int(end_day) + 1))
+        summary, absence_schedule, absence_gantt_path = handle_staff_absence(
+            current_schedule,
+            int(staff_id),
+            absence_dates,
+            max_hours_per_staff,
+            overtime_percent
+        )
+        
+        return summary, absence_schedule, absence_gantt_path
+
+    # Connect the absence handler button
+    handle_absence_btn.click(
+        fn=handle_absence_click,
+        inputs=[
+            absent_staff,
+            absence_start,
+            absence_end,
+            csv_schedule,  # Current schedule
+            max_hours_per_staff,  # Add this parameter
+            overtime_percent  # Add this parameter
+        ],
+        outputs=[
+            absence_result,
+            updated_schedule,
+            absence_gantt_chart
+        ]
+    )
+
+# Launch the Gradio app
+iface.launch(share=True)
+
+def create_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("# NEF Scheduling System")
+        
+        with gr.Tabs() as tabs:
+            with gr.Tab("Schedule Input"):
+                # Schedule input components
+                with gr.Row():
+                    csv_input = gr.File(label="Upload Schedule Data (CSV)")
+                    schedule_preview = gr.DataFrame(label="Schedule Preview")
+            
+            with gr.Tab("Schedule Output"):
+                # Schedule output components
+                with gr.Row():
+                    schedule_output = gr.DataFrame(label="Generated Schedule")
+                    download_btn = gr.Button("Download Schedule")
+            
+            with gr.Tab("Constraints and Analytics"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Applied Constraints")
+                        constraints_text = gr.TextArea(label="", interactive=False)
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### Monthly Distribution")
+                            monthly_chart = gr.HTML(label="Monthly Hours Distribution")
+                            
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### Weekly Distribution")
+                            weekly_charts = gr.HTML(label="Weekly Hours Distribution")
+
+        with gr.TabItem("Staff Absence Handler"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Handle Staff Absence")
+                    absent_staff = gr.Number(label="Staff ID to be absent", precision=0)
+                    absence_start = gr.Number(label="Start Day", precision=0)
+                    absence_end = gr.Number(label="End Day", precision=0)
+                    handle_absence_btn = gr.Button("Redistribute Shifts", variant="primary")
+                
+                with gr.Column():
+                    absence_result = gr.TextArea(label="Redistribution Results", interactive=False)
+                    updated_schedule = gr.DataFrame(label="Updated Schedule")
+                    absence_gantt_chart = gr.Image(label="Absence Schedule Visualization", elem_id="absence_gantt_chart")
+
+    return demo
+
+def handle_staff_absence(schedule_df, absent_staff_id, absence_dates, max_hours_per_staff, overtime_percent):
+    """
+    Redistribute shifts of absent staff member to others, prioritizing staff with lowest monthly hours
+    """
+    try:
+        # Create a copy of the original schedule
+        new_schedule = schedule_df.copy()
+        
+        # Get shifts that need to be redistributed
+        absent_shifts = new_schedule[
+            (new_schedule['staff_id'] == absent_staff_id) & 
+            (new_schedule['day'].isin(absence_dates))
+        ]
+        
+        if absent_shifts.empty:
+            return "No shifts found for the specified staff member on given dates.", None, None
+        
+        # Get available staff (excluding absent staff)
+        available_staff = sorted(list(set(new_schedule['staff_id']) - {absent_staff_id}))
+        
+        # Calculate current hours for each staff member
+        current_hours = new_schedule.groupby('staff_id')['duration'].sum()
+        
+        # Sort staff by current hours (ascending) to prioritize those with fewer hours
+        staff_hours_sorted = current_hours.reindex(available_staff).sort_values()
+        available_staff = staff_hours_sorted.index.tolist()
+        
+        # Calculate remaining available hours for each staff
+        max_allowed_hours = max_hours_per_staff * (1 + overtime_percent/100)
+        available_hours = {
+            staff_id: max_allowed_hours - current_hours.get(staff_id, 0)
+            for staff_id in available_staff
+        }
+        
+        results = []
+        unassigned_shifts = []
+        
+        # Process each shift that needs to be redistributed
+        for _, shift in absent_shifts.iterrows():
+            # Find eligible staff for this shift, prioritizing those with fewer hours
+            eligible_staff = []
+            eligible_staff_hours = {}
+            
+            for staff_id in available_staff:
+                # Check if staff has enough remaining hours
+                if available_hours[staff_id] >= shift['duration']:
+                    # Check if staff is not already working that day
+                    staff_shifts_that_day = new_schedule[
+                        (new_schedule['staff_id'] == staff_id) & 
+                        (new_schedule['day'] == shift['day'])
+                    ]
+                    
+                    if staff_shifts_that_day.empty:
+                        # Check minimum rest period (11 hours)
+                        day_before = new_schedule[
+                            (new_schedule['staff_id'] == staff_id) & 
+                            (new_schedule['day'] == shift['day'] - 1)
+                        ]
+                        
+                        day_after = new_schedule[
+                            (new_schedule['staff_id'] == staff_id) & 
+                            (new_schedule['day'] == shift['day'] + 1)
+                        ]
+                        
+                        can_work = True
+                        if not day_before.empty:
+                            end_time_before = day_before.iloc[0]['end']
+                            if (shift['start'] + 24 - end_time_before) < 11:
+                                can_work = False
+                        
+                        if not day_after.empty and can_work:
+                            start_time_after = day_after.iloc[0]['start']
+                            if (starttime_after + 24 - shift['end']) < 11:
+                                can_work = False
+                        
+                        if can_work:
+                            eligible_staff.append(staff_id)
+                            eligible_staff_hours[staff_id] = current_hours.get(staff_id, 0)
+            
+            if eligible_staff:
+                # Sort eligible staff by current hours to prioritize those with fewer hours
+                sorted_eligible = sorted(eligible_staff, key=lambda x: eligible_staff_hours[x])
+                best_staff = sorted_eligible[0]  # Select staff with lowest hours
+                
+                # Update the schedule
+                new_schedule.loc[shift.name, 'staff_id'] = best_staff
+                
+                # Update available hours and current hours
+                available_hours[best_staff] -= shift['duration']
+                current_hours[best_staff] = current_hours.get(best_staff, 0) + shift['duration']
+                
+                results.append(
+                    f"Shift on Day {shift['day']} ({shift['duration']} hours) "
+                    f"reassigned to Staff {best_staff} (current hours: {current_hours[best_staff]:.1f})"
+                )
+            else:
+                unassigned_shifts.append(
+                    f"Could not reassign shift on Day {shift['day']} ({shift['duration']} hours)"
+                )
+        
+        # Generate detailed summary with hours distribution
+        summary = "\n".join([
+            "Shift Redistribution Summary:",
+            "----------------------------",
+            f"Staff {absent_staff_id} absent for {len(absence_dates)} days",
+            f"Successfully reassigned: {len(results)} shifts",
+            f"Failed to reassign: {len(unassigned_shifts)} shifts",
+            "\nCurrent Hours Distribution:",
+            "-------------------------"
+        ] + [
+            f"Staff {s}: {current_hours.get(s, 0):.1f} hours (of max {max_allowed_hours:.1f})"
+            for s in sorted(available_staff)
+        ] + [
+            "\nReassignment Details:",
+            *results,
+            "\nUnassigned Shifts:",
+            *unassigned_shifts
+        ])
+        
+        # Filter the schedule for the absence period
+        absence_schedule = new_schedule[new_schedule['day'].isin(absence_dates)].copy()
+        
+        # Create a Gantt chart for the absence period
+        absence_gantt_path = create_gantt_chart(absence_schedule, len(absence_dates), len(set(absence_schedule['staff_id'])))
+        
+        if unassigned_shifts:
+            return summary, None, None
+        else:
+            return summary, absence_schedule, absence_gantt_path
+            
+    except Exception as e:
+        return f"Error redistributing shifts: {str(e)}", None, None
+
+class FastScheduler:
+    def __init__(self, num_staff, num_days, possible_shifts, staff_requirements, constraints):
+        self.num_staff = num_staff
+        self.num_days = num_days
+        self.possible_shifts = possible_shifts
+        self.staff_requirements = staff_requirements
+        self.constraints = constraints
+        self.best_schedule = None
+        self.best_score = float('inf')
+        # Pre-compute shift lookups for faster access
+        self.shift_lookup = {shift['id']: shift for shift in possible_shifts}
+        self.cycle_shifts = self._precompute_cycle_shifts()
+        # Track staff state
+        self.staff_sequences = {}
+        self.staff_hours = {}
+        self.max_monthly_hours = constraints['max_hours_per_staff']
+
+    def _precompute_cycle_shifts(self):
+        """Pre-compute which shifts can cover each cycle"""
+        cycle_shifts = {}
+        for cycle in self.staff_requirements[0].keys():
+            cycle_shifts[cycle] = [shift for shift in self.possible_shifts if cycle in shift['cycles_covered']]
+        return cycle_shifts
+
+    def optimize(self, time_limit=300):
+        """Main optimization method"""
+        start_time = time.time()
+        schedule = []
+        
+        # Process each day
+        for day in range(1, self.num_days + 1):
+            # Get requirements for this day
+            day_requirements = self.staff_requirements[day-1]
+            
+            # Process each cycle
+            for cycle, staff_needed in day_requirements.items():
+                staff_assigned = 0
+                
+                # Try each staff member until we meet the requirement
+                for staff_id in range(1, self.num_staff + 1):
+                    # Check if we've met the requirement
+                    if staff_assigned >= staff_needed:
+                        break
+                        
+                    # Check if we're out of time
+                    if time.time() - start_time > time_limit:
+                        return None
+                    
+                    # Try to assign a shift
+                    shift = self._find_optimal_shift(staff_id, day, cycle, self.staff_hours)
+                    if shift:
+                        schedule.append(shift)
+                        staff_assigned += 1
+            
+            # Validate the schedule after each day
+            score = self._evaluate_schedule(schedule)
+            if score == float('inf'):
+                return None
+        
+        # Final validation
+        final_score = self._evaluate_schedule(schedule)
+        if final_score == float('inf'):
+            return None
+            
+        return schedule
+
+    def _find_optimal_shift(self, staff_id, day, cycle, staff_hours):
+        """Optimized shift finding with early exits and pre-computed lookups"""
+        # Quick access to staff's current state
+        staff_info = self.staff_sequences.get(staff_id)
+        current_hours = self.staff_hours.get(staff_id, 0)
+
+        # Early exit if staff has reached maximum hours
+        if current_hours >= self.max_monthly_hours:
+            return None
+
+        # Use pre-computed valid shifts for this cycle
+        valid_shifts = self.cycle_shifts.get(cycle, [])
+        if not valid_shifts:
+            return None
+
+        # Quick consecutive days check
+        if staff_info and staff_info.get('consecutive_days', 0) >= 6 and day - staff_info['last_day'] == 1:
+            return None
+
+        # Filter shifts based on timing consistency (highest priority)
+        if staff_info and day - staff_info['last_day'] == 1:
+            required_start = staff_info['last_time']
+            valid_shifts = [s for s in valid_shifts if s['start'] == required_start]
+            if not valid_shifts:
+                return None
+
+        # Quick hours check
+        valid_shifts = [s for s in valid_shifts if current_hours + s['duration'] <= self.max_monthly_hours]
+        if not valid_shifts:
+            return None
+
+        # Check if staff already has a shift this day
+        if any(s['staff_id'] == staff_id and s['day'] == day for s in self.best_schedule or []):
+            return None
+
+        # Select first valid shift (optimization over finding "best" shift)
+        shift = valid_shifts[0]
+        assigned_shift = {
+            'staff_id': staff_id,
+            'day': day,
+            'shift_id': shift['id'],
+            'start': shift['start'],
+            'end': shift['end'],
+            'duration': shift['duration'],
+            'cycles_covered': list(shift['cycles_covered'])
+        }
+
+        # Update staff tracking
+        consecutive_days = 1 if not staff_info else (
+            staff_info['consecutive_days'] + 1 if day - staff_info['last_day'] == 1 else 1
+        )
+        
+        self.staff_sequences[staff_id] = {
+            'last_day': day,
+            'last_time': shift['start'],
+            'consecutive_days': consecutive_days
+        }
+        self.staff_hours[staff_id] = current_hours + shift['duration']
+
+        return assigned_shift
+
+    def _evaluate_schedule(self, schedule):
+        """Optimized schedule evaluation with early exits"""
+        if not schedule:
+            return float('inf')
+
+        # Pre-compute staff shifts dictionary
+        staff_shifts = {}
+        for shift in schedule:
+            staff_id = shift['staff_id']
+            if staff_id not in staff_shifts:
+                staff_shifts[staff_id] = []
+            staff_shifts[staff_id].append(shift)
+            
+            # Early exit on hours violation
+            if self.staff_hours.get(staff_id, 0) > self.max_monthly_hours:
+                return float('inf')
+
+        # Quick timing consistency check with early exit
+        for shifts in staff_shifts.values():
+            shifts.sort(key=lambda x: x['day'])
+            for i in range(1, len(shifts)):
+                if (shifts[i]['day'] - shifts[i-1]['day'] == 1 and 
+                    shifts[i]['start'] != shifts[i-1]['start']):
+                    return float('inf')
+
+        # Coverage check with early exit
+        coverage = self._check_coverage_requirements(schedule)
+        if coverage > 0:
+            return float('inf')
+
+        return 0  # Valid schedule found
+
+    def _check_coverage_requirements(self, schedule):
+        """Optimized coverage check using pre-computed data"""
+        day_cycle_coverage = {}
+        
+        # Pre-compute coverage needs
+        for shift in schedule:
+            day = shift['day']
+            if day not in day_cycle_coverage:
+                day_cycle_coverage[day] = {cycle: 0 for cycle in self.staff_requirements[0].keys()}
+            
+            for cycle in shift['cycles_covered']:
+                day_cycle_coverage[day][cycle] += 1
+
+        # Check coverage
+        violations = 0
+        for day in range(1, self.num_days + 1):
+            if day not in day_cycle_coverage:
+                return float('inf')  # Missing day coverage
+                
+            day_coverage = day_cycle_coverage[day]
+            required = self.staff_requirements[day-1]
+            
+            for cycle, needed in required.items():
+                if day_coverage[cycle] < needed:
+                    violations += needed - day_coverage[cycle]
+                    if violations > 0:  # Early exit on any violation
+                        return violations
+
+        return violations
+
+    def reset(self):
+        """Reset the scheduler state"""
+        self.best_schedule = None
+        self.best_score = float('inf')
+        self.staff_sequences = {}
+        self.staff_hours = {}
+
+def process_solution(solution, min_staff, num_days):
+    try:
+        # Create schedule from solution
+        schedule = []
+        
+        for s in range(min_staff):
+            for d in range(num_days):
+                # Find continuous blocks of working hours
+                working_hours = []
+                for h in range(24):
+                    if solution[s,d,h] == 1:
+                        working_hours.append(h)
+                
+                if working_hours:
+                    # Find shift blocks
+                    shift_start = working_hours[0]
+                    shift_end = working_hours[-1] + 1
+                    
+                    schedule.append({
+                        'staff_id': s + 1,
+                        'day': d + 1,
+                        'start': shift_start,
+                        'end': shift_end,
+                        'duration': shift_end - shift_start
+                    })
+        
+        if schedule:
+            schedule_df = pd.DataFrame(schedule)
+            
+            # Create staff assignment table
+            staff_assignment = {}
+            for s in range(min_staff):
+                staff_assignment[f'Staff {s+1}'] = []
+                for d in range(num_days):
+                    hours = sum(solution[s,d,h] for h in range(24))
+            staff_assignment_df = pd.DataFrame(staff_assignment)
+            staff_assignment_df.index = [f'Day {d+1}' for d in range(num_days)]
+            
+            # Create visualizations
+            gantt_path = create_gantt_chart(schedule_df, num_days, min_staff)
+            
+            # Create downloadable files
+            schedule_csv = schedule_df.to_csv(index=False)
+            staff_csv = staff_assignment_df.to_csv()
+            
+            return (
+                staff_assignment_df,
+                gantt_path,
+                schedule_df,
+                None,  # plot_path not used
+                schedule_csv,
+                staff_csv
+            )
+        else:
+            raise ValueError("No valid schedule found in solution")
+            
+    except Exception as e:
+        print(f"Error processing solution: {str(e)}")
+        return None