add streamlit and clean the optimizer

Home.py

@@ -0,0 +1,233 @@
+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")
+
+# 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>📈 Analytics & Reports</h3>
+        <p>Rich visualization and reporting:</p>
+        <ul>
+            <li>Interactive dashboards</li>
+            <li>Cost analysis charts</li>
+            <li>Performance metrics</li>
+            <li>Export capabilities</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)

STREAMLIT_README.md

@@ -0,0 +1,161 @@
+# SD Roster Optimization Tool - Multi-Page Streamlit Interface
+
+A comprehensive multi-page Streamlit web application for supply chain roster optimization using OR-Tools.
+
+## 🏗️ Application Structure
+
+### 🏠 Home Page
+- **Welcome Dashboard**: Overview and navigation hub
+- **Global Settings**: Shared data path and date configuration  
+- **System Status**: Component availability and health checks
+- **Quick Navigation**: Direct links to main functionalities
+
+### 📊 Dataset Metadata Page
+Comprehensive data analysis across five detailed tabs:
+
+#### 📋 Data Overview Tab
+- **Key Metrics**: Orders, quantities, products, employees, production lines
+- **Data Quality Analysis**: Completeness scores and missing data indicators
+- **Data Freshness**: Latest data timestamps and age indicators
+
+#### 📦 Demand Analysis Tab  
+- **Demand Metrics**: Total, average, max, min order sizes
+- **Top Products**: Ranking by demand volume with visualizations
+- **Daily Patterns**: Trend analysis and demand variability
+- **Distribution Analysis**: Order quantity and frequency distributions
+
+#### 👥 Workforce Analysis Tab
+- **Employee Metrics**: Total staff, types, distribution
+- **Cost Structure**: Hourly rates by employee type and shift
+- **Productivity Analysis**: Performance metrics by employee type
+
+#### 🏭 Production Capacity Tab
+- **Line Metrics**: Total lines, types, maximum capacities
+- **Capacity Distribution**: Line allocation and utilization potential
+- **Theoretical Analysis**: Maximum capacity calculations by shift
+
+#### 💰 Cost Analysis Tab
+- **Cost Structure**: Min/max/average hourly rates and ranges
+- **Budget Planning**: Minimum and maximum cost scenarios
+- **Projections**: Weekly and monthly cost estimates
+
+### 🎯 Optimization Page
+Advanced optimization interface with comprehensive results:
+
+#### 📊 Summary Tab
+- Total optimization cost and key metrics
+- Cost efficiency analysis (cost per day, cost per unit)
+- Optimization parameters used
+
+#### 📈 Production Tab
+- Production vs. demand comparison by product
+- Fulfillment rate analysis with interactive charts
+- Production schedule visualization
+
+#### 👷 Labor Tab
+- Labor allocation by employee type and shift
+- Required headcount analysis
+- Daily and average staffing requirements
+
+#### 💰 Costs Tab
+- Detailed cost breakdown by employee type and shift
+- Cost distribution visualizations
+- Priority mode analysis (when applicable)
+
+## Quick Start
+
+### 1. Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Run the Application
+```bash
+# Option 1: Using the runner script
+python run_streamlit.py
+
+# Option 2: Direct streamlit command
+streamlit run Home.py
+```
+
+### 3. Access the Application
+Open your browser to: `http://localhost:8501`
+
+## Usage Guide
+
+### Navigation Flow
+1. **Start at Home**: Configure global settings and navigate to specific functions
+2. **Explore Metadata**: Analyze your data across the comprehensive metadata tabs
+3. **Run Optimization**: Configure parameters and execute optimization on the dedicated page
+4. **Analyze Results**: Review detailed results across multiple result tabs
+
+### Page-by-Page Guide
+1. **Home Page**: Set data paths, select date ranges, check system status
+2. **Dataset Metadata**: Deep dive into demand, workforce, capacity, and cost analysis
+3. **Optimization**: Configure optimization parameters, run optimization, analyze results
+
+## Technical Details
+
+### Optimization Engine
+- Built on Google OR-Tools for mixed-integer programming
+- Supports multiple constraint modes for realistic business scenarios
+- Handles complex multi-product, multi-shift, multi-line scheduling
+
+### Data Sources
+The application automatically loads data from:
+- `COOIS_Released_Prod_Orders.csv` - Production orders and demand
+- Employee data files - Staff availability and costs
+- Production line configuration - Line capacities and capabilities
+
+### Configuration
+Key optimization parameters can be adjusted in `src/config/optimization_config.py`:
+- Employee types and costs
+- Shift definitions and durations
+- Production line capacities
+- Constraint modes and business rules
+
+## Business Scenarios
+
+### Priority Mode (Recommended)
+- Uses UNICEF Fixed term staff first
+- Engages Humanizer staff only when fixed staff at capacity
+- Reflects realistic business operations
+
+### Mandatory Mode
+- Forces all fixed staff to work full hours
+- More expensive but ensures full utilization
+- Useful for guaranteed staffing scenarios
+
+### Demand-Driven Mode
+- Purely cost-optimized scheduling
+- No mandatory fixed hours
+- Most cost-efficient but may underutilize staff
+
+## Troubleshooting
+
+### Common Issues
+1. **No Date Ranges Available**: Ensure your data files are in the correct location
+2. **Optimization Fails**: Check that demand data exists for the selected date range
+3. **Import Errors**: Verify all dependencies are installed
+
+### Performance Tips
+- Smaller date ranges optimize faster
+- Reducing product count can improve solve time
+- Priority mode typically solves faster than mandatory mode
+
+## File Structure
+```
+Home.py                   # Main home page (entry point)
+pages/
+  ├── 1_📊_Dataset_Metadata.py  # Comprehensive data analysis page
+  └── 2_🎯_Optimization.py      # Optimization interface and results
+run_streamlit.py          # Convenient runner script  
+src/
+  ├── models/optimizer_real.py  # Core optimization engine
+  ├── config/optimization_config.py  # Configuration parameters
+  └── etl/                # Data extraction and transformation
+streamlit_app_old.py      # Backup of original single-page app
+```
+
+## Support
+For technical issues or feature requests, refer to the main project documentation or contact the development team.

