clean code for optimizer

src/models/optimizer_real.py

@@ -26,7 +26,6 @@ from src.config.optimization_config import (
     get_max_hour_per_shift_per_person,   # DYNAMIC: {1: hours, 2: hours, 3: hours}
     get_per_product_speed,       # DYNAMIC: {6: cap_units_per_hour, 7: cap_units_per_hour}
     get_max_parallel_workers,        # DYNAMIC: {6: max_workers, 7: max_workers}
-    DAILY_WEEKLY_SCHEDULE,           # 'daily' or 'weekly' 
     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
@@ -41,9 +40,6 @@ from src.config.optimization_config import (
     get_fixed_min_unicef_per_day,    # DYNAMIC: Minimum UNICEF employees required per day
 )
 
-# -----------------------------------------
-# 추가 파라미터 설정 (config에 없던 것들) - TODO: 실제 값 채우세요
-# -----------------------------------------
 
 
 # 2) kit_line_match
@@ -98,39 +94,51 @@ def sort_products_by_hierarchy(product_list):
         in_degree[product] = 0
     
     # Build edges based on actual dependencies
-    dependency_count = 0
+    # KIT_DEPENDENCIES = {product: [dependencies]} - "What does THIS product need?"
+    # graph = {dependency: [products]} - "What depends on THIS dependency?"
+    # 
+    # Example transformation:
+    # KIT_DEPENDENCIES = {'subkit_A': ['prepack_1'], 'master_B': ['subkit_A']}
+    # After building: graph = {'prepack_1': ['subkit_A'], 'subkit_A': ['master_B']}
+    # This means: prepack_1 is needed by subkit_A, subkit_A is needed by master_B
+    #
+    # Example:
+    # 1. product='subkit_A', deps=['prepack_1']
+    #    → graph['prepack_1'].append('subkit_A')
+    #    → graph = {'prepack_1': ['subkit_A']}
+    # 2. product='master_B', deps=['subkit_A'] 
+    #    → graph['subkit_A'].append('master_B')
+    #    → graph = {'prepack_1': ['subkit_A'], 'subkit_A': ['master_B']}
+    
+    
     for product in products_with_hierarchy:
-        deps = KIT_DEPENDENCIES.get(product, [])
+        deps = KIT_DEPENDENCIES.get(product, []) #dependencies = products that has to be packed first
         for dep in deps:
             if dep in products_with_hierarchy:  # Only if dependency is in our production list
-                graph[dep].append(product)  # dep -> product
+                # REVERSE THE RELATIONSHIP: 
+                # KIT_DEPENDENCIES says: "product needs dep"
+                # graph says: "dep is needed by product"
+                graph[dep].append(product)  # dep -> product (reverse the relationship!)
                 in_degree[product] += 1
-                dependency_count += 1
-    
-    print(f"[HIERARCHY] Found {dependency_count} dependency relationships in production list")
     
     # Topological sort with hierarchy level priority
     sorted_products = []
+    #queue = able to remove from both sides
     queue = deque()
     
-    # Start with products that have no dependencies, prioritized by hierarchy level
-    no_deps = [(KIT_LEVELS.get(p, 999), p) for p in products_with_hierarchy if in_degree[p] == 0]
-    no_deps.sort()  # Sort by (level, product_id)
-    
-    for _, product in no_deps:
-        queue.append(product)
+    # Start with products that have no dependencies
+    for product in products_with_hierarchy:
+        if in_degree[product] == 0:
+            queue.append(product)
     
     while queue:
         current = queue.popleft()
         sorted_products.append(current)
         
-        # Process dependents
-        dependents = [(KIT_LEVELS.get(dep, 999), dep) for dep in graph[current]]
-        dependents.sort()  # Sort by hierarchy level first
-        
-        for _, dependent in dependents:
-            in_degree[dependent] -= 1
-            if in_degree[dependent] == 0:
+        # Process dependents - sort by hierarchy level first
+        for dependent in sorted(graph[current], key=lambda p: (KIT_LEVELS.get(p, 999), p)):
+            in_degree[dependent] -= 1 #decrement the in_degree of the dependent
+            if in_degree[dependent] == 0: #if the in_degree of the dependent is 0, add it to the queue so that it can be processed
                 queue.append(dependent)
     
     # Check for cycles (shouldn't happen with proper hierarchy)
@@ -141,7 +149,7 @@ def sort_products_by_hierarchy(product_list):
         remaining_sorted = sorted(remaining, key=lambda p: (KIT_LEVELS.get(p, 999), p))
         sorted_products.extend(remaining_sorted)
     
-    # Add products without hierarchy at the end
+    # Add products without hierarchy information at the end
     sorted_products.extend(sorted(products_without_hierarchy))
     
     print(f"[HIERARCHY] Dependency-aware production order: {len(sorted_products)} products")
@@ -249,10 +257,6 @@ def solve_fixed_team_weekly():
             print(f"   RECOMMENDATION: Change EVENING_SHIFT_MODE to 'activate_evening' to enable evening shift")
             print(f"   This will add shift 3 to increase capacity\n")
 
-    # 3) DAILY_WEEKLY_SCHEDULE warning (current model only enforces weekly demand)
-    if DAILY_WEEKLY_SCHEDULE.lower() == "daily":
-        print("[INFO] DAILY_WEEKLY_SCHEDULE='daily' but this model only enforces weekly demand. "
-              "If daily demand decomposition is needed, please let us know.")
 
     # --- Solver ---
     solver = pywraplp.Solver.CreateSolver('CBC')