Trying to fix infinite reloading

src/config/optimization_config.py

@@ -130,7 +130,17 @@ def get_line_list():
 # 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()
     
@@ -152,7 +162,6 @@ 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):
@@ -161,26 +170,29 @@ 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
 
-KIT_LINE_MATCH_DICT = get_kit_line_match()
+# Lazy property - will be initialized on first access
+@property
+def KIT_LINE_MATCH_DICT():
+    return 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 Exception as e:
-        print(f"Could not get line counts from streamlit session: {e}")
+    except:
+        pass
     
-    print(f"Loading default line count values from data files")
+    # Default: load 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
@@ -200,28 +212,23 @@ 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 Exception as e:
-        print(f"Could not get cost list from streamlit session: {e}")
+    except:
+        pass
     
-    print(f"Loading default cost values")
-    # Default hourly rates - Important: multiple employment types with different costs
+    # Default hourly rates
     return DefaultConfig.DEFAULT_COST_RATES
 
 def shift_code_to_name():
@@ -233,18 +240,6 @@ 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):
@@ -255,20 +250,9 @@ 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": {},
@@ -277,10 +261,7 @@ 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]
@@ -289,9 +270,6 @@ 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
 
@@ -300,22 +278,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 Exception as e:
-        print(f"Could not get max employee counts from streamlit session: {e}")
+    except:
+        pass
     
-    print(f"Loading default max employee values")
+    # Default: get date span dynamically
+    date_span, _, _ = get_date_span()
     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
@@ -332,8 +310,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 Exception as e:
-        print(f"Could not get max hours per shift from session: {e}")
+    except:
+        pass
     
     # Fallback to default only if not configured by user
     return DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON
@@ -341,13 +319,6 @@ 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"""
@@ -355,8 +326,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 Exception as e:
-        print(f"Could not get evening shift threshold from session: {e}")
+    except:
+        pass
     
     # Fallback to default only if not configured by user
     return getattr(DefaultConfig, 'EVENING_SHIFT_DEMAND_THRESHOLD', 10000)
@@ -367,8 +338,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 Exception as e:
-        print(f"Could not get fixed min UNICEF from session: {e}")
+    except:
+        pass
     
     # 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})
@@ -406,22 +377,45 @@ 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():
-    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}")
-        
+    """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
+    
     # 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
 
-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")
+# 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
 
 def get_max_parallel_workers():
     """Get max parallel workers - checks Streamlit session state first"""
@@ -429,8 +423,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 Exception as e:
-        print(f"Could not get max parallel workers from session: {e}")
+    except:
+        pass
     
     # Fallback to default only if not configured by user
     return DefaultConfig.MAX_PARALLEL_WORKERS
@@ -456,10 +450,9 @@ 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 ImportError:
-        pass  # Streamlit not available in CLI mode
+    except:
+        pass
     
     # Default value - minimum UNICEF Fixed term employees required per day
     return 2
@@ -477,19 +470,14 @@ 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 Exception as e:
-        print(f"Could not get payment mode config from streamlit session: {e}")
+    except:
+        pass
     
     # Default payment mode configuration
-    print(f"Loading default payment mode configuration")
-    payment_mode_config = DefaultConfig.PAYMENT_MODE_CONFIG
-    
-    return payment_mode_config
+    return DefaultConfig.PAYMENT_MODE_CONFIG
 
 # DO NOT load at import time - always call get_payment_mode_config() dynamically
 
@@ -503,24 +491,8 @@ 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/demand_filtering.py

@@ -140,7 +140,7 @@ class DemandFilter:
         
         # Calculate available capacity hours
         # Available hours = line_count × total_hours_per_day × days_in_period
-        available_hours = line_count * total_hours_per_day * len(DATE_SPAN)
+        available_hours = line_count * total_hours_per_day * len(date_span)
         
         return available_hours
 

src/models/optimizer_real.py

