Solve default problem and none date issue

src/config/optimization_config.py

@@ -14,124 +14,71 @@ import importlib
 
 
 def get_date_span():
+    """Get date span from streamlit session state, or return default"""
     try:
-        # Try to get from streamlit session state (from config page)
         import streamlit as st
-        if hasattr(st, 'session_state') and 'start_date' in st.session_state:
-            from datetime import datetime, timedelta
-            start_date = datetime.combine(st.session_state.start_date, datetime.min.time())
-            
-            # Check if we have calculated planning_days, otherwise determine from data
-            if 'planning_days' in st.session_state and st.session_state.planning_days:
+        if hasattr(st, 'session_state'):
+            # Get from session state without printing (avoid spam)
+            if 'start_date' in st.session_state and 'planning_days' in st.session_state:
+                from datetime import datetime, timedelta
+                start_date = datetime.combine(st.session_state.start_date, datetime.min.time())
                 planning_days = st.session_state.planning_days
                 end_date = start_date + timedelta(days=planning_days - 1)
-            else:
-                # Determine date range from actual demand data for the exact start date
-                try:
-                    demand_data = extract.read_orders_data(start_date=start_date)
-                    if not demand_data.empty:
-                        import pandas as pd
-                        # Get unique finish dates for this exact start date
-                        finish_dates = pd.to_datetime(demand_data["Basic finish date"]).dt.date.unique()
-                        finish_dates = sorted(finish_dates)
-                        if finish_dates:
-                            end_date = datetime.combine(max(finish_dates), datetime.min.time())
-                            planning_days = (end_date - start_date).days + 1
-                        else:
-                            end_date = start_date
-                            planning_days = 1
-                    else:
-                        end_date = start_date + timedelta(days=4)  # Default 5 days
-                        planning_days = 5
-                except Exception as e:
-                    print(f"Could not determine date range from data: {e}")
-                    end_date = start_date + timedelta(days=4)  # Default 5 days
-                    planning_days = 5
-            
-            date_span = list(range(1, planning_days + 1))
-            print(f"Using dates from config page: {start_date} to {end_date} ({planning_days} days)")
-            print("date span", date_span)
-            return date_span, start_date, end_date
-    except Exception as e:
-        print(f"Could not get dates from streamlit session: {e}")
+                date_span = list(range(1, planning_days + 1))
+                return date_span, start_date, end_date
+    except:
+        pass
     
-    print(f"Loading default date values")
-    # Default to match the user's data in COOIS_Released_Prod_Orders.csv
+    # Default values - no printing to avoid spam
     from datetime import datetime
-    return list(range(1, 6)), datetime(2025, 7, 7), datetime(2025, 7, 11)  # Default 5 days
-
+    return list(range(1, 6)), datetime(2025, 7, 7), datetime(2025, 7, 11)
 
-#fetch date from streamlit or default value. The streamlit and default references the demand data (COOIS_Planned_and_Released.csv)
-DATE_SPAN, start_date, end_date = get_date_span() 
 
-# Note: No need to set global dates - extract functions take start_date as parameter directly
-print(f"\n📅 DATE RANGE: {start_date} to {end_date}")
-print(f"📁 PRODUCT SOURCE: COOIS_Released_Prod_Orders.csv")
+# Only call get_date_span() when explicitly needed - avoid module-level execution
+# DATE_SPAN, start_date, end_date = get_date_span()  # REMOVED - called dynamically instead
+DATE_SPAN = None
+start_date = None
+end_date = None
 
 def get_product_list():
-    """
-    Get filtered product list.
-    IMPORTANT: This dynamically loads data to reflect current Streamlit configs/dates.
-    """
+    """Get filtered product list without printing spam"""
     try:
-        # Always get fresh filtered products to reflect current configs
         from src.demand_filtering import DemandFilter
         filter_instance = DemandFilter()
-        
-        # Force reload data to pick up new dates/configs
         filter_instance.load_data(force_reload=True)