pages/1_📊_Dataset_Metadata.py

@@ -0,0 +1,669 @@
+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 = st.tabs([
+    "📋 Data Overview", 
+    "📦 Demand Analysis", 
+    "👥 Workforce Analysis", 
+    "🏭 Production Capacity", 
+    "💰 Cost Analysis"
+])
+
+# 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.CAP_PER_LINE_PER_HOUR
+        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}")
+
+# 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

@@ -0,0 +1,633 @@
+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_real import OptimizerReal
+    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:
+            # Create optimizer instance
+            optimizer = OptimizerReal()
+            
+            # Run optimization and get structured results
+            results = optimizer.solve_option_A_multi_day_generalized()
+            
+            if results is None:
+                st.error("❌ Optimization returned no results")
+            elif results.get('status') == 'failed':
+                st.error(f"❌ Optimization failed: {results.get('message', 'Unknown error')}")
+            else:
+                st.session_state.optimization_results = results
+                st.session_state.optimizer = optimizer
+                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")
+        
+        # Additional summary metrics
+        col_s1, col_s2, col_s3 = st.columns(3)
+        
+        with col_s1:
+            st.metric("🎯 Total Demand", f"{params.get('total_demand', 0):,.0f}")
+        with col_s2:
+            cost_per_unit = total_cost / params.get('total_demand', 1) if params.get('total_demand', 0) > 0 else 0
+            st.metric("💵 Cost per Unit", f"${cost_per_unit:.3f}")
+        with col_s3:
+            st.metric("⚙️ Constraint Mode", params.get('constraint_mode', 'N/A'))
+        
+        # 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")
+        
+        production_results = results.get('production_results', {})
+        if production_results:
+            # Create production summary table
+            prod_data = []
+            for product, data in production_results.items():
+                prod_data.append({
+                    'Product': product,
+                    'Demand': data['demand'],
+                    'Produced': data['produced'],
+                    'Fulfillment %': f"{data['fulfillment_rate']:.1f}%",
+                    'Status': '✅ Met' if data['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)

requirements.txt

@@ -1,15 +1,17 @@
-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
+absl-py>=2.3.1
+dotenv>=0.9.9
+immutabledict>=4.2.1
+numpy>=2.2.0
+ortools>=9.14.0
+pandas>=2.3.0
+plotly>=5.24.0
+protobuf>=3.20,<6
+psycopg2-binary>=2.9.9
+python-dateutil>=2.9.0
+python-dotenv>=1.0.0
+pytz>=2025.2
+six>=1.17.0
+SQLAlchemy>=2.0.36
+streamlit>=1.39.0
+typing_extensions>=4.14.0
+tzdata>=2025.2

run_streamlit.py

@@ -0,0 +1,33 @@
+#!/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/config/optimization_config.py

@@ -195,6 +195,12 @@ CAP_PER_LINE_PER_HOUR = {
 # number of products that can be produced per hour per line
 #This information is critical and it should not rely on the productivity information
 
+MAX_PARALLEL_WORKERS = {
+    6: 6,  # long line can have max 6 workers simultaneously
+    7: 4,  # short line can have max 4 workers simultaneously
+}
+# maximum number of workers that can work on a line at the same time
+
 DAILY_WEEKLY_SCHEDULE = "daily"  # daily or weekly ,this needs to be implementedin  in         if F_x1_day is not None... F_x1_week is not None... also need to change x1 to Fixedstaff_first_shift
 
 # Fixed staff constraint mode

src/models/optimizer_real.py

@@ -94,10 +94,6 @@ class OptimizerReal:
             # 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 == "available":
-            # Option 2: Available hours constraint (staff can work up to limit but not forced)
-            F_x1_day = None
-            print("Using AVAILABLE hours constraint (not yet implemented)")
         elif constraint_mode == "priority":
             # Option 3: Priority-based (realistic business model)
             F_x1_day = None
@@ -111,6 +107,7 @@ class OptimizerReal:
         
          # e.g., F_x1_day =  sum(F_x1_day.values()) if you want weekly instead (then set F_x1_day=None)
         cap_per_line_per_hour = self.config.CAP_PER_LINE_PER_HOUR
+
         # Optional skill/compatibility: allow[(e,p,ell)] = 1/0 (1=allowed; 0=forbid)
         allow = {}
         for e in employee_types:
@@ -121,7 +118,7 @@ class OptimizerReal:
         # -----------------------------
         # 3) SOLVER
         # -----------------------------
-        solver = pywraplp.Solver.CreateSolver("CBC")  # or 'SCIP' if available
+        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()
@@ -137,14 +134,15 @@ class OptimizerReal:
                 for p in product_list:
                     for ell in line_type_cnt_tuple:
                         for t in days:
-                            # Upper bound per (e,s,t): shift cap * available headcount that day
+                            # 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:
@@ -155,6 +153,7 @@ class OptimizerReal:
                         )
 
         # 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:
@@ -164,6 +163,7 @@ class OptimizerReal:
                     )
 
         # 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:
@@ -191,6 +191,7 @@ class OptimizerReal:
         # -----------------------------
 
         # 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
@@ -198,21 +199,26 @@ class OptimizerReal:
                     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)
+        # 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:
@@ -224,9 +230,8 @@ class OptimizerReal:
                         )
 
         # 6.4 Per-line throughput cap (units/hour × line-hours)
