Revert to 5ce2749d (roll back HEAD→5ce2...)

src/config/optimization_config.py

@@ -92,55 +92,59 @@ 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 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
-    
+    """
+    Get the list of active shifts based on EVENING_SHIFT_MODE setting.
+    """
     all_shifts = get_shift_list()
     
-    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)
+    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}")
+        
     else:
-        return [s for s in all_shifts if s in ShiftType.REGULAR_AND_OVERTIME]
+        # 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!
 
 
 def get_line_list():
-    """Get line list from session state or default"""
+    """Get line list - try from streamlit session state first, then from data files"""
     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:
-        pass
+    except Exception as e:
+        print(f"Could not get lines from streamlit session: {e}")
     
     # Default: load from data files
+    print(f"Loading line list from data files")
     line_df = extract.read_packaging_line_data()
-    return line_df["id"].unique().tolist()
+    line_list = line_df["id"].unique().tolist()
+    return line_list
 
 # DO NOT load at import time - always call get_line_list() dynamically
 # LINE_LIST = get_line_list()  # REMOVED - was causing stale data!
 
 
-# Module-level cache for kit line match - prevents reloading on every access
-_KIT_LINE_MATCH_DICT_CACHE = None
-
 def get_kit_line_match():
-    """Get kit line match dictionary with caching to prevent reload on every import"""
-    global _KIT_LINE_MATCH_DICT_CACHE
-    
-    # Return cached value if available
-    if _KIT_LINE_MATCH_DICT_CACHE is not None:
-        return _KIT_LINE_MATCH_DICT_CACHE
-    
     kit_line_match = extract.read_kit_line_match_data()
     kit_line_match_dict = kit_line_match.set_index("kit_name")["line_type"].to_dict()
     
@@ -162,6 +166,7 @@ def get_kit_line_match():
             if line_id is not None:
                 converted_dict[kit] = line_id
             else:
+                print(f"Warning: Unknown line type '{line_name}' for kit {kit}")
                 # Default to long line if unknown
                 converted_dict[kit] = LineType.LONG_LINE
         elif isinstance(line_name, (int, float)) and not pd.isna(line_name):
@@ -170,29 +175,26 @@ def get_kit_line_match():
         else:
             # Missing or empty line type - skip (no production needed for non-standalone masters)
             pass  # Don't add to converted_dict - these kits won't have line assignments
-    
-    # Cache the result
-    _KIT_LINE_MATCH_DICT_CACHE = converted_dict
+            
     return converted_dict
 
-# Lazy property - will be initialized on first access
-@property
-def KIT_LINE_MATCH_DICT():
-    return get_kit_line_match()
+KIT_LINE_MATCH_DICT = get_kit_line_match()
 
 
 def get_line_cnt_per_type():
-    """Get line counts from session state or default"""
     try:
+        # Try to get from streamlit session state (from config page)
         import streamlit as st
         if hasattr(st, 'session_state') and 'line_counts' in st.session_state:
+            print(f"Using line counts from config page: {st.session_state.line_counts}")
             return st.session_state.line_counts
-    except:
-        pass
+    except Exception as e:
+        print(f"Could not get line counts from streamlit session: {e}")
     
-    # Default: load from data files
+    print(f"Loading default line count values from data files")
     line_df = extract.read_packaging_line_data()
     line_cnt_per_type = line_df.set_index("id")["line_count"].to_dict()
+    print("line cnt per type", line_cnt_per_type)
     return line_cnt_per_type
 
 # DO NOT load at import time - always call get_line_cnt_per_type() dynamically
@@ -212,23 +214,28 @@ def get_demand_dictionary(force_reload=False):
         filter_instance.load_data(force_reload=True)
         
         demand_dictionary = filter_instance.get_filtered_demand_dictionary()
+        print(f"📈 FRESH FILTERED DEMAND: {len(demand_dictionary)} products with total demand {sum(demand_dictionary.values())}")
+        print(f"🔄 LOADED DYNAMICALLY: Reflects current Streamlit configs")
         return demand_dictionary
     except Exception as e:
+        print(f"Error loading dynamic demand dictionary: {e}")
         raise Exception("Demand dictionary not found with error:"+str(e))
 
 # DO NOT load at import time - always call get_demand_dictionary() dynamically
 # DEMAND_DICTIONARY = get_demand_dictionary()  # REMOVED - was causing stale data!
 
 def get_cost_list_per_emp_shift():