-        
-        product_list = filter_instance.get_filtered_product_list()
-        print(f"📦 FRESH FILTERED PRODUCTS: {len(product_list)} products ready for optimization")
-        print(f"🎯 Products: {product_list}")
-        return product_list
-    except Exception as e:
-        print(f"Error loading dynamic product list: {e}")
-        # Fallback to unfiltered list
-        product_list = transformed_data.get_released_product_list(start_date)
-        print(f"📦 FALLBACK UNFILTERED PRODUCTS: {len(product_list)} products -> {product_list}")
-        return product_list
-
-# DO NOT load at import time - always call get_product_list() dynamically
-# PRODUCT_LIST = get_product_list()  # REMOVED - was causing stale data!
+        return filter_instance.get_filtered_product_list()
+    except:
+        # Fallback: get from session state start_date
+        date_span, start_date, end_date = get_date_span()
+        return transformed_data.get_released_product_list(start_date)
 
 
 def get_employee_type_list():
-    """Get employee type list - try from streamlit session state first, then from data files"""
+    """Get employee type list from session state or default"""
     try:
-        # Try to get from streamlit session state (from Dataset Metadata page)
         import streamlit as st
         if hasattr(st, 'session_state') and 'selected_employee_types' in st.session_state:
-            print(f"Using employee types from Dataset Metadata page: {st.session_state.selected_employee_types}")
             return st.session_state.selected_employee_types
-    except Exception as e:
-        print(f"Could not get employee types from streamlit session: {e}")
+    except:
+        pass
     
     # Default: load from data files
-    print(f"Loading employee type list from data files")
     employee_type_list = extract.read_employee_data()
-    emp_type_list = employee_type_list["employment_type"].unique()
-    return emp_type_list
-        
-# DO NOT load at import time - always call get_employee_type_list() dynamically
-# EMPLOYEE_TYPE_LIST = get_employee_type_list()  # REMOVED - was causing stale data!
+    return employee_type_list["employment_type"].unique().tolist()
 
+        
 def get_shift_list():
-    """Get shift list - try from streamlit session state first, then from data files"""
+    """Get shift list from session state or default"""
     try:
-        # Try to get from streamlit session state (from Dataset Metadata page)
         import streamlit as st
         if hasattr(st, 'session_state') and 'selected_shifts' in st.session_state:
-            print(f"Using shifts from Dataset Metadata page: {st.session_state.selected_shifts}")
             return st.session_state.selected_shifts
-    except Exception as e:
-        print(f"Could not get shifts from streamlit session: {e}")
+    except:
+        pass
     
     # Default: load from data files
-    print(f"Loading shift list from data files")
     shift_list = extract.get_shift_info()
-    shift_list = shift_list["id"].unique()
-    return shift_list
+    return shift_list["id"].unique().tolist()
 
 # Evening shift activation mode - define early to avoid circular dependency
 # Options:
@@ -145,53 +92,39 @@ EVENING_SHIFT_MODE = "normal"  # Default: only regular + overtime
 EVENING_SHIFT_DEMAND_THRESHOLD = 0.9  # Activate if regular+overtime capacity < 90% of demand
 
 def get_active_shift_list():
-    """
-    Get the list of active shifts based on EVENING_SHIFT_MODE setting.
-    """
+    """Get the list of active shifts based on EVENING_SHIFT_MODE or session state"""
+    # Check session state first
+    try:
+        import streamlit as st
+        if hasattr(st, 'session_state') and 'evening_shift_mode' in st.session_state:
+            mode = st.session_state.evening_shift_mode
+        else:
+            mode = EVENING_SHIFT_MODE
+    except:
+        mode = EVENING_SHIFT_MODE
+    
     all_shifts = get_shift_list()
     
