cleaned demand filtering

src/demand_filtering.py

@@ -89,13 +89,6 @@ class DemandFilter:
         except Exception as e:
             print(f"Error loading data for filtering: {str(e)}")
             return False
-    
-    def too_high_demand_filter(self, product_id: str) -> bool:
-        """
-        Check if the demand for a product is too high.
-        If too high, the product will be excluded from optimization.
-        """
-        return True
         
     
     def standalone_master_filter(self, product_id: str) -> Tuple[str, bool]:
@@ -121,6 +114,102 @@ class DemandFilter:
                 return "unknown", False
         else:
             return "unclassified", False
+
+    def _get_line_type_capacity(self, line_type: int) -> int:
+        """
+        Calculate the total capacity in hours for a specific line type.
+        
+        Args:
+            line_type: The line type ID (e.g., 6 for Long Line, 7 for Mini Load)
+            
+        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
+        
+        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()
+        
+        # Get line count for this specific line type
+        line_count = line_cnt_per_type.get(line_type, 0)
+        
+        # Calculate total hours per day (sum of all active shift hours)
+        total_hours_per_day = sum(max_hours_per_shift_dict.get(shift, 0) for shift in active_shifts)
+        
+        # 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)
+        
+        return available_hours
+
+    def get_maximum_packaging_capacity(self) -> int:
+        """
+        Get the maximum packaging capacity across all line types.
+        
+        Returns:
+            int: Maximum total capacity in hours across all lines
+        """
+        from src.config.optimization_config import get_line_cnt_per_type
+        
+        line_cnt_per_type = get_line_cnt_per_type()
+        total_capacity = 0
+        
+        for line_type, line_count in line_cnt_per_type.items():
+            if line_count > 0:  # Only count active lines
+                line_capacity = self._get_line_type_capacity(line_type)
+                total_capacity += line_capacity
+        
+        return total_capacity
+
+    def too_high_demand_filter(self, product_id: str) -> bool:
+        """
+        Check if the demand for a product is too high.
+        
+        A product has "too high demand" when the total processing hours needed
+        exceeds the available capacity hours for the product's assigned line type.
+        
+        NOTE: This method assumes all prerequisite data is available (demand > 0,
+        line assignment exists, speed data exists). The main filter function
+        should handle these edge cases.
+        
+        Calculation:
+        - Processing hours needed = demand_quantity / production_speed_per_hour
+        - Available hours = line_count × hours_per_shift × shifts_per_day × days_in_period
+        
+        Args:
+            product_id: The product ID to check
+            
+        Returns:
+            bool: True if demand is too high (should be excluded), False otherwise
+        """
+        # Get demand for this product (assumes demand > 0, checked by main filter)
+        demand = self.demand_data.get(product_id, 0)
+        if demand <= 0:
+            return False
+        # Get line assignment for this product (assumes exists, checked by main filter)
+        if self.line_assignments is None or product_id not in self.line_assignments:
+            return False
+        line_type = self.line_assignments.get(product_id)
+        
+        # Get production speed data (assumes exists, checked by main filter)
+        if self.speed_data is None or product_id not in self.speed_data:
+            return False
+        production_speed_per_hour = self.speed_data[product_id]
+        
+        # Calculate processing hours needed
+        processing_hours_needed = demand / production_speed_per_hour
+        
+        # Get available capacity for this specific line type
+        available_hours = self._get_line_type_capacity(line_type)
+        
+        # Check if processing hours needed exceeds available capacity
+        is_too_high = processing_hours_needed > available_hours
+        
+        if is_too_high:
+            print(f"⚠️  HIGH DEMAND WARNING: {product_id} needs {processing_hours_needed:.1f}h but only {available_hours:.1f}h available (line_type={line_type}, demand={demand}, speed={production_speed_per_hour:.1f}/h)")
+        
+        return is_too_high
     
     def is_product_ready_for_optimization(self, product_id: str) -> Tuple[bool, List[str]]:
         """
@@ -175,6 +264,13 @@ class DemandFilter:
         if self.speed_data is None or product_id not in self.speed_data:
             exclusion_reasons.append("Missing production speed data")
         
+        # Check if demand is too high (only if we have all required data)
+        if self.too_high_demand_filter(product_id):
+            exclusion_reasons.append("Demand exceeds available production capacity")
+
+        
+
+
         is_ready = len(exclusion_reasons) == 0
         return is_ready, exclusion_reasons
     
@@ -199,8 +295,6 @@ class DemandFilter:
         excluded_demand = {}
         excluded_details = {}
         
-        print("🔍 FILTERING DEMAND DATA FOR OPTIMIZATION")
-        
         for product_id, demand in self.demand_data.items():
             is_ready, exclusion_reasons = self.is_product_ready_for_optimization(product_id)
             
@@ -215,27 +309,6 @@ class DemandFilter:
         # Sort products for consistent output
         included_products.sort()
         excluded_products.sort()