-    """Get cost list from session state or default"""
     try:
+        # Try to get from streamlit session state (from config page)
         import streamlit as st
         if hasattr(st, 'session_state') and 'cost_list_per_emp_shift' in st.session_state:
+            print(f"Using cost list from config page: {st.session_state.cost_list_per_emp_shift}")
             return st.session_state.cost_list_per_emp_shift
-    except:
-        pass
+    except Exception as e:
+        print(f"Could not get cost list from streamlit session: {e}")
     
-    # Default hourly rates
+    print(f"Loading default cost values")
+    # Default hourly rates - Important: multiple employment types with different costs
     return DefaultConfig.DEFAULT_COST_RATES
 
 def shift_code_to_name():
@@ -240,6 +247,18 @@ def line_code_to_name():
 
 # DO NOT load at import time - always call get_cost_list_per_emp_shift() dynamically
 # COST_LIST_PER_EMP_SHIFT = get_cost_list_per_emp_shift()  # REMOVED - was causing stale data!
+        
+
+
+# COST_LIST_PER_EMP_SHIFT = {  # WH_Workforce_Hourly_Pay_Scale
+#     "Fixed": {1: 0, 2: 22, 3: 18},
+#     "Humanizer": {1: 10, 2: 10, 3: 10},
+# }
+
+
+
+
+
 
 
 def get_team_requirements(product_list=None):
@@ -250,9 +269,20 @@ def get_team_requirements(product_list=None):
     if product_list is None:
         product_list = get_product_list()  # Get fresh product list
         
+    try:
+        # Check if streamlit has this data (for future extension)
+        # streamlit_team_req = dashboard.team_requirements
+        # return streamlit_team_req
+        pass
+    except Exception as e:
+        print(f"Using default value for team requirements, extracting from CSV: {e}")
+        
     # Read the kits calculation data directly
     kits_df = extract.read_personnel_requirement_data()