-    if EVENING_SHIFT_MODE == "normal":
-        # Only regular and overtime shifts - NO evening shift
-        active_shifts = [s for s in all_shifts if s in ShiftType.REGULAR_AND_OVERTIME]
-        print(f"[SHIFT MODE] Normal mode: Using shifts {active_shifts} (Regular + Overtime only, NO evening)")
-        
-    elif EVENING_SHIFT_MODE == "activate_evening":
-        # All shifts including evening (2)
-        active_shifts = list(all_shifts)
-        print(f"[SHIFT MODE] Evening activated: Using all shifts {active_shifts}")
-        
-    elif EVENING_SHIFT_MODE == "always_available":
-        # All shifts always available
-        active_shifts = list(all_shifts)
-        print(f"[SHIFT MODE] Always available: Using all shifts {active_shifts}")
-        
+    if mode == "normal":
+        return [s for s in all_shifts if s in ShiftType.REGULAR_AND_OVERTIME]
+    elif mode in ["activate_evening", "always_available"]:
+        return list(all_shifts)
     else:
-        # Default to normal mode
-        active_shifts = [s for s in all_shifts if s in ShiftType.REGULAR_AND_OVERTIME]
-        print(f"[SHIFT MODE] Unknown mode '{EVENING_SHIFT_MODE}', defaulting to normal: {active_shifts}")
-    
-    return active_shifts
-
-# DO NOT load at import time - always call get_active_shift_list() dynamically
-# SHIFT_LIST = get_active_shift_list()  # REMOVED - was causing stale data!
+        return [s for s in all_shifts if s in ShiftType.REGULAR_AND_OVERTIME]
 
 
 def get_line_list():
-    """Get line list - try from streamlit session state first, then from data files"""
+    """Get line list from session state or default"""
     try:
-        # Try to get from streamlit session state (from Dataset Metadata page)
         import streamlit as st
         if hasattr(st, 'session_state') and 'selected_lines' in st.session_state:
-            print(f"Using lines from Dataset Metadata page: {st.session_state.selected_lines}")
             return st.session_state.selected_lines
-    except Exception as e:
-        print(f"Could not get lines from streamlit session: {e}")
+    except:
+        pass
     
     # Default: load from data files
-    print(f"Loading line list from data files")
     line_df = extract.read_packaging_line_data()
-    line_list = line_df["id"].unique().tolist()
-    return line_list
+    return line_df["id"].unique().tolist()
 
 # DO NOT load at import time - always call get_line_list() dynamically
 # LINE_LIST = get_line_list()  # REMOVED - was causing stale data!
@@ -559,7 +492,6 @@ def get_payment_mode_config():
     return payment_mode_config
 
 # DO NOT load at import time - always call get_payment_mode_config() dynamically
-# PAYMENT_MODE_CONFIG = get_payment_mode_config()  # REMOVED - was causing stale data!
 
 # ============================================================================
 # INITIALIZE MODULE-LEVEL VARIABLES

src/demand_filtering.py