-        
-        # Print summary
-        total_demand = sum(self.demand_data.values())
-        included_total = sum(included_demand.values())
-        excluded_total = sum(excluded_demand.values())
-        
-        print(f"✅ INCLUDED in optimization: {len(included_products)} products ({included_total:,} units)")
-        print(f"🚫 EXCLUDED from optimization: {len(excluded_products)} products ({excluded_total:,} units)")
-        print(f"📊 Total demand: {total_demand:,} units")
-        
-        # Print exclusion breakdown
-        if excluded_products:
-            print(f"\n📋 EXCLUSION BREAKDOWN:")
-            reason_counts = {}
-            for reasons in excluded_details.values():
-                for reason in reasons:
-                    reason_counts[reason] = reason_counts.get(reason, 0) + 1
-            
-            for reason, count in reason_counts.items():
-                print(f"  • {reason}: {count} products")
-        
         # Print data quality warnings for included products
         included_without_hierarchy = sum(1 for pid in included_products if self.standalone_master_filter(pid)[0] == "unclassified")
         if included_without_hierarchy > 0:
@@ -282,6 +355,9 @@ class DemandFilter:
             
             # Get production speed info
             has_speed_data = speed_data is not None and product_id in speed_data
+
+            # too high demand
+            has_too_high_demand = self.too_high_demand_filter(product_id)
             
             product_details[product_id] = {
                 'demand': demand,
@@ -296,13 +372,16 @@ class DemandFilter:
                 'has_line_assignment': line_assignment is not None,
                 'has_staffing': (unicef_staff + humanizer_staff) > 0,
                 'has_hierarchy': product_type != "unclassified",
-                'has_speed_data': has_speed_data
+                'has_speed_data': has_speed_data,
+                'has_too_high_demand': has_too_high_demand
             }
         
         # Calculate data quality statistics for included products
         included_without_speed = sum(1 for pid in included_products if not product_details[pid]['has_speed_data'])
         included_without_hierarchy = sum(1 for pid in included_products if not product_details[pid]['has_hierarchy'])
         
+        # Count products excluded due to too high demand
+        excluded_with_too_high_demand = sum(1 for pid in excluded_products if product_details[pid]['has_too_high_demand'])
         return {
             'included_count': len(included_products),
             'included_demand': sum(included_demand.values()),
@@ -316,7 +395,8 @@ class DemandFilter:
             'excluded_products': excluded_products,
             # Data quality metrics for included products
             'included_missing_speed_count': included_without_speed,
-            'included_missing_hierarchy_count': included_without_hierarchy
+            'included_missing_hierarchy_count': included_without_hierarchy,
+            'excluded_with_too_high_demand_count': excluded_with_too_high_demand
         }
 
 

src/demand_validation_viz.py

@@ -87,7 +87,12 @@ class DemandValidationViz:
                 if not details['has_hierarchy']:
                     issues.append("no_hierarchy_data")
                 validation_status = f"⚠️ Data Issues: {', '.join(issues)}" if issues else "✅ Ready for optimization"
-            
+
+
+
+            if details['has_too_high_demand']:
+                issues.append("too_high_demand")
+                validation_status = f"⚠️ Data Issues: {', '.join(issues)}" if issues else "✅ Ready for optimization"
             results.append({
                 'Product ID': product_id,
                 'Demand': details['demand'],
@@ -108,6 +113,7 @@ class DemandValidationViz:
                 'Excluded from Optimization': not details['is_included_in_optimization'],
                 'Exclusion Reasons': ', '.join(details['exclusion_reasons']) if details['exclusion_reasons'] else '',
                 'Data Quality Issues': ', '.join(issues) if details['is_included_in_optimization'] and 'issues' in locals() and issues else '',
+                'Has Too High Demand': "✅" if details['has_too_high_demand'] else "❌",
                 'Validation Status': validation_status
             })
         
@@ -134,7 +140,8 @@ class DemandValidationViz:
             'no_hierarchy': len(included_df[included_df['Has Hierarchy Data'] == "❌"]),
             'standalone_masters': analysis['standalone_masters_count'],
             'total_unicef_needed': sum(p['unicef_staff'] for p in analysis['product_details'].values()),
-            'total_humanizer_needed': sum(p['humanizer_staff'] for p in analysis['product_details'].values())
+            'total_humanizer_needed': sum(p['humanizer_staff'] for p in analysis['product_details'].values()),
+            'excluded_with_too_high_demand': analysis['excluded_with_too_high_demand_count']
         }
 
 
@@ -191,7 +198,8 @@ def display_demand_validation():
                 delta=None if stats['no_speed'] == 0 else "Will use default")
     col4.metric("No Hierarchy Data", stats['no_hierarchy'],
                 delta=None if stats['no_hierarchy'] == 0 else "Issue")
-    
+    col5.metric("Excluded: Too High Demand", stats['excluded_with_too_high_demand'],
+                delta=None if stats['excluded_with_too_high_demand'] == 0 else "Excluded")
     # ===== INCLUDED PRODUCTS TABLE =====
     included_df = validation_df[validation_df['Excluded from Optimization'] == False].copy()
     excluded_df = validation_df[validation_df['Excluded from Optimization'] == True].copy()