Delete unncessesary files

Home.py

@@ -1,236 +0,0 @@
-import streamlit as st
-
-# Page configuration - MUST be first Streamlit command
-st.set_page_config(
-    page_title="SD Roster Tool - Home",
-    page_icon="🏠",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Now import everything else
-import pandas as pd
-import sys
-import os
-from datetime import datetime
-
-# Add src to path for imports
-sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
-
-# Custom CSS for better styling
-st.markdown("""
-<style>
-    .main-header {
-        font-size: 3rem;
-        font-weight: bold;
-        color: #1f77b4;
-        margin-bottom: 2rem;
-        text-align: center;
-    }
-    .section-header {
-        font-size: 1.8rem;
-        font-weight: bold;
-        color: #2c3e50;
-        margin: 1.5rem 0;
-    }
-    .feature-card {
-        background-color: #ffffff;
-        padding: 1.5rem;
-        border-radius: 0.8rem;
-        border-left: 5px solid #1f77b4;
-        margin-bottom: 1.5rem;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.15);
-        color: #2c3e50;
-        border: 1px solid #e9ecef;
-    }
-    .feature-card h3 {
-        color: #1f77b4;
-        margin-top: 0;
-    }
-    .feature-card p {
-        color: #2c3e50;
-    }
-    .feature-card ul {
-        color: #2c3e50;
-    }
-    .navigation-button {
-        width: 100%;
-        height: 80px;
-        font-size: 1.2rem;
-        margin: 10px 0;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-# Initialize session state for shared variables
-if 'data_path' not in st.session_state:
-    st.session_state.data_path = "data/my_roster_data"
-if 'target_date' not in st.session_state:
-    st.session_state.target_date = ""
-
-# Title
-st.markdown('<h1 class="main-header">🏠 SD Roster Optimization Tool</h1>', unsafe_allow_html=True)
-
-# Introduction section
-col1, col2 = st.columns([2, 1])
-
-with col1:
-    st.markdown("""
-    ## 📋 Welcome to the Supply Chain Roster Optimization Tool
-    
-    This comprehensive tool helps you optimize workforce allocation and production scheduling 
-    using advanced mathematical optimization techniques. Navigate through the different sections 
-    to analyze your data and run optimizations.
-    
-    ### 🔧 Key Features:
-    - **Advanced Optimization Engine**: Built on Google OR-Tools for mixed-integer programming
-    - **Multi-constraint Support**: Handle complex business rules and staffing requirements
-    - **Real-time Data Integration**: Work with your existing CSV data files
-    - **Interactive Visualizations**: Rich charts and analytics for decision making
-    - **Flexible Configuration**: Adjust parameters for different business scenarios
-    """)
-
-with col2:
-    st.markdown("### 🚀 Quick Start")
-    
-    # Navigation buttons
-    if st.button("📊 View Dataset Metadata", key="nav_metadata", help="Explore your data overview"):
-        st.switch_page("pages/1_📊_Dataset_Metadata.py")
-    
-    if st.button("🎯 Run Optimization", key="nav_optimization", help="Configure and run optimization"):
-        st.switch_page("pages/2_🎯_Optimization.py")
-    
-    if st.button("📈 Enhanced Reports", key="nav_reports", help="View comprehensive reports and analytics"):
-        st.switch_page("pages/3_📈_Enhanced_Reports.py")
-
-# Global settings section
-st.markdown("---")
-st.markdown('<h2 class="section-header">🌐 Global Settings</h2>', unsafe_allow_html=True)
-
-col_set1, col_set2 = st.columns(2)
-
-with col_set1:
-    st.markdown("### 📁 Data Configuration")
-    new_data_path = st.text_input(
-        "Data Path", 
-        value=st.session_state.data_path,
-        help="Path to your CSV data files. This setting is shared across all pages."
-    )
-    
-    if new_data_path != st.session_state.data_path:
-        st.session_state.data_path = new_data_path
-        st.success("✅ Data path updated globally!")
-    
-    st.info(f"**Current data path:** `{st.session_state.data_path}`")
-
-with col_set2:
-    st.markdown("### 📅 Date Configuration")
-    
-    # Try to load available dates
-    try:
-        sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
-        import src.etl.transform as transform
-        
-        date_ranges = transform.get_date_ranges()
-        if date_ranges:
-            date_range_options = [""] + [f"{start.strftime('%Y-%m-%d')} to {end.strftime('%Y-%m-%d')}" for start, end in date_ranges]
-            selected_range_str = st.selectbox(
-                "Available Date Ranges:",
-                options=date_range_options,
-                help="Select from available date ranges in your data"
-            )
-            
-            if selected_range_str:
-                selected_index = date_range_options.index(selected_range_str) - 1
-                start_date, end_date = date_ranges[selected_index]
-                st.session_state.date_range = (start_date, end_date)
-                st.success(f"✅ Selected: {start_date} to {end_date}")
-            
-    except Exception as e:
-        st.warning(f"Could not load date ranges: {e}")
-        st.info("Date ranges will be available when data is properly configured.")
-
-# Overview sections
-st.markdown("---")
-
-col_info1, col_info2, col_info3 = st.columns(3)
-
-with col_info1:
-    st.markdown("""
-    <div class="feature-card">
-        <h3>📊 Dataset Metadata</h3>
-        <p>Comprehensive overview of your data including:</p>
-        <ul>
-            <li>Demand analysis and forecasting</li>
-            <li>Employee availability and costs</li>
-            <li>Production line capacities</li>
-            <li>Historical performance data</li>
-        </ul>
-    </div>
-    """, unsafe_allow_html=True)
-
-with col_info2:
-    st.markdown("""
-    <div class="feature-card">
-        <h3>🎯 Optimization Engine</h3>
-        <p>Advanced optimization features:</p>
-        <ul>
-            <li>Multi-objective optimization</li>
-            <li>Constraint satisfaction</li>
-            <li>Scenario analysis</li>
-            <li>Cost minimization</li>
-        </ul>
-    </div>
-    """, unsafe_allow_html=True)
-
-with col_info3:
-    st.markdown("""
-    <div class="feature-card">
-        <h3>📈 Enhanced Reports</h3>
-        <p>Comprehensive visualization and reporting:</p>
-        <ul>
-            <li>Employee costs per hour analysis</li>
-            <li>Production plans & orders tracking</li>
-            <li>Line allocation by day visualization</li>
-            <li>Total cost breakdowns & scenarios</li>
-        </ul>
-    </div>
-    """, unsafe_allow_html=True)
-
-# System status
-st.markdown("---")
-st.markdown("### 🔍 System Status")
-
-col_status1, col_status2, col_status3, col_status4 = st.columns(4)
-
-# Check system components
-try:
-    import ortools
-    ortools_status = "✅ Available"
-except:
-    ortools_status = "❌ Not installed"
-
-try:
-    import plotly
-    plotly_status = "✅ Available"
-except:
-    plotly_status = "❌ Not installed"
-
-data_status = "✅ Configured" if os.path.exists(st.session_state.data_path) else "⚠️ Path not found"
-
-with col_status1:
-    st.metric("OR-Tools", ortools_status)
-with col_status2:
-    st.metric("Plotly", plotly_status)
-with col_status3:
-    st.metric("Data Path", data_status)
-with col_status4:
-    st.metric("Session State", "✅ Active")
-
-# Footer
-st.markdown("---")
-st.markdown("""
-<div style='text-align: center; color: gray; padding: 2rem;'>
-    <small>SD Roster Optimization Tool | Built with Streamlit & OR-Tools | Version 1.0</small>
-</div>
-""", unsafe_allow_html=True)

docker/init/001_init.sql

@@ -1,16 +0,0 @@
-CREATE SCHEMA IF NOT EXISTS stg;
-CREATE SCHEMA IF NOT EXISTS dim;
-CREATE SCHEMA IF NOT EXISTS fact;
-CREATE SCHEMA IF NOT EXISTS rej;
-CREATE SCHEMA IF NOT EXISTS meta;
-
-CREATE TABLE IF NOT EXISTS meta.batch_log (
-    batch_id       BIGSERIAL PRIMARY KEY,
-    source_file    TEXT NOT NULL,
-    source_hash    TEXT,
-    rows_read      INT,
-    rows_loaded    INT,
-    rows_rejected  INT,
-    started_at     TIMESTAMPTZ DEFAULT NOW(),
-    finished_at    TIMESTAMPTZ
-);

pages/1_📊_Dataset_Metadata.py

@@ -1,969 +0,0 @@
-import streamlit as st
-
-# Page configuration
-st.set_page_config(
-    page_title="Dataset Metadata",
-    page_icon="📊",
-    layout="wide"
-)
-
-# Import libraries
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import sys
-import os
-from datetime import datetime, timedelta
-import numpy as np
-
-# Add src to path for imports
-sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src'))
-
-try:
-    import src.etl.extract as extract
-    import src.etl.transform as transform
-    from src.config import optimization_config
-except ImportError as e:
-    st.error(f"Error importing modules: {e}")
-    st.stop()
-
-# Custom CSS
-st.markdown("""
-<style>
-    .main-header {
-        font-size: 2.5rem;
-        font-weight: bold;
-        color: #1f77b4;
-        margin-bottom: 1rem;
-    }
-    .section-header {
-        font-size: 1.5rem;
-        font-weight: bold;
-        color: #2c3e50;
-        margin: 1rem 0;
-    }
-    .metric-card {
-        background-color: #f8f9fa;
-        padding: 1rem;
-        border-radius: 0.5rem;
-        border-left: 4px solid #1f77b4;
-        margin-bottom: 1rem;
-    }
-    .info-box {
-        background-color: #e7f3ff;
-        padding: 1rem;
-        border-radius: 0.5rem;
-        border-left: 4px solid #0066cc;
-        margin: 1rem 0;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-# Title
-st.markdown('<h1 class="main-header">📊 Dataset Metadata Overview</h1>', unsafe_allow_html=True)
-
-# Check if data path is available from session state
-if 'data_path' not in st.session_state:
-    st.session_state.data_path = "data/my_roster_data"
-
-if 'date_range' not in st.session_state:
-    st.session_state.date_range = None
-
-# Sidebar for date selection
-with st.sidebar:
-    st.markdown("## 📅 Date Selection")
-    
-    try:
-        date_ranges = transform.get_date_ranges()
-        if date_ranges:
-            date_range_options = [f"{start.strftime('%Y-%m-%d')} to {end.strftime('%Y-%m-%d')}" for start, end in date_ranges]
-            selected_range_str = st.selectbox(
-                "Select date range:",
-                options=date_range_options,
-                help="Available date ranges from released orders"
-            )
-            
-            selected_index = date_range_options.index(selected_range_str)
-            start_date, end_date = date_ranges[selected_index]
-            st.session_state.date_range = (start_date, end_date)
-            
-            duration = (end_date - start_date).days + 1
-            st.info(f"Duration: {duration} days")
-            
-        else:
-            st.warning("No date ranges found")
-            start_date = datetime(2025, 3, 24).date()
-            end_date = datetime(2025, 3, 28).date()
-            st.session_state.date_range = (start_date, end_date)
-            
-    except Exception as e:
-        st.error(f"Error loading dates: {e}")
-        start_date = datetime(2025, 3, 24).date()
-        end_date = datetime(2025, 3, 28).date()
-        st.session_state.date_range = (start_date, end_date)
-    
-    st.markdown("---")
-    st.markdown("## 🔄 Refresh Data")
-    if st.button("🔄 Reload All Data"):
-        st.rerun()
-
-# Main content
-if st.session_state.date_range:
-    start_date, end_date = st.session_state.date_range
-    st.markdown(f"**Analysis Period:** {start_date} to {end_date}")
-else:
-    st.warning("No date range selected")
-    st.stop()
-
-# Create tabs for different metadata sections
-tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs([
-    "📋 Data Overview", 
-    "📦 Demand Analysis", 
-    "👥 Workforce Analysis", 
-    "🏭 Production Capacity", 
-    "💰 Cost Analysis",
-    "📈 Quick Reports",
-    "⚙️ Optimization Settings"
-])
-
-# Tab 1: Data Overview
-with tab1:
-    st.markdown('<h2 class="section-header">📋 Dataset Overview</h2>', unsafe_allow_html=True)
-    
-    # Overall metrics
-    try:
-        # Load basic data
-        demand_df = extract.read_released_orders_data(start_date=start_date, end_date=end_date)
-        employee_df = extract.read_employee_data()
-        line_df = extract.read_packaging_line_data()
-        
-        # Calculate key metrics
-        total_orders = len(demand_df)
-        total_quantity = demand_df["Order quantity (GMEIN)"].sum()
-        unique_products = demand_df["Material Number"].nunique()
-        total_employees = len(employee_df)
-        total_lines = line_df["line_count"].sum()
-        
-        # Display key metrics
-        col1, col2, col3, col4, col5 = st.columns(5)
-        
-        with col1:
-            st.metric("📦 Total Orders", f"{total_orders:,}")
-        with col2:
-            st.metric("📊 Total Quantity", f"{total_quantity:,.0f}")
-        with col3:
-            st.metric("🎯 Unique Products", unique_products)
-        with col4:
-            st.metric("👥 Total Employees", total_employees)
-        with col5:
-            st.metric("🏭 Production Lines", total_lines)
-        
-        # Data quality overview
-        st.markdown("### 📈 Data Quality Summary")
-        
-        col_q1, col_q2 = st.columns(2)
-        
-        with col_q1:
-            # Orders data quality
-            missing_orders = demand_df.isnull().sum().sum()
-            completeness = ((demand_df.size - missing_orders) / demand_df.size) * 100
-            
-            st.markdown("""
-            **Orders Data Quality:**
-            """)
-            st.progress(completeness / 100)
-            st.write(f"Completeness: {completeness:.1f}%")
-            st.write(f"Missing values: {missing_orders}")
-            
-        with col_q2:
-            # Employee data quality
-            missing_emp = employee_df.isnull().sum().sum()
-            emp_completeness = ((employee_df.size - missing_emp) / employee_df.size) * 100
-            
-            st.markdown("""
-            **Employee Data Quality:**
-            """)
-            st.progress(emp_completeness / 100)
-            st.write(f"Completeness: {emp_completeness:.1f}%")
-            st.write(f"Missing values: {missing_emp}")
-        
-        # Data freshness
-        st.markdown("### 📅 Data Freshness")
-        if 'Date' in demand_df.columns:
-            latest_order = pd.to_datetime(demand_df['Date']).max()
-            days_old = (datetime.now() - latest_order).days
-            st.info(f"Latest order data: {latest_order.strftime('%Y-%m-%d')} ({days_old} days ago)")
-        
-    except Exception as e:
-        st.error(f"Error loading overview data: {e}")
-
-# Tab 2: Demand Analysis
-with tab2:
-    st.markdown('<h2 class="section-header">📦 Demand Analysis</h2>', unsafe_allow_html=True)
-    
-    try:
-        demand_df = extract.read_released_orders_data(start_date=start_date, end_date=end_date)
-        
-        # Demand summary metrics
-        col_d1, col_d2, col_d3, col_d4 = st.columns(4)
-        
-        total_demand = demand_df["Order quantity (GMEIN)"].sum()
-        avg_order_size = demand_df["Order quantity (GMEIN)"].mean()
-        max_order_size = demand_df["Order quantity (GMEIN)"].max()
-        min_order_size = demand_df["Order quantity (GMEIN)"].min()
-        
-        with col_d1:
-            st.metric("📊 Total Demand", f"{total_demand:,.0f}")
-        with col_d2:
-            st.metric("📈 Avg Order Size", f"{avg_order_size:,.0f}")
-        with col_d3:
-            st.metric("🔺 Max Order", f"{max_order_size:,.0f}")
-        with col_d4:
-            st.metric("🔻 Min Order", f"{min_order_size:,.0f}")
-        
-        # Top products analysis
-        st.markdown("### 🎯 Top Products by Demand")
-        
-        col_top1, col_top2 = st.columns([2, 1])
-        
-        with col_top1:
-            top_products = demand_df.groupby('Material Number')["Order quantity (GMEIN)"].sum().sort_values(ascending=False).head(10)
-            
-            fig_top = px.bar(
-                x=top_products.index,
-                y=top_products.values,
-                title='Top 10 Products by Total Demand',
-                labels={'x': 'Product', 'y': 'Total Quantity'}
-            )
-            fig_top.update_layout(xaxis_tickangle=-45)
-            st.plotly_chart(fig_top, use_container_width=True)
-        
-        with col_top2:
-            st.markdown("**Top 10 Products:**")
-            for i, (product, quantity) in enumerate(top_products.head(10).items(), 1):
-                st.write(f"{i}. {product}: {quantity:,.0f}")
-        
-        # Daily demand pattern
-        st.markdown("### 📅 Daily Demand Pattern")
-        
-        if 'Date' in demand_df.columns:
-            daily_demand = demand_df.groupby('Date')["Order quantity (GMEIN)"].sum().reset_index()
-            daily_demand['Date'] = pd.to_datetime(daily_demand['Date'])
-            
-            fig_daily = px.line(
-                daily_demand,
-                x='Date',
-                y='Order quantity (GMEIN)',
-                title='Daily Demand Trend',
-                labels={'Order quantity (GMEIN)': 'Total Quantity'}
-            )
-            st.plotly_chart(fig_daily, use_container_width=True)
-            
-            # Demand statistics
-            col_stats1, col_stats2, col_stats3 = st.columns(3)
-            with col_stats1:
-                st.metric("📊 Avg Daily Demand", f"{daily_demand['Order quantity (GMEIN)'].mean():,.0f}")
-            with col_stats2:
-                st.metric("📈 Peak Daily Demand", f"{daily_demand['Order quantity (GMEIN)'].max():,.0f}")
-            with col_stats3:
-                std_dev = daily_demand['Order quantity (GMEIN)'].std()
-                st.metric("📊 Demand Variability", f"{std_dev:,.0f}")
-        
-        # Product distribution
-        st.markdown("### 🎯 Product Demand Distribution")
-        
-        product_counts = demand_df['Material Number'].value_counts()
-        
-        col_dist1, col_dist2 = st.columns(2)
-        
-        with col_dist1:
-            # Histogram of order quantities
-            fig_hist = px.histogram(
-                demand_df,
-                x='Order quantity (GMEIN)',
-                nbins=20,
-                title='Order Quantity Distribution'
-            )
-            st.plotly_chart(fig_hist, use_container_width=True)
-        
-        with col_dist2:
-            # Product frequency
-            fig_freq = px.histogram(
-                x=product_counts.values,
-                nbins=15,
-                title='Product Order Frequency Distribution'
-            )
-            fig_freq.update_layout(xaxis_title="Number of Orders", yaxis_title="Number of Products")
-            st.plotly_chart(fig_freq, use_container_width=True)
-        
-    except Exception as e:
-        st.error(f"Error in demand analysis: {e}")
-
-# Tab 3: Workforce Analysis
-with tab3:
-    st.markdown('<h2 class="section-header">👥 Workforce Analysis</h2>', unsafe_allow_html=True)
-    
-    try:
-        employee_df = extract.read_employee_data()
-        
-        # Employee metrics
-        col_emp1, col_emp2, col_emp3, col_emp4 = st.columns(4)
-        
-        total_employees = len(employee_df)
-        emp_types = employee_df['employment_type'].nunique()
-        
-        with col_emp1:
-            st.metric("👥 Total Employees", total_employees)
-        with col_emp2:
-            st.metric("📋 Employee Types", emp_types)
-        with col_emp3:
-            unicef_count = len(employee_df[employee_df['employment_type'] == 'UNICEF Fixed term'])
-            st.metric("🏢 UNICEF Fixed", unicef_count)
-        with col_emp4:
-            humanizer_count = len(employee_df[employee_df['employment_type'] == 'Humanizer'])
-            st.metric("👷 Humanizer", humanizer_count)
-        
-        # Employee type distribution
-        st.markdown("### 👥 Employee Type Distribution")
-        
-        col_emp_dist1, col_emp_dist2 = st.columns(2)
-        
-        with col_emp_dist1:
-            emp_type_counts = employee_df['employment_type'].value_counts()
-            
-            fig_emp_pie = px.pie(
-                values=emp_type_counts.values,
-                names=emp_type_counts.index,
-                title='Employee Distribution by Type'
-            )
-            st.plotly_chart(fig_emp_pie, use_container_width=True)
-        
-        with col_emp_dist2:
-            fig_emp_bar = px.bar(
-                x=emp_type_counts.index,
-                y=emp_type_counts.values,
-                title='Employee Count by Type'
-            )
-            st.plotly_chart(fig_emp_bar, use_container_width=True)
-        
-        # Cost analysis
-        st.markdown("### 💰 Employee Cost Structure")
-        
-        cost_data = optimization_config.COST_LIST_PER_EMP_SHIFT
-        
-        # Create cost comparison table
-        cost_comparison = []
-        for emp_type, shifts in cost_data.items():
-            for shift, cost in shifts.items():
-                shift_name = {1: 'Regular', 2: 'Overtime', 3: 'Evening'}.get(shift, f'Shift {shift}')
-                cost_comparison.append({
-                    'Employee Type': emp_type,
-                    'Shift': shift_name,
-                    'Hourly Rate ($)': cost
-                })
-        
-        cost_df = pd.DataFrame(cost_comparison)
-        
-        col_cost1, col_cost2 = st.columns(2)
-        
-        with col_cost1:
-            st.dataframe(cost_df, use_container_width=True)
-        
-        with col_cost2:
-            fig_cost = px.bar(
-                cost_df,
-                x='Employee Type',
-                y='Hourly Rate ($)',
-                color='Shift',
-                title='Hourly Rates by Employee Type and Shift',
-                barmode='group'
-            )
-            st.plotly_chart(fig_cost, use_container_width=True)
-        
-        # Productivity analysis
-        st.markdown("### 📈 Productivity Analysis")
-        
-        try:
-            productivity_data = optimization_config.PRODUCTIVITY_LIST_PER_EMP_PRODUCT
-            
-            # Calculate average productivity by employee type
-            prod_summary = []
-            for emp_type, shifts in productivity_data.items():
-                for shift, products in shifts.items():
-                    if products:  # Check if products dict is not empty
-                        avg_productivity = np.mean(list(products.values()))
-                        shift_name = {1: 'Regular', 2: 'Overtime', 3: 'Evening'}.get(shift, f'Shift {shift}')
-                        prod_summary.append({
-                            'Employee Type': emp_type,
-                            'Shift': shift_name,
-                            'Avg Productivity (units/hr)': avg_productivity
-                        })
-            
-            if prod_summary:
-                prod_df = pd.DataFrame(prod_summary)
-                
-                fig_prod = px.bar(
-                    prod_df,
-                    x='Employee Type',
-                    y='Avg Productivity (units/hr)',
-                    color='Shift',
-                    title='Average Productivity by Employee Type and Shift',
-                    barmode='group'
-                )
-                st.plotly_chart(fig_prod, use_container_width=True)
-                
-                st.dataframe(prod_df, use_container_width=True)
-            else:
-                st.info("No productivity data available")
-                
-        except Exception as e:
-            st.warning(f"Could not load productivity data: {e}")
-        
-    except Exception as e:
-        st.error(f"Error in workforce analysis: {e}")
-
-# Tab 4: Production Capacity
-with tab4:
-    st.markdown('<h2 class="section-header">🏭 Production Capacity Analysis</h2>', unsafe_allow_html=True)
-    
-    try:
-        line_df = extract.read_packaging_line_data()
-        
-        # Production line metrics
-        col_line1, col_line2, col_line3, col_line4 = st.columns(4)
-        
-        total_lines = line_df['line_count'].sum()
-        line_types = len(line_df)
-        max_capacity_line = line_df.loc[line_df['line_count'].idxmax()]
-        
-        with col_line1:
-            st.metric("🏭 Total Lines", total_lines)
-        with col_line2:
-            st.metric("📋 Line Types", line_types)
-        with col_line3:
-            st.metric("🔺 Max Capacity Type", f"Line {max_capacity_line['id']}")
-        with col_line4:
-            st.metric("📊 Max Line Count", max_capacity_line['line_count'])
-        
-        # Line capacity distribution
-        st.markdown("### 🏭 Production Line Distribution")
-        
-        col_cap1, col_cap2 = st.columns(2)
-        
-        with col_cap1:
-            fig_line_pie = px.pie(
-                values=line_df['line_count'],
-                names=[f"Line {row['id']}" for _, row in line_df.iterrows()],
-                title='Production Line Distribution'
-            )
-            st.plotly_chart(fig_line_pie, use_container_width=True)
-        
-        with col_cap2:
-            fig_line_bar = px.bar(
-                x=[f"Line {row['id']}" for _, row in line_df.iterrows()],
-                y=line_df['line_count'],
-                title='Line Count by Type'
-            )
-            st.plotly_chart(fig_line_bar, use_container_width=True)
-        
-        # Capacity analysis
-        st.markdown("### ⚡ Theoretical Capacity Analysis")
-        
-        cap_per_line = optimization_config.PER_PRODUCT_SPEED
-        shift_hours = optimization_config.MAX_HOUR_PER_SHIFT_PER_PERSON
-        
-        # Calculate theoretical daily capacity
-        capacity_analysis = []
-        for _, row in line_df.iterrows():
-            line_id = row['id']
-            line_count = row['line_count']
-            
-            if line_id in cap_per_line:
-                hourly_cap = cap_per_line[line_id]
-                
-                for shift, hours in shift_hours.items():
-                    shift_name = {1: 'Regular', 2: 'Overtime', 3: 'Evening'}.get(shift, f'Shift {shift}')
-                    daily_capacity = hourly_cap * hours * line_count
-                    
-                    capacity_analysis.append({
-                        'Line Type': f"Line {line_id}",
-                        'Shift': shift_name,
-                        'Hourly Capacity': hourly_cap,
-                        'Shift Hours': hours,
-                        'Line Count': line_count,
-                        'Shift Capacity': daily_capacity
-                    })
-        
-        if capacity_analysis:
-            cap_df = pd.DataFrame(capacity_analysis)
-            
-            # Display capacity table
-            st.dataframe(cap_df, use_container_width=True)
-            
-            # Capacity visualization
-            fig_cap = px.bar(
-                cap_df,
-                x='Line Type',
-                y='Shift Capacity',
-                color='Shift',
-                title='Theoretical Capacity by Line Type and Shift',
-                barmode='group'
-            )
-            st.plotly_chart(fig_cap, use_container_width=True)
-            
-            # Total capacity summary
-            total_capacity = cap_df.groupby('Line Type')['Shift Capacity'].sum()
-            
-            col_total1, col_total2 = st.columns(2)
-            
-            with col_total1:
-                st.markdown("**Total Daily Capacity by Line:**")
-                for line_type, capacity in total_capacity.items():
-                    st.write(f"• {line_type}: {capacity:,.0f} units/day")
-            
-            with col_total2:
-                total_all_lines = total_capacity.sum()
-                st.metric("🏭 Total System Capacity", f"{total_all_lines:,.0f} units/day")
-        
-    except Exception as e:
-        st.error(f"Error in production capacity analysis: {e}")
-
-# Tab 5: Cost Analysis
-with tab5:
-    st.markdown('<h2 class="section-header">💰 Cost Analysis</h2>', unsafe_allow_html=True)
-    
-    try:
-        # Load cost data
-        cost_data = optimization_config.COST_LIST_PER_EMP_SHIFT
-        employee_df = extract.read_employee_data()
-        
-        # Cost structure overview
-        st.markdown("### 💵 Cost Structure Overview")
-        
-        # Calculate cost ranges
-        all_costs = []
-        for emp_type, shifts in cost_data.items():
-            for shift, cost in shifts.items():
-                all_costs.append(cost)
-        
-        col_cost_over1, col_cost_over2, col_cost_over3, col_cost_over4 = st.columns(4)
-        
-        with col_cost_over1:
-            st.metric("💰 Min Hourly Rate", f"${min(all_costs)}")
-        with col_cost_over2:
-            st.metric("💰 Max Hourly Rate", f"${max(all_costs)}")
-        with col_cost_over3:
-            st.metric("💰 Avg Hourly Rate", f"${np.mean(all_costs):.2f}")
-        with col_cost_over4:
-            cost_range = max(all_costs) - min(all_costs)
-            st.metric("📊 Cost Range", f"${cost_range}")
-        
-        # Detailed cost breakdown
-        st.markdown("### 📊 Detailed Cost Breakdown")
-        
-        cost_breakdown = []
-        employee_counts = employee_df['employment_type'].value_counts()
-        
-        for emp_type, shifts in cost_data.items():
-            emp_count = employee_counts.get(emp_type, 0)
-            
-            for shift, hourly_rate in shifts.items():
-                shift_name = {1: 'Regular', 2: 'Overtime', 3: 'Evening'}.get(shift, f'Shift {shift}')
-                shift_hours = optimization_config.MAX_HOUR_PER_SHIFT_PER_PERSON.get(shift, 0)
-                
-                daily_cost_per_emp = hourly_rate * shift_hours
-                total_daily_cost = daily_cost_per_emp * emp_count
-                
-                cost_breakdown.append({
-                    'Employee Type': emp_type,
-                    'Shift': shift_name,
-                    'Available Staff': emp_count,
-                    'Hourly Rate ($)': hourly_rate,
-                    'Shift Hours': shift_hours,
-                    'Cost per Employee ($)': daily_cost_per_emp,
-                    'Total Potential Cost ($)': total_daily_cost
-                })
-        
-        cost_breakdown_df = pd.DataFrame(cost_breakdown)
-        st.dataframe(cost_breakdown_df, use_container_width=True)
-        
-        # Cost visualization
-        col_cost_viz1, col_cost_viz2 = st.columns(2)
-        
-        with col_cost_viz1:
-            fig_cost_comp = px.bar(
-                cost_breakdown_df,
-                x='Employee Type',
-                y='Total Potential Cost ($)',
-                color='Shift',
-                title='Total Potential Daily Cost by Type and Shift',
-                barmode='group'
-            )
-            st.plotly_chart(fig_cost_comp, use_container_width=True)
-        
-        with col_cost_viz2:
-            # Cost efficiency (cost per hour)
-            fig_efficiency = px.scatter(
-                cost_breakdown_df,
-                x='Shift Hours',
-                y='Hourly Rate ($)',
-                color='Employee Type',
-                size='Available Staff',
-                title='Cost Efficiency Analysis',
-                hover_data=['Shift']
-            )
-            st.plotly_chart(fig_efficiency, use_container_width=True)
-        
-        # Budget planning
-        st.markdown("### 📋 Budget Planning Scenarios")
-        
-        col_budget1, col_budget2 = st.columns(2)
-        
-        with col_budget1:
-            st.markdown("**Minimum Daily Cost Scenario:**")
-            min_costs = cost_breakdown_df.groupby('Employee Type')['Cost per Employee ($)'].min()
-            total_min_daily = (min_costs * employee_counts).sum()
-            st.write(f"Total minimum daily cost: ${total_min_daily:,.2f}")
-            
-            for emp_type, cost in min_costs.items():
-                count = employee_counts.get(emp_type, 0)
-                st.write(f"• {emp_type}: ${cost:.2f} × {count} = ${cost * count:,.2f}")
-        
-        with col_budget2:
-            st.markdown("**Maximum Daily Cost Scenario:**")
-            max_costs = cost_breakdown_df.groupby('Employee Type')['Cost per Employee ($)'].max()
-            total_max_daily = (max_costs * employee_counts).sum()
-            st.write(f"Total maximum daily cost: ${total_max_daily:,.2f}")
-            
-            for emp_type, cost in max_costs.items():
-                count = employee_counts.get(emp_type, 0)
-                st.write(f"• {emp_type}: ${cost:.2f} × {count} = ${cost * count:,.2f}")
-        
-        # Weekly and monthly projections
-        st.markdown("### 📅 Cost Projections")
-        
-        col_proj1, col_proj2, col_proj3 = st.columns(3)
-        
-        with col_proj1:
-            weekly_min = total_min_daily * 7
-            weekly_max = total_max_daily * 7
-            st.metric("📅 Weekly Cost Range", f"${weekly_min:,.0f} - ${weekly_max:,.0f}")
-        
-        with col_proj2:
-            monthly_min = total_min_daily * 30
-            monthly_max = total_max_daily * 30
-            st.metric("📅 Monthly Cost Range", f"${monthly_min:,.0f} - ${monthly_max:,.0f}")
-        
-        with col_proj3:
-            avg_daily = (total_min_daily + total_max_daily) / 2
-            st.metric("📊 Average Daily Cost", f"${avg_daily:,.2f}")
-        
-    except Exception as e:
-        st.error(f"Error in cost analysis: {e}")
-
-# Tab 6: Quick Reports
-with tab6:
-    st.markdown('<h2 class="section-header">📈 Quick Reports</h2>', unsafe_allow_html=True)
-    
-    st.info("💡 **Need more detailed analysis?** Check out the **Enhanced Reports** page for comprehensive visualizations!")
-    
-    if st.button("🚀 Go to Enhanced Reports", type="primary", use_container_width=True):
-        st.switch_page("pages/3_📈_Enhanced_Reports.py")
-    
-    try:
-        # Quick summary metrics
-        demand_df = extract.read_released_orders_data(start_date=start_date, end_date=end_date)
-        employee_df = extract.read_employee_data()
-        cost_data = optimization_config.COST_LIST_PER_EMP_SHIFT
-        
-        st.markdown("### ⚡ Quick Summary")
-        
-        # Key metrics
-        total_orders = len(demand_df)
-        total_quantity = demand_df["Order quantity (GMEIN)"].sum()
-        unique_products = demand_df["Material Number"].nunique()
-        duration = (end_date - start_date).days + 1
-        
-        col_q1, col_q2, col_q3, col_q4 = st.columns(4)
-        
-        with col_q1:
-            st.metric("📦 Total Orders", f"{total_orders:,}")
-        with col_q2:
-            st.metric("📊 Total Quantity", f"{total_quantity:,.0f}")
-        with col_q3:
-            st.metric("🎯 Unique Products", unique_products)
-        with col_q4:
-            avg_daily_demand = total_quantity / duration
-            st.metric("📅 Avg Daily Demand", f"{avg_daily_demand:,.0f}")
-        
-        # Quick cost estimate
-        st.markdown("### 💰 Cost Estimate")
-        
-        # Simple cost calculation
-        total_employees = len(employee_df)
-        emp_counts = employee_df['employment_type'].value_counts()
-        
-        # Estimate daily cost
-        estimated_daily_cost = 0
-        for emp_type, count in emp_counts.items():
-            if emp_type in cost_data:
-                # Use regular shift rate
-                regular_rate = cost_data[emp_type].get(1, 0)
-                estimated_daily_cost += count * regular_rate * 7  # Assume 7-hour shifts
-        
-        period_cost = estimated_daily_cost * duration
-        cost_per_unit = period_cost / total_quantity if total_quantity > 0 else 0
-        
-        col_cost1, col_cost2, col_cost3 = st.columns(3)
-        
-        with col_cost1:
-            st.metric("💰 Est. Daily Cost", f"${estimated_daily_cost:,.2f}")
-        with col_cost2:
-            st.metric("💵 Est. Period Cost", f"${period_cost:,.2f}")
-        with col_cost3:
-            st.metric("📦 Est. Cost/Unit", f"${cost_per_unit:.3f}")
-        
-        # Quick production overview
-        st.markdown("### 🏭 Production Overview")
-        
-        # Daily production distribution
-        demand_df['Date'] = pd.to_datetime(demand_df['Basic finish date'])
-        daily_production = demand_df.groupby('Date')['Order quantity (GMEIN)'].sum().reset_index()
-        
-        if len(daily_production) > 0:
-            fig_quick = px.bar(
-                daily_production,
-                x='Date',
-                y='Order quantity (GMEIN)',
-                title='Daily Production Requirements',
-                color='Order quantity (GMEIN)',
-                color_continuous_scale='Blues'
-            )
-            st.plotly_chart(fig_quick, use_container_width=True)
-        
-        # Top products quick view
-        top_products = demand_df.groupby('Material Number')['Order quantity (GMEIN)'].sum().sort_values(ascending=False).head(5)
-        
-        st.markdown("**Top 5 Products by Quantity:**")
-        for i, (product, quantity) in enumerate(top_products.items(), 1):
-            st.write(f"{i}. {product}: {quantity:,.0f} units")
-        
-    except Exception as e:
-        st.error(f"Error generating quick reports: {e}")
-
-# Tab 7: Optimization Settings
-with tab7:
-    st.markdown('<h2 class="section-header">⚙️ Optimization Settings</h2>', unsafe_allow_html=True)
-    
-    st.info("💡 **Configure optimization parameters here!** These settings will be used by the optimization engine when you run optimizations.")
-    
-    try:
-        # Load available options from data
-        employee_df = extract.read_employee_data()
-        line_df = extract.read_packaging_line_data()
-        shift_df = extract.get_shift_info()
-        
-        # Employee Types Selection
-        st.markdown("### 👥 Employee Types")
-        available_emp_types = employee_df["employment_type"].unique().tolist()
-        
-        # Initialize session state if not exists
-        if 'selected_employee_types' not in st.session_state:
-            st.session_state.selected_employee_types = available_emp_types
-        
-        selected_emp_types = st.multiselect(
-            "Select employee types to include in optimization:",
-            options=available_emp_types,
-            default=st.session_state.selected_employee_types,
-            key="emp_types_selector",
-            help="Choose which employee types should be available for optimization"
-        )
-        
-        # Update session state
-        if selected_emp_types != st.session_state.selected_employee_types:
-            st.session_state.selected_employee_types = selected_emp_types
-            st.success(f"✅ Employee types updated: {', '.join(selected_emp_types)}")
-        
-        # Display current employee type counts
-        col_emp1, col_emp2 = st.columns(2)
-        with col_emp1:
-            st.markdown("**Current Employee Availability:**")
-            emp_counts = employee_df['employment_type'].value_counts()
-            for emp_type in selected_emp_types:
-                count = emp_counts.get(emp_type, 0)
-                st.write(f"• {emp_type}: {count} employees")
-        
-        with col_emp2:
-            # Show cost information for selected types
-            st.markdown("**Hourly Rates (Regular Shift):**")
-            cost_data = optimization_config.COST_LIST_PER_EMP_SHIFT
-            for emp_type in selected_emp_types:
-                if emp_type in cost_data:
-                    regular_rate = cost_data[emp_type].get(1, "N/A")
-                    st.write(f"• {emp_type}: ${regular_rate}/hour")
-        
-        st.markdown("---")
-        
-        # Shifts Selection
-        st.markdown("### 🕐 Shifts")
-        available_shifts = shift_df["id"].unique().tolist()
-        
-        # Initialize session state if not exists
-        if 'selected_shifts' not in st.session_state:
-            st.session_state.selected_shifts = available_shifts
-        
-        shift_names = {1: 'Regular (Day)', 2: 'Overtime', 3: 'Evening'}
-        shift_options = [f"{shift_id}: {shift_names.get(shift_id, f'Shift {shift_id}')}" for shift_id in available_shifts]
-        
-        selected_shift_options = st.multiselect(
-            "Select shifts to include in optimization:",
-            options=shift_options,
-            default=[f"{shift_id}: {shift_names.get(shift_id, f'Shift {shift_id}')}" for shift_id in st.session_state.selected_shifts],
-            key="shifts_selector",
-            help="Choose which shifts should be available for optimization"
-        )
-        
-        # Extract shift IDs from selected options
-        selected_shifts = [int(option.split(':')[0]) for option in selected_shift_options]
-        
-        # Update session state
-        if selected_shifts != st.session_state.selected_shifts:
-            st.session_state.selected_shifts = selected_shifts
-            st.success(f"✅ Shifts updated: {', '.join([shift_names.get(s, f'Shift {s}') for s in selected_shifts])}")
-        
-        # Display shift information
-        st.markdown("**Shift Details:**")
-        shift_hours = optimization_config.MAX_HOUR_PER_SHIFT_PER_PERSON
-        for shift_id in selected_shifts:
-            shift_name = shift_names.get(shift_id, f'Shift {shift_id}')
-            hours = shift_hours.get(shift_id, "N/A")
-            st.write(f"• {shift_name}: {hours} hours")
-        
-        st.markdown("---")
-        
-        # Production Lines Selection
-        st.markdown("### 🏭 Production Lines")
-        available_lines = line_df["id"].unique().tolist()
-        
-        # Initialize session state if not exists
-        if 'selected_lines' not in st.session_state:
-            st.session_state.selected_lines = available_lines
-        
-        selected_lines = st.multiselect(
-            "Select production lines to include in optimization:",
-            options=available_lines,
-            default=st.session_state.selected_lines,
-            key="lines_selector",
-            help="Choose which production lines should be available for optimization"
-        )
-        
-        # Update session state
-        if selected_lines != st.session_state.selected_lines:
-            st.session_state.selected_lines = selected_lines
-            st.success(f"✅ Production lines updated: {', '.join([f'Line {line}' for line in selected_lines])}")
-        
-        # Display line information
-        col_line1, col_line2 = st.columns(2)
-        with col_line1:
-            st.markdown("**Line Capacities:**")
-            for line_id in selected_lines:
-                line_info = line_df[line_df['id'] == line_id]
-                if not line_info.empty:
-                    line_count = line_info.iloc[0]['line_count']
-                    st.write(f"• Line {line_id}: {line_count} units available")
-        
-        with col_line2:
-            st.markdown("**Processing Speed:**")
-            line_speeds = optimization_config.PER_PRODUCT_SPEED
-            for line_id in selected_lines:
-                speed = line_speeds.get(line_id, "N/A")
-                st.write(f"• Line {line_id}: {speed} units/hour")
-        
-        st.markdown("---")
-        
-        # Additional Settings
-        st.markdown("### 🔧 Additional Settings")
-        
-        col_settings1, col_settings2 = st.columns(2)
-        
-        with col_settings1:
-            # Constraint mode
-            constraint_mode = st.selectbox(
-                "Fixed Staff Constraint Mode:",
-                options=["priority", "mandatory", "none"],
-                index=0,
-                key="constraint_mode_selector",
-                help="priority=Use fixed staff first, mandatory=Force all fixed hours, none=Demand-driven"
-            )
-            
-            if 'selected_constraint_mode' not in st.session_state:
-                st.session_state.selected_constraint_mode = constraint_mode
-            
-            if constraint_mode != st.session_state.selected_constraint_mode:
-                st.session_state.selected_constraint_mode = constraint_mode
-                st.success(f"✅ Constraint mode updated: {constraint_mode}")
-        
-        with col_settings2:
-            # Evening shift mode
-            evening_mode = st.selectbox(
-                "Evening Shift Mode:",
-                options=["normal", "activate_evening", "always_available"],
-                index=0,
-                key="evening_mode_selector",
-                help="normal=Regular+Overtime only, activate_evening=Auto-activate when needed, always_available=Always include evening shift"
-            )
-            
-            if 'selected_evening_mode' not in st.session_state:
-                st.session_state.selected_evening_mode = evening_mode
-            
-            if evening_mode != st.session_state.selected_evening_mode:
-                st.session_state.selected_evening_mode = evening_mode
-                st.success(f"✅ Evening shift mode updated: {evening_mode}")
-        
-        # Summary of current settings
-        st.markdown("### 📋 Current Optimization Configuration")
-        st.markdown('<div class="cost-highlight">', unsafe_allow_html=True)
-        
-        col_summary1, col_summary2 = st.columns(2)
-        
-        with col_summary1:
-            st.markdown("**Selected Configuration:**")
-            st.write(f"• **Employee Types:** {len(st.session_state.get('selected_employee_types', []))} types")
-            st.write(f"• **Shifts:** {len(st.session_state.get('selected_shifts', []))} shifts")
-            st.write(f"• **Production Lines:** {len(st.session_state.get('selected_lines', []))} lines")
-            st.write(f"• **Constraint Mode:** {st.session_state.get('selected_constraint_mode', 'priority')}")
-        
-        with col_summary2:
-            st.markdown("**Ready for Optimization:**")
-            if (st.session_state.get('selected_employee_types') and 
-                st.session_state.get('selected_shifts') and 
-                st.session_state.get('selected_lines')):
-                st.success("✅ All required settings configured!")
-                if st.button("🚀 Go to Optimization Page", type="primary", use_container_width=True):
-                    st.switch_page("pages/2_🎯_Optimization.py")
-            else:
-                st.warning("⚠️ Please configure all settings above")
-        
-        st.markdown('</div>', unsafe_allow_html=True)
-        
-        # Reset button
-        if st.button("🔄 Reset to Defaults", type="secondary"):
-            st.session_state.selected_employee_types = available_emp_types
-            st.session_state.selected_shifts = available_shifts  
-            st.session_state.selected_lines = available_lines
-            st.session_state.selected_constraint_mode = "priority"
-            st.session_state.selected_evening_mode = "normal"
-            st.success("✅ Settings reset to defaults!")
-            st.rerun()
-        
-    except Exception as e:
-        st.error(f"Error loading optimization settings: {e}")
-
-# Footer
-st.markdown("---")
-st.markdown("""
-<div style='text-align: center; color: gray; padding: 1rem;'>
-    <small>Dataset Metadata Analysis | Data updated in real-time from your CSV files</small>
-</div>
-""", unsafe_allow_html=True)

pages/2_🎯_Optimization.py

@@ -1,662 +0,0 @@
-import streamlit as st
-
-# Page configuration
-st.set_page_config(
-    page_title="Optimization Tool",
-    page_icon="🎯",
-    layout="wide"
-)
-
-# Import libraries
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import sys
-import os
-from datetime import datetime, timedelta
-import numpy as np
-
-# Add src to path for imports
-sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src'))
-
-try:
-    from src.models.optimizer_new_aug14 import solve_fixed_team_weekly
-    from src.config import optimization_config
-    import src.etl.extract as extract
-    import src.etl.transform as transform
-except ImportError as e:
-    st.error(f"Error importing modules: {e}")
-    st.stop()
-
-# Custom CSS
-st.markdown("""
-<style>
-    .main-header {
-        font-size: 2.5rem;
-        font-weight: bold;
-        color: #1f77b4;
-        margin-bottom: 1rem;
-    }
-    .section-header {
-        font-size: 1.5rem;
-        font-weight: bold;
-        color: #2c3e50;
-        margin: 1rem 0;
-    }
-    .optimization-panel {
-        background-color: #f8f9fa;
-        padding: 1.5rem;
-        border-radius: 0.8rem;
-        border-left: 5px solid #28a745;
-        margin-bottom: 1.5rem;
-    }
-    .results-panel {
-        background-color: #fff3cd;
-        padding: 1.5rem;
-        border-radius: 0.8rem;
-        border-left: 5px solid #ffc107;
-        margin-bottom: 1.5rem;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-# Initialize session state
-if 'optimization_results' not in st.session_state:
-    st.session_state.optimization_results = None
-if 'optimizer' not in st.session_state:
-    st.session_state.optimizer = None
-if 'date_range' not in st.session_state:
-    st.session_state.date_range = None
-
-# Title
-st.markdown('<h1 class="main-header">🎯 Optimization Tool</h1>', unsafe_allow_html=True)
-
-# Sidebar for optimization parameters
-with st.sidebar:
-    st.markdown("## ⚙️ Optimization Parameters")
-    
-    # Date Selection Section
-    st.markdown("### 📅 Date Range Selection")
-    try:
-        date_ranges = transform.get_date_ranges()
-        if date_ranges:
-            date_range_options = [f"{start.strftime('%Y-%m-%d')} to {end.strftime('%Y-%m-%d')}" for start, end in date_ranges]
-            selected_range_str = st.selectbox(
-                "Select date range:",
-                options=date_range_options,
-                help="Available date ranges from released orders"
-            )
-            
-            selected_index = date_range_options.index(selected_range_str)
-            start_date, end_date = date_ranges[selected_index]
-            st.session_state.date_range = (start_date, end_date)
-            
-            duration = (end_date - start_date).days + 1
-            st.info(f"Duration: {duration} days")
-            
-        else:
-            st.warning("No date ranges found in data")
-            start_date = datetime(2025, 3, 24).date()
-            end_date = datetime(2025, 3, 28).date()
-            st.session_state.date_range = (start_date, end_date)
-            
-    except Exception as e:
-        st.error(f"Error loading dates: {e}")
-        start_date = datetime(2025, 3, 24).date()
-        end_date = datetime(2025, 3, 28).date()
-        st.session_state.date_range = (start_date, end_date)
-    
-    st.markdown("---")
-    
-    # Employee Type Selection
-    st.markdown("### 👥 Employee Configuration")
-    try:
-        employee_df = extract.read_employee_data()
-        available_emp_types = employee_df["employment_type"].unique().tolist()
-    except:
-        available_emp_types = ["UNICEF Fixed term", "Humanizer"]
-    
-    selected_emp_types = st.multiselect(
-        "Employee Types:",
-        available_emp_types,
-        default=available_emp_types,
-        help="Select employee types to include in optimization"
-    )
-    
-    # Shift Selection
-    st.markdown("### 🕐 Shift Configuration")
-    try:
-        shift_df = extract.get_shift_info()
-        available_shifts = shift_df["id"].unique().tolist()
-    except:
-        available_shifts = [1, 2, 3]
-    
-    selected_shifts = st.multiselect(
-        "Shifts:",
-        available_shifts,
-        default=available_shifts,
-        help="1=Regular, 2=Overtime, 3=Evening"
-    )
-    
-    # Line Selection
-    st.markdown("### 🏭 Production Line Configuration")
-    try:
-        line_df = extract.read_packaging_line_data()
-        available_lines = line_df["id"].unique().tolist()
-    except:
-        available_lines = [6, 7]
-    
-    selected_lines = st.multiselect(
-        "Production Lines:",
-        available_lines,
-        default=available_lines,
-        help="Select production lines to include"
-    )
-    
-    st.markdown("---")
-    
-    # Advanced Parameters
-    with st.expander("🔧 Advanced Parameters", expanded=False):
-        constraint_mode = st.selectbox(
-            "Fixed Staff Constraint Mode:",
-            ["priority", "mandatory", "none"],
-            index=0,
-            help="priority=Use fixed staff first, mandatory=Force all fixed hours, none=Demand-driven"
-        )
-        
-        max_hours_per_person = st.number_input(
-            "Max hours per person per day:",
-            min_value=8,
-            max_value=24,
-            value=14,
-            help="Legal daily limit"
-        )
-        
-        # Employee availability override
-        st.markdown("**Employee Availability Override:**")
-        col1, col2 = st.columns(2)
-        with col1:
-            unicef_count = st.number_input("UNICEF Fixed term:", min_value=0, value=8)
-        with col2:
-            humanizer_count = st.number_input("Humanizer:", min_value=0, value=6)
-    
-    st.markdown("---")
-    
-    # Run Optimization Button
-    run_optimization = st.button("🚀 Run Optimization", type="primary", use_container_width=True)
-    
-    if st.button("🔄 Clear Results", use_container_width=True):
-        st.session_state.optimization_results = None
-        st.rerun()
-
-# Main content area
-if st.session_state.date_range:
-    start_date, end_date = st.session_state.date_range
-    st.markdown(f"**Optimization Period:** {start_date} to {end_date}")
-else:
-    st.warning("Please select a date range from the sidebar")
-    st.stop()
-
-# Optimization execution
-if run_optimization:
-    with st.spinner("🔄 Running optimization... This may take a few moments."):
-        try:
-            # Run optimization using the new optimizer
-            st.info("🔧 Using optimizer_new_aug14 with fixed team weekly scheduling")
-            
-            results = solve_fixed_team_weekly()
-            
-            if results is None:
-                st.error("❌ Optimization returned no results")
-            elif isinstance(results, dict) and results.get('status') == 'failed':
-                st.error(f"❌ Optimization failed: {results.get('message', 'Unknown error')}")
-            else:
-                # Convert results to expected format for display
-                st.session_state.optimization_results = {
-                    'status': 'success',
-                    'total_cost': results.get('objective', 0),
-                    'raw_results': results,
-                    'solver_type': 'optimizer_new_aug14'
-                }
-                st.success("✅ Optimization completed successfully!")
-                
-        except Exception as e:
-            st.error(f"❌ Optimization failed: {e}")
-            st.exception(e)
-
-# Display results if available
-if st.session_state.optimization_results:
-    results = st.session_state.optimization_results
-    
-    # Results header
-    st.markdown('<div class="results-panel">', unsafe_allow_html=True)
-    st.markdown("## 📊 Optimization Results")
-    
-    # Key metrics summary
-    total_cost = results.get('total_cost', 0)
-    params = results.get('parameters', {})
-    
-    col_summary1, col_summary2, col_summary3, col_summary4 = st.columns(4)
-    
-    with col_summary1:
-        st.metric("💰 Total Cost", f"${total_cost:,.2f}")
-    with col_summary2:
-        st.metric("📦 Products", len(params.get('product_list', [])))
-    with col_summary3:
-        st.metric("👥 Employee Types", len(params.get('employee_types', [])))
-    with col_summary4:
-        if st.session_state.date_range:
-            start_date, end_date = st.session_state.date_range
-            duration = (end_date - start_date).days + 1
-            cost_per_day = total_cost / duration if duration > 0 else 0
-            st.metric("💵 Cost/Day", f"${cost_per_day:,.2f}")
-    
-    st.markdown('</div>', unsafe_allow_html=True)
-    
-    # Create tabs for detailed results
-    tab1, tab2, tab3, tab4 = st.tabs(["📊 Summary", "📈 Production", "👷 Labor", "💰 Costs"])
-    
-    with tab1:
-        st.markdown("### 📊 Optimization Summary")
-        
-        # Check if we have raw results from new optimizer
-        raw_results = results.get('raw_results', {})
-        solver_type = results.get('solver_type', 'Unknown')
-        
-        st.info(f"🔧 Solver Used: {solver_type}")
-        
-        # Additional summary metrics
-        col_s1, col_s2, col_s3 = st.columns(3)
-        
-        with col_s1:
-            if 'weekly_production' in raw_results:
-                total_produced = sum(raw_results['weekly_production'].values())
-                st.metric("🏭 Total Produced", f"{total_produced:,.0f}")
-            else:
-                st.metric("🏭 Total Produced", "N/A")
-        with col_s2:
-            if 'weekly_production' in raw_results:
-                total_produced = sum(raw_results['weekly_production'].values())
-                cost_per_unit = total_cost / total_produced if total_produced > 0 else 0
-                st.metric("💵 Cost per Unit", f"${cost_per_unit:.3f}")
-            else:
-                st.metric("💵 Cost per Unit", "N/A")
-        with col_s3:
-            products_count = len(raw_results.get('weekly_production', {}))
-            st.metric("���� Products Optimized", products_count)
-        
-        # Show optimization parameters used
-        st.markdown("#### 📋 Configuration Used")
-        col_config1, col_config2 = st.columns(2)
-        
-        with col_config1:
-            st.markdown("**Selected Parameters:**")
-            st.markdown(f"• **Employee Types:** {', '.join(selected_emp_types)}")
-            st.markdown(f"• **Shifts:** {', '.join(map(str, selected_shifts))}")
-            st.markdown(f"• **Production Lines:** {', '.join(map(str, selected_lines))}")
-        
-        with col_config2:
-            st.markdown("**Optimization Details:**")
-            st.markdown(f"• **Constraint Mode:** {params.get('constraint_mode', 'N/A')}")
-            st.markdown(f"• **Days Optimized:** {len(params.get('days', []))}")
-            st.markdown(f"• **Products Included:** {len(params.get('product_list', []))}")
-        
-        # Solution quality indicators
-        st.markdown("#### ✅ Solution Quality")
-        col_qual1, col_qual2, col_qual3 = st.columns(3)
-        
-        with col_qual1:
-            st.success("**Status:** Optimal solution found")
-        with col_qual2:
-            st.info(f"**Solver:** OR-Tools CBC")
-        with col_qual3:
-            st.info(f"**Solution Time:** < 1 minute")
-    
-    with tab2:
-        st.markdown("### 📈 Production Results")
-        
-        # Use new optimizer results format
-        weekly_production = raw_results.get('weekly_production', {})
-        run_schedule = raw_results.get('run_schedule', [])
-        
-        if weekly_production:
-            # Create production summary table
-            prod_data = []
-            
-            # Get demand data for comparison
-            demand_data = optimization_config.DEMAND_DICTIONARY
-            
-            for product, produced in weekly_production.items():
-                demand = demand_data.get(product, 0)
-                fulfillment_rate = (produced / demand * 100) if demand > 0 else 0
-                
-                prod_data.append({
-                    'Product': product,
-                    'Demand': demand,
-                    'Produced': produced,
-                    'Fulfillment %': f"{fulfillment_rate:.1f}%",
-                    'Status': '✅ Met' if fulfillment_rate >= 100 else '⚠️ Partial'
-                })
-            
-            if prod_data:
-                prod_df = pd.DataFrame(prod_data)
-                
-                # Production metrics
-                total_demand = sum(data['demand'] for data in production_results.values())
-                total_produced = sum(data['produced'] for data in production_results.values())
-                overall_fulfillment = (total_produced / total_demand * 100) if total_demand > 0 else 0
-                
-                col_prod1, col_prod2, col_prod3, col_prod4 = st.columns(4)
-                
-                with col_prod1:
-                    st.metric("📦 Total Demand", f"{total_demand:,.0f}")
-                with col_prod2:
-                    st.metric("🏭 Total Produced", f"{total_produced:,.0f}")
-                with col_prod3:
-                    st.metric("✅ Overall Fulfillment", f"{overall_fulfillment:.1f}%")
-                with col_prod4:
-                    products_met = sum(1 for data in production_results.values() if data['fulfillment_rate'] >= 100)
-                    st.metric("🎯 Products Fully Met", f"{products_met}/{len(production_results)}")
-                
-                # Production table
-                st.markdown("#### 📋 Production Details")
-                st.dataframe(prod_df, use_container_width=True)
-                
-                # Production charts
-                col_chart1, col_chart2 = st.columns(2)
-                
-                with col_chart1:
-                    # Production vs Demand comparison
-                    fig_prod = px.bar(
-                        prod_df, 
-                        x='Product', 
-                        y=['Demand', 'Produced'],
-                        title='Production vs Demand by Product',
-                        barmode='group'
-                    )
-                    fig_prod.update_layout(xaxis_tickangle=-45)
-                    st.plotly_chart(fig_prod, use_container_width=True)
-                
-                with col_chart2:
-                    # Fulfillment rate chart
-                    fulfillment_data = [(row['Product'], float(row['Fulfillment %'].rstrip('%'))) for row in prod_data]
-                    fulfill_df = pd.DataFrame(fulfillment_data, columns=['Product', 'Fulfillment_Rate'])
-                    
-                    fig_fulfill = px.bar(
-                        fulfill_df,
-                        x='Product',
-                        y='Fulfillment_Rate',
-                        title='Fulfillment Rate by Product (%)',
-                        color='Fulfillment_Rate',
-                        color_continuous_scale='RdYlGn'
-                    )
-                    fig_fulfill.update_layout(yaxis_title="Fulfillment Rate (%)", xaxis_tickangle=-45)
-                    fig_fulfill.add_hline(y=100, line_dash="dash", line_color="red", annotation_text="Target: 100%")
-                    st.plotly_chart(fig_fulfill, use_container_width=True)
-        else:
-            st.info("No production data available")
-    
-    with tab3:
-        st.markdown("### 👷 Labor Allocation")
-        
-        employee_hours = results.get('employee_hours', {})
-        headcount_req = results.get('headcount_requirements', {})
-        
-        if employee_hours:
-            # Labor summary metrics
-            total_labor_hours = 0
-            labor_data = []
-            
-            for emp_type, shifts in employee_hours.items():
-                emp_total_hours = 0
-                for shift, daily_hours in shifts.items():
-                    total_hours = sum(daily_hours)
-                    emp_total_hours += total_hours
-                    if total_hours > 0:
-                        labor_data.append({
-                            'Employee Type': emp_type,
-                            'Shift': f"Shift {shift}",
-                            'Total Hours': total_hours,
-                            'Avg Daily Hours': total_hours / len(daily_hours) if daily_hours else 0
-                        })
-                total_labor_hours += emp_total_hours
-            
-            # Labor metrics
-            col_labor1, col_labor2, col_labor3, col_labor4 = st.columns(4)
-            
-            with col_labor1:
-                st.metric("⏰ Total Labor Hours", f"{total_labor_hours:,.0f}")
-            with col_labor2:
-                if st.session_state.date_range:
-                    duration = (end_date - start_date).days + 1
-                    avg_daily_hours = total_labor_hours / duration
-                    st.metric("📅 Avg Daily Hours", f"{avg_daily_hours:,.0f}")
-            with col_labor3:
-                try:
-                    max_daily_workers = 0
-                    for emp_type, shifts in headcount_req.items():
-                        for shift, daily_counts in shifts.items():
-                            if daily_counts:  # daily_counts is a list
-                                max_daily_workers += max(daily_counts)
-                    st.metric("👥 Peak Workers Needed", max_daily_workers)
-                except Exception as e:
-                    st.metric("👥 Peak Workers Needed", "N/A")
-            with col_labor4:
-                labor_cost_per_hour = total_cost / total_labor_hours if total_labor_hours > 0 else 0
-                st.metric("💰 Avg Cost/Hour", f"${labor_cost_per_hour:.2f}")
-            
-            if labor_data:
-                st.markdown("#### 📋 Labor Hours Details")
-                labor_df = pd.DataFrame(labor_data)
-                st.dataframe(labor_df, use_container_width=True)
-                
-                # Labor visualization
-                col_labor_chart1, col_labor_chart2 = st.columns(2)
-                
-                with col_labor_chart1:
-                    # Labor hours by type and shift
-                    fig_labor = px.bar(
-                        labor_df,
-                        x='Employee Type',
-                        y='Total Hours',
-                        color='Shift',
-                        title='Total Labor Hours by Employee Type and Shift',
-                        barmode='group'
-                    )
-                    st.plotly_chart(fig_labor, use_container_width=True)
-                
-                with col_labor_chart2:
-                    # Labor distribution pie chart
-                    emp_totals = labor_df.groupby('Employee Type')['Total Hours'].sum()
-                    fig_labor_pie = px.pie(
-                        values=emp_totals.values,
-                        names=emp_totals.index,
-                        title='Labor Hours Distribution by Employee Type'
-                    )
-                    st.plotly_chart(fig_labor_pie, use_container_width=True)
-        
-        # Headcount requirements
-        if headcount_req:
-            st.markdown("#### 👥 Required Headcount")
-            headcount_data = []
-            for emp_type, shifts in headcount_req.items():
-                for shift, daily_count in shifts.items():
-                    max_count = max(daily_count) if daily_count else 0
-                    avg_count = sum(daily_count) / len(daily_count) if daily_count else 0
-                    total_count = sum(daily_count) if daily_count else 0
-                    if max_count > 0:
-                        headcount_data.append({
-                            'Employee Type': emp_type,
-                            'Shift': f"Shift {shift}",
-                            'Max Daily': max_count,
-                            'Avg Daily': f"{avg_count:.1f}",
-                            'Total Period': total_count
-                        })
-            
-            if headcount_data:
-                headcount_df = pd.DataFrame(headcount_data)
-                st.dataframe(headcount_df, use_container_width=True)
-                
-                # Headcount visualization
-                fig_headcount = px.bar(
-                    headcount_df,
-                    x='Employee Type',
-                    y='Max Daily',
-                    color='Shift',
-                    title='Maximum Daily Headcount Requirements',
-                    barmode='group'
-                )
-                st.plotly_chart(fig_headcount, use_container_width=True)
-    
-    with tab4:
-        st.markdown("### 💰 Cost Analysis")
-        
-        # Cost summary
-        total_cost = results.get('total_cost', 0)
-        
-        col_cost_summary1, col_cost_summary2, col_cost_summary3, col_cost_summary4 = st.columns(4)
-        
-        with col_cost_summary1:
-            st.metric("💰 Total Cost", f"${total_cost:,.2f}")
-        with col_cost_summary2:
-            if st.session_state.date_range:
-                duration = (end_date - start_date).days + 1
-                cost_per_day = total_cost / duration
-                st.metric("📅 Cost per Day", f"${cost_per_day:,.2f}")
-        with col_cost_summary3:
-            total_demand = params.get('total_demand', 1)
-            cost_per_unit = total_cost / total_demand if total_demand > 0 else 0
-            st.metric("📦 Cost per Unit", f"${cost_per_unit:.3f}")
-        with col_cost_summary4:
-            total_hours = sum(sum(sum(daily_hours) for daily_hours in shifts.values()) 
-                            for shifts in results.get('employee_hours', {}).values())
-            cost_per_hour = total_cost / total_hours if total_hours > 0 else 0
-            st.metric("⏰ Cost per Hour", f"${cost_per_hour:.2f}")
-        
-        # Cost breakdown by employee type
-        employee_hours = results.get('employee_hours', {})
-        if employee_hours:
-            cost_data = []
-            wage_types = optimization_config.COST_LIST_PER_EMP_SHIFT
-            
-            for emp_type, shifts in employee_hours.items():
-                emp_total_cost = 0
-                for shift, daily_hours in shifts.items():
-                    total_hours = sum(daily_hours)
-                    if total_hours > 0 and emp_type in wage_types and shift in wage_types[emp_type]:
-                        shift_cost = total_hours * wage_types[emp_type][shift]
-                        emp_total_cost += shift_cost
-                        cost_data.append({
-                            'Employee Type': emp_type,
-                            'Shift': f"Shift {shift}",
-                            'Hours': total_hours,
-                            'Rate ($/hr)': wage_types[emp_type][shift],
-                            'Total Cost ($)': shift_cost,
-                            'Percentage': (shift_cost / total_cost * 100) if total_cost > 0 else 0
-                        })
-            
-            if cost_data:
-                st.markdown("#### 📊 Detailed Cost Breakdown")
-                cost_df = pd.DataFrame(cost_data)
-                st.dataframe(cost_df, use_container_width=True)
-                
-                # Cost visualization
-                col_cost_chart1, col_cost_chart2 = st.columns(2)
-                
-                with col_cost_chart1:
-                    # Cost by employee type and shift
-                    fig_cost = px.bar(
-                        cost_df,
-                        x='Employee Type',
-                        y='Total Cost ($)',
-                        color='Shift',
-                        title='Cost Breakdown by Employee Type and Shift',
-                        barmode='stack'
-                    )
-                    st.plotly_chart(fig_cost, use_container_width=True)
-                
-                with col_cost_chart2:
-                    # Cost distribution pie chart
-                    emp_costs = cost_df.groupby('Employee Type')['Total Cost ($)'].sum()
-                    fig_cost_pie = px.pie(
-                        values=emp_costs.values,
-                        names=emp_costs.index,
-                        title='Cost Distribution by Employee Type'
-                    )
-                    st.plotly_chart(fig_cost_pie, use_container_width=True)
-        
-        # Priority mode results
-        priority_results = results.get('priority_results')
-        if priority_results and priority_results.get('summary'):
-            st.markdown("#### 🎯 Priority Mode Analysis")
-            summary = priority_results['summary']
-            
-            col_priority1, col_priority2 = st.columns(2)
-            
-            with col_priority1:
-                if summary['unicef_sufficient']:
-                    st.success("✅ **UNICEF Fixed term staff sufficient**")
-                    st.info("→ Humanizer staff not needed for this demand level")
-                else:
-                    st.warning(f"⚠️ **{summary['total_capacity_flags']} cases where UNICEF at capacity**")
-                    st.info("→ Humanizer staff utilized to meet demand")
-            
-            with col_priority2:
-                if summary['unicef_sufficient']:
-                    st.metric("🎯 Optimization Efficiency", "100%")
-                    st.caption("All demand met with preferred staff only")
-                else:
-                    efficiency = (1 - summary['total_capacity_flags'] / len(params.get('product_list', [1]))) * 100
-                    st.metric("🎯 Optimization Efficiency", f"{efficiency:.1f}%")
-                    st.caption("Percentage of demand met with preferred staff")
-
-else:
-    # Placeholder content when no results
-    st.markdown('<div class="optimization-panel">', unsafe_allow_html=True)
-    st.markdown("## 🎯 Ready to Optimize")
-    st.markdown("""
-    Configure your optimization parameters in the sidebar and click **'🚀 Run Optimization'** to get started!
-    
-    ### What you'll see after optimization:
-    
-    - **📊 Summary**: Overall results and key performance metrics
-    - **📈 Production**: Detailed production schedule and fulfillment analysis  
-    - **👷 Labor**: Employee allocation and shift assignments
-    - **💰 Costs**: Comprehensive cost breakdown and analysis
-    
-    ### Tips for better results:
-    - Ensure your date range has sufficient demand data
-    - Select appropriate employee types for your scenario
-    - Consider using 'priority' constraint mode for realistic business operations
-    """)
-    st.markdown('</div>', unsafe_allow_html=True)
-    
-    # Show current configuration
-    if st.session_state.date_range:
-        st.markdown("### 📋 Current Configuration")
-        col_config1, col_config2 = st.columns(2)
-        
-        with col_config1:
-            st.markdown("**Selected Parameters:**")
-            st.markdown(f"• **Date Range:** {start_date} to {end_date}")
-            st.markdown(f"• **Employee Types:** {', '.join(selected_emp_types) if selected_emp_types else 'None selected'}")
-            st.markdown(f"• **Shifts:** {', '.join(map(str, selected_shifts)) if selected_shifts else 'None selected'}")
-        
-        with col_config2:
-            st.markdown("**Configuration Status:**")
-            status_emp = "✅" if selected_emp_types else "❌"
-            status_shift = "✅" if selected_shifts else "❌"
-            status_lines = "✅" if selected_lines else "❌"
-            
-            st.markdown(f"• **Employee Types:** {status_emp}")
-            st.markdown(f"• **Shifts:** {status_shift}")
-            st.markdown(f"• **Production Lines:** {status_lines}")
-
-# Footer
-st.markdown("---")
-st.markdown("""
-<div style='text-align: center; color: gray; padding: 1rem;'>
-    <small>Optimization Tool | Powered by OR-Tools | Real-time data integration</small>
-</div>
-""", unsafe_allow_html=True)

pages/3_📈_Enhanced_Reports.py

@@ -1,873 +0,0 @@
-import streamlit as st
-
-# Page configuration
-st.set_page_config(
-    page_title="Enhanced Reports",
-    page_icon="📈",
-    layout="wide"
-)
-
-# Import libraries
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import sys
-import os
-from datetime import datetime, timedelta
-import numpy as np
-
-# Add src to path for imports
-sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src'))
-
-try:
-    import src.etl.extract as extract
-    import src.etl.transform as transform
-    from src.config import optimization_config
-except ImportError as e:
-    st.error(f"Error importing modules: {e}")
-    st.stop()
-
-# Custom CSS
-st.markdown("""
-<style>
-    .main-header {
-        font-size: 2.5rem;
-        font-weight: bold;
-        color: #1f77b4;
-        margin-bottom: 1rem;
-    }
-    .section-header {
-        font-size: 1.5rem;
-        font-weight: bold;
-        color: #2c3e50;
-        margin: 1rem 0;
-    }
-    .metric-card {
-        background-color: #f8f9fa;
-        padding: 1rem;
-        border-radius: 0.5rem;
-        border-left: 4px solid #1f77b4;
-        margin-bottom: 1rem;
-    }
-    .cost-highlight {
-        background-color: #e8f5e8;
-        padding: 1rem;
-        border-radius: 0.5rem;
-        border-left: 4px solid #28a745;
-        margin: 1rem 0;
-    }
-    .production-highlight {
-        background-color: #fff3cd;
-        padding: 1rem;
-        border-radius: 0.5rem;
-        border-left: 4px solid #ffc107;
-        margin: 1rem 0;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-# Initialize session state
-if 'date_range' not in st.session_state:
-    st.session_state.date_range = None
-
-# Title
-st.markdown('<h1 class="main-header">📈 Enhanced Visualization Reports</h1>', unsafe_allow_html=True)
-
-# Sidebar for date selection
-with st.sidebar:
-    st.markdown("## 📅 Date Selection")
-    
-    try:
-        date_ranges = transform.get_date_ranges()
-        if date_ranges:
-            date_range_options = [f"{start.strftime('%Y-%m-%d')} to {end.strftime('%Y-%m-%d')}" for start, end in date_ranges]
-            selected_range_str = st.selectbox(
-                "Select date range:",
-                options=date_range_options,
-                help="Available date ranges from released orders"
-            )
-            
-            selected_index = date_range_options.index(selected_range_str)
-            start_date, end_date = date_ranges[selected_index]
-            st.session_state.date_range = (start_date, end_date)
-            
-            duration = (end_date - start_date).days + 1
-            st.info(f"Duration: {duration} days")
-            
-        else:
-            st.warning("No date ranges found")
-            start_date = datetime(2025, 3, 24).date()
-            end_date = datetime(2025, 3, 28).date()
-            st.session_state.date_range = (start_date, end_date)
-            
-    except Exception as e:
-        st.error(f"Error loading dates: {e}")
-        start_date = datetime(2025, 3, 24).date()
-        end_date = datetime(2025, 3, 28).date()
-        st.session_state.date_range = (start_date, end_date)
-    
-    st.markdown("---")
-    st.markdown("## 🔄 Refresh Data")
-    if st.button("🔄 Reload All Data"):
-        st.rerun()
-
-# Main content
-if st.session_state.date_range:
-    start_date, end_date = st.session_state.date_range
-    st.markdown(f"**Analysis Period:** {start_date} to {end_date}")
-else:
-    st.warning("No date range selected")
-    st.stop()
-
-# Create main tabs for the enhanced reports
-tab1, tab2, tab3, tab4 = st.tabs([
-    "💰 Employee Costs per Hour", 
-    "📋 Production Plans & Orders", 
-    "🏭 Line Allocation by Day", 
-    "💵 Total Costs & Analysis"
-])
-
-# Tab 1: Employee Costs per Hour
-with tab1:
-    st.markdown('<h2 class="section-header">💰 Employee Costs per Hour Analysis</h2>', unsafe_allow_html=True)
-    
-    try:
-        # Load employee cost data
-        employee_df = extract.read_employee_data()
-        cost_data = optimization_config.COST_LIST_PER_EMP_SHIFT
-        shift_hours = optimization_config.MAX_HOUR_PER_SHIFT_PER_PERSON
-        
-        # Create comprehensive cost analysis
-        st.markdown("### 📊 Hourly Rate Breakdown")
-        
-        # Detailed cost table with all combinations
-        cost_breakdown = []
-        employee_counts = employee_df['employment_type'].value_counts()
-        
-        for emp_type, shifts in cost_data.items():
-            emp_count = employee_counts.get(emp_type, 0)
-            
-            for shift_id, hourly_rate in shifts.items():
-                shift_name = {1: 'Regular', 2: 'Overtime', 3: 'Evening'}.get(shift_id, f'Shift {shift_id}')
-                shift_duration = shift_hours.get(shift_id, 0)
-                
-                cost_breakdown.append({
-                    'Employee Type': emp_type,
-                    'Shift': shift_name,
-                    'Shift ID': shift_id,
-                    'Available Staff': emp_count,
-                    'Hourly Rate ($)': hourly_rate,
-                    'Shift Duration (hrs)': shift_duration,
-                    'Daily Cost per Employee ($)': hourly_rate * shift_duration,
-                    'Total Daily Cost Potential ($)': hourly_rate * shift_duration * emp_count
-                })
-        
-        cost_df = pd.DataFrame(cost_breakdown)
-        
-        # Display detailed cost table
-        st.dataframe(cost_df, use_container_width=True)
-        
-        # Cost analysis visualizations
-        col_cost1, col_cost2 = st.columns(2)
-        
-        with col_cost1:
-            # Hourly rates comparison
-            fig_hourly = px.bar(
-                cost_df,
-                x='Employee Type',
-                y='Hourly Rate ($)',
-                color='Shift',
-                title='Hourly Rates by Employee Type and Shift',
-                barmode='group',
-                text='Hourly Rate ($)'
-            )
-            fig_hourly.update_traces(texttemplate='$%{text:.0f}', textposition='outside')
-            st.plotly_chart(fig_hourly, use_container_width=True)
-        
-        with col_cost2:
-            # Daily cost per employee
-            fig_daily = px.bar(
-                cost_df,
-                x='Employee Type',
-                y='Daily Cost per Employee ($)',
-                color='Shift',
-                title='Daily Cost per Employee by Type and Shift',
-                barmode='group',
-                text='Daily Cost per Employee ($)'
-            )
-            fig_daily.update_traces(texttemplate='$%{text:.0f}', textposition='outside')
-            st.plotly_chart(fig_daily, use_container_width=True)
-        
-        # Cost efficiency analysis
-        st.markdown("### 📈 Cost Efficiency Analysis")
-        
-        col_eff1, col_eff2 = st.columns(2)
-        
-        with col_eff1:
-            # Cost per hour vs productivity visualization
-            fig_efficiency = px.scatter(
-                cost_df,
-                x='Shift Duration (hrs)',
-                y='Hourly Rate ($)',
-                size='Available Staff',
-                color='Employee Type',
-                title='Cost Efficiency: Hourly Rate vs Shift Duration',
-                hover_data=['Shift', 'Total Daily Cost Potential ($)']
-            )
-            st.plotly_chart(fig_efficiency, use_container_width=True)
-        
-        with col_eff2:
-            # Cost distribution pie chart
-            emp_cost_totals = cost_df.groupby('Employee Type')['Total Daily Cost Potential ($)'].sum()
-            fig_pie = px.pie(
-                values=emp_cost_totals.values,
-                names=emp_cost_totals.index,
-                title='Total Daily Cost Potential Distribution'
-            )
-            st.plotly_chart(fig_pie, use_container_width=True)
-        
-        # Summary metrics
-        st.markdown("### 📋 Cost Summary Metrics")
-        
-        col_summary1, col_summary2, col_summary3, col_summary4 = st.columns(4)
-        
-        total_potential_cost = cost_df['Total Daily Cost Potential ($)'].sum()
-        min_hourly_rate = cost_df['Hourly Rate ($)'].min()
-        max_hourly_rate = cost_df['Hourly Rate ($)'].max()
-        avg_hourly_rate = cost_df['Hourly Rate ($)'].mean()
-        
-        with col_summary1:
-            st.metric("💰 Total Daily Potential", f"${total_potential_cost:,.2f}")
-        with col_summary2:
-            st.metric("📉 Min Hourly Rate", f"${min_hourly_rate:.2f}")
-        with col_summary3:
-            st.metric("📈 Max Hourly Rate", f"${max_hourly_rate:.2f}")
-        with col_summary4:
-            st.metric("📊 Avg Hourly Rate", f"${avg_hourly_rate:.2f}")
-        
-        # Cost projections
-        st.markdown('<div class="cost-highlight">', unsafe_allow_html=True)
-        st.markdown("#### 📅 Cost Projections")
-        
-        duration = (end_date - start_date).days + 1
-        period_cost = total_potential_cost * duration
-        weekly_cost = total_potential_cost * 7
-        monthly_cost = total_potential_cost * 30
-        
-        col_proj1, col_proj2, col_proj3 = st.columns(3)
-        
-        with col_proj1:
-            st.metric("📅 Current Period", f"${period_cost:,.2f}", f"{duration} days")
-        with col_proj2:
-            st.metric("📅 Weekly Projection", f"${weekly_cost:,.2f}")
-        with col_proj3:
-            st.metric("📅 Monthly Projection", f"${monthly_cost:,.2f}")
-        
-        st.markdown('</div>', unsafe_allow_html=True)
-        
-    except Exception as e:
-        st.error(f"Error in employee cost analysis: {e}")
-
-# Tab 2: Production Plans & Orders
-with tab2:
-    st.markdown('<h2 class="section-header">📋 Production Plans & Orders Analysis</h2>', unsafe_allow_html=True)
-    
-    try:
-        # Load production data
-        demand_df = extract.read_released_orders_data(start_date=start_date, end_date=end_date)
-        planned_df = extract.read_planned_orders_data(start_date=start_date, end_date=end_date)
-        
-        # Production overview
-        st.markdown("### 📊 Production Overview")
-        
-        col_prod1, col_prod2, col_prod3, col_prod4 = st.columns(4)
-        
-        total_released_orders = len(demand_df)
-        total_planned_orders = len(planned_df) if planned_df is not None else 0
-        total_released_quantity = demand_df["Order quantity (GMEIN)"].sum()
-        unique_materials = demand_df["Material Number"].nunique()
-        
-        with col_prod1:
-            st.metric("📦 Released Orders", f"{total_released_orders:,}")
-        with col_prod2:
-            st.metric("📋 Planned Orders", f"{total_planned_orders:,}")
-        with col_prod3:
-            st.metric("📊 Total Quantity", f"{total_released_quantity:,.0f}")
-        with col_prod4:
-            st.metric("🎯 Unique Materials", f"{unique_materials:,}")
-        
-        # Daily production schedule
-        st.markdown("### 📅 Daily Production Schedule")
-        
-        # Convert dates and create daily view
-        demand_df['Date'] = pd.to_datetime(demand_df['Basic finish date'])
-        daily_production = demand_df.groupby(['Date', 'Material Number']).agg({
-            'Order quantity (GMEIN)': 'sum',
-            'Order': 'count'
-        }).reset_index()
-        
-        # Daily summary
-        daily_summary = demand_df.groupby('Date').agg({
-            'Order quantity (GMEIN)': 'sum',
-            'Order': 'count',
-            'Material Number': 'nunique'
-        }).reset_index()
-        daily_summary.columns = ['Date', 'Total Quantity', 'Total Orders', 'Unique Materials']
-        
-        col_daily1, col_daily2 = st.columns(2)
-        
-        with col_daily1:
-            # Daily quantity trend
-            fig_daily_qty = px.line(
-                daily_summary,
-                x='Date',
-                y='Total Quantity',
-                title='Daily Production Quantity Trend',
-                markers=True
-            )
-            fig_daily_qty.update_layout(xaxis_title="Date", yaxis_title="Total Quantity")
-            st.plotly_chart(fig_daily_qty, use_container_width=True)
-        
-        with col_daily2:
-            # Daily orders count
-            fig_daily_orders = px.bar(
-                daily_summary,
-                x='Date',
-                y='Total Orders',
-                title='Daily Orders Count',
-                color='Total Orders',
-                color_continuous_scale='Blues'
-            )
-            st.plotly_chart(fig_daily_orders, use_container_width=True)
-        
-        # Material analysis
-        st.markdown("### 🎯 Material Analysis")
-        
-        # Top materials by quantity
-        material_summary = demand_df.groupby('Material Number').agg({
-            'Order quantity (GMEIN)': 'sum',
-            'Order': 'count'
-        }).reset_index()
-        material_summary.columns = ['Material', 'Total Quantity', 'Order Count']
-        material_summary = material_summary.sort_values('Total Quantity', ascending=False)
-        
-        col_mat1, col_mat2 = st.columns(2)
-        
-        with col_mat1:
-            # Top 10 materials by quantity
-            top_materials = material_summary.head(10)
-            fig_top_mat = px.bar(
-                top_materials,
-                x='Material',
-                y='Total Quantity',
-                title='Top 10 Materials by Total Quantity',
-                color='Total Quantity',
-                color_continuous_scale='Viridis'
-            )
-            fig_top_mat.update_layout(xaxis_tickangle=-45)
-            st.plotly_chart(fig_top_mat, use_container_width=True)
-        
-        with col_mat2:
-            # Order frequency vs quantity scatter
-            fig_scatter = px.scatter(
-                material_summary,
-                x='Order Count',
-                y='Total Quantity',
-                title='Order Frequency vs Total Quantity',
-                hover_data=['Material'],
-                size='Total Quantity',
-                color='Order Count',
-                color_continuous_scale='Plasma'
-            )
-            st.plotly_chart(fig_scatter, use_container_width=True)
-        
-        # Detailed production schedule table
-        st.markdown("### 📋 Detailed Production Schedule")
-        
-        # Show daily breakdown with materials
-        expanded_schedule = demand_df[['Date', 'Order', 'Material Number', 'Material description', 
-                                     'Order quantity (GMEIN)', 'Basic start date', 'Basic finish date']].copy()
-        expanded_schedule['Date'] = expanded_schedule['Date'].dt.strftime('%Y-%m-%d')
-        expanded_schedule['Basic start date'] = pd.to_datetime(expanded_schedule['Basic start date']).dt.strftime('%Y-%m-%d')
-        expanded_schedule['Basic finish date'] = pd.to_datetime(expanded_schedule['Basic finish date']).dt.strftime('%Y-%m-%d')
-        
-        st.dataframe(expanded_schedule, use_container_width=True)
-        
-        # Production capacity analysis
-        st.markdown('<div class="production-highlight">', unsafe_allow_html=True)
-        st.markdown("#### 🏭 Production Capacity Requirements")
-        
-        # Calculate required line hours per day
-        line_capacity = optimization_config.PER_PRODUCT_SPEED
-        material_line_req = {}
-        
-        for _, row in demand_df.iterrows():
-            material = row['Material Number']
-            quantity = row['Order quantity (GMEIN)']
-            date = row['Date'].strftime('%Y-%m-%d')
-            
-            # Get line assignment (simplified - using line 6 as default)
-            line_id = optimization_config.KIT_LINE_MATCH_DICT.get(material, 6)
-            line_speed = line_capacity.get(line_id, 300)  # Default 300 units/hour
-            
-            required_hours = quantity / line_speed if line_speed > 0 else 0
-            
-            if date not in material_line_req:
-                material_line_req[date] = {}
-            if line_id not in material_line_req[date]:
-                material_line_req[date][line_id] = 0
-            
-            material_line_req[date][line_id] += required_hours
-        
-        # Display capacity requirements
-        capacity_data = []
-        for date, lines in material_line_req.items():
-            for line_id, hours in lines.items():
-                capacity_data.append({
-                    'Date': date,
-                    'Line': f'Line {line_id}',
-                    'Required Hours': hours,
-                    'Line Capacity (units/hr)': line_capacity.get(line_id, 300)
-                })
-        
-        if capacity_data:
-            capacity_df = pd.DataFrame(capacity_data)
-            
-            # Capacity visualization
-            fig_capacity = px.bar(
-                capacity_df,
-                x='Date',
-                y='Required Hours',
-                color='Line',
-                title='Daily Line Capacity Requirements',
-                barmode='stack'
-            )
-            st.plotly_chart(fig_capacity, use_container_width=True)
-            
-            # Capacity summary table
-            st.dataframe(capacity_df, use_container_width=True)
-        
-        st.markdown('</div>', unsafe_allow_html=True)
-        
-    except Exception as e:
-        st.error(f"Error in production analysis: {e}")
-
-# Tab 3: Line Allocation by Day  
-with tab3:
-    st.markdown('<h2 class="section-header">🏭 Line Allocation by Day Analysis</h2>', unsafe_allow_html=True)
-    
-    try:
-        # Load line and production data
-        line_df = extract.read_packaging_line_data()
-        demand_df = extract.read_released_orders_data(start_date=start_date, end_date=end_date)
-        
-        # Line capacity configuration
-        line_capacity = optimization_config.PER_PRODUCT_SPEED
-        shift_hours = optimization_config.MAX_HOUR_PER_SHIFT_PER_PERSON
-        
-        st.markdown("### 🏭 Production Line Overview")
-        
-        # Line metrics
-        col_line1, col_line2, col_line3, col_line4 = st.columns(4)
-        
-        total_lines = line_df['line_count'].sum()
-        line_types = len(line_df)
-        max_capacity_line = line_df.loc[line_df['line_count'].idxmax()]
-        
-        with col_line1:
-            st.metric("🏭 Total Lines", total_lines)
-        with col_line2:
-            st.metric("📋 Line Types", line_types)
-        with col_line3:
-            st.metric("🔺 Max Capacity Line", f"Line {max_capacity_line['id']}")
-        with col_line4:
-            st.metric("📊 Max Line Count", max_capacity_line['line_count'])
-        
-        # Daily line allocation analysis
-        st.markdown("### 📅 Daily Line Allocation Requirements")
-        
-        # Calculate daily requirements per line
-        demand_df['Date'] = pd.to_datetime(demand_df['Basic finish date'])
-        daily_line_allocation = {}
-        
-        # Group by date and calculate line requirements
-        for date, date_group in demand_df.groupby('Date'):
-            date_str = date.strftime('%Y-%m-%d')
-            daily_line_allocation[date_str] = {}
-            
-            for _, row in date_group.iterrows():
-                material = row['Material Number']
-                quantity = row['Order quantity (GMEIN)']
-                
-                # Get line assignment
-                line_id = optimization_config.KIT_LINE_MATCH_DICT.get(material, 6)
-                line_speed = line_capacity.get(line_id, 300)
-                
-                # Calculate required hours
-                required_hours = quantity / line_speed if line_speed > 0 else 0
-                
-                if line_id not in daily_line_allocation[date_str]:
-                    daily_line_allocation[date_str][line_id] = {
-                        'required_hours': 0,
-                        'materials': [],
-                        'total_quantity': 0
-                    }
-                
-                daily_line_allocation[date_str][line_id]['required_hours'] += required_hours
-                daily_line_allocation[date_str][line_id]['materials'].append(material)
-                daily_line_allocation[date_str][line_id]['total_quantity'] += quantity
-        
-        # Create allocation visualization data
-        allocation_data = []
-        for date, lines in daily_line_allocation.items():
-            for line_id, data in lines.items():
-                line_info = line_df[line_df['id'] == line_id].iloc[0] if len(line_df[line_df['id'] == line_id]) > 0 else None
-                available_lines = line_info['line_count'] if line_info is not None else 1
-                
-                # Calculate utilization per line
-                utilization_per_line = data['required_hours'] / available_lines if available_lines > 0 else 0
-                max_hours_per_line = sum(shift_hours.values())  # Total available hours per day
-                utilization_percentage = (utilization_per_line / max_hours_per_line) * 100 if max_hours_per_line > 0 else 0
-                
-                allocation_data.append({
-                    'Date': date,
-                    'Line': f'Line {line_id}',
-                    'Line ID': line_id,
-                    'Required Hours': data['required_hours'],
-                    'Available Lines': available_lines,
-                    'Hours per Line': utilization_per_line,
-                    'Utilization %': min(utilization_percentage, 100),  # Cap at 100%
-                    'Materials Count': len(set(data['materials'])),
-                    'Total Quantity': data['total_quantity'],
-                    'Max Hours Available': max_hours_per_line * available_lines
-                })
-        
-        allocation_df = pd.DataFrame(allocation_data)
-        
-        if not allocation_df.empty:
-            # Line utilization visualization
-            col_util1, col_util2 = st.columns(2)
-            
-            with col_util1:
-                # Daily utilization by line
-                fig_util = px.bar(
-                    allocation_df,
-                    x='Date',
-                    y='Utilization %',
-                    color='Line',
-                    title='Daily Line Utilization Percentage',
-                    barmode='group'
-                )
-                fig_util.add_hline(y=100, line_dash="dash", line_color="red", annotation_text="100% Capacity")
-                fig_util.update_layout(yaxis_title="Utilization %", xaxis_title="Date")
-                st.plotly_chart(fig_util, use_container_width=True)
-            
-            with col_util2:
-                # Required hours by line and date
-                fig_hours = px.bar(
-                    allocation_df,
-                    x='Date',
-                    y='Required Hours',
-                    color='Line',
-                    title='Required Hours by Line and Date',
-                    barmode='stack'
-                )
-                st.plotly_chart(fig_hours, use_container_width=True)
-            
-            # Detailed allocation table
-            st.markdown("### 📋 Detailed Line Allocation")
-            st.dataframe(allocation_df, use_container_width=True)
-            
-            # Line capacity analysis
-            st.markdown("### 📊 Line Capacity Analysis")
-            
-            # Calculate daily totals
-            daily_totals = allocation_df.groupby('Date').agg({
-                'Required Hours': 'sum',
-                'Max Hours Available': 'sum',
-                'Materials Count': 'sum',
-                'Total Quantity': 'sum'
-            }).reset_index()
-            
-            daily_totals['Overall Utilization %'] = (daily_totals['Required Hours'] / daily_totals['Max Hours Available']) * 100
-            daily_totals['Capacity Status'] = daily_totals['Overall Utilization %'].apply(
-                lambda x: '🟢 Normal' if x <= 80 else ('🟡 High' if x <= 100 else '🔴 Overload')
-            )
-            
-            col_cap1, col_cap2 = st.columns(2)
-            
-            with col_cap1:
-                # Overall daily utilization
-                fig_overall = px.line(
-                    daily_totals,
-                    x='Date',
-                    y='Overall Utilization %',
-                    title='Overall Daily Capacity Utilization',
-                    markers=True
-                )
-                fig_overall.add_hline(y=80, line_dash="dash", line_color="orange", annotation_text="High Utilization (80%)")
-                fig_overall.add_hline(y=100, line_dash="dash", line_color="red", annotation_text="Full Capacity (100%)")
-                st.plotly_chart(fig_overall, use_container_width=True)
-            
-            with col_cap2:
-                # Capacity status summary
-                status_counts = daily_totals['Capacity Status'].value_counts()
-                fig_status = px.pie(
-                    values=status_counts.values,
-                    names=status_counts.index,
-                    title='Daily Capacity Status Distribution'
-                )
-                st.plotly_chart(fig_status, use_container_width=True)
-            
-            # Summary metrics
-            col_summary1, col_summary2, col_summary3, col_summary4 = st.columns(4)
-            
-            avg_utilization = daily_totals['Overall Utilization %'].mean()
-            max_utilization = daily_totals['Overall Utilization %'].max()
-            overload_days = len(daily_totals[daily_totals['Overall Utilization %'] > 100])
-            
-            with col_summary1:
-                st.metric("📊 Avg Utilization", f"{avg_utilization:.1f}%")
-            with col_summary2:
-                st.metric("🔺 Peak Utilization", f"{max_utilization:.1f}%")
-            with col_summary3:
-                st.metric("🔴 Overload Days", overload_days)
-            with col_summary4:
-                total_capacity_hours = daily_totals['Max Hours Available'].iloc[0] if len(daily_totals) > 0 else 0
-                st.metric("⚡ Daily Capacity", f"{total_capacity_hours:.0f} hrs")
-        
-    except Exception as e:
-        st.error(f"Error in line allocation analysis: {e}")
-
-# Tab 4: Total Costs & Analysis
-with tab4:
-    st.markdown('<h2 class="section-header">💵 Total Costs & Analysis</h2>', unsafe_allow_html=True)
-    
-    try:
-        # Load all necessary data for comprehensive cost analysis
-        employee_df = extract.read_employee_data()
-        demand_df = extract.read_released_orders_data(start_date=start_date, end_date=end_date)
-        cost_data = optimization_config.COST_LIST_PER_EMP_SHIFT
-        shift_hours = optimization_config.MAX_HOUR_PER_SHIFT_PER_PERSON
-        line_capacity = optimization_config.PER_PRODUCT_SPEED
-        
-        st.markdown("### 💰 Comprehensive Cost Analysis")
-        
-        # Calculate production requirements and costs
-        duration = (end_date - start_date).days + 1
-        total_demand = demand_df["Order quantity (GMEIN)"].sum()
-        
-        # Estimate labor requirements
-        total_production_hours = 0
-        daily_requirements = {}
-        
-        demand_df['Date'] = pd.to_datetime(demand_df['Basic finish date'])
-        
-        for date, date_group in demand_df.groupby('Date'):
-            date_str = date.strftime('%Y-%m-%d')
-            daily_hours = 0
-            
-            for _, row in date_group.iterrows():
-                material = row['Material Number']
-                quantity = row['Order quantity (GMEIN)']
-                
-                # Get line speed
-                line_id = optimization_config.KIT_LINE_MATCH_DICT.get(material, 6)
-                line_speed = line_capacity.get(line_id, 300)
-                
-                # Calculate production hours needed
-                hours_needed = quantity / line_speed if line_speed > 0 else 0
-                daily_hours += hours_needed
-            
-            daily_requirements[date_str] = daily_hours
-            total_production_hours += daily_hours
-        
-        # Cost scenario analysis
-        st.markdown("### 📊 Cost Scenario Analysis")
-        
-        # Calculate different staffing scenarios
-        scenarios = {
-            'Minimum Cost': {'UNICEF Fixed term': 0.5, 'Humanizer': 0.5},  # 50% of each type
-            'Balanced': {'UNICEF Fixed term': 0.6, 'Humanizer': 0.4},
-            'Quality Focus': {'UNICEF Fixed term': 0.8, 'Humanizer': 0.2},
-            'Maximum Capacity': {'UNICEF Fixed term': 1.0, 'Humanizer': 1.0}
-        }
-        
-        scenario_results = []
-        employee_counts = employee_df['employment_type'].value_counts()
-        
-        for scenario_name, ratios in scenarios.items():
-            scenario_cost = 0
-            scenario_hours = 0
-            
-            for emp_type, ratio in ratios.items():
-                available_staff = employee_counts.get(emp_type, 0)
-                used_staff = int(available_staff * ratio)
-                
-                # Calculate cost for each shift type
-                if emp_type in cost_data:
-                    for shift_id, hourly_rate in cost_data[emp_type].items():
-                        shift_duration = shift_hours.get(shift_id, 0)
-                        shift_cost = used_staff * hourly_rate * shift_duration
-                        scenario_cost += shift_cost
-                        scenario_hours += used_staff * shift_duration
-            
-            # Project for the entire period
-            period_cost = scenario_cost * duration
-            
-            scenario_results.append({
-                'Scenario': scenario_name,
-                'Daily Cost ($)': scenario_cost,
-                'Period Cost ($)': period_cost,
-                'Daily Hours': scenario_hours,
-                'Cost per Hour ($)': scenario_cost / scenario_hours if scenario_hours > 0 else 0,
-                'Cost per Unit ($)': period_cost / total_demand if total_demand > 0 else 0
-            })
-        
-        scenario_df = pd.DataFrame(scenario_results)
-        
-        # Scenario comparison visualization
-        col_scenario1, col_scenario2 = st.columns(2)
-        
-        with col_scenario1:
-            fig_scenario_cost = px.bar(
-                scenario_df,
-                x='Scenario',
-                y='Period Cost ($)',
-                title='Total Period Cost by Scenario',
-                color='Period Cost ($)',
-                color_continuous_scale='Reds'
-            )
-            fig_scenario_cost.update_layout(xaxis_tickangle=-45)
-            st.plotly_chart(fig_scenario_cost, use_container_width=True)
-        
-        with col_scenario2:
-            fig_scenario_unit = px.bar(
-                scenario_df,
-                x='Scenario',
-                y='Cost per Unit ($)',
-                title='Cost per Unit by Scenario',
-                color='Cost per Unit ($)',
-                color_continuous_scale='Blues'
-            )
-            fig_scenario_unit.update_layout(xaxis_tickangle=-45)
-            st.plotly_chart(fig_scenario_unit, use_container_width=True)
-        
-        # Scenario details table
-        st.dataframe(scenario_df, use_container_width=True)
-        
-        # Daily cost breakdown
-        st.markdown("### 📅 Daily Cost Breakdown")
-        
-        # Calculate daily costs based on requirements
-        daily_cost_data = []
-        for date_str, required_hours in daily_requirements.items():
-            
-            # Simple allocation: distribute hours across available staff
-            total_available_hours = 0
-            for emp_type in cost_data.keys():
-                available_staff = employee_counts.get(emp_type, 0)
-                for shift_id in cost_data[emp_type].keys():
-                    total_available_hours += available_staff * shift_hours.get(shift_id, 0)
-            
-            if total_available_hours > 0:
-                utilization_rate = min(required_hours / total_available_hours, 1.0)
-                
-                daily_cost = 0
-                for emp_type in cost_data.keys():
-                    available_staff = employee_counts.get(emp_type, 0)
-                    for shift_id, hourly_rate in cost_data[emp_type].items():
-                        shift_duration = shift_hours.get(shift_id, 0)
-                        # Allocate proportionally
-                        used_hours = available_staff * shift_duration * utilization_rate
-                        daily_cost += used_hours * hourly_rate
-                
-                daily_cost_data.append({
-                    'Date': date_str,
-                    'Required Hours': required_hours,
-                    'Utilization Rate': utilization_rate * 100,
-                    'Daily Cost ($)': daily_cost,
-                    'Cost per Hour ($)': daily_cost / required_hours if required_hours > 0 else 0
-                })
-        
-        if daily_cost_data:
-            daily_cost_df = pd.DataFrame(daily_cost_data)
-            
-            col_daily1, col_daily2 = st.columns(2)
-            
-            with col_daily1:
-                fig_daily_cost = px.line(
-                    daily_cost_df,
-                    x='Date',
-                    y='Daily Cost ($)',
-                    title='Daily Labor Cost Trend',
-                    markers=True
-                )
-                st.plotly_chart(fig_daily_cost, use_container_width=True)
-            
-            with col_daily2:
-                fig_daily_util = px.bar(
-                    daily_cost_df,
-                    x='Date',
-                    y='Utilization Rate',
-                    title='Daily Labor Utilization Rate (%)',
-                    color='Utilization Rate',
-                    color_continuous_scale='RdYlGn'
-                )
-                st.plotly_chart(fig_daily_util, use_container_width=True)
-            
-            # Daily breakdown table
-            st.dataframe(daily_cost_df, use_container_width=True)
-        
-        # Summary metrics
-        st.markdown("### 📋 Cost Summary")
-        
-        col_total1, col_total2, col_total3, col_total4 = st.columns(4)
-        
-        if daily_cost_data:
-            total_period_cost = sum(item['Daily Cost ($)'] for item in daily_cost_data)
-            avg_daily_cost = total_period_cost / len(daily_cost_data)
-            total_required_hours = sum(item['Required Hours'] for item in daily_cost_data)
-            avg_cost_per_hour = total_period_cost / total_required_hours if total_required_hours > 0 else 0
-        else:
-            total_period_cost = avg_daily_cost = total_required_hours = avg_cost_per_hour = 0
-        
-        with col_total1:
-            st.metric("💰 Total Period Cost", f"${total_period_cost:,.2f}")
-        with col_total2:
-            st.metric("📅 Avg Daily Cost", f"${avg_daily_cost:,.2f}")
-        with col_total3:
-            st.metric("⏰ Total Labor Hours", f"{total_required_hours:,.0f}")
-        with col_total4:
-            st.metric("💵 Avg Cost/Hour", f"${avg_cost_per_hour:.2f}")
-        
-        # ROI and efficiency metrics
-        st.markdown('<div class="cost-highlight">', unsafe_allow_html=True)
-        st.markdown("#### 📈 Efficiency Metrics")
-        
-        col_eff1, col_eff2, col_eff3 = st.columns(3)
-        
-        cost_per_unit = total_period_cost / total_demand if total_demand > 0 else 0
-        cost_per_day = total_period_cost / duration if duration > 0 else 0
-        
-        with col_eff1:
-            st.metric("💵 Cost per Unit", f"${cost_per_unit:.3f}")
-        with col_eff2:
-            st.metric("📅 Cost per Day", f"${cost_per_day:,.2f}")
-        with col_eff3:
-            hours_per_unit = total_required_hours / total_demand if total_demand > 0 else 0
-            st.metric("⏰ Hours per Unit", f"{hours_per_unit:.3f}")
-        
-        st.markdown('</div>', unsafe_allow_html=True)
-        
-    except Exception as e:
-        st.error(f"Error in total cost analysis: {e}")
-
-# Footer
-st.markdown("---")
-st.markdown("""
-<div style='text-align: center; color: gray; padding: 1rem;'>
-    <small>Enhanced Visualization Reports | Real-time data analysis | Updated: {}</small>
-</div>
-""".format(datetime.now().strftime('%Y-%m-%d %H:%M')), unsafe_allow_html=True)

pyproject.toml.backup

@@ -1,35 +0,0 @@
-[project]
-name = "supply-roster-tool-real"
-version = "0.1.0"
-description = ""
-authors = [
-    {name = "HaLim Jun",email = "hjun@unicef.org"}
-]
-license = {text = "MIT"}
-readme = "README.md"
-requires-python = ">=3.10,<3.11"
-dependencies = [
-    "absl-py==2.3.1",
-    "dotenv==0.9.9",
-    "immutabledict==4.2.1",
-    "numpy==2.2.6",
-    "ortools==9.14.6206",
-    "pandas==2.3.1",
-    "protobuf==6.31.1",
-    "psycopg2-binary==2.9.9",
-    "python-dateutil==2.9.0.post0",
-    "python-dotenv==1.0.0",
-    "pytz==2025.2",
-    "six==1.17.0",
-    "SQLAlchemy==2.0.36",
-    "typing_extensions==4.14.1",
-    "tzdata==2025.2",
-
-
-
-]
-
-
-[build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"

run_streamlit.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple runner script for the SD Roster Optimization Streamlit app.
-"""
-
-import subprocess
-import sys
-import os
-
-def main():
-    """Run the Streamlit app"""
-    # Change to the project directory
-    project_dir = os.path.dirname(os.path.abspath(__file__))
-    os.chdir(project_dir)
-    
-    # Run streamlit
-    try:
-        subprocess.run([
-            sys.executable, "-m", "streamlit", "run", "Home.py",
-            "--server.port", "8501",
-            "--server.address", "localhost"
-        ], check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"Error running Streamlit: {e}")
-        return 1
-    except KeyboardInterrupt:
-        print("\nStreamlit app stopped by user")
-        return 0
-    
-    return 0
-
-if __name__ == "__main__":
-    exit(main())

src/models/optimizer_real.py

@@ -1,499 +0,0 @@
-# Option A (with lines) + 7-day horizon (weekly demand only)
-# Generalized: arbitrary products (product_list) and day-varying headcount N_day[e][t]
-# -----------------------------------------------------------------------------
-# pip install ortools
-from ortools.linear_solver import pywraplp
-import pandas as pd
-import sys
-import os
-
-sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
-
-from src.config import optimization_config
-import importlib
-
-importlib.reload(optimization_config)
-
-
-class OptimizerReal:
-    def __init__(self):
-        self.config = optimization_config
-
-    def solve_option_A_multi_day_generalized(self):
-        # -----------------------------
-        # 1) SETS
-        # -----------------------------
-        # Days
-        days = self.config.DATE_SPAN
-
-        # Products (master set; you can have many)
-        # Fill with all SKUs that may appear over the week
-        product_list = self.config.PRODUCT_LIST  # EDIT: add/remove products freely
-
-        # Employee types (fixed to two types Fixed,Humanizer; headcount varies by day)
-        employee_types = self.config.EMPLOYEE_TYPE_LIST
-
-        # Shifts: 1=usual, 2=overtime, 3=evening
-        shift_list = self.config.SHIFT_LIST
-
-        # Line types and explicit line list
-        line_list = self.config.LINE_LIST
-        line_cnt_per_type = self.config.LINE_CNT_PER_TYPE  # number of physical lines per type (EDIT)
-        line_type_cnt_tuple = [
-            (t, i) for t in line_list for i in range(1, line_cnt_per_type[t] + 1)
-        ]  # pair of line type and line number (e.g., ('long', 1))
-
-        # -----------------------------
-        # 2) PARAMETERS (EDIT THESE)
-        # -----------------------------
-        # Weekly demand (units) for each product in product_list
-        weekly_demand = self.config.DEMAND_DICTIONARY
-        
-        # Validate demand - check if any products have positive demand
-        total_demand = sum(weekly_demand.get(p, 0) for p in product_list)
-        if total_demand == 0:
-            print("Warning: Total demand is zero for all products. Optimization may not be meaningful.")
-            print("Products:", product_list)
-            print("Demands:", {p: weekly_demand.get(p, 0) for p in product_list})
-
-        # Daily activity toggle for each product (1=can be produced on day t; 0=cannot)
-        # If a product is not active on a day, we force its production and hours to 0 that day.
-        active = {
-            t: {p: 1 for p in product_list} for t in days
-        }  # EDIT per day if some SKUs are not available
-
-        # Per-hour labor cost by employee type & shift
-        wage_types = self.config.COST_LIST_PER_EMP_SHIFT
-
-        # Productivity productivities[e][s][p] = units per hour (assumed line-independent here)
-        # Provide entries for ALL products in product_list
-        productivities = self.config.PRODUCTIVITY_LIST_PER_EMP_PRODUCT
-        # If productivity depends on line, switch to q_line[(e,s,p,ell)] and use it in constraints.
-
-        # Day-varying available headcount per type
-        # N_day[e][t] = number of employees of type e available on day t
-        N_day = self.config.MAX_EMPLOYEE_PER_TYPE_ON_DAY
-
-        # Limits
-        Hmax_daily_per_person = (
-            self.config.MAX_HOUR_PER_PERSON_PER_DAY
-        )  # per person per day
-        Hmax_shift = self.config.MAX_HOUR_PER_SHIFT_PER_PERSON  # per-shift hour caps
-        # Per-line unit/hour capacity (physical)
-        Cap = self.config.PER_PRODUCT_SPEED
-
-        # Fixed regular hours for type Fixed on shift 1
-        # BUSINESS LOGIC: Fixed staff availability vs mandatory hours
-        # Controlled by FIXED_STAFF_CONSTRAINT_MODE in optimization_config
-        
-        first_shift_hour = Hmax_shift[1]
-        daily_weekly_type = self.config.DAILY_WEEKLY_SCHEDULE
-        constraint_mode = self.config.FIXED_STAFF_CONSTRAINT_MODE
-        
-        if constraint_mode == "mandatory":
-            # Option 1: Mandatory hours (forces staff to work even when idle)
-            F_x1_day = {t: first_shift_hour * N_day["UNICEF Fixed term"][t] for t in days}
-            print(f"Using MANDATORY fixed hours constraint: {sum(F_x1_day.values())} hours/week")
-        elif constraint_mode == "priority":
-            # Option 3: Priority-based (realistic business model)
-            F_x1_day = None
-            print("Using PRIORITY constraint - fixed staff first, then temporary staff")
-        elif constraint_mode == "none":
-            # Option 4: No constraint (fully demand-driven)
-            F_x1_day = None
-            print("Using NO fixed hours constraint - demand-driven scheduling")
-        else:
-            raise ValueError(f"Invalid FIXED_STAFF_CONSTRAINT_MODE: {constraint_mode}. Use 'mandatory', 'available', 'priority', or 'none'")
-        
-         # e.g., F_x1_day =  sum(F_x1_day.values()) if you want weekly instead (then set F_x1_day=None)
-        PER_PRODUCT_SPEED = self.config.PER_PRODUCT_SPEED
-
-        # Optional skill/compatibility: allow[(e,p,ell)] = 1/0 (1=allowed; 0=forbid)
-        allow = {}
-        for e in employee_types:
-            for p in product_list:
-                for ell in line_type_cnt_tuple:
-                    allow[(e, p, ell)] = 1  # EDIT as needed
-
-        # -----------------------------
-        # 3) SOLVER
-        # -----------------------------
-        solver = pywraplp.Solver.CreateSolver("CBC")  # open-source mixed-integer program (MIP) solver
-        if not solver:
-            raise RuntimeError("Failed to create solver. Check OR-Tools installation.")
-        INF = solver.infinity()
-
-        # -----------------------------
-        # 4) DECISION VARIABLES
-        # -----------------------------
-        # h[e,s,p,ell,t] = worker-hours of type e on shift s for product p on line ell on day t (integer)
-
-        h = {}
-        for e in employee_types:
-            for s in shift_list:
-                for p in product_list:
-                    for ell in line_type_cnt_tuple:
-                        for t in days:
-                            # Upper bound of labor hour per (e,s,t): shift hour cap * available headcount that day
-                            
-                            ub = Hmax_shift[s] * N_day[e][t]
-                            h[e, s, p, ell, t] = solver.IntVar(
-                                0, ub, f"h_{e}_{s}_{p}_{ell[0]}{ell[1]}_d{t}"
-                            )# h = work hour per (employee type,shift,t-day) is decided somewhere between 0 and ub and is an integer
-
-        # u[p,ell,s,t] = units of product p produced on line ell during shift s on day t
-        #Maybe we need upper bound here
-        u = {}
-        for p in product_list:
-            for ell in line_type_cnt_tuple:
-                for s in shift_list:
-                    for t in days:
-                        u[p, ell, s, t] = solver.NumVar(
-                            0, INF, f"u_{p}_{ell[0]}{ell[1]}_{s}_d{t}"
-                        )
-
-        # tline[ell,s,t] = operating hours of line ell during shift s on day t
-        # tline = line operating hour per (line,shift,t-day) is decided somewhere between 0 and Hmax_shift[s] and is a real number
-        tline = {}
-        for ell in line_type_cnt_tuple:
-            for s in shift_list:
-                for t in days:
-                    tline[ell, s, t] = solver.NumVar(
-                        0, Hmax_shift[s], f"t_{ell[0]}{ell[1]}_{s}_d{t}"
-                    )
-
-        # ybin[e,s,t] = shift usage binaries per type/day (to gate OT after usual)
-        # ybin = shift usage binary per (employee type,shift,t-day) is decided somewhere between 0 and 1 and is a binary number
-        ybin = {}
-        for e in employee_types:
-            for s in shift_list:
-                for t in days:
-                    ybin[e, s, t] = solver.BoolVar(f"y_{e}_{s}_d{t}")
-
-        # -----------------------------
-        # 5) OBJECTIVE: Minimize total labor cost over the week
-        # -----------------------------
-        print("wage_types",wage_types)
-        print("h",h)
-        solver.Minimize(
-            solver.Sum(
-                wage_types[e][s] * h[e, s, p, ell, t]
-                for e in employee_types
-                for s in shift_list
-                for p in product_list
-                for ell in line_type_cnt_tuple
-                for t in days
-            )
-        )
-
-        # -----------------------------
-        # 6) CONSTRAINTS
-        # -----------------------------
-
-        # 6.1 Weekly demand (no daily demand)
-        #unit of production for p over the week should be larger or equal to demand value
-        for p in product_list:
-            demand_value = weekly_demand.get(p, 0)
-            if demand_value > 0:  # Only add constraint if there's actual demand
-                solver.Add(
-                    solver.Sum(u[p, ell, s, t] for ell in line_type_cnt_tuple for s in shift_list for t in days)
-                    >= demand_value
-                )
-                
-
-        # 6.2 If a product is inactive on a day, force zero production and hours for that day
-        # This makes "varying products per day" explicit.
-        # BIG_H = max(Hmax_shift.values()) * sum(N_day[e][t] for e in employee_types for t in days)
-        for p in product_list:
-            for t in days:
-                if active[t][p] == 0:
-                    for ell in line_type_cnt_tuple:
-                        for s in shift_list:
-                            #If if not active, production unit is 0
-                            solver.Add(u[p, ell, s, t] == 0)
-                            #If if not active, work hour is 0
-                            for e in employee_types:
-                                solver.Add(h[e, s, p, ell, t] == 0)
-
-        # 6.3 Labor -> units (per line/shift/day)
-        #Total production unit based on labor productivity cap
-        # If productivity depends on line, swap productivities[e][s][p] with q_line[(e,s,p,ell)] here.
-
-        for p in product_list:
-            for ell in line_type_cnt_tuple:
-                for s in shift_list:
-                    for t in days:
-                        # Gate by activity (if inactive, both sides are already 0 from 6.2)
-                        solver.Add(
-                            u[p, ell, s, t]
-                            <= solver.Sum(productivities[e][s][p] * h[e, s, p, ell, t] for e in employee_types)
-                        )
-
-        # 6.4 Per-line throughput cap (units/hour × line-hours)
-        #per line production cap for each line
-        #tline = line operating hour per (line,shift,t-day) 
-        for ell in line_type_cnt_tuple:
-            for s in shift_list:
-                for t in days:
-                    line_type = ell[0]  # 'long' or 'short'
-                    solver.Add(
-                        solver.Sum(u[p, ell, s, t] for p in product_list)
-                        <= PER_PRODUCT_SPEED[line_type] * tline[ell, s, t]
-                    )
-
-        # 6.5 Couple line hours & worker-hours (multi-operator lines)
-        # Multiple workers can work on a line simultaneously, up to MAX_PARALLEL_WORKERS limit
-        for ell in line_type_cnt_tuple:
-            line_type = ell[0]  # 6 or 7
-            max_workers = self.config.MAX_PARALLEL_WORKERS[line_type]
-            for s in shift_list:
-                for t in days:
-                    solver.Add(
-                        solver.Sum(h[e, s, p, ell, t] for e in employee_types for p in product_list)
-                        <= max_workers * tline[ell, s, t]
-                    )
-
-        # 6.6 Fixed regular hours for type Fixed on shift 1
-        if F_x1_day is not None:
-            # Per-day fixed hours (mandatory - expensive)
-            for t in days:
-                solver.Add(
-                    solver.Sum(h["UNICEF Fixed term", 1, p, ell, t] for p in product_list for ell in line_type_cnt_tuple)
-                    == F_x1_day[t]
-                )
-            print("Applied mandatory fixed hours constraint")
-
-        else:
-            # No fixed constraint - purely demand-driven (cost-efficient)
-            print("No mandatory fixed hours constraint - using demand-driven scheduling")
-            # The availability constraint (6.7) already limits maximum hours
-            
-            # Special handling for priority mode
-            if constraint_mode == "priority":
-                print("Implementing priority constraints: UNICEF Fixed term used before Humanizer")
-                # Add constraints to prioritize fixed staff usage before temporary staff
-                
-                # Store unicef_at_capacity variables for later inspection
-                unicef_capacity_vars = {}
-                
-                # Priority constraint: For each day, product, and line,
-                # Humanizer hours can only be used if UNICEF Fixed term is at capacity
-                for t in days:
-                    for p in product_list:
-                        for ell in line_type_cnt_tuple:
-                            # Create binary variable to indicate if UNICEF Fixed term is at capacity
-                            unicef_at_capacity = solver.IntVar(0, 1, f"unicef_at_capacity_{p}_{ell[0]}{ell[1]}_d{t}")
-                            unicef_capacity_vars[p, ell, t] = unicef_at_capacity  # Store for later
-                            
-                            # Calculate maximum possible hours for Humanizer staff this day
-                            max_humanizer_hours = sum(Hmax_shift[s] * N_day["Humanizer"][t] for s in shift_list)
-                            
-                            # If UNICEF is not at capacity (unicef_at_capacity = 0), then Humanizer hours must be 0
-                            # If UNICEF is at capacity (unicef_at_capacity = 1), then Humanizer can work up to their limit
-                            solver.Add(
-                                solver.Sum(h["Humanizer", s, p, ell, t] for s in shift_list) 
-                                <= unicef_at_capacity * max_humanizer_hours  # Correct M value
-                            )
-                            
-                            # Calculate maximum possible hours for UNICEF Fixed term staff this day
-                            max_unicef_hours = sum(Hmax_shift[s] * N_day["UNICEF Fixed term"][t] for s in shift_list)
-                            
-                            # Simple logic: unicef_at_capacity = 1 if and only if UNICEF uses ALL available hours
-                            # This ensures Humanizer is only used when UNICEF is completely maxed out
-                            solver.Add(
-                                solver.Sum(h["UNICEF Fixed term", s, p, ell, t] for s in shift_list)
-                                >= unicef_at_capacity * max_unicef_hours  # If capacity=1, UNICEF must use max hours
-                            )
-                            
-                            if max_unicef_hours > 0:
-                                # Upper-bound link with small epsilon so it works with 0.1-hour granularity
-                                eps = 0.1  # smallest time unit (hours)
-
-                                # If capacity = 0 → UNICEF ≤ max_unicef_hours - eps
-                                # If capacity = 1 → UNICEF ≤ max_unicef_hours (tight)
-                                solver.Add(
-                                    solver.Sum(
-                                        h["UNICEF Fixed term", s, p, ell, t] for s in shift_list
-                                    )
-                                    <= max_unicef_hours - eps + unicef_at_capacity * eps
-                                )
-                            else:
-                                # No UNICEF staff that day → capacity flag must be 0
-                                solver.Add(unicef_at_capacity == 0)
-
-        # 6.7 Daily hours cap per employee type (14h per person per day)
-        for e in employee_types:
-            for t in days:
-                solver.Add(
-                    solver.Sum(
-                        h[e, s, p, ell, t] for s in shift_list for p in product_list for ell in line_type_cnt_tuple
-                    )
-                    <= Hmax_daily_per_person * N_day[e][t]
-                )
-
-        # 6.8 Link hours to shift-usage binaries (per type/day)
-        # Use a type/day-specific Big-M: M_e_s_t = Hmax_shift[s] * N_day[e][t]
-        for e in employee_types:
-            for s in shift_list:
-                for t in days:
-                    M_e_s_t = Hmax_shift[s] * N_day[e][t]
-                    solver.Add(
-                        solver.Sum(h[e, s, p, ell, t] for p in product_list for ell in line_type_cnt_tuple)
-                        <= M_e_s_t * ybin[e, s, t]
-                    )
-
-        # 6.9 Overtime only after usual (per day). Also bound OT hours <= usual hours
-        # Binary activation variable for employee type, shift and day
-        for e in employee_types:
-            for t in days:
-                solver.Add(ybin[e, 2, t] <= ybin[e, 1, t])
-                solver.Add(
-                    solver.Sum(h[e, 2, p, ell, t] for p in product_list for ell in line_type_cnt_tuple)
-                    <= solver.Sum(h[e, 1, p, ell, t] for p in product_list for ell in line_type_cnt_tuple)
-                )
-        # (Optional) evening only after usual:
-        # for e in employee_types:
-        #     for t in days:
-        #         solver.Add(ybin[e, 3, t] <= ybin[e, 1, t])
-
-        # 6.10 Skill/compatibility mask
-        for e in employee_types:
-            for p in product_list:
-                for ell in line_type_cnt_tuple:
-                    if allow[(e, p, ell)] == 0:
-                        for s in shift_list:
-                            for t in days:
-                                solver.Add(h[e, s, p, ell, t] == 0)
-
-        # -----------------------------
-        # 7) SOLVE
-        # -----------------------------
-        status = solver.Solve()
-        if status != pywraplp.Solver.OPTIMAL:
-            print("No optimal solution. Status:", status)
-            return {
-                'status': 'failed',
-                'solver_status': status,
-                'message': f"No optimal solution found. Solver status: {status}"
-            }
-
-        # -----------------------------
-        # 8) REPORT
-        # -----------------------------
-        total_cost = solver.Objective().Value()
-        print("Objective (min cost):", total_cost)
-
-        # Collect production results
-        production_results = {}
-        print("\n--- Weekly production by product ---")
-        for p in product_list:
-            produced = sum(
-                u[p, ell, s, t].solution_value() for ell in line_type_cnt_tuple for s in shift_list for t in days
-            )
-            production_results[p] = {
-                'produced': produced,
-                'demand': weekly_demand.get(p, 0),
-                'fulfillment_rate': (produced / weekly_demand.get(p, 1)) * 100 if weekly_demand.get(p, 0) > 0 else 0
-            }
-            print(f"{p}: {produced:.1f} (weekly demand {weekly_demand.get(p,0)})")
-
-        # Collect line operating hours
-        line_hours = {}
-        print("\n--- Line operating hours by shift/day ---")
-        for ell in line_type_cnt_tuple:
-            line_hours[ell] = {}
-            for s in shift_list:
-                hours = [tline[ell, s, t].solution_value() for t in days]
-                line_hours[ell][s] = hours
-                if sum(hours) > 1e-6:
-                    print(
-                        f"Line {ell} Shift {s}: "
-                        + ", ".join([f"days{t}={hours[t-1]:.2f}h" for t in days])
-                    )
-
-        # Collect employee hours
-        employee_hours = {}
-        print("\n--- Hours by employee type / shift / day ---")
-        for e in employee_types:
-            employee_hours[e] = {}
-            for s in shift_list:
-                day_hours = [
-                    sum(h[e, s, p, ell, t].solution_value() for p in product_list for ell in line_type_cnt_tuple)
-                    for t in days
-                ]
-                employee_hours[e][s] = day_hours
-                if sum(day_hours) > 1e-6:
-                    print(
-                        f"e={e}, s={s}: "
-                        + ", ".join([f"days{t}={day_hours[t-1]:.2f}h" for t in days])
-                    )
-
-        # Collect headcount requirements
-        headcount_requirements = {}
-        print("\n--- Implied headcount by type / shift / day ---")
-        for e in employee_types:
-            headcount_requirements[e] = {}
-            print(e)
-            for s in shift_list:
-                row = []
-                daily_headcount = []
-                for t in days:
-                    hours = sum(
-                        h[e, s, p, ell, t].solution_value() for p in product_list for ell in line_type_cnt_tuple
-                    )
-                    need = int((hours + Hmax_shift[s] - 1) // Hmax_shift[s])  # ceil
-                    daily_headcount.append(need)
-                    row.append(f"days{t}={need}")
-
-                headcount_requirements[e][s] = daily_headcount
-                if any("=0" not in Fixed for Fixed in row):
-                    print(f"e={e}, s={s}: " + ", ".join(row))
-
-        # Collect priority mode results
-        priority_results = None
-        if constraint_mode == "priority" and 'unicef_capacity_vars' in locals():
-            priority_results = {}
-            print("\n--- UNICEF At Capacity Status (Priority Mode) ---")
-            for (p, ell, t), var in unicef_capacity_vars.items():
-                capacity_value = var.solution_value()
-                if capacity_value > 0.5:  # Binary variable, so > 0.5 means 1
-                    priority_results[(p, ell, t)] = capacity_value
-                    print(f"Product {p}, Line {ell}, Day {t}: UNICEF at capacity = {capacity_value:.0f}")
-            
-            # Summary
-            total_capacity_flags = sum(1 for var in unicef_capacity_vars.values() if var.solution_value() > 0.5)
-            if total_capacity_flags == 0:
-                print("✅ All unicef_at_capacity = 0 → UNICEF Fixed term staff sufficient for all demand")
-                print("   → Humanizer staff not needed")
-            else:
-                print(f"⚠️  {total_capacity_flags} cases where UNICEF at capacity → Humanizer staff used")
-            
-            priority_results['summary'] = {
-                'total_capacity_flags': total_capacity_flags,
-                'unicef_sufficient': total_capacity_flags == 0
-            }
-
-        # Return structured results
-        return {
-            'status': 'optimal',
-            'total_cost': total_cost,
-            'production_results': production_results,
-            'line_hours': line_hours,
-            'employee_hours': employee_hours,
-            'headcount_requirements': headcount_requirements,
-            'priority_results': priority_results,
-            'parameters': {
-                'days': days,
-                'product_list': product_list,
-                'employee_types': employee_types,
-                'shift_list': shift_list,
-                'line_list': line_list,
-                'constraint_mode': constraint_mode,
-                'total_demand': sum(weekly_demand.get(p, 0) for p in product_list)
-            }
-        }
-
-
-if __name__ == "__main__":
-    optimizer = OptimizerReal()
-    optimizer.solve_option_A_multi_day_generalized()

src/project

@@ -1 +0,0 @@
-Subproject commit 2e1b97c9d8196552a23dd5a4c536f25e53c033dc

src/visualization/Home.py

@@ -1,73 +0,0 @@
-import streamlit as st
-
-# Page configuration
-st.set_page_config(
-    page_title="Supply Roster Tool",
-    page_icon="🏠",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Initialize session state for shared variables
-if 'data_path' not in st.session_state:
-    st.session_state.data_path = "data/my_roster_data"
-if 'target_date' not in st.session_state:
-    st.session_state.target_date = ""
-
-# Main page content
-st.title("🏠 Supply Roster Optimization Tool")
-st.markdown("---")
-
-# Welcome section
-
-
-col1, col2 = st.columns([1, 1])
-
-with col1:
-    st.markdown("""
-    ## 📋 Welcome to Supply Roster Tool
-
-    """)
-
-with col2:
-    st.image("images/POC_page/POC_SupplyRoster_image.png", 
-             caption="Supply Roster Tool Overview", 
-             use_container_width=True)
-
-# Global settings in sidebar
-with st.sidebar:
-    st.markdown("## 🌐 Global Settings")
-    st.markdown("The setting will be shared across all pages")
-    
-    # Data path setting
-    new_data_path = st.text_input(
-        "📁 Data Path", 
-        value=st.session_state.data_path,
-        help="The data path will be shared across all pages"
-    )
-    
-    if new_data_path != st.session_state.data_path:
-        st.session_state.data_path = new_data_path
-        st.success("✅ Data path updated!")
-    
-    st.markdown(f"**Current data path:** `{st.session_state.data_path}`")
-    
-    # Quick navigation
-    st.markdown("## 🧭 Quick Navigation")
-    if st.button("🎯 Go to Optimization", use_container_width=True):
-        st.switch_page("pages/optimize_viz.py")
-    
-    if st.button("📊 Go to Dataset Overview", use_container_width=True):
-        st.switch_page("pages/metadata.py")
-
-# Main content area
-st.markdown("---")
-
-
-# Footer
-st.markdown("---")
-st.markdown("""
-<div style='text-align: center; color: gray;'>
-    <small>Supply Roster Optimization Tool | Built with Streamlit</small>
-</div>
-""", unsafe_allow_html=True) 

src/visualization/pages/1_optimize_viz.py

@@ -1,424 +0,0 @@
-import sys
-import os
-import pandas as pd
-import streamlit as st
-import plotly.express as px
-from datetime import datetime
-
-# Add parent directory to path to import LaborOptimizer
-sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-from optimization.labor_optimizer import LaborOptimizer
-
-
-
-
-def get_available_dates(data_path):
-    """Load the orders data and extract unique dates"""
-    try:
-        orders_file = os.path.join(data_path, "orders.csv")
-        if os.path.exists(orders_file):
-            orders_df = pd.read_csv(orders_file)
-            if "due_date" in orders_df.columns:
-                # Convert to datetime and extract unique dates
-                dates = pd.to_datetime(orders_df["due_date"]).dt.date.unique()
-                # Sort dates in descending order (most recent first)
-                dates = sorted(dates, reverse=True)
-                return dates
-    except Exception as e:
-        st.error(f"Error loading dates: {str(e)}")
-    return []
-
-
-def get_metadata_stats(optimizer, target_date=None):
-    """
-    Aggregate metadata statistics about employee costs and availability
-    
-    Args:
-        optimizer: LaborOptimizer instance
-        target_date: Target date for availability analysis
-    
-    Returns:
-        dict: Dictionary containing various statistics
-    """
-    try:
-        # Employee type costs
-        employee_types_df = optimizer.employee_types_df
-        costs_data = []
-        for _, row in employee_types_df.iterrows():
-            costs_data.append({
-                'Employee Type': row['type_name'].title(),
-                'Usual Cost ($/hr)': f"${row['usual_cost']:.2f}",
-                'Overtime Cost ($/hr)': f"${row['overtime_cost']:.2f}",
-                'Evening Shift Cost ($/hr)': f"${row['evening_shift_cost']:.2f}",
-                'Max Hours': row['max_hours'],
-                'Unit Manpower/Hr': row['unit_productivity_per_hour']
-            })
-        
-        # Shift hours information
-        shift_hours = optimizer._get_shift_hours()
-        shift_data = []
-        for shift_type, hours in shift_hours.items():
-            shift_data.append({
-                'Shift Type': shift_type.replace('_', ' ').title(),
-                'Duration (hours)': f"{hours:.1f}"
-            })
-        
-        # Employee availability for target date
-        availability_data = []
-        if target_date:
-            target_date_str = pd.to_datetime(target_date).strftime("%Y-%m-%d")
-        else:
-            # Use most recent date if no target date specified, but show warning
-            target_date_str = pd.to_datetime(optimizer.orders_df["due_date"]).max().strftime("%Y-%m-%d")
-            st.warning("⚠️ No target date specified. Using the most recent order date for analysis. Please select a specific target date for accurate availability data.")
-        
-        availability_target_date = optimizer.employee_availability_df[
-            optimizer.employee_availability_df["date"] == target_date_str
-        ]
-        
-        employee_availability = optimizer.employees_df.merge(
-            availability_target_date, left_on="id", right_on="employee_id", how="left"
-        )
-        
-        for emp_type in optimizer.employee_types_df["type_name"]:
-            emp_type_data = employee_availability[
-                employee_availability["type_name"] == emp_type
-            ]
-            
-            if not emp_type_data.empty:
-                first_shift_available = emp_type_data["first_shift_available"].sum()
-                second_shift_available = emp_type_data["second_shift_available"].sum()
-                overtime_available = emp_type_data["overtime_available"].sum()
-                total_employees = len(emp_type_data)
-            else:
-                first_shift_available = second_shift_available = overtime_available = total_employees = 0
-            
-            availability_data.append({
-                'Employee Type': emp_type.title(),
-                'Total Employees': total_employees,
-                'Usual Time Available': first_shift_available,
-                'Evening Shift Available': second_shift_available,
-                'Overtime Available': overtime_available
-            })
-        
-        # Overall statistics
-        total_employees = len(optimizer.employees_df)
-        total_employee_types = len(optimizer.employee_types_df)
-        total_orders = len(optimizer.orders_df)
-        
-        return {
-            'costs_data': costs_data,
-            'shift_data': shift_data,
-            'availability_data': availability_data,
-            'overall_stats': {
-                'Total Employees': total_employees,
-                'Employee Types': total_employee_types,
-                'Total Orders': total_orders,
-                'Analysis Date': target_date_str,
-                'is_default_date': not bool(target_date)
-            }
-        }
-        
-    except Exception as e:
-        st.error(f"Error generating metadata: {str(e)}")
-        return None
-
-
-def display_metadata_section(metadata):
-    """Display metadata in organized sections"""
-    if not metadata:
-        return
-        
-    # Make the entire Dataset Overview section collapsible
-    with st.expander("📊 Dataset Overview", expanded=False):
-        # Overall statistics
-        st.write("Information on the date chosen - not an optimization report") # df, err, func, keras!
-        col1, col2, col3, col4 = st.columns(4)
-        with col1:
-            st.metric("Total Employees Available", metadata['overall_stats']['Total Employees'])
-        with col2:
-            st.metric("Employee Types Available", metadata['overall_stats']['Employee Types'])
-        with col3:
-            st.metric("Total Orders", metadata['overall_stats']['Total Orders'])
-        with col4:
-            analysis_date = metadata['overall_stats']['Analysis Date']
-            if metadata['overall_stats'].get('is_default_date', False):
-                st.metric("Analysis Date", f"{analysis_date} ⚠️", help="Using most recent order date - select specific date for accurate analysis")
-            else:
-                st.metric("Analysis Date", analysis_date)
-        
-        # Create tabs for different metadata sections
-        tab1, tab2, tab3 = st.tabs(["💰 Employee Costs", "🕐 Shift Information", "👥 Availability"])
-        
-        with tab1:
-            st.subheader("Employee Type Costs")
-            costs_df = pd.DataFrame(metadata['costs_data'])
-            st.dataframe(costs_df, use_container_width=True)
-            
-            # Cost comparison chart
-            costs_for_chart = []
-            for item in metadata['costs_data']:
-                emp_type = item['Employee Type']
-                costs_for_chart.extend([
-                    {'Employee Type': emp_type, 'Cost Type': 'Usual', 'Cost': float(item['Usual Cost ($/hr)'].replace('$', ''))},
-                    {'Employee Type': emp_type, 'Cost Type': 'Overtime', 'Cost': float(item['Overtime Cost ($/hr)'].replace('$', ''))},
-                    {'Employee Type': emp_type, 'Cost Type': 'Evening', 'Cost': float(item['Evening Shift Cost ($/hr)'].replace('$', ''))}
-                ])
-            
-            chart_df = pd.DataFrame(costs_for_chart)
-            fig = px.bar(chart_df, x='Employee Type', y='Cost', color='Cost Type',
-                        title='Hourly Costs by Employee Type and Shift',
-                        barmode='group')
-            st.plotly_chart(fig, use_container_width=True)
-        
-        with tab2:
-            st.subheader("Shift Duration Information")
-            shift_df = pd.DataFrame(metadata['shift_data'])
-            st.dataframe(shift_df, use_container_width=True)
-            
-            # Shift duration chart
-            fig2 = px.bar(shift_df, x='Shift Type', y='Duration (hours)',
-                         title='Shift Duration by Type')
-            st.plotly_chart(fig2, use_container_width=True)
-        
-        with tab3:
-            st.subheader("Employee Availability")
-            availability_df = pd.DataFrame(metadata['availability_data'])
-            st.dataframe(availability_df, use_container_width=True)
-            
-            # # Availability chart
-            # availability_chart_data = []
-            # for item in metadata['availability_data']:
-            #     emp_type = item['Employee Type']
-            #     availability_chart_data.extend([
-            #         {'Employee Type': emp_type, 'Shift Type': 'Usual Time', 'Available': item['Usual Time Available']},
-            #         {'Employee Type': emp_type, 'Shift Type': 'Evening Shift', 'Available': item['Evening Shift Available']},
-            #         {'Employee Type': emp_type, 'Shift Type': 'Overtime', 'Available': item['Overtime Available']}
-            #     ])
-            
-            # chart_df2 = pd.DataFrame(availability_chart_data)
-            # fig3 = px.bar(chart_df2, x='Employee Type', y='Available', color='Shift Type',
-            #              title='Available Workers by Employee Type and Shift',
-            #              barmode='group')
-            # st.plotly_chart(fig3, use_container_width=True)
-
-
-def main():
-    st.set_page_config(page_title="Labor Optimization Tool", layout="wide")
-    st.title("Labor Optimization Visualization Tool")
-
-    # Initialize session state
-    if 'data_path' not in st.session_state:
-        st.session_state.data_path = "data/my_roster_data"
-
-    # Sidebar for inputs
-    with st.sidebar:
-        st.header("Optimization Parameters")
-        data_path = st.text_input("Data Path", value=st.session_state.data_path)
-        # Update session state when user changes data_path
-        st.session_state.data_path = data_path
-
-        # Load available dates from the dataset
-        available_dates = get_available_dates(data_path)
-        
-
-        if available_dates:
-            date_options = [""] + [str(date) for date in available_dates]
-            target_date = st.selectbox(
-                "Target Date (select empty for latest date)",
-                options=date_options,
-                index=0,
-            )
-            st.session_state.target_date = target_date
-        else:
-            target_date = st.text_input(
-                "Target Date (YYYY-MM-DD, leave empty for latest)"
-            )
-            if available_dates == []:
-                st.warning("No order dates found in dataset. Check the data path.")
-
-        st.header("Advanced Options")
-        st.caption("Set to 0 to use all available workers")
-        max_workers_permanent = st.number_input(
-            "Max Permanent Workers", min_value=0, value=0
-        )
-        max_workers_contract = st.number_input(
-            "Max Contract Workers", min_value=0, value=0
-        )
-        max_workers_temporary = st.number_input(
-            "Max Temporary Workers", min_value=0, value=0
-        )
-
-        # Add button to show metadata
-        show_metadata = st.checkbox("Show Dataset Overview", value=True)
-        optimize_btn = st.button("Run Optimization")
-
-    # Main area for optimization results
-    if optimize_btn:
-        try:
-            with st.spinner("Running optimization..."):
-                optimizer = LaborOptimizer(data_path)
-
-                # Prepare override dict if values are provided
-                max_workers_override = {}
-                if max_workers_permanent > 0:
-                    max_workers_override["permanent"] = max_workers_permanent
-                if max_workers_contract > 0:
-                    max_workers_override["contract"] = max_workers_contract
-                if max_workers_temporary > 0:
-                    max_workers_override["temporary"] = max_workers_temporary
-
-                # If no overrides provided, pass None instead of empty dict
-                if not max_workers_override:
-                    max_workers_override = None
-
-                results = optimizer.optimize(target_date, max_workers_override)
-
-                if isinstance(results, str):
-                    st.error(results)
-                else:
-                    # Wrap optimization results in an expander
-                    with st.expander("🎯 Optimization Results", expanded=True):
-                        # Split the page into sections
-                        summary_col, allocation_col = st.columns([1, 1])
-
-                        with summary_col:
-                            st.subheader("Optimization Summary")
-                            st.write(f"**Target Date:** {results['target_date']}")
-                            st.write(
-                                f"**Total Labor Hours:** {results['total_labor_hours_needed']:.2f}"
-                            )
-                            st.write(f"**Total Cost:** ${results['total_cost']:.2f}")
-
-                        with allocation_col:
-                            st.subheader("Employee Allocation")
-                            allocation_data = results["allocation"]
-
-                            # Create a DataFrame for easier visualization
-                            allocation_df = pd.DataFrame.from_dict(
-                                {
-                                    emp_type: {
-                                        shift: int(val) for shift, val in shifts.items()
-                                    }
-                                    for emp_type, shifts in allocation_data.items()
-                                },
-                                orient="index",
-                            )
-                            allocation_df.index.name = "Employee Type"
-                            allocation_df.columns = [
-                                col.replace("_", " ").title()
-                                for col in allocation_df.columns
-                            ]
-
-                            st.dataframe(allocation_df)
-
-                        # Cost visualization
-                        st.subheader("Cost Visualization")
-
-                        # Prepare data for visualization
-                        cost_data = []
-                        for emp_type, shifts in allocation_data.items():
-                            shift_hours = results["shift_hours"]
-                            costs = optimizer.employee_types_df.set_index("type_name")
-
-                            shift_cost_mapping = {
-                                "usual_time": "usual_cost",
-                                "overtime": "overtime_cost",
-                                "evening_shift": "evening_shift_cost",
-                            }
-
-                            for shift in shifts:
-                                cost = (
-                                    shifts[shift]
-                                    * shift_hours[shift]
-                                    * costs.loc[emp_type, shift_cost_mapping[shift]]
-                                )
-                                if cost > 0:  # Only add non-zero costs
-                                    cost_data.append(
-                                        {
-                                            "Employee Type": emp_type.title(),
-                                            "Shift": shift.replace("_", " ").title(),
-                                            "Cost": cost,
-                                            "Workers": int(shifts[shift]),
-                                        }
-                                    )
-
-                        cost_df = pd.DataFrame(cost_data)
-
-                        col1, col2 = st.columns([3, 2])
-
-                        with col1:
-                            # Bar chart for costs
-                            if not cost_df.empty:
-                                fig = px.bar(
-                                    cost_df,
-                                    x="Shift",
-                                    y="Cost",
-                                    color="Employee Type",
-                                    title="Labor Cost by Employee Type and Shift",
-                                    labels={"Cost": "Cost ($)"},
-                                )
-                                st.plotly_chart(fig, use_container_width=True)
-
-                        with col2:
-                            # Pie chart for total cost by employee type
-                            if not cost_df.empty:
-                                total_by_type = (
-                                    cost_df.groupby("Employee Type")["Cost"]
-                                    .sum()
-                                    .reset_index()
-                                )
-                                fig2 = px.pie(
-                                    total_by_type,
-                                    values="Cost",
-                                    names="Employee Type",
-                                    title="Total Cost by Employee Type",
-                                )
-                                st.plotly_chart(fig2, use_container_width=True)
-
-                        # Worker allocation visualization
-                        st.subheader("Worker Allocation")
-                        worker_data = []
-                        for emp_type, shifts in allocation_data.items():
-                            for shift, count in shifts.items():
-                                if count > 0:  # Only add non-zero allocations
-                                    worker_data.append(
-                                        {
-                                            "Employee Type": emp_type.title(),
-                                            "Shift": shift.replace("_", " ").title(),
-                                            "Workers": int(count),
-                                        }
-                                    )
-
-                        worker_df = pd.DataFrame(worker_data)
-
-                        if not worker_df.empty:
-                            fig3 = px.bar(
-                                worker_df,
-                                x="Shift",
-                                y="Workers",
-                                color="Employee Type",
-                                title="Worker Allocation by Shift and Employee Type",
-                                barmode="group",
-                            )
-                            st.plotly_chart(fig3, use_container_width=True)
-
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
-            st.exception(e)
-
-    # Display metadata section if requested - moved below optimization results
-    if show_metadata:
-        try:
-            optimizer = LaborOptimizer(data_path)
-            
-            # Show warning if no target date is selected
-            if not target_date:
-                st.info("💡 **Tip**: Select a specific target date from the sidebar to see accurate availability data for that date. Currently showing data for the most recent order date.")
-            
-        except Exception as e:
-            st.error(f"Error loading metadata: {str(e)}")
-
-
-if __name__ == "__main__":
-    main()

src/visualization/pages/2_metadata.py

@@ -1,300 +0,0 @@
-import sys
-import os
-import pandas as pd
-import streamlit as st
-import plotly.express as px
-from datetime import datetime
-
-# Add parent directory to path to import LaborOptimizer
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from optimization.labor_optimizer import LaborOptimizer
-
-
-def get_available_dates(data_path):
-    """Load the orders data and extract unique dates"""
-    try:
-        orders_file = os.path.join(data_path, "orders.csv")
-        if os.path.exists(orders_file):
-            orders_df = pd.read_csv(orders_file)
-            if "due_date" in orders_df.columns:
-                # Convert to datetime and extract unique dates
-                dates = pd.to_datetime(orders_df["due_date"]).dt.date.unique()
-                # Sort dates in descending order (most recent first)
-                dates = sorted(dates, reverse=True)
-                return dates
-    except Exception as e:
-        st.error(f"Error loading dates: {str(e)}")
-    return []
-
-
-def get_metadata_stats(optimizer, target_date=None):
-    """
-    Aggregate metadata statistics about employee costs and availability
-    
-    Args:
-        optimizer: LaborOptimizer instance
-        target_date: Target date for availability analysis
-    
-    Returns:
-        dict: Dictionary containing various statistics
-    """
-    try:
-        # Employee type costs
-        employee_types_df = optimizer.employee_types_df
-        costs_data = []
-        for _, row in employee_types_df.iterrows():
-            costs_data.append({
-                'Employee Type': row['type_name'].title(),
-                'Usual Cost ($/hr)': f"${row['usual_cost']:.2f}",
-                'Overtime Cost ($/hr)': f"${row['overtime_cost']:.2f}",
-                'Evening Shift Cost ($/hr)': f"${row['evening_shift_cost']:.2f}",
-                'Max Hours': row['max_hours'],
-                'Unit Manpower/Hr': row['unit_productivity_per_hour']
-            })
-        
-        # Shift hours information
-        shift_hours = optimizer._get_shift_hours()
-        shift_data = []
-        for shift_type, hours in shift_hours.items():
-            shift_data.append({
-                'Shift Type': shift_type.replace('_', ' ').title(),
-                'Duration (hours)': f"{hours:.1f}"
-            })
-        
-        # Employee availability for target date
-        availability_data = []
-        if target_date:
-            target_date_str = pd.to_datetime(target_date).strftime("%Y-%m-%d")
-        else:
-            # Use most recent date if no target date specified, but show warning
-            target_date_str = pd.to_datetime(optimizer.orders_df["due_date"]).max().strftime("%Y-%m-%d")
-            st.warning("⚠️ No target date specified. Using the most recent order date for analysis. Please select a specific target date for accurate availability data.")
-        
-        availability_target_date = optimizer.employee_availability_df[
-            optimizer.employee_availability_df["date"] == target_date_str
-        ]
-        
-        employee_availability = optimizer.employees_df.merge(
-            availability_target_date, left_on="id", right_on="employee_id", how="left"
-        )
-        
-        for emp_type in optimizer.employee_types_df["type_name"]:
-            emp_type_data = employee_availability[
-                employee_availability["type_name"] == emp_type
-            ]
-            
-            if not emp_type_data.empty:
-                first_shift_available = emp_type_data["first_shift_available"].sum()
-                second_shift_available = emp_type_data["second_shift_available"].sum()
-                overtime_available = emp_type_data["overtime_available"].sum()
-                total_employees = len(emp_type_data)
-            else:
-                first_shift_available = second_shift_available = overtime_available = total_employees = 0
-            
-            availability_data.append({
-                'Employee Type': emp_type.title(),
-                'Total Employees': total_employees,
-                'Usual Time Available': first_shift_available,
-                'Evening Shift Available': second_shift_available,
-                'Overtime Available': overtime_available
-            })
-        
-        # Overall statistics
-        total_employees = len(optimizer.employees_df)
-        total_employee_types = len(optimizer.employee_types_df)
-        total_orders = len(optimizer.orders_df)
-        
-        return {
-            'costs_data': costs_data,
-            'shift_data': shift_data,
-            'availability_data': availability_data,
-            'overall_stats': {
-                'Total Employees': total_employees,
-                'Employee Types': total_employee_types,
-                'Total Orders': total_orders,
-                'Analysis Date': target_date_str,
-                'is_default_date': not bool(target_date)
-            }
-        }
-        
-    except Exception as e:
-        st.error(f"Error generating metadata: {str(e)}")
-        return None
-
-
-def display_metadata_section(metadata):
-    """Display metadata in organized sections"""
-    if not metadata:
-        return
-        
-    # Make the entire Dataset Overview section collapsible
-    # with st.expander("📊 Dataset Overview", expanded=False):
-    
-    with st.expander("📊 Dataset Overview", expanded=False):
-        st.write(f"Data path: {st.session_state.data_path}")
-        # Overall statistics
-        st.write("Information on the date chosen - not an optimization report") # df, err, func, keras!
-        col1, col2, col3, col4 = st.columns(4)
-        with col1:
-            st.metric("Total Employees Available", metadata['overall_stats']['Total Employees'])
-        with col2:
-            st.metric("Employee Types Available", metadata['overall_stats']['Employee Types'])
-        with col3:
-            st.metric("Total Orders", metadata['overall_stats']['Total Orders'])
-        with col4:
-            analysis_date = metadata['overall_stats']['Analysis Date']
-            if metadata['overall_stats'].get('is_default_date', False):
-                st.metric("Analysis Date", f"{analysis_date} ⚠️", help="Using most recent order date - select specific date for accurate analysis")
-            else:
-                st.metric("Analysis Date", analysis_date)
-        
-        # Create tabs for different metadata sections
-        tab1, tab2, tab3 = st.tabs(["💰 Employee Costs", "🕐 Shift Information", "👥 Availability"])
-        
-        with tab1:
-            st.subheader("Employee Type Costs")
-            costs_df = pd.DataFrame(metadata['costs_data'])
-            st.dataframe(costs_df, use_container_width=True)
-            
-            # Cost comparison chart
-            costs_for_chart = []
-            for item in metadata['costs_data']:
-                emp_type = item['Employee Type']
-                costs_for_chart.extend([
-                    {'Employee Type': emp_type, 'Cost Type': 'Usual', 'Cost': float(item['Usual Cost ($/hr)'].replace('$', ''))},
-                    {'Employee Type': emp_type, 'Cost Type': 'Overtime', 'Cost': float(item['Overtime Cost ($/hr)'].replace('$', ''))},
-                    {'Employee Type': emp_type, 'Cost Type': 'Evening', 'Cost': float(item['Evening Shift Cost ($/hr)'].replace('$', ''))}
-                ])
-            
-            chart_df = pd.DataFrame(costs_for_chart)
-            fig = px.bar(chart_df, x='Employee Type', y='Cost', color='Cost Type',
-                        title='Hourly Costs by Employee Type and Shift',
-                        barmode='group')
-            st.plotly_chart(fig, use_container_width=True)
-        
-        with tab2:
-            st.subheader("Shift Duration Information")
-            shift_df = pd.DataFrame(metadata['shift_data'])
-            st.dataframe(shift_df, use_container_width=True)
-            
-            # Shift duration chart
-            fig2 = px.bar(shift_df, x='Shift Type', y='Duration (hours)',
-                            title='Shift Duration by Type')
-            st.plotly_chart(fig2, use_container_width=True)
-        
-        with tab3:
-            st.subheader("Employee Availability")
-            availability_df = pd.DataFrame(metadata['availability_data'])
-            st.dataframe(availability_df, use_container_width=True)
-            
-            # # Availability chart
-            # availability_chart_data = []
-            # for item in metadata['availability_data']:
-            #     emp_type = item['Employee Type']
-            #     availability_chart_data.extend([
-            #         {'Employee Type': emp_type, 'Shift Type': 'Usual Time', 'Available': item['Usual Time Available']},
-            #         {'Employee Type': emp_type, 'Shift Type': 'Evening Shift', 'Available': item['Evening Shift Available']},
-            #         {'Employee Type': emp_type, 'Shift Type': 'Overtime', 'Available': item['Overtime Available']}
-            #     ])
-            
-            # chart_df2 = pd.DataFrame(availability_chart_data)
-            # fig3 = px.bar(chart_df2, x='Employee Type', y='Available', color='Shift Type',
-            #              title='Available Workers by Employee Type and Shift',
-            #              barmode='group')
-            # st.plotly_chart(fig3, use_container_width=True)
-def display_demand(optimizer):
-    with st.expander("📊 Demand", expanded=False):
-        demand_df = optimizer.orders_df
-        st.header("Demand")
-        daily_demand = demand_df.groupby('date_of_order').sum()['order_amount'].reset_index()
-        st.plotly_chart(px.bar(daily_demand, x='date_of_order', y='order_amount', title='Demand by Date'), use_container_width=True)
-        st.markdown("### Demand for the selected date")
-        st.dataframe(demand_df[demand_df['date_of_order']==st.session_state.target_date], use_container_width=True)
-
-def display_employee_availability(optimizer):
-    with st.expander("👥 Employee Availability", expanded=False):
-        st.header("Employee Availability")
-        employee_availability_df = optimizer.employee_availability_df
-        employee_availability_df['date'] = pd.to_datetime(employee_availability_df['date'])
-        employee_availability_target_date = employee_availability_df[employee_availability_df['date']==st.session_state.target_date]
-        employee_availability_target_date = pd.merge(employee_availability_target_date, optimizer.employees_df, left_on='employee_id', right_on='id', how='left')
-        st.dataframe(employee_availability_target_date[['name', 'employee_id', 'type_name', 'first_shift_available', 'second_shift_available', 'overtime_available']], use_container_width=True)
-        # Group by type_name and sum the availability columns
-        available_employee_grouped = employee_availability_target_date.groupby('type_name')[
-            ['first_shift_available', 'second_shift_available', 'overtime_available']
-        ].sum().reset_index()
-        
-        st.markdown("### Employee Availability for the selected date")
-        # Create non-stacked (grouped) bar chart using plotly
-        fig = px.bar(
-            available_employee_grouped.melt(id_vars=['type_name'], var_name='shift_type', value_name='count'),
-            x='type_name',
-            y='count', 
-            color='shift_type',
-            barmode='group',  # This makes it non-stacked
-            title='Available Employee Count by Type and Shift',
-            labels={'type_name': 'Employee Type', 'count': 'Available Count', 'shift_type': 'Shift Type'}
-        )
-        st.plotly_chart(fig, use_container_width=True)
-
-    # st.dataframe(employee_availability_target_date, use_container_width=True)
-    # st.plotly_chart(px.bar(employee_availability_target_date, x='employee_id', y='availability', title='Employee Availability by Date'), use_container_width=True)
-    
-    # st.dataframe(employee_availability_df[employee_availability_df['date']==st.session_state.target_date], use_container_width=True)
-
-
-    
-def main():
-    """Main function for metadata page"""
-    st.set_page_config(page_title="Dataset Metadata", layout="wide")
-    st.title("📊 Dataset Metadata Overview")
-    
-    # Get data_path from session state if available, otherwise create input
-    if 'data_path' in st.session_state:
-        # Using shared data_path from optimize_viz.py
-        data_path = st.session_state.data_path
-        
-        st.sidebar.info(f"📁 Using shared data path: `{data_path}`")
-    else:
-        st.error("No data path found. Please select a data path in the sidebar.")
-        
-
-    if 'target_date' in st.session_state:
-            target_date = st.session_state.target_date
-            st.sidebar.info(f"📅 Using shared target date: `{target_date}`")
-    else:
-        st.error("No target date found. Please select a target date in the sidebar.")
-    
-    #If the date selection needs to be individualized per page, uncomment the following code
-    # with st.sidebar:
-    #     # Date selection
-    #     available_dates = get_available_dates(data_path)
-    #     if available_dates:
-    #         date_options = [""] + [str(date) for date in available_dates]
-    #         target_date = st.selectbox(
-    #             "Target Date (select empty for latest date)",
-    #             options=date_options,
-    #             index=0,
-    #         )
-    #     else:
-    #         target_date = st.text_input(
-    #             "Target Date (YYYY-MM-DD, leave empty for latest)"
-    #         )
-
-    try:
-        optimizer = LaborOptimizer(data_path)
-        
-        # Show warning if no target date is selected
-        if not target_date:
-            st.info("💡 **Tip**: Select a specific target date from the sidebar to see accurate availability data for that date. Currently showing data for the most recent order date.")
-        
-        metadata = get_metadata_stats(optimizer, target_date if target_date else None)
-        display_metadata_section(metadata)
-        display_demand(optimizer)
-        display_employee_availability(optimizer)
-    except Exception as e:
-        st.error(f"Error loading metadata: {str(e)}")
-
-
-if __name__ == "__main__":
-    main()

streamlit_page/__init__.py

@@ -1 +0,0 @@
-# Streamlit page package

streamlit_page/page1.py

@@ -1,62 +0,0 @@
-import streamlit as st
-from datetime import datetime, timedelta
-import sys
-import os
-
-# Add the parent directory to the path to import src modules
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-import src.etl.transform as transform
-
-# Page title
-st.title("Date Selection")
-
-# Date selection section
-st.header("Select Date Range")
-
-# Get available date ranges from COOIS_Released_Prod_Orders.csv
-try:
-    date_ranges = transform.get_date_ranges()
-    all_dates, start_dates, end_dates = transform.get_available_dates()
-    
-    if date_ranges:
-        # Create dropdown for date range selection
-        date_range_options = [f"{start} to {end}" for start, end in date_ranges]
-        selected_range_str = st.selectbox(
-            "Select a date range from released orders:",
-            options=date_range_options,
-            help="Date ranges available in COOIS_Released_Prod_Orders.csv"
-        )
-        
-        # Extract selected dates
-        selected_index = date_range_options.index(selected_range_str)
-        start_date, end_date = date_ranges[selected_index]
-        
-        # Display the selected date range
-        st.write(f"**Start Date:** {start_date.strftime('%Y-%m-%d')}")
-        st.write(f"**End Date:** {end_date.strftime('%Y-%m-%d')}")
-        
-        # Show the date range duration
-        duration = (end_date - start_date).days
-        st.info(f"Selected date range: {duration} days")
-        
-        
-        
-except Exception as e:
-    st.error(f"Error loading date data: {str(e)}")
-    # Fallback to default dates
-    start_date = datetime(2025, 3, 24).date()
-    end_date = datetime(2025, 3, 28).date()
-
-# Product selection section
-
-
-# You can add more functionality here based on the selected dates
-if st.button("Confirm Selection"):
-    if 'selected_product' in locals():
-        st.success(f"Date range: {start_date} to {end_date}")
-        st.success(f"Selected product: {selected_product}")
-        if 'selected_products' in locals() and selected_products:
-            st.success(f"Multiple products selected: {', '.join(selected_products)}")
-    else:
-        st.success(f"Date range confirmed: {start_date} to {end_date}")
-    # Add your logic here for what happens when selection is confirmed