@@ -125,11 +125,12 @@ class DemandFilter:
         Returns:
             int: Total capacity in hours for this line type
         """
-        from src.config.optimization_config import get_line_cnt_per_type, get_max_hour_per_shift_per_person, get_active_shift_list, DATE_SPAN
+        from src.config.optimization_config import get_line_cnt_per_type, get_max_hour_per_shift_per_person, get_active_shift_list, get_date_span
         
         line_cnt_per_type = get_line_cnt_per_type()
         max_hours_per_shift_dict = get_max_hour_per_shift_per_person()
         active_shifts = get_active_shift_list()
+        date_span, _, _ = get_date_span()  # Get date span dynamically
         
         # Get line count for this specific line type
         line_count = line_cnt_per_type.get(line_type, 0)

src/models/optimizer_real.py

@@ -13,7 +13,7 @@ from src.config.constants import ShiftType, LineType, KitLevel
 
 # ---- config import (프로젝트 경로에 맞춰 조정) ----
 from src.config.optimization_config import (
-    DATE_SPAN,                # [1..N]
+    get_date_span,            # DYNAMIC: Get date span dynamically
     get_product_list,         # DYNAMIC: list of products (e.g., ['A','B',...])
     get_employee_type_list,   # DYNAMIC: e.g., ['UNICEF Fixed term','Humanizer']
     get_active_shift_list,    # DYNAMIC: e.g., [1,2,3]
@@ -41,9 +41,8 @@ from src.config.optimization_config import (
 
 
 
-# 2) kit_line_match
+# 2) kit_line_match - no printing to avoid spam
 KIT_LINE_MATCH_DICT
-print("KIT_LINE_MATCH_DICT",KIT_LINE_MATCH_DICT)
 
 # 3) If specific product is not produced on specific date, set it to 0
 # ACTIVE will be built dynamically in solve function based on fresh PRODUCT_LIST
@@ -182,6 +181,9 @@ def run_optimization_for_week():
     DEMAND_DICTIONARY = get_demand_dictionary()
     TEAM_REQ_PER_PRODUCT = get_team_requirements(PRODUCT_LIST)
     
+    # Get date span dynamically
+    DATE_SPAN, start_date, end_date = get_date_span()
+    
     print(f"📦 LOADED PRODUCTS: {len(PRODUCT_LIST)} products")
     print(f"📈 LOADED DEMAND: {sum(DEMAND_DICTIONARY.values())} total units")
     print(f"👥 LOADED TEAM REQUIREMENTS: {len(TEAM_REQ_PER_PRODUCT)} employee types")

ui/app.py

@@ -6,11 +6,15 @@ Simplified version with configuration and optimization results
 import streamlit as st
 import sys
 import os
+
+# Add project root to path BEFORE imports
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
 from ui.pages.config_page import render_config_page
 from ui.pages.optimization_results import display_optimization_results
 from src.demand_validation_viz import display_demand_validation
-# Add src directory to path for imports
-sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
 
 # Set page config
 st.set_page_config(

ui/pages/config_page.py

@@ -248,91 +248,56 @@ def render_config_page():
         display_optimization_results(st.session_state.optimization_results)
 
 def initialize_session_state():
-    """Initialize session state with values from optimization_config.py (single source of truth)"""
+    """Initialize session state with simple default values using Streamlit's standard pattern"""
     
-    # Load ALL values from optimization_config.py - NO hard-coded defaults here
-    try:
-        sys.path.append('src')
-        from config.optimization_config import (
-            # Import the actual computed values, not just constants
-            EVENING_SHIFT_MODE, EVENING_SHIFT_DEMAND_THRESHOLD,
-            FIXED_STAFF_CONSTRAINT_MODE,
-            MAX_HOUR_PER_PERSON_PER_DAY, get_max_hour_per_shift_per_person,
-            get_max_parallel_workers, get_cost_list_per_emp_shift,
-            get_payment_mode_config, get_line_cnt_per_type,
-            get_max_employee_per_type_on_day, start_date, end_date,
-            shift_code_to_name, line_code_to_name, get_fixed_min_unicef_per_day
-        )
-        
-        # Get current dynamic values
-        MAX_HOUR_PER_SHIFT_PER_PERSON = get_max_hour_per_shift_per_person()
-        MAX_PARALLEL_WORKERS = get_max_parallel_workers()
-        COST_LIST_PER_EMP_SHIFT = get_cost_list_per_emp_shift()
-        PAYMENT_MODE_CONFIG = get_payment_mode_config()
-        LINE_CNT_PER_TYPE = get_line_cnt_per_type()
-        MAX_EMPLOYEE_PER_TYPE_ON_DAY = get_max_employee_per_type_on_day()
-        FIXED_MIN_UNICEF_PER_DAY = get_fixed_min_unicef_per_day()
-        
-        # Get the actual computed default values from optimization_config.py
-        defaults = {
-            # Schedule configuration - from optimization_config.py
-            'start_date': start_date.date() if hasattr(start_date, 'date') else start_date,
-            'schedule_type': 'weekly',  # Fixed to weekly only
-            
-            # Shift configuration - from optimization_config.py
-            'evening_shift_mode': EVENING_SHIFT_MODE,
-            'evening_shift_threshold': EVENING_SHIFT_DEMAND_THRESHOLD,
-            
-            # Fixed staff configuration - from optimization_config.py
-            'fixed_staff_mode': FIXED_STAFF_CONSTRAINT_MODE,
-            'fixed_min_unicef_per_day': FIXED_MIN_UNICEF_PER_DAY,
-            
-            # Payment configuration - from optimization_config.py
-            'payment_mode_shift_1': PAYMENT_MODE_CONFIG.get(ShiftType.REGULAR),
-            'payment_mode_shift_2': PAYMENT_MODE_CONFIG.get(ShiftType.EVENING), 
-            'payment_mode_shift_3': PAYMENT_MODE_CONFIG.get(ShiftType.OVERTIME),
-            
-            # Working hours - from optimization_config.py
-            'max_hour_per_person_per_day': MAX_HOUR_PER_PERSON_PER_DAY,
-            'max_hours_shift_1': MAX_HOUR_PER_SHIFT_PER_PERSON.get(ShiftType.REGULAR),
-            'max_hours_shift_2': MAX_HOUR_PER_SHIFT_PER_PERSON.get(ShiftType.EVENING),
-            'max_hours_shift_3': MAX_HOUR_PER_SHIFT_PER_PERSON.get(ShiftType.OVERTIME),
-            
-            # Operations - from optimization_config.py
-            'max_parallel_workers_long_line': MAX_PARALLEL_WORKERS.get(LineType.LONG_LINE),
-            'max_parallel_workers_mini_load': MAX_PARALLEL_WORKERS.get(LineType.MINI_LOAD),
-            
-            # Workforce limits - from optimization_config.py (computed values)
-            'max_unicef_per_day': list(MAX_EMPLOYEE_PER_TYPE_ON_DAY.get("UNICEF Fixed term", {}).values())[0] if MAX_EMPLOYEE_PER_TYPE_ON_DAY.get("UNICEF Fixed term") else 8,
-            'max_humanizer_per_day': list(MAX_EMPLOYEE_PER_TYPE_ON_DAY.get("Humanizer", {}).values())[0] if MAX_EMPLOYEE_PER_TYPE_ON_DAY.get("Humanizer") else 10,
-            
-            # Line counts - from optimization_config.py (data-driven)
-            'line_count_long_line': LINE_CNT_PER_TYPE.get(LineType.LONG_LINE),
-            'line_count_mini_load': LINE_CNT_PER_TYPE.get(LineType.MINI_LOAD),
-            
-            # Cost rates - from optimization_config.py (computed or default values)
-            'unicef_rate_shift_1': COST_LIST_PER_EMP_SHIFT.get("UNICEF Fixed term", {}).get(ShiftType.REGULAR),
-            'unicef_rate_shift_2': COST_LIST_PER_EMP_SHIFT.get("UNICEF Fixed term", {}).get(ShiftType.EVENING),
-            'unicef_rate_shift_3': COST_LIST_PER_EMP_SHIFT.get("UNICEF Fixed term", {}).get(ShiftType.OVERTIME),
-            'humanizer_rate_shift_1': COST_LIST_PER_EMP_SHIFT.get("Humanizer", {}).get(ShiftType.REGULAR),
-            'humanizer_rate_shift_2': COST_LIST_PER_EMP_SHIFT.get("Humanizer", {}).get(ShiftType.EVENING),
-            'humanizer_rate_shift_3': COST_LIST_PER_EMP_SHIFT.get("Humanizer", {}).get(ShiftType.OVERTIME),
-            
-            # Data Selection defaults - reasonable defaults, not ALL available
-            'selected_employee_types': ["UNICEF Fixed term", "Humanizer"],
-            'selected_shifts': [1, 3],  # Regular and Overtime by default, not evening
-            'selected_lines': [6, 7],   # Both Long Line and Mini Load
-        }
-        
-    except Exception as e:
-        st.error(f"❌ Could not load values from optimization_config.py: {e}")
-        st.error("Please check that the optimization_config.py file is working correctly.")
-        st.stop()  # Stop execution - we shouldn't have fallback values here
-    
-    # Initialize session state with values from optimization_config.py
-    for key, value in defaults.items():
-        if key not in st.session_state and value is not None:
-            st.session_state[key] = value
+    # Simple default values - no complex imports or function calls
+    # Use setdefault to avoid overwriting existing values
+    
+    # Schedule defaults
+    st.session_state.setdefault('start_date', datetime.date(2025, 7, 7))
+    st.session_state.setdefault('schedule_type', 'weekly')
+    
+    # Shift defaults
+    st.session_state.setdefault('evening_shift_mode', 'normal')
+    st.session_state.setdefault('evening_shift_threshold', 0.9)
+    
+    # Staff defaults
+    st.session_state.setdefault('fixed_staff_mode', 'priority')
+    st.session_state.setdefault('fixed_min_unicef_per_day', 5)
+    
+    # Payment modes
+    st.session_state.setdefault('payment_mode_shift_1', 'bulk')
+    st.session_state.setdefault('payment_mode_shift_2', 'bulk')
+    st.session_state.setdefault('payment_mode_shift_3', 'partial')
+    
+    # Working hours
+    st.session_state.setdefault('max_hour_per_person_per_day', 14)
+    st.session_state.setdefault('max_hours_shift_1', 9.0)
+    st.session_state.setdefault('max_hours_shift_2', 7.0)
+    st.session_state.setdefault('max_hours_shift_3', 4.0)
+    
+    # Workforce limits
+    st.session_state.setdefault('max_unicef_per_day', 8)
+    st.session_state.setdefault('max_humanizer_per_day', 10)
+    
+    # Operations
+    st.session_state.setdefault('line_count_long_line', 3)
+    st.session_state.setdefault('line_count_mini_load', 2)
+    st.session_state.setdefault('max_parallel_workers_long_line', 7)
+    st.session_state.setdefault('max_parallel_workers_mini_load', 5)
+    
+    # Cost rates
+    st.session_state.setdefault('unicef_rate_shift_1', 12.5)
+    st.session_state.setdefault('unicef_rate_shift_2', 15.0)
+    st.session_state.setdefault('unicef_rate_shift_3', 18.75)
+    st.session_state.setdefault('humanizer_rate_shift_1', 10.0)
+    st.session_state.setdefault('humanizer_rate_shift_2', 12.0)
+    st.session_state.setdefault('humanizer_rate_shift_3', 15.0)
+    
+    # Data selection
+    st.session_state.setdefault('selected_employee_types', ["UNICEF Fixed term", "Humanizer"])
+    st.session_state.setdefault('selected_shifts', [1, 3])
+    st.session_state.setdefault('selected_lines', [6, 7])
 
 def render_schedule_config():
     """Render schedule configuration section"""
@@ -343,7 +308,7 @@ def render_schedule_config():
     with col1:
         st.session_state.start_date = st.date_input(
             "Start Date",
-            value=st.session_state.start_date,
+            value=st.session_state.get('start_date', datetime.date(2025, 7, 7)),
             help="Exact start date to filter demand data - will only use orders that start on this specific date"
         )
     
@@ -357,7 +322,9 @@ def render_schedule_config():
     st.session_state.evening_shift_mode = st.selectbox(
         "Evening Shift Mode",
         options=['normal', 'activate_evening', 'always_available'],
-        index=['normal', 'activate_evening', 'always_available'].index(st.session_state.evening_shift_mode),
+        index=['normal', 'activate_evening', 'always_available'].index(
+            st.session_state.get('evening_shift_mode', 'normal')
+        ),
         help="""
         - **Normal**: Only regular shift (1) and overtime shift (3)
         - **Activate Evening**: Allow evening shift (2) when demand is high
@@ -365,12 +332,12 @@ def render_schedule_config():
         """
     )
     
-    if st.session_state.evening_shift_mode == 'activate_evening':
+    if st.session_state.get('evening_shift_mode') == 'activate_evening':
         st.session_state.evening_shift_threshold = st.slider(
             "Evening Shift Activation Threshold",
             min_value=0.1,
             max_value=1.0,
-            value=st.session_state.evening_shift_threshold,
+            value=st.session_state.get('evening_shift_threshold', 0.9),
             step=0.1,
             help="Activate evening shift if regular+overtime capacity < threshold of demand"
         )
@@ -383,7 +350,9 @@ def render_workforce_config():
     st.session_state.fixed_staff_mode = st.selectbox(
         "Fixed Staff Constraint Mode",
         options=['mandatory', 'available', 'priority', 'none'],
-        index=['mandatory', 'available', 'priority', 'none'].index(st.session_state.fixed_staff_mode),
+        index=['mandatory', 'available', 'priority', 'none'].index(
+            st.session_state.get('fixed_staff_mode', 'priority')
+        ),
         help="""
         - **Mandatory**: Forces all fixed staff to work full hours every day
         - **Available**: Staff available up to limits but not forced
@@ -402,7 +371,7 @@ def render_workforce_config():
             "Max UNICEF Fixed Term per Day",
             min_value=1,
             max_value=50,
-            value=st.session_state.max_unicef_per_day,
+            value=st.session_state.get('max_unicef_per_day', 8),
             help="Maximum number of UNICEF fixed term employees per day"
         )
     
@@ -411,7 +380,7 @@ def render_workforce_config():
             "Max Humanizer per Day",
             min_value=1,
             max_value=50,
-            value=st.session_state.max_humanizer_per_day,
+            value=st.session_state.get('max_humanizer_per_day', 10),
             help="Maximum number of Humanizer employees per day"
         )
     
@@ -422,7 +391,7 @@ def render_workforce_config():
         "Fixed Minimum UNICEF per Day",
         min_value=0,
         max_value=20,
-        value=st.session_state.fixed_min_unicef_per_day,
+        value=st.session_state.get('fixed_min_unicef_per_day', 5),
         help="Minimum number of UNICEF Fixed term employees required every working day (constraint)"
         )
     
@@ -433,7 +402,7 @@ def render_workforce_config():
         "Max Hours per Person per Day",
         min_value=1,
         max_value=24,
-        value=st.session_state.max_hour_per_person_per_day,
+        value=st.session_state.get('max_hour_per_person_per_day', 14),
         help="Legal maximum working hours per person per day"
     )
     
@@ -444,7 +413,7 @@ def render_workforce_config():
             "Max Hours - Shift 1 (Regular)",
             min_value=1.0,
             max_value=12.0,
-            value=float(st.session_state.max_hours_shift_1),
+            value=float(st.session_state.get('max_hours_shift_1', 9.0)),
             step=0.5,
             help="Maximum hours per person for regular shift"
         )
@@ -454,7 +423,7 @@ def render_workforce_config():
             "Max Hours - Shift 2 (Evening)",
             min_value=1.0,
             max_value=12.0,
-            value=float(st.session_state.max_hours_shift_2),
+            value=float(st.session_state.get('max_hours_shift_2', 7.0)),
             step=0.5,
             help="Maximum hours per person for evening shift"
         )
@@ -464,7 +433,7 @@ def render_workforce_config():
             "Max Hours - Shift 3 (Overtime)",
             min_value=1.0,
             max_value=12.0,
-            value=float(st.session_state.max_hours_shift_3),
+            value=float(st.session_state.get('max_hours_shift_3', 4.0)),
             step=0.5,
             help="Maximum hours per person for overtime shift"
         )
@@ -483,7 +452,7 @@ def render_operations_config():
             "Number of Long Lines",
             min_value=1,
             max_value=20,
-            value=st.session_state.line_count_long_line,
+            value=st.session_state.get('line_count_long_line', 3),
             help="Number of long line production lines available"
         )
         
@@ -491,7 +460,7 @@ def render_operations_config():
             "Max Workers per Long Line",
             min_value=1,
             max_value=50,
-            value=st.session_state.max_parallel_workers_long_line,
+            value=st.session_state.get('max_parallel_workers_long_line', 7),
             help="Maximum number of workers that can work simultaneously on a long line"
         )
     
@@ -500,7 +469,7 @@ def render_operations_config():
             "Number of Mini Load Lines",
             min_value=1,
             max_value=20,
-            value=st.session_state.line_count_mini_load,
+            value=st.session_state.get('line_count_mini_load', 2),
             help="Number of mini load production lines available"
         )
         
@@ -508,7 +477,7 @@ def render_operations_config():
             "Max Workers per Mini Load Line",
             min_value=1,
             max_value=50,
-            value=st.session_state.max_parallel_workers_mini_load,
+            value=st.session_state.get('max_parallel_workers_mini_load', 5),
             help="Maximum number of workers that can work simultaneously on a mini load line"
         )
 
@@ -531,7 +500,7 @@ def render_cost_config():
         st.session_state.payment_mode_shift_1 = st.selectbox(
             "Shift 1 (Regular) Payment",
             options=['bulk', 'partial'],
-            index=0 if st.session_state.payment_mode_shift_1 == 'bulk' else 1,
+            index=0 if st.session_state.get('payment_mode_shift_1', 'bulk') == 'bulk' else 1,
             help="Payment mode for regular shift"
         )
     
@@ -539,7 +508,7 @@ def render_cost_config():
         st.session_state.payment_mode_shift_2 = st.selectbox(
             "Shift 2 (Evening) Payment",
             options=['bulk', 'partial'],
-            index=0 if st.session_state.payment_mode_shift_2 == 'bulk' else 1,
+            index=0 if st.session_state.get('payment_mode_shift_2', 'bulk') == 'bulk' else 1,
             help="Payment mode for evening shift"
         )
     
@@ -547,7 +516,7 @@ def render_cost_config():
         st.session_state.payment_mode_shift_3 = st.selectbox(
             "Shift 3 (Overtime) Payment",
             options=['bulk', 'partial'],
-            index=0 if st.session_state.payment_mode_shift_3 == 'bulk' else 1,
+            index=0 if st.session_state.get('payment_mode_shift_3', 'partial') == 'bulk' else 1,
             help="Payment mode for overtime shift"
         )
     
@@ -562,7 +531,7 @@ def render_cost_config():
             "Shift 1 (Regular) - UNICEF",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.unicef_rate_shift_1),
+            value=float(st.session_state.get('unicef_rate_shift_1', 12.5)),
             step=0.01,
             format="%.2f",
             help="Hourly rate for UNICEF Fixed Term staff during regular shift"
@@ -573,7 +542,7 @@ def render_cost_config():
             "Shift 2 (Evening) - UNICEF",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.unicef_rate_shift_2),
+            value=float(st.session_state.get('unicef_rate_shift_2', 15.0)),
             step=0.01,
             format="%.2f",
             help="Hourly rate for UNICEF Fixed Term staff during evening shift"
@@ -584,7 +553,7 @@ def render_cost_config():
             "Shift 3 (Overtime) - UNICEF",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.unicef_rate_shift_3),
+            value=float(st.session_state.get('unicef_rate_shift_3', 18.75)),
             step=0.01,
             format="%.2f",
             help="Hourly rate for UNICEF Fixed Term staff during overtime shift"
@@ -598,7 +567,7 @@ def render_cost_config():
             "Shift 1 (Regular) - Humanizer",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.humanizer_rate_shift_1),
+            value=float(st.session_state.get('humanizer_rate_shift_1', 10.0)),
             step=0.01,
             format="%.2f",
             help="Hourly rate for Humanizer staff during regular shift"
@@ -609,7 +578,7 @@ def render_cost_config():
             "Shift 2 (Evening) - Humanizer",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.humanizer_rate_shift_2),
+            value=float(st.session_state.get('humanizer_rate_shift_2', 12.0)),
             step=0.01,
             format="%.2f",
             help="Hourly rate for Humanizer staff during evening shift"
@@ -620,7 +589,7 @@ def render_cost_config():
             "Shift 3 (Overtime) - Humanizer",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.humanizer_rate_shift_3),
+            value=float(st.session_state.get('humanizer_rate_shift_3', 15.0)),
             step=0.01,
             format="%.2f",
             help="Hourly rate for Humanizer staff during overtime shift"