-        print("================================================")
-        print("cap_per_line_per_hour",cap_per_line_per_hour)
-        print("tline",tline)
+        #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:
@@ -236,22 +241,17 @@ class OptimizerReal:
                         <= cap_per_line_per_hour[line_type] * tline[ell, s, t]
                     )
 
-        # 6.5 Couple line hours & worker-hours (single-operator lines → tight equality)
+        # 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(
-                        tline[ell, s, t]
-                        == solver.Sum(h[e, s, p, ell, t] for e in employee_types for p in product_list)
+                        solver.Sum(h[e, s, p, ell, t] for e in employee_types for p in product_list)
+                        <= max_workers * tline[ell, s, t]
                     )
-        # If multi-operator lines (up to Wmax[ell] concurrent workers), replace above with:
-        # Wmax = {ell: 2, ...}
-        # for ell in line_type_cnt_tuple:
-        #   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) <= Wmax[ell] * tline[ell, s, t]
-        #       )
 
         # 6.6 Fixed regular hours for type Fixed on shift 1
         if F_x1_day is not None:
@@ -262,15 +262,7 @@ class OptimizerReal:
                     == F_x1_day[t]
                 )
             print("Applied mandatory fixed hours constraint")
-        # elif F_x1_week is not None:
-        #     # Per-week fixed hours (mandatory - expensive)
-        #     solver.Add(
-        #         solver.Sum(
-        #             h["UNICEF Fixed term", 1, p, ell, t] for p in product_list for ell in line_type_cnt_tuple for t in days
-        #         )
-        #         == F_x1_week
-        #     )
-        #     print("Applied mandatory weekly fixed hours constraint")
+
         else:
             # No fixed constraint - purely demand-driven (cost-efficient)
             print("No mandatory fixed hours constraint - using demand-driven scheduling")
@@ -281,6 +273,9 @@ class OptimizerReal:
                 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:
@@ -288,22 +283,43 @@ class OptimizerReal:
                         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
                             
-                            # UNICEF Fixed term capacity for this specific (p, ell, t)
-                            max_unicef_hours = Hmax_shift[1] * N_day["UNICEF Fixed term"][t]
+                            # 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
+                            # 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_unicef_hours  # Large M value
+                                <= unicef_at_capacity * max_humanizer_hours  # Correct M value
                             )
                             
-                            # Force unicef_at_capacity = 1 only when UNICEF hours are significant
+                            # 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 * 0.1  # Small threshold to trigger capacity flag
+                                >= 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:
@@ -327,6 +343,7 @@ class OptimizerReal:
                     )
 
         # 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])
@@ -354,58 +371,128 @@ class OptimizerReal:
         status = solver.Solve()
         if status != pywraplp.Solver.OPTIMAL:
             print("No optimal solution. Status:", status)
-            return
+            return {
+                'status': 'failed',
+                'solver_status': status,
+                'message': f"No optimal solution found. Solver status: {status}"
+            }
 
         # -----------------------------
         # 8) REPORT
         # -----------------------------
-        print("Objective (min cost):", solver.Objective().Value())
+        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()

streamlit_app.py

@@ -0,0 +1,517 @@
+import streamlit as st
+
+# Page configuration - MUST be first Streamlit command
+st.set_page_config(
+    page_title="SD Roster Optimization Tool",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Now import everything else
+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(__file__), 'src'))
+
+from src.models.optimizer_real import OptimizerReal
+from src.config import optimization_config
+import src.etl.extract as extract
+import src.etl.transform as transform
+
+# Custom CSS for better styling
+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;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2rem;
+    }
+</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">📊 SD Roster Optimization Tool</h1>', unsafe_allow_html=True)
+
+# Create layout: Left sidebar + Main content
+with st.sidebar:
+    st.markdown("## 🎛️ Control Panel")
+    
+    # Date Selection Section
+    st.markdown("### 📅 Date Range Selection")
+    try:
+        # Get available date ranges from the data
+        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"
+            )
+            
+            # Extract selected dates
+            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)
+            
+            # Display duration
+            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("---")
+    
+    # Optimization Parameters Section
+    st.markdown("### ⚙️ Optimization Parameters")
+    
+    # Employee Type Selection
+    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
+    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
+    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"
+    )
+    
+    # Advanced Parameters
+    with st.expander("🔧 Advanced Parameters"):
+        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)
+
+# Main content area
+col1, col2 = st.columns([1, 2])
+
+# Left column - Metadata
+with col1:
+    st.markdown('<h2 class="section-header">📋 Metadata & Overview</h2>', unsafe_allow_html=True)
+    
+    # Show current date range
+    if st.session_state.date_range:
+        start_date, end_date = st.session_state.date_range
+        st.markdown(f"**Selected Period:** {start_date} to {end_date}")
+    
+    # Demand Information
+    with st.expander("📊 Demand Overview", expanded=True):
+        try:
+            if st.session_state.date_range:
+                start_date, end_date = st.session_state.date_range
+                demand_df = extract.read_released_orders_data(start_date=start_date, end_date=end_date)
+                
+                # Total demand metrics
+                total_orders = len(demand_df)
+                total_quantity = demand_df["Order quantity (GMEIN)"].sum()
+                unique_products = demand_df["Material Number"].nunique()
+                
+                col_d1, col_d2, col_d3 = st.columns(3)
+                with col_d1:
+                    st.metric("Total Orders", total_orders)
+                with col_d2:
+                    st.metric("Total Quantity", f"{total_quantity:,.0f}")
+                with col_d3:
+                    st.metric("Unique Products", unique_products)
+                
+                # Top products by demand
+                top_products = demand_df.groupby('Material Number')["Order quantity (GMEIN)"].sum().sort_values(ascending=False).head(5)
+                
+                if not top_products.empty:
+                    st.markdown("**Top 5 Products by Demand:**")
+                    for product, quantity in top_products.items():
+                        st.markdown(f"• {product}: {quantity:,.0f}")
+                
+        except Exception as e:
+            st.error(f"Error loading demand data: {e}")
+    
+    # Employee Information
+    with st.expander("👥 Employee Overview", expanded=True):
+        try:
+            employee_df = extract.read_employee_data()
+            
+            # Employee metrics
+            total_employees = len(employee_df)
+            emp_by_type = employee_df.groupby("employment_type").size()
+            
+            st.metric("Total Employees", total_employees)
+            
+            st.markdown("**By Employment Type:**")
+            for emp_type, count in emp_by_type.items():
+                st.markdown(f"• {emp_type}: {count}")
+                
+        except Exception as e:
+            st.error(f"Error loading employee data: {e}")
+    
+    # Production Lines
+    with st.expander("🏭 Production Lines", expanded=True):
+        try:
+            line_df = extract.read_packaging_line_data()
+            
+            st.markdown("**Available Lines:**")
+            for _, row in line_df.iterrows():
+                st.markdown(f"• Line {row['id']}: {row['line_count']} units")
+                
+        except Exception as e:
+            st.error(f"Error loading line data: {e}")
+
+# Right column - Optimization Results
+with col2:
+    st.markdown('<h2 class="section-header">🎯 Optimization Results</h2>', unsafe_allow_html=True)
+    
+    if run_optimization:
+        with st.spinner("Running optimization..."):
+            try:
+                # Create optimizer instance
+                optimizer = OptimizerReal()
+                
+                # Run optimization and get structured results
+                results = optimizer.solve_option_A_multi_day_generalized()
+                
+                if results is None:
+                    st.error("❌ Optimization returned no results")
+                elif results.get('status') == 'failed':
+                    st.error(f"❌ Optimization failed: {results.get('message', 'Unknown error')}")
+                else:
+                    st.session_state.optimization_results = results
+                    st.session_state.optimizer = optimizer
+                    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
+        
+        # Create tabs for different result views
+        tab1, tab2, tab3, tab4 = st.tabs(["📊 Summary", "📈 Production", "👷 Labor", "💰 Costs"])
+        
+        with tab1:
+            st.markdown("### Optimization Summary")
+            
+            # Display key metrics
+            total_cost = results.get('total_cost', 0)
+            st.metric("💰 Total Optimization Cost", f"${total_cost:,.2f}")
+            
+            # Additional summary metrics
+            params = results.get('parameters', {})
+            col_s1, col_s2, col_s3 = st.columns(3)
+            
+            with col_s1:
+                st.metric("Total Products", len(params.get('product_list', [])))
+            with col_s2:
+                st.metric("Employee Types", len(params.get('employee_types', [])))
+            with col_s3:
+                st.metric("Total Demand", f"{params.get('total_demand', 0):,.0f}")
+            
+            # Show optimization parameters used
+            st.markdown("**Optimization Parameters:**")
+            if st.session_state.date_range:
+                start_date, end_date = st.session_state.date_range
+                duration = (end_date - start_date).days + 1
+                st.markdown(f"• Date Range: {start_date} to {end_date} ({duration} days)")
+            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))}")
+            st.markdown(f"• Constraint Mode: {params.get('constraint_mode', 'N/A')}")
+            
+            # Cost efficiency metrics
+            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
+                cost_per_unit = total_cost / params.get('total_demand', 1) if params.get('total_demand', 0) > 0 else 0
+                
+                col_e1, col_e2 = st.columns(2)
+                with col_e1:
+                    st.metric("Cost per Day", f"${cost_per_day:,.2f}")
+                with col_e2:
+                    st.metric("Cost per Unit", f"${cost_per_unit:.3f}")
+        
+        with tab2:
+            st.markdown("### Production Results")
+            
+            production_results = results.get('production_results', {})
+            if production_results:
+                # Create production summary table
+                prod_data = []
+                for product, data in production_results.items():
+                    prod_data.append({
+                        'Product': product,
+                        'Demand': data['demand'],
+                        'Produced': data['produced'],
+                        'Fulfillment %': f"{data['fulfillment_rate']:.1f}%"
+                    })
+                
+                if prod_data:
+                    prod_df = pd.DataFrame(prod_data)
+                    st.dataframe(prod_df, use_container_width=True)
+                    
+                    # Production fulfillment chart
+                    fig_prod = px.bar(
+                        prod_df, 
+                        x='Product', 
+                        y=['Demand', 'Produced'],
+                        title='Production vs Demand by Product',
+                        barmode='group'
+                    )
+                    st.plotly_chart(fig_prod, use_container_width=True)
+                    
+                    # 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 (%)")
+                    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:
+                # Create labor hours visualization
+                labor_data = []
+                for emp_type, shifts in employee_hours.items():
+                    for shift, daily_hours in shifts.items():
+                        total_hours = sum(daily_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
+                            })
+                
+                if labor_data:
+                    labor_df = pd.DataFrame(labor_data)
+                    st.dataframe(labor_df, use_container_width=True)
+                    
+                    # Labor hours chart
+                    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)
+            
+            # 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
+                        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}"
+                            })
+                
+                if headcount_data:
+                    headcount_df = pd.DataFrame(headcount_data)
+                    st.dataframe(headcount_df, use_container_width=True)
+        
+        with tab4:
+            st.markdown("### Cost Analysis")
+            
+            total_cost = results.get('total_cost', 0)
+            st.metric("Total Optimization Cost", f"${total_cost:,.2f}")
+            
+            # Cost breakdown by employee type (estimated)
+            employee_hours = results.get('employee_hours', {})
+            if employee_hours:
+                cost_data = []
+                # Use wage data from config
+                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': wage_types[emp_type][shift],
+                                'Cost': shift_cost
+                            })
+                
+                if cost_data:
+                    cost_df = pd.DataFrame(cost_data)
+                    st.dataframe(cost_df, use_container_width=True)
+                    
+                    # Cost breakdown chart
+                    fig_cost = px.pie(
+                        cost_df,
+                        values='Cost',
+                        names='Employee Type',
+                        title='Cost Distribution by Employee Type'
+                    )
+                    st.plotly_chart(fig_cost, use_container_width=True)
+                    
+                    # Cost by shift chart
+                    fig_shift_cost = px.bar(
+                        cost_df,
+                        x='Employee Type',
+                        y='Cost',
+                        color='Shift',
+                        title='Cost Breakdown by Employee Type and Shift',
+                        barmode='stack'
+                    )
+                    st.plotly_chart(fig_shift_cost, 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']
+                if summary['unicef_sufficient']:
+                    st.success("✅ UNICEF Fixed term staff sufficient for all demand")
+                    st.info("→ Humanizer staff not needed")
+                else:
+                    st.warning(f"⚠️ {summary['total_capacity_flags']} cases where UNICEF at capacity")
+                    st.info("→ Humanizer staff utilized")
+    
+    else:
+        st.info("👈 Click 'Run Optimization' in the sidebar to see results")
+        
+        # Show placeholder content
+        st.markdown("""
+        ### What you'll see here:
+        
+        - **📊 Summary**: Overall optimization results and key metrics
+        - **📈 Production**: Production schedule by product and day
+        - **👷 Labor**: Employee allocation and shift assignments
+        - **💰 Costs**: Detailed cost breakdown and analysis
+        
+        Configure your parameters in the sidebar and click 'Run Optimization' to get started!
+        """)
+
+# Footer
+st.markdown("---")
+st.markdown("""
+<div style='text-align: center; color: gray; padding: 2rem;'>
+    <small>SD Roster Optimization Tool | Built with Streamlit & OR-Tools</small>
+</div>
+""", unsafe_allow_html=True)

streamlit_app_old.py

@@ -0,0 +1,517 @@
+import streamlit as st
+
+# Page configuration - MUST be first Streamlit command
+st.set_page_config(
+    page_title="SD Roster Optimization Tool",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Now import everything else
+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(__file__), 'src'))
+
+from src.models.optimizer_real import OptimizerReal
+from src.config import optimization_config
+import src.etl.extract as extract
+import src.etl.transform as transform
+
+# Custom CSS for better styling
+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;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2rem;
+    }
+</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">📊 SD Roster Optimization Tool</h1>', unsafe_allow_html=True)
+
+# Create layout: Left sidebar + Main content
+with st.sidebar:
+    st.markdown("## 🎛️ Control Panel")
+    
+    # Date Selection Section
+    st.markdown("### 📅 Date Range Selection")
+    try:
+        # Get available date ranges from the data
+        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"
+            )
+            
+            # Extract selected dates
+            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)
+            
+            # Display duration
+            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("---")
+    
+    # Optimization Parameters Section
+    st.markdown("### ⚙️ Optimization Parameters")
+    
+    # Employee Type Selection
+    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
+    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
+    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"
+    )
+    
+    # Advanced Parameters
+    with st.expander("🔧 Advanced Parameters"):
+        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)
+
+# Main content area
+col1, col2 = st.columns([1, 2])
+
+# Left column - Metadata
+with col1:
+    st.markdown('<h2 class="section-header">📋 Metadata & Overview</h2>', unsafe_allow_html=True)
+    
+    # Show current date range
+    if st.session_state.date_range:
+        start_date, end_date = st.session_state.date_range
+        st.markdown(f"**Selected Period:** {start_date} to {end_date}")
+    
+    # Demand Information
+    with st.expander("📊 Demand Overview", expanded=True):
+        try:
+            if st.session_state.date_range:
+                start_date, end_date = st.session_state.date_range
+                demand_df = extract.read_released_orders_data(start_date=start_date, end_date=end_date)
+                
+                # Total demand metrics
+                total_orders = len(demand_df)
+                total_quantity = demand_df["Order quantity (GMEIN)"].sum()
+                unique_products = demand_df["Material Number"].nunique()
+                
+                col_d1, col_d2, col_d3 = st.columns(3)
+                with col_d1:
+                    st.metric("Total Orders", total_orders)
+                with col_d2:
+                    st.metric("Total Quantity", f"{total_quantity:,.0f}")
+                with col_d3:
+                    st.metric("Unique Products", unique_products)
+                
+                # Top products by demand
+                top_products = demand_df.groupby('Material Number')["Order quantity (GMEIN)"].sum().sort_values(ascending=False).head(5)
+                
+                if not top_products.empty:
+                    st.markdown("**Top 5 Products by Demand:**")
+                    for product, quantity in top_products.items():
+                        st.markdown(f"• {product}: {quantity:,.0f}")
+                
+        except Exception as e:
+            st.error(f"Error loading demand data: {e}")
+    
+    # Employee Information
+    with st.expander("👥 Employee Overview", expanded=True):
+        try:
+            employee_df = extract.read_employee_data()
+            
+            # Employee metrics
+            total_employees = len(employee_df)
+            emp_by_type = employee_df.groupby("employment_type").size()
+            
+            st.metric("Total Employees", total_employees)
+            
+            st.markdown("**By Employment Type:**")
+            for emp_type, count in emp_by_type.items():
+                st.markdown(f"• {emp_type}: {count}")
+                
+        except Exception as e:
+            st.error(f"Error loading employee data: {e}")
+    
+    # Production Lines
+    with st.expander("🏭 Production Lines", expanded=True):
+        try:
+            line_df = extract.read_packaging_line_data()
+            
+            st.markdown("**Available Lines:**")
+            for _, row in line_df.iterrows():
+                st.markdown(f"• Line {row['id']}: {row['line_count']} units")
+                
+        except Exception as e:
+            st.error(f"Error loading line data: {e}")
+
+# Right column - Optimization Results
+with col2:
+    st.markdown('<h2 class="section-header">🎯 Optimization Results</h2>', unsafe_allow_html=True)
+    
+    if run_optimization:
+        with st.spinner("Running optimization..."):
+            try:
+                # Create optimizer instance
+                optimizer = OptimizerReal()
+                
+                # Run optimization and get structured results
+                results = optimizer.solve_option_A_multi_day_generalized()
+                
+                if results is None:
+                    st.error("❌ Optimization returned no results")
+                elif results.get('status') == 'failed':
+                    st.error(f"❌ Optimization failed: {results.get('message', 'Unknown error')}")
+                else:
+                    st.session_state.optimization_results = results
+                    st.session_state.optimizer = optimizer
+                    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
+        
+        # Create tabs for different result views
+        tab1, tab2, tab3, tab4 = st.tabs(["📊 Summary", "📈 Production", "👷 Labor", "💰 Costs"])
+        
+        with tab1:
+            st.markdown("### Optimization Summary")
+            
+            # Display key metrics
+            total_cost = results.get('total_cost', 0)
+            st.metric("💰 Total Optimization Cost", f"${total_cost:,.2f}")
+            
+            # Additional summary metrics
+            params = results.get('parameters', {})
+            col_s1, col_s2, col_s3 = st.columns(3)
+            
+            with col_s1:
+                st.metric("Total Products", len(params.get('product_list', [])))
+            with col_s2:
+                st.metric("Employee Types", len(params.get('employee_types', [])))
+            with col_s3:
+                st.metric("Total Demand", f"{params.get('total_demand', 0):,.0f}")
+            
+            # Show optimization parameters used
+            st.markdown("**Optimization Parameters:**")
+            if st.session_state.date_range:
+                start_date, end_date = st.session_state.date_range
+                duration = (end_date - start_date).days + 1
+                st.markdown(f"• Date Range: {start_date} to {end_date} ({duration} days)")
+            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))}")
+            st.markdown(f"• Constraint Mode: {params.get('constraint_mode', 'N/A')}")
+            
+            # Cost efficiency metrics
+            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
+                cost_per_unit = total_cost / params.get('total_demand', 1) if params.get('total_demand', 0) > 0 else 0
+                
+                col_e1, col_e2 = st.columns(2)
+                with col_e1:
+                    st.metric("Cost per Day", f"${cost_per_day:,.2f}")
+                with col_e2:
+                    st.metric("Cost per Unit", f"${cost_per_unit:.3f}")
+        
+        with tab2:
+            st.markdown("### Production Results")
+            
+            production_results = results.get('production_results', {})
+            if production_results:
+                # Create production summary table
+                prod_data = []
+                for product, data in production_results.items():
+                    prod_data.append({
+                        'Product': product,
+                        'Demand': data['demand'],
+                        'Produced': data['produced'],
+                        'Fulfillment %': f"{data['fulfillment_rate']:.1f}%"
+                    })
+                
+                if prod_data:
+                    prod_df = pd.DataFrame(prod_data)
+                    st.dataframe(prod_df, use_container_width=True)
+                    
+                    # Production fulfillment chart
+                    fig_prod = px.bar(
+                        prod_df, 
+                        x='Product', 
+                        y=['Demand', 'Produced'],
+                        title='Production vs Demand by Product',
+                        barmode='group'
+                    )
+                    st.plotly_chart(fig_prod, use_container_width=True)
+                    
+                    # 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 (%)")
+                    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:
+                # Create labor hours visualization
+                labor_data = []
+                for emp_type, shifts in employee_hours.items():
+                    for shift, daily_hours in shifts.items():
+                        total_hours = sum(daily_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
+                            })
+                
+                if labor_data:
+                    labor_df = pd.DataFrame(labor_data)
+                    st.dataframe(labor_df, use_container_width=True)
+                    
+                    # Labor hours chart
+                    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)
+            
+            # 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
+                        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}"
+                            })
+                
+                if headcount_data:
+                    headcount_df = pd.DataFrame(headcount_data)
+                    st.dataframe(headcount_df, use_container_width=True)
+        
+        with tab4:
+            st.markdown("### Cost Analysis")
+            
+            total_cost = results.get('total_cost', 0)
+            st.metric("Total Optimization Cost", f"${total_cost:,.2f}")
+            
+            # Cost breakdown by employee type (estimated)
+            employee_hours = results.get('employee_hours', {})
+            if employee_hours:
+                cost_data = []
+                # Use wage data from config
+                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': wage_types[emp_type][shift],
+                                'Cost': shift_cost
+                            })
+                
+                if cost_data:
+                    cost_df = pd.DataFrame(cost_data)
+                    st.dataframe(cost_df, use_container_width=True)
+                    
+                    # Cost breakdown chart
+                    fig_cost = px.pie(
+                        cost_df,
+                        values='Cost',
+                        names='Employee Type',
+                        title='Cost Distribution by Employee Type'
+                    )
+                    st.plotly_chart(fig_cost, use_container_width=True)
+                    
+                    # Cost by shift chart
+                    fig_shift_cost = px.bar(
+                        cost_df,
+                        x='Employee Type',
+                        y='Cost',
+                        color='Shift',
+                        title='Cost Breakdown by Employee Type and Shift',
+                        barmode='stack'
+                    )
+                    st.plotly_chart(fig_shift_cost, 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']
+                if summary['unicef_sufficient']:
+                    st.success("✅ UNICEF Fixed term staff sufficient for all demand")
+                    st.info("→ Humanizer staff not needed")
+                else:
+                    st.warning(f"⚠️ {summary['total_capacity_flags']} cases where UNICEF at capacity")
+                    st.info("→ Humanizer staff utilized")
+    
+    else:
+        st.info("👈 Click 'Run Optimization' in the sidebar to see results")
+        
+        # Show placeholder content
+        st.markdown("""
+        ### What you'll see here:
+        
+        - **📊 Summary**: Overall optimization results and key metrics
+        - **📈 Production**: Production schedule by product and day
+        - **👷 Labor**: Employee allocation and shift assignments
+        - **💰 Costs**: Detailed cost breakdown and analysis
+        
+        Configure your parameters in the sidebar and click 'Run Optimization' to get started!
+        """)
+
+# Footer
+st.markdown("---")
+st.markdown("""
+<div style='text-align: center; color: gray; padding: 2rem;'>
+    <small>SD Roster Optimization Tool | Built with Streamlit & OR-Tools</small>
+</div>
+""", unsafe_allow_html=True)