@@ -28,13 +28,13 @@ from src.config.optimization_config import (
     FIXED_STAFF_CONSTRAINT_MODE,     # not used in fixed-team model (동시 투입이라 무의미)
     get_team_requirements,    # DYNAMIC: {emp_type: {product: team_size}} from Kits_Calculation.csv
     get_payment_mode_config,         # DYNAMIC: {shift: 'bulk'/'partial'} payment mode configuration
-    KIT_LINE_MATCH_DICT,
+    get_kit_line_match,              # DYNAMIC: Get kit line match lazily
     EVENING_SHIFT_MODE,
     EVENING_SHIFT_DEMAND_THRESHOLD,
     # Hierarchy variables for production ordering
-    KIT_LEVELS,                      # {kit_id: level} where 0=prepack, 1=subkit, 2=master
-    KIT_DEPENDENCIES,                # {kit_id: [dependency_list]}
-    PRODUCTION_PRIORITY_ORDER,       # [kit_ids] sorted by production priority
+    get_kit_levels,                  # DYNAMIC: {kit_id: level} where 0=prepack, 1=subkit, 2=master
+    get_kit_dependencies,            # DYNAMIC: {kit_id: [dependency_list]}
+    get_production_priority_order,   # DYNAMIC: [kit_ids] sorted by production priority
     # Fixed staffing requirements
     get_fixed_min_unicef_per_day,    # DYNAMIC: Minimum UNICEF employees required per day
 )
@@ -42,7 +42,7 @@ from src.config.optimization_config import (
 
 
 # 2) kit_line_match - no printing to avoid spam
-KIT_LINE_MATCH_DICT
+# KIT_LINE_MATCH_DICT loaded lazily in functions that need it
 
 # 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
@@ -171,6 +171,13 @@ def sort_products_by_hierarchy(product_list):
 # Dependency ordering is now handled by topological sorting in sort_products_by_hierarchy()
 
 def run_optimization_for_week():
+    # Load hierarchy data lazily at the start of optimization
+    global KIT_LEVELS, KIT_DEPENDENCIES, PRODUCTION_PRIORITY_ORDER, KIT_LINE_MATCH_DICT
+    KIT_LEVELS = get_kit_levels()
+    KIT_DEPENDENCIES = get_kit_dependencies()
+    PRODUCTION_PRIORITY_ORDER = get_production_priority_order()
+    KIT_LINE_MATCH_DICT = get_kit_line_match()
+    
     # *** CRITICAL: Load fresh data to reflect current Streamlit configs ***
     print("\n" + "="*60)
     print("🔄 LOADING FRESH DATA FOR OPTIMIZATION")

src/models/optimizer_real_import_fix.txt

@@ -0,0 +1,34 @@
+# ---- config import (프로젝트 경로에 맞춰 조정) ----
+from src.config.optimization_config import (
+    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]
+    get_line_list,            # DYNAMIC: e.g., [6,7]  (line type ids)
+    get_line_cnt_per_type,    # DYNAMIC: {6: count_of_long_lines, 7: count_of_short_lines}
+    get_demand_dictionary,    # DYNAMIC: {product: total_units_over_period}
+    get_cost_list_per_emp_shift,  # DYNAMIC: {emp_type: {shift: cost_per_hour}}
+    get_max_employee_per_type_on_day,    # DYNAMIC: {emp_type: {t: headcount}}
+    MAX_HOUR_PER_PERSON_PER_DAY,     # e.g., 14
+    get_max_hour_per_shift_per_person,   # DYNAMIC: {1: hours, 2: hours, 3: hours}
+    get_max_parallel_workers,        # DYNAMIC: {6: max_workers, 7: max_workers}
+    FIXED_STAFF_CONSTRAINT_MODE,     # not used in fixed-team model (동시 투입이라 무의미)
+    get_team_requirements,    # DYNAMIC: {emp_type: {product: team_size}} from Kits_Calculation.csv
+    get_payment_mode_config,         # DYNAMIC: {shift: 'bulk'/'partial'} payment mode configuration
+    get_kit_line_match,              # DYNAMIC: Get kit line match lazily
+    EVENING_SHIFT_MODE,
+    EVENING_SHIFT_DEMAND_THRESHOLD,
+    # Hierarchy variables for production ordering - now using getter functions
+    get_kit_levels,                  # DYNAMIC: {kit_id: level} where 0=prepack, 1=subkit, 2=master
+    get_kit_dependencies,            # DYNAMIC: {kit_id: [dependency_list]}
+    get_production_priority_order,   # DYNAMIC: [kit_ids] sorted by production priority
+    # Fixed staffing requirements
+    get_fixed_min_unicef_per_day,    # DYNAMIC: Minimum UNICEF employees required per day
+)
+
+
+
+# 2) kit_line_match - lazy load on first use
+KIT_LINE_MATCH_DICT = get_kit_line_match()
+
+

src/preprocess/kit_composition_cleaner.py

@@ -109,8 +109,7 @@ class KitCompositionCleaner:
             })
         
         self.master_df = pd.DataFrame(master_data)
-        print(f"Created {len(self.master_df)} master kit records")
-        print(f"Standalone masters with 'long line': {sum(self.master_df['line_type'] == 'long line')}")
+
         
         return self.master_df