-    
+    # kits_path = "data/real_data_excel/converted_csv/Kits__Calculation.csv"
+    # kits_df = pd.read_csv(kits_path)
+    print("kits_df columns:", kits_df.columns.tolist())
+    print("kits_df head:", kits_df.head())
     # Initialize the team requirements dictionary
     team_req_dict = {
         "UNICEF Fixed term": {},
@@ -261,7 +291,10 @@ def get_team_requirements(product_list=None):
     
     # Process each product in the product list
     for product in product_list:
+        print("product",product)
+        print(f"Processing team requirements for product: {product}")
         product_data = kits_df[kits_df['Kit'] == product]
+        print("product_data",product_data)
         if not product_data.empty:
             # Extract Humanizer and UNICEF staff requirements
             humanizer_req = product_data["Humanizer"].iloc[0]
@@ -270,6 +303,9 @@ def get_team_requirements(product_list=None):
             # Convert to int (data is already cleaned in extract function)
             team_req_dict["Humanizer"][product] = int(humanizer_req)
             team_req_dict["UNICEF Fixed term"][product] = int(unicef_req)
+        else:
+            print(f"Warning: Product {product} not found in Kits Calculation data, setting requirements to 0")
+            
     
     return team_req_dict
 
@@ -278,22 +314,22 @@ def get_team_requirements(product_list=None):
 
 
 def get_max_employee_per_type_on_day():
-    """Get max employee counts from session state or default"""
     try:
+        # Try to get from streamlit session state (from config page)
         import streamlit as st
         if hasattr(st, 'session_state') and 'max_employee_per_type_on_day' in st.session_state:
+            print(f"Using max employee counts from config page: {st.session_state.max_employee_per_type_on_day}")
             return st.session_state.max_employee_per_type_on_day
-    except:
-        pass
+    except Exception as e:
+        print(f"Could not get max employee counts from streamlit session: {e}")
     
-    # Default: get date span dynamically
-    date_span, _, _ = get_date_span()
+    print(f"Loading default max employee values")
     max_employee_per_type_on_day = {
         "UNICEF Fixed term": {
-            t: 8 for t in date_span
+            t: 8 for t in DATE_SPAN
         },
         "Humanizer": {
-            t: 10 for t in date_span
+            t: 10 for t in DATE_SPAN
         }
     }
     return max_employee_per_type_on_day
@@ -310,8 +346,8 @@ def get_max_hour_per_shift_per_person():
         import streamlit as st
         if hasattr(st, 'session_state') and 'max_hour_per_shift_per_person' in st.session_state:
             return st.session_state.max_hour_per_shift_per_person
-    except:
-        pass
+    except Exception as e:
+        print(f"Could not get max hours per shift from session: {e}")
     
     # Fallback to default only if not configured by user
     return DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON
@@ -319,6 +355,13 @@ def get_max_hour_per_shift_per_person():
 # DO NOT load at import time - always call get_max_hour_per_shift_per_person() dynamically
 # MAX_HOUR_PER_SHIFT_PER_PERSON = get_max_hour_per_shift_per_person()  # REMOVED - was causing stale data!
 
+# Removed unnecessary getter functions - use direct imports instead:
+# - MAX_HOUR_PER_PERSON_PER_DAY
+# - MAX_HOUR_PER_SHIFT_PER_PERSON  
+# - KIT_LINE_MATCH_DICT
+# - MAX_PARALLEL_WORKERS
+# - EVENING_SHIFT_MODE
+
 # Keep these complex getters that access DefaultConfig or have complex logic:
 def get_evening_shift_demand_threshold():
     """Get evening shift demand threshold - checks Streamlit session state first"""
@@ -326,8 +369,8 @@ def get_evening_shift_demand_threshold():
         import streamlit as st
         if hasattr(st, 'session_state') and 'evening_shift_demand_threshold' in st.session_state:
             return st.session_state.evening_shift_demand_threshold
-    except:
-        pass
+    except Exception as e:
+        print(f"Could not get evening shift threshold from session: {e}")
     
     # Fallback to default only if not configured by user
     return getattr(DefaultConfig, 'EVENING_SHIFT_DEMAND_THRESHOLD', 10000)
@@ -338,8 +381,8 @@ def get_fixed_min_unicef_per_day():
         import streamlit as st
         if hasattr(st, 'session_state') and 'fixed_min_unicef_per_day' in st.session_state:
             return st.session_state.fixed_min_unicef_per_day
-    except:
-        pass
+    except Exception as e:
+        print(f"Could not get fixed min UNICEF from session: {e}")
     
     # Fallback to default only if not configured by user
     return getattr(DefaultConfig, 'FIXED_MIN_UNICEF_PER_DAY', {1: 1, 2: 1, 3: 1, 4: 1, 5: 1})
@@ -377,45 +420,22 @@ def _ensure_fresh_config():
 # after all functions are defined. This ensures all getter functions are available.
 
 # ---- Kit Hierarchy for Production Ordering ----
-# Module-level cache for hierarchy - prevents reloading on every import
-_KIT_HIERARCHY_CACHE = None
-
 def get_kit_hierarchy_data():
-    """Load kit hierarchy data from extract functions with caching"""
-    global _KIT_HIERARCHY_CACHE
-    
-    # Return cached value if available
-    if _KIT_HIERARCHY_CACHE is not None:
-        return _KIT_HIERARCHY_CACHE
-    
+    try:
+        # Try to get from streamlit first (future extension)
+        # streamlit_hierarchy = dashboard.kit_hierarchy_data
+        # return streamlit_hierarchy
+        pass
+    except Exception as e:
+        print(f"Using default hierarchy data from extract: {e}")
+        
     # Get hierarchy data from extract functions
     kit_levels, dependencies, priority_order = extract.get_production_order_data()
     
-    # Cache the result
-    _KIT_HIERARCHY_CACHE = (kit_levels, dependencies, priority_order)
     return kit_levels, dependencies, priority_order
 
-# Lazy properties - will be initialized on first access
-def get_kit_levels():
-    """Get kit levels lazily"""
-    kit_levels, _, _ = get_kit_hierarchy_data()
-    return kit_levels
-
-def get_kit_dependencies():
-    """Get kit dependencies lazily"""
-    _, dependencies, _ = get_kit_hierarchy_data()
-    return dependencies
-
-def get_production_priority_order():
-    """Get production priority order lazily"""
-    _, _, priority_order = get_kit_hierarchy_data()
-    return priority_order
-
-# Initialize only on first access - use properties
-KIT_LEVELS = None
-KIT_DEPENDENCIES = None
-PRODUCTION_PRIORITY_ORDER = None
-KIT_LINE_MATCH_DICT = None
+KIT_LEVELS, KIT_DEPENDENCIES, PRODUCTION_PRIORITY_ORDER = get_kit_hierarchy_data()
+print(f"Kit Hierarchy loaded: {len(KIT_LEVELS)} kits, Priority order: {len(PRODUCTION_PRIORITY_ORDER)} items")
 
 def get_max_parallel_workers():
     """Get max parallel workers - checks Streamlit session state first"""
@@ -423,8 +443,8 @@ def get_max_parallel_workers():
         import streamlit as st
         if hasattr(st, 'session_state') and 'max_parallel_workers' in st.session_state:
             return st.session_state.max_parallel_workers
-    except:
-        pass
+    except Exception as e:
+        print(f"Could not get max parallel workers from session: {e}")
     
     # Fallback to default only if not configured by user
     return DefaultConfig.MAX_PARALLEL_WORKERS
@@ -450,9 +470,10 @@ def get_fixed_min_unicef_per_day():
     try:
         import streamlit as st
         if hasattr(st, 'session_state') and 'fixed_min_unicef_per_day' in st.session_state:
+            print(f"Using fixed minimum UNICEF per day from config page: {st.session_state.fixed_min_unicef_per_day}")
             return st.session_state.fixed_min_unicef_per_day
-    except:
-        pass
+    except ImportError:
+        pass  # Streamlit not available in CLI mode
     
     # Default value - minimum UNICEF Fixed term employees required per day
     return 2
@@ -470,14 +491,19 @@ def get_payment_mode_config():
     - "partial": Pay only for actual hours worked
     """
     try:
+        # Try to get from streamlit session state (from Dataset Metadata page)
         import streamlit as st
         if hasattr(st, 'session_state') and 'payment_mode_config' in st.session_state:
+            print(f"Using payment mode config from streamlit session: {st.session_state.payment_mode_config}")
             return st.session_state.payment_mode_config
-    except:
-        pass
+    except Exception as e:
+        print(f"Could not get payment mode config from streamlit session: {e}")
     
     # Default payment mode configuration
-    return DefaultConfig.PAYMENT_MODE_CONFIG
+    print(f"Loading default payment mode configuration")
+    payment_mode_config = DefaultConfig.PAYMENT_MODE_CONFIG
+    
+    return payment_mode_config
 
 # DO NOT load at import time - always call get_payment_mode_config() dynamically
 
@@ -491,8 +517,24 @@ def get_payment_mode_config():
 # This prevents the infinite loop where importing this module triggers Streamlit session access
 # which causes the app to reload, which imports this module again, etc.
 
+# Initialize with default values (will use fallback data when no Streamlit session)
+# PER_PRODUCT_SPEED = extract.read_package_speed_data()
+# LINE_LIST = get_line_list()
+# EMPLOYEE_TYPE_LIST = get_employee_type_list()
+# SHIFT_LIST = get_active_shift_list()
+# LINE_CNT_PER_TYPE = get_line_cnt_per_type()
+# COST_LIST_PER_EMP_SHIFT = get_cost_list_per_emp_shift()
+# MAX_EMPLOYEE_PER_TYPE_ON_DAY = get_max_employee_per_type_on_day()
+# MAX_HOUR_PER_SHIFT_PER_PERSON = get_max_hour_per_shift_per_person()
+# MAX_PARALLEL_WORKERS = get_max_parallel_workers()
+# FIXED_MIN_UNICEF_PER_DAY = get_fixed_min_unicef_per_day()
+# PAYMENT_MODE_CONFIG = get_payment_mode_config()
+
+print("✅ Module-level configuration functions defined (variables initialized dynamically)")
+
 # Note: These variables are initialized once at import time with default/fallback values.
 # To get fresh values after changing Streamlit configuration, either:
 # 1. Call the get_*() functions directly (RECOMMENDED for dynamic use)
 # 2. Call _ensure_fresh_config() to refresh all module-level variables
 # 3. Use importlib.reload() to reload the entire module
+

src/visualization/__init__.py

@@ -0,0 +1,5 @@
+"""
+Visualization package for Supply Roster Optimization Tool
+Provides visualization dashboards and charts for optimization results
+"""
+

src/visualization/hierarchy_dashboard.py

@@ -17,13 +17,12 @@ except ImportError:
 
 import numpy as np
 import sys
-sys.path.append('src')
 
-from config.optimization_config import (
+from src.config.optimization_config import (
     KIT_LEVELS, KIT_DEPENDENCIES, TEAM_REQ_PER_PRODUCT, 
     shift_code_to_name, line_code_to_name
 )
-from config.constants import ShiftType, LineType, KitLevel
+from src.config.constants import ShiftType, LineType, KitLevel
 
 # Import kit relationships dashboard
 try:

src/visualization/kit_relationships.py

@@ -11,9 +11,8 @@ import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import json
 import sys
-sys.path.append('src')
 
-from config.constants import ShiftType, LineType, KitLevel
+from src.config.constants import ShiftType, LineType, KitLevel
 
 # Optional networkx for advanced network layouts
 try:

ui/pages/config_page.py

@@ -10,9 +10,6 @@ import os
 from src.config import optimization_config
 from src.config.constants import ShiftType, LineType
 
-# Add src directory to path for imports
-sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
 def render_config_page():
     """Render the configuration page with all user input controls"""
     
@@ -663,7 +660,6 @@ def save_configuration():
     
     # Get available demand dates from data to determine the actual date range
     try:
-        sys.path.append('src')
         import src.preprocess.extract as extract
         import pandas as pd
         from datetime import datetime
@@ -918,7 +914,6 @@ def display_user_friendly_summary(config):
     # Demand Data Preview
     st.subheader("📊 Demand Data Preview")
     try:
-        sys.path.append('src')
         import src.preprocess.extract as extract
         from datetime import datetime
         
@@ -1069,8 +1064,7 @@ def run_optimization():
         st.info(f"👥 Max UNICEF/day: {st.session_state.max_unicef_per_day}, Max Humanizer/day: {st.session_state.max_humanizer_per_day}")
         
         # Import and run the optimization (after clearing)
-        sys.path.append('src')
-        from models.optimizer_real import run_optimization_for_week
+        from src.models.optimizer_real import run_optimization_for_week
         
         # Run the optimization
         with st.spinner('Optimizing workforce schedule...'):
@@ -1101,12 +1095,6 @@ def check_critical_data_issues():
     
     try:
         # Add src to path if needed
-        import sys
-        import os
-        src_path = os.path.join(os.path.dirname(__file__), 'src')
-        if src_path not in sys.path:
-            sys.path.append(src_path)
-            
         from src.demand_validation_viz import DemandValidationViz
         
         # Initialize validator and load data

ui/pages/optimization_results.py

@@ -93,8 +93,7 @@ def display_weekly_summary(results):
     
     with col3:
         # Calculate fulfillment rate
-        sys.path.append('src')
-        from config.optimization_config import get_demand_dictionary
+        from src.config.optimization_config import get_demand_dictionary
         DEMAND_DICTIONARY = get_demand_dictionary()
         total_demand = sum(DEMAND_DICTIONARY.values())
         fulfillment_rate = (total_production / total_demand * 100) if total_demand > 0 else 0
@@ -264,8 +263,7 @@ def display_line_schedules(results):
     
     # Process schedule data
     schedule_data = []
-    sys.path.append('src')
-    from config.optimization_config import get_team_requirements, get_demand_dictionary, shift_code_to_name, line_code_to_name
+    from src.config.optimization_config import get_team_requirements, get_demand_dictionary, shift_code_to_name, line_code_to_name
     TEAM_REQ_PER_PRODUCT = get_team_requirements()
     DEMAND_DICTIONARY = get_demand_dictionary()
     
@@ -504,8 +502,7 @@ def display_kit_production(results):
     
     # Weekly production summary
     production_data = []
-    sys.path.append('src')
-    from config.optimization_config import get_demand_dictionary
+    from src.config.optimization_config import get_demand_dictionary
     DEMAND_DICTIONARY = get_demand_dictionary()
     
     for product, production in results['weekly_production'].items():
@@ -540,8 +537,7 @@ def display_cost_analysis(results):
     st.subheader("💰 Cost Breakdown Analysis")
     
     # Calculate cost breakdown
-    sys.path.append('src')
-    from config.optimization_config import get_cost_list_per_emp_shift, get_team_requirements, shift_code_to_name, line_code_to_name
+    from src.config.optimization_config import get_cost_list_per_emp_shift, get_team_requirements, shift_code_to_name, line_code_to_name
     COST_LIST_PER_EMP_SHIFT = get_cost_list_per_emp_shift()  # Dynamic call
     TEAM_REQ_PER_PRODUCT = get_team_requirements()