datupapi 1.112.0__tar.gz → 1.112.1__tar.gz

{datupapi-1.112.0 → datupapi-1.112.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datupapi
-Version: 1.112.0
+Version: 1.112.1
 Summary: Utility library to support Datup AI MLOps processes
 Author: Datup AI
 Author-email: ramiro@datup.ai

{datupapi-1.112.0 → datupapi-1.112.1}/datupapi/inventory/src/FutureInventory/future_reorder.py

@@ -14,6 +14,101 @@ from datupapi.inventory.src.SuggestedForecast.suggested_forecast import Suggeste
 from datupapi.inventory.src.FutureInventory.daily_usage_future import DailyUsageFuture
 
 
+def _generate_item_dates_worker(key, df_lead_time, periods, period2, start_date, start_date_zero, default_coverage, location):
+    """
+    Generate dates for a single item in the worker process context.
+    This function replicates the logic from future_date() but for a single item.
+    
+    Args:
+        key: Item identifier (str) or (item, location) tuple
+        df_lead_time: Lead time DataFrame (filtered for this item)
+        periods: Number of periods to generate (for ReorderFreq > 20)
+        period2: Number of periods to generate (for ReorderFreq <= 20)
+        start_date: Start date for period 1 (can be None)
+        start_date_zero: Custom start date for period 0 (can be None)
+        default_coverage: Default coverage days
+        location: Boolean indicating location-based processing
+                 (Note: This parameter is kept for interface consistency but is not
+                 directly used in date generation logic, as dates depend on ReorderFreq
+                 which is already in the filtered df_lead_time)
+        
+    Returns:
+        List[str]: List of dates in 'YYYYMMDD' format
+    """
+    try:
+        # Determine the starting date for period 0
+        if start_date_zero is not None:
+            # Use custom start date for period 0
+            actual_date = pd.to_datetime(start_date_zero, format='%Y-%m-%d')
+        else:
+            # Use current system date for period 0 (original behavior)
+            DOCKER_CONFIG_PATH = os.path.join('/opt/ml/processing/input', 'config.yml')
+            utils = Utils(config_file=DOCKER_CONFIG_PATH, logfile='data_io', log_path='output/logs')
+            timestamp = utils.set_timestamp()
+            actual_date = pd.to_datetime(str(int(float(timestamp[0:8]))), format='%Y%m%d')
+        
+        # Determine which period count to use based on ReorderFreq
+        reorder_freq = df_lead_time['ReorderFreq'].iloc[0]
+        if pd.isna(reorder_freq) or reorder_freq == 0:
+            reorder_freq = default_coverage
+        reorder_freq = int(reorder_freq)
+        
+        # Use period2 for ReorderFreq <= 20, otherwise use periods
+        if reorder_freq <= 20:
+            effective_periods = period2
+        else:
+            effective_periods = periods
+        
+        # Use effective_periods + 1 internally to calculate one extra period for transit calculations
+        end_date = actual_date + pd.DateOffset(months=effective_periods + 1)
+        
+        # Handle start_date = None case
+        if start_date is None:
+            # If start_date is None, use actual_date as the base for period 1
+            base_start_date = actual_date
+        else:
+            base_start_date = pd.to_datetime(start_date, format='%Y-%m-%d')
+        
+        # ReorderFreq was already calculated above, no need to recalculate
+        
+        # Generate date range for this item
+        date_range = []
+        
+        # Always include actual date (period 0)
+        date_range.append(actual_date)
+        
+        # Include base_start_date if after actual_date
+        if base_start_date > actual_date:
+            date_range.append(base_start_date)
+        
+        # Generate subsequent dates using a controlled loop instead of pd.date_range
+        current_date = base_start_date + timedelta(days=reorder_freq)
+        while current_date <= end_date:
+            date_range.append(current_date)
+            current_date += timedelta(days=reorder_freq)
+        
+        # Convert to string format
+        date_strings = [d.strftime('%Y%m%d') for d in date_range]
+        
+        return date_strings
+        
+    except Exception as e:
+        print(f"Error generating dates for item {key}: {str(e)}")
+        # Return a minimal date list with just the current date
+        try:
+            if start_date_zero is not None:
+                actual_date = pd.to_datetime(start_date_zero, format='%Y-%m-%d')
+            else:
+                DOCKER_CONFIG_PATH = os.path.join('/opt/ml/processing/input', 'config.yml')
+                utils = Utils(config_file=DOCKER_CONFIG_PATH, logfile='data_io', log_path='output/logs')
+                timestamp = utils.set_timestamp()
+                actual_date = pd.to_datetime(str(int(float(timestamp[0:8]))), format='%Y%m%d')
+            return [actual_date.strftime('%Y%m%d')]
+        except:
+            # Last resort: return today's date
+            return [datetime.now().strftime('%Y%m%d')]
+
+
 def process_item_batch_complete(batch_args):
     """
     Process a batch of items in parallel with complete functionality.
@@ -24,7 +119,7 @@ def process_item_batch_complete(batch_args):
     
     Args:
         batch_args (tuple): Contains all necessary data for batch processing:
-            - batch_items: List of item data tuples (key, dates, lead_time_df, inv_df)
+            - batch_items: List of item data tuples (key, lead_time_df, inv_df)
             - df_fcst: Forecast data DataFrame
             - df_prep: Preparation data DataFrame
             - metadata: List of metadata columns
@@ -35,22 +130,32 @@ def process_item_batch_complete(batch_args):
             - integer: Boolean for integer formatting of quantities
             - verbose: Boolean for detailed logging
             - df_transit: Transit schedule DataFrame (optional)
+            - periods: Number of periods to generate
+            - start_date: Start date for period 1 (can be None)
+            - start_date_zero: Custom start date for period 0 (can be None)
     
     Returns:
         pd.DataFrame: Combined results for all items in the batch, or empty DataFrame if errors
     """
     try:
         (batch_items, df_fcst, df_prep, metadata, location, default_coverage,
-         complete_suggested, security_stock_ref, integer, verbose, df_transit) = batch_args
+         complete_suggested, security_stock_ref, integer, verbose, df_transit,
+         periods, period2, start_date, start_date_zero) = batch_args
         
         results = []
         processed_count = 0
         error_count = 0
         
         for item_data in batch_items:
-            key, dates, current_df_lead_time, current_df_inv = item_data
+            key, current_df_lead_time, current_df_inv = item_data
             
             try:
+                # Generate dates for this item locally in the worker process
+                dates = _generate_item_dates_worker(
+                    key, current_df_lead_time, periods, period2, start_date,
+                    start_date_zero, default_coverage, location
+                )
+                
                 # Procesar este ítem usando la lógica completa con timeout implícito
                 item_result = _process_item_complete(
                     key, dates, current_df_lead_time, current_df_inv,
@@ -157,7 +262,11 @@ def _process_item_complete(key, dates, current_df_lead_time, current_df_inv,
                 
                 # Update last_suggested_value for next iteration
                 if 'SuggestedForecast' in suggested_forecasts[i].columns:
-                    last_suggested_value = suggested_forecasts[i]['SuggestedForecast'].iloc[0]
+                    new_suggested_value = suggested_forecasts[i]['SuggestedForecast'].iloc[0]
+                    
+                    # Only update if the new value is not NaN
+                    if not pd.isna(new_suggested_value):
+                        last_suggested_value = new_suggested_value
                 
                 # Calculate daily usage with optimized calls
                 df_avgs[i], df_maxs[i] = _calculate_daily_usage_complete(
@@ -192,7 +301,27 @@ def _process_item_complete(key, dates, current_df_lead_time, current_df_inv,
                     
             except Exception as e:
                 # Log error but continue with next period
-                print(f"Warning: Error processing period {i} for item {key}: {str(e)}")
+                import traceback
+                tb = traceback.extract_tb(e.__traceback__)
+                function_name = tb[-1].name if tb else 'unknown'
+                line_number = tb[-1].lineno if tb else 'unknown'
+                
+                print(f"Warning: Error processing period {i} for item {key}:")
+                print(f"   Function: {function_name} (line {line_number})")
+                print(f"   Error: {str(e)}")
+                print(f"   Error type: {type(e).__name__}")
+                print(f"   Date value: {repr(date)} (type: {type(date)})")
+                print(f"   Period index: {i}")
+                print(f"   Total dates available: {len(dates)}")
+                
+                # Print more context for debugging
+                if hasattr(e, '__cause__') and e.__cause__:
+                    print(f"   Caused by: {str(e.__cause__)}")
+                
+                # Print the full traceback for error analysis
+                print(f"   Full traceback:")
+                traceback.print_exc()
+                
                 continue
     
         # After processing all periods, update FutureInventoryTransitArrival
@@ -233,7 +362,26 @@ def _process_item_complete(key, dates, current_df_lead_time, current_df_inv,
         
     except Exception as e:
         # Handle any unexpected errors at the item level
-        print(f"Error processing item {key}: {str(e)}")
+        import traceback
+        tb = traceback.extract_tb(e.__traceback__)
+        function_name = tb[-1].name if tb else 'unknown'
+        line_number = tb[-1].lineno if tb else 'unknown'
+        
+        print(f"Error processing item {key}:")
+        print(f"   Function: {function_name} (line {line_number})")
+        print(f"   Error: {str(e)}")
+        print(f"   Error type: {type(e).__name__}")
+        print(f"   Item dates: {dates[:5] if dates else 'None'}... (showing first 5)")
+        print(f"   Total dates: {len(dates) if dates else 0}")
+        
+        # Print more context for debugging
+        if hasattr(e, '__cause__') and e.__cause__:
+            print(f"   Caused by: {str(e.__cause__)}")
+        
+        # Print the full traceback for error analysis
+        print(f"   Full traceback:")
+        traceback.print_exc()
+        
         return None
 
 
@@ -282,11 +430,116 @@ def _format_value_complete(value, field_name, integer):
         return value
 
 
+def _suggested_forecast_fallback(current_df_lead_time, current_df_inv, date, df_fcst, metadata, location, default_coverage):
+    """
+    Simplified SuggestedForecast fallback function for multiprocessing compatibility.
+    
+    This function provides a basic forecast calculation when the main SuggestedForecast class fails
+    due to multiprocessing issues. It calculates the forecast using an average-based approach:
+    
+    1. Sum all forecasts in the coverage period
+    2. Calculate daily average (sum / total_days_in_period)
+    3. Multiply by coverage days
+    4. Round up to nearest integer
+    
+    Args:
+        current_df_lead_time: Lead time DataFrame for this item
+        current_df_inv: Inventory DataFrame for this item
+        date: Date string in 'YYYYMMDD' format
+        df_fcst: Forecast DataFrame
+        metadata: List of metadata columns
+        location: Boolean indicating location-based processing
+        default_coverage: Default coverage days
+        
+    Returns:
+        pd.DataFrame: DataFrame with SuggestedForecast column
+    """
+    try:
+        # Parse the date
+        current_date = pd.to_datetime(date, format='%Y%m%d')
+        
+        # Get coverage for this item
+        coverage = current_df_lead_time['Coverage'].iloc[0] if 'Coverage' in current_df_lead_time.columns else default_coverage
+        if pd.isna(coverage):
+            coverage = default_coverage
+        coverage = int(coverage)
+        
+        # Calculate forecast end date
+        forecast_end_date = current_date + timedelta(days=coverage)
+        
+        # Filter forecast data for this item and date range
+        if location:
+            item = current_df_inv['Item'].iloc[0]
+            loc = current_df_inv['Location'].iloc[0]
+            forecast_mask = (df_fcst['Item'] == item) & (df_fcst['Location'] == loc)
+        else:
+            item = current_df_inv['Item'].iloc[0]
+            forecast_mask = df_fcst['Item'] == item
+        
+        # Add date range filter - get all forecast data for this item
+        forecast_mask &= (df_fcst['Date'] >= current_date) & (df_fcst['Date'] <= forecast_end_date)
+        
+        item_forecast = df_fcst[forecast_mask]
+        
+        # Calculate suggested forecast using average-based approach
+        if not item_forecast.empty and 'Forecast' in item_forecast.columns:
+            # Step 1: Sum all forecasts in the period
+            total_forecast = item_forecast['Forecast'].sum()
+            
+            # Step 2: Calculate total days in the forecast period
+            # Simplification: assume 30 days per month for calculation
+            total_days_in_period = len(item_forecast)  # Number of forecast records
+            if total_days_in_period == 0:
+                suggested_forecast = 0.0
+            else:
+                # Step 3: Calculate daily average
+                daily_average = total_forecast / total_days_in_period
+                
+                # Step 4: Multiply by coverage days
+                suggested_forecast = daily_average * coverage
+                
+                # Step 5: Round up to nearest integer
+                suggested_forecast = np.ceil(suggested_forecast)
+            
+            
+        else:
+            # Fallback: use 0 if no forecast data available
+            suggested_forecast = 0.0
+            item = current_df_inv['Item'].iloc[0]
+            location_msg = ""
+            if location and 'Location' in current_df_inv.columns:
+                loc = current_df_inv['Location'].iloc[0]
+                location_msg = f" at location {loc}"
+            print(f"   ⚠️ No forecast data found for item {item}{location_msg}, using 0")
+        
+        # Create result DataFrame
+        result_df = current_df_inv[metadata].copy()
+        result_df['SuggestedForecast'] = suggested_forecast
+        
+        # Add required columns
+        result_df['PurchaseFactor'] = current_df_inv.get('PurchaseFactor', pd.Series([1])).iloc[0]
+        result_df['ItemDescription'] = current_df_inv.get('ItemDescription', pd.Series([''])).iloc[0]
+        
+        return result_df
+        
+    except Exception as e:
+        print(f"   ❌ Fallback SuggestedForecast also failed: {str(e)}")
+        # Last resort: return basic structure with 0 forecast
+        result_df = current_df_inv[metadata].copy()
+        result_df['SuggestedForecast'] = 0.0
+        result_df['PurchaseFactor'] = current_df_inv.get('PurchaseFactor', pd.Series([1])).iloc[0]
+        result_df['ItemDescription'] = current_df_inv.get('ItemDescription', pd.Series([''])).iloc[0]
+        return result_df
+
+
 def _calculate_suggested_forecast_complete(current_df_lead_time, current_df_inv, date, last_suggested_value,
-                                         df_fcst, df_prep, metadata, location, default_coverage, complete_suggested):
+                                          df_fcst, df_prep, metadata, location, default_coverage, complete_suggested):
     """Calculate suggested forecast for the given date using the SuggestedForecast class."""
     # Convert current date to datetime
-    current_date = pd.to_datetime(date, format='%Y%m%d')
+    try:
+        current_date = pd.to_datetime(date, format='%Y%m%d')
+    except Exception as e:
+        raise ValueError(f"_calculate_suggested_forecast_complete: Invalid date '{date}' - {str(e)}")
     
     # Get the maximum forecast date available
     max_forecast_date = df_fcst['Date'].max()
@@ -329,21 +582,36 @@ def _calculate_suggested_forecast_complete(current_df_lead_time, current_df_inv,
                         join_='left'
                     ).suggested_forecast()
                 except Exception as e:
-                    # Get item identifier for error message
-                    item = current_df_inv['Item'].iloc[0]
-                    location_msg = ""
-                    if location and 'Location' in current_df_inv.columns:
-                        loc = current_df_inv['Location'].iloc[0]
-                        location_msg = f" at location {loc}"
+                    print(f"   ❌ Initial calculation failed: {str(e)}")
+                    print(f"   🔄 Attempting fallback SuggestedForecast calculation...")
                     
-                    error_msg = (
-                        f"Cannot calculate initial forecast for item {item}{location_msg}. "
-                        f"Forecast data extends only to {max_forecast_date.strftime('%Y-%m-%d')}, "
-                        f"but coverage of {int(coverage)} days from {current_date.strftime('%Y-%m-%d')} "
-                        f"requires forecast data until {required_forecast_end_date.strftime('%Y-%m-%d')}. "
-                        f"Original error: {str(e)}"
-                    )
-                    raise ValueError(error_msg)
+                    try:
+                        # Use simplified fallback function
+                        fallback_result = _suggested_forecast_fallback(
+                            current_df_lead_time, current_df_inv, date, df_fcst,
+                            metadata, location, default_coverage
+                        )
+                        
+                        return fallback_result
+                        
+                    except Exception as fallback_error:
+                        print(f"   ❌ Fallback initial calculation also failed: {str(fallback_error)}")
+                        
+                        # Get item identifier for error message
+                        item = current_df_inv['Item'].iloc[0]
+                        location_msg = ""
+                        if location and 'Location' in current_df_inv.columns:
+                            loc = current_df_inv['Location'].iloc[0]
+                            location_msg = f" at location {loc}"
+                        
+                        error_msg = (
+                            f"Cannot calculate initial forecast for item {item}{location_msg}. "
+                            f"Forecast data extends only to {max_forecast_date.strftime('%Y-%m-%d')}, "
+                            f"but coverage of {int(coverage)} days from {current_date.strftime('%Y-%m-%d')} "
+                            f"requires forecast data until {required_forecast_end_date.strftime('%Y-%m-%d')}. "
+                            f"Original error: {str(e)}"
+                        )
+                        raise ValueError(error_msg)
         else:
             # Get item identifier for error message
             item = current_df_inv['Item'].iloc[0]
@@ -361,36 +629,73 @@ def _calculate_suggested_forecast_complete(current_df_lead_time, current_df_inv,
             raise ValueError(error_msg)
     
     # If validation passes, proceed with the original calculation
-    return SuggestedForecast(
-        df_LeadTimes=current_df_lead_time,
-        df_Forecast=df_fcst,
-        df_Prep=df_prep,
-        df_inv=current_df_inv,
-        column_forecast='SuggestedForecast',
-        columns_metadata=metadata,
-        frequency_='M',
-        location=location,
-        actualdate=date,
-        default_coverage_=default_coverage,
-        join_='left'
-    ).suggested_forecast()
+    try:
+        result = SuggestedForecast(
+            df_LeadTimes=current_df_lead_time,
+            df_Forecast=df_fcst,
+            df_Prep=df_prep,
+            df_inv=current_df_inv,
+            column_forecast='SuggestedForecast',
+            columns_metadata=metadata,
+            frequency_='M',
+            location=location,
+            actualdate=date,
+            default_coverage_=default_coverage,
+            join_='left'
+        ).suggested_forecast()
+        
+            
+        return result
+        
+    except Exception as e:
+        print(f"   ❌ Normal calculation failed: {str(e)}")
+        print(f"   🔄 Attempting fallback SuggestedForecast calculation...")
+        
+        try:
+            # Use simplified fallback function
+            fallback_result = _suggested_forecast_fallback(
+                current_df_lead_time, current_df_inv, date, df_fcst,
+                metadata, location, default_coverage
+            )
+            
+            
+            return fallback_result
+            
+        except Exception as fallback_error:
+            print(f"   ❌ Fallback calculation also failed: {str(fallback_error)}")
+            # Re-raise the original error
+            raise e
 
 
 def _calculate_daily_usage_complete(suggested_forecast_df, date, df_fcst, location):
     """Calculate average and maximum daily usage rates."""
-    df_avg = DailyUsageFuture(
-        location=location,
-        column_forecast='SuggestedForecast',
-        date=date,
-        df_fcst=df_fcst
-    ).daily_usage(suggested_forecast_df, 'AvgDailyUsage').fillna(0)
-
-    df_max = DailyUsageFuture(
-        location=location,
-        column_forecast='SuggestedForecast',
-        date=date,
-        df_fcst=df_fcst
-    ).daily_usage(df_avg, 'MaxDailyUsage').fillna(0)
+    
+    try:
+        df_avg = DailyUsageFuture(
+            location=location,
+            column_forecast='SuggestedForecast',
+            date=date,
+            df_fcst=df_fcst
+        ).daily_usage(suggested_forecast_df, 'AvgDailyUsage').fillna(0)
+        
+        df_max = DailyUsageFuture(
+            location=location,
+            column_forecast='SuggestedForecast',
+            date=date,
+            df_fcst=df_fcst
+        ).daily_usage(df_avg, 'MaxDailyUsage').fillna(0)
+        
+    except Exception as e:
+        print(f"   ❌ DailyUsageFuture error: {str(e)}")
+        print(f"   ❌ Error type: {type(e).__name__}")
+        
+        # Print more detailed error info
+        import traceback
+        print(f"   ❌ Full traceback:")
+        traceback.print_exc()
+        
+        # Re-raise the original error to maintain the error flow
+        raise e
     
     return df_avg, df_max
 
@@ -442,8 +747,29 @@ def _calculate_security_stock_data_complete(df_max, current_df_lead_time, defaul
     # Calculate SuggestedForecastPeriod
     if period_index == 0 and dates is not None and len(dates) > 1:
         # For period 0, use days to next period instead of reorder frequency
-        current_date = pd.to_datetime(dates[0], format='%Y%m%d')
-        next_date = pd.to_datetime(dates[1], format='%Y%m%d')
+        try:
+            # Validate dates array and indices
+            if len(dates) < 2:
+                raise ValueError(f"Insufficient dates for period 0 calculation: need at least 2 dates, got {len(dates)}")
+            
+            # Validate date formats before conversion
+            if not isinstance(dates[0], str) or len(dates[0]) != 8:
+                raise ValueError(f"Invalid dates[0] format: {repr(dates[0])} (expected 8-character string)")
+            if not isinstance(dates[1], str) or len(dates[1]) != 8:
+                raise ValueError(f"Invalid dates[1] format: {repr(dates[1])} (expected 8-character string)")
+            
+            current_date = pd.to_datetime(dates[0], format='%Y%m%d')
+            next_date = pd.to_datetime(dates[1], format='%Y%m%d')
+            
+        except Exception as e:
+            error_msg = f"_calculate_security_stock_data_complete: Date processing error - "
+            error_msg += f"dates[0]='{dates[0] if len(dates) > 0 else 'MISSING'}' "
+            error_msg += f"(type: {type(dates[0]) if len(dates) > 0 else 'N/A'}), "
+            error_msg += f"dates[1]='{dates[1] if len(dates) > 1 else 'MISSING'}' "
+            error_msg += f"(type: {type(dates[1]) if len(dates) > 1 else 'N/A'}), "
+            error_msg += f"period_index={period_index}, dates_length={len(dates)}, "
+            error_msg += f"original_error: {str(e)}"
+            raise ValueError(error_msg)
         days_to_next_period = (next_date - current_date).days
         
         # Formula: SuggestedForecast × (days_to_next_period / coverage)
@@ -509,7 +835,10 @@ def _prepare_transit_schedule_complete(key, transit_amount, dates, df_transit, l
     if df_transit is None:
         # Default logic: complete transit arrives in period 1
         if len(dates) > 1:
-            arrival_date = pd.to_datetime(dates[1], format='%Y%m%d')
+            try:
+                arrival_date = pd.to_datetime(dates[1], format='%Y%m%d')
+            except Exception as e:
+                raise ValueError(f"_prepare_transit_schedule_complete: Invalid date dates[1]='{dates[1]}' - {str(e)}")
             transit_schedule.append({
                 'quantity': transit_amount,
                 'arrival_date': arrival_date
@@ -540,7 +869,10 @@ def _prepare_transit_schedule_complete(key, transit_amount, dates, df_transit, l
         else:
             # If no transit data provided for this item, use default logic
             if len(dates) > 1:
-                arrival_date = pd.to_datetime(dates[1], format='%Y%m%d')
+                try:
+                    arrival_date = pd.to_datetime(dates[1], format='%Y%m%d')
+                except Exception as e:
+                    raise ValueError(f"_prepare_transit_schedule_complete: Invalid fallback date dates[1]='{dates[1]}' - {str(e)}")
                 transit_schedule.append({
                     'quantity': transit_amount,
                     'arrival_date': arrival_date
@@ -648,8 +980,30 @@ def _process_future_period_complete(current_df_inv, df_sstock, df_previous, key,
     previous_stock = df_previous['FutureInventory'].iloc[0] - consumption
     
     # Process transit orders - EXACTLY like future_reorder_optimized line 467-473
-    current_date = pd.to_datetime(date, format='%Y%m%d')
-    previous_date = pd.to_datetime(dates[i-1], format='%Y%m%d')
+    try:
+        # Validate indices before accessing dates array
+        if i <= 0:
+            raise ValueError(f"Invalid period index {i} for future period processing (must be > 0)")
+        if i-1 >= len(dates):
+            raise ValueError(f"Previous period index {i-1} is out of bounds for dates array of length {len(dates)}")
+        
+        # Validate date values before conversion
+        if not isinstance(date, str) or len(date) != 8:
+            raise ValueError(f"Invalid current date format: {repr(date)} (expected 8-character string)")
+        if not isinstance(dates[i-1], str) or len(dates[i-1]) != 8:
+            raise ValueError(f"Invalid previous date format: {repr(dates[i-1])} (expected 8-character string)")
+        
+        current_date = pd.to_datetime(date, format='%Y%m%d')
+        previous_date = pd.to_datetime(dates[i-1], format='%Y%m%d')
+        
+    except Exception as e:
+        error_msg = f"_process_future_period_complete: Date processing error - "
+        error_msg += f"current='{date}' (type: {type(date)}), "
+        error_msg += f"previous='{dates[i-1] if i-1 < len(dates) else 'INDEX_OUT_OF_BOUNDS'}' "
+        error_msg += f"(type: {type(dates[i-1]) if i-1 < len(dates) else 'N/A'}), "
+        error_msg += f"period_index={i}, dates_length={len(dates)}, "
+        error_msg += f"original_error: {str(e)}"
+        raise ValueError(error_msg)
     
     stock_from_arrivals, new_transit, transit_arrivals = _process_transit_orders_complete(
         transit_orders, key, current_date, previous_date
@@ -712,12 +1066,38 @@ class FutureReorder():
     """
     Versión completa optimizada para procesamiento masivo de datasets grandes.
     Incluye TODA la funcionalidad de la clase original pero optimizada para paralelización.
+    
+    Nueva funcionalidad period2:
+    - period2 controla el número de períodos para ítems con ReorderFreq <= 20
+    - periods controla el número de períodos para ítems con ReorderFreq > 20
+    - Esto permite reducir el número de resultados para ítems con frecuencias de reorden pequeñas
     """
 
     def __init__(self, df_inv, df_lead_time, df_prep, df_fcst, periods, start_date,
                  location=False, security_stock_ref=False, df_transit=None, integer=True,
                  complete_suggested=False, start_date_zero=None, batch_size=None, n_workers=None,
-                 verbose=True):
+                 verbose=True, period2=2):
+        """
+        Initialize FutureReorder with enhanced period control.
+        
+        Args:
+            df_inv: Inventory DataFrame
+            df_lead_time: Lead time DataFrame
+            df_prep: Preparation DataFrame
+            df_fcst: Forecast DataFrame
+            periods: Number of periods for items with ReorderFreq > 20
+            start_date: Start date for calculations
+            location: Boolean for location-based processing
+            security_stock_ref: Boolean for reference-based security stock
+            df_transit: Transit DataFrame (optional)
+            integer: Boolean for integer formatting
+            complete_suggested: Boolean for complete suggested forecast mode
+            start_date_zero: Custom start date for period 0
+            batch_size: Batch size for parallel processing (auto-configured if None)
+            n_workers: Number of workers for parallel processing (auto-configured if None)
+            verbose: Boolean for detailed logging
+            period2: Number of periods for items with ReorderFreq <= 20 (default: 2)
+        """
         
         # Original parameters - TODOS los parámetros de la clase original
         self.df_inv = df_inv
@@ -726,6 +1106,7 @@ class FutureReorder():
         self.df_fcst = df_fcst
         self.default_coverage = 30
         self.periods = periods
+        self.period2 = period2
         self.start_date = pd.to_datetime(start_date, format='%Y-%m-%d') if start_date is not None else None
         self.location = location
         self.security_stock_ref = security_stock_ref
@@ -785,7 +1166,7 @@ class FutureReorder():
                 'df_fcst': len(self.df_fcst),
                 'df_transit': len(self.df_transit) if self.df_transit is not None else 0
             }
-            self._log("🔍 Pre-filtering dataframes based on df_inv...")
+            self._log("📊 Pre-filtering dataframes based on df_inv...")
         
         # Create base filter from df_inv
         if self.location:
@@ -967,16 +1348,26 @@ class FutureReorder():
         
         return item_dates
 
-    def _prepare_batch_data(self, item_dates):
-        """Prepara datos por lotes de manera eficiente. Replicates exactly the logic from future_reorder_optimized."""
+    def _prepare_batch_data(self):
+        """
+        Prepara datos por lotes de manera eficiente sin generar fechas pre-calculadas.
+        Las fechas se generarán localmente en cada worker process.
+        """
         batch_data = []
         
-        for key, dates in item_dates.items():
+        # Get unique items from df_inv
+        if self.location:
+            unique_items = self.df_inv[['Item', 'Location']].drop_duplicates()
+        else:
+            unique_items = self.df_inv[['Item']].drop_duplicates()
+        
+        for _, row in unique_items.iterrows():
             try:
-                # Get dataframes for this item - EXACTLY like future_reorder_optimized _get_current_dataframes_optimized
                 if self.location:
+                    key = (row['Item'], row['Location'])
                     item, location = key
                 else:
+                    key = row['Item']
                     item = key
                     location = None
                     
@@ -994,7 +1385,8 @@ class FutureReorder():
                 current_df_inv = self.df_inv[mask_inv]
                 
                 if not current_df_lead_time.empty and not current_df_inv.empty:
-                    batch_data.append((key, dates, current_df_lead_time, current_df_inv))
+                    # Only include key and dataframes, dates will be generated in worker
+                    batch_data.append((key, current_df_lead_time, current_df_inv))
                     
             except Exception as e:
                 if self.verbose:
@@ -1083,7 +1475,7 @@ class FutureReorder():
             last_date = unique_dates[-1]
             filtered_df = df[df['PurchaseDate_dt'] != last_date].copy()
             
-            self._log(f"🔍 Filtered periods (start_date=None): Only removed last period ({last_date.strftime('%Y-%m-%d')})")
+            self._log(f"📊 Filtered periods (start_date=None): Only removed last period ({last_date.strftime('%Y-%m-%d')})")
             
         else:
             # When start_date is specified, filter both first and last periods (original logic)
@@ -1099,7 +1491,7 @@ class FutureReorder():
                 (df['PurchaseDate_dt'] != last_date)
             ].copy()
             
-            self._log(f"🔍 Filtered periods: Removed period 0 ({first_date.strftime('%Y-%m-%d')}) and last period ({last_date.strftime('%Y-%m-%d')})")
+            self._log(f"📊 Filtered periods: Removed period 0 ({first_date.strftime('%Y-%m-%d')}) and last period ({last_date.strftime('%Y-%m-%d')})")
         
         # Drop the temporary datetime column
         filtered_df = filtered_df.drop('PurchaseDate_dt', axis=1)
@@ -1115,7 +1507,7 @@ class FutureReorder():
         large datasets efficiently through batching, multiprocessing, and optimized algorithms.
         
         Processing Pipeline:
-        1. Generate future dates based on reorder frequencies
+        1. Generate future dates based on reorder frequencies and period control
         2. Pre-filter and prepare data for batch processing
         3. Split items into optimally-sized batches
         4. Process batches in parallel using multiple CPU cores
@@ -1130,6 +1522,11 @@ class FutureReorder():
         - Implements intelligent error handling and recovery
         - Optimizes memory usage through efficient data structures
         
+        Period Control Logic:
+        - Items with ReorderFreq <= 20: Uses period2 (default: 2 periods)
+        - Items with ReorderFreq > 20: Uses periods parameter
+        - This reduces output volume for high-frequency reorder items
+        
         Period Filtering Logic:
         - When start_date=None: Only removes last period (keeps period 0 as current)
         - When start_date specified: Removes both period 0 and last period
@@ -1152,13 +1549,14 @@ class FutureReorder():
                 - Coverage parameters: ReorderFreq, Coverage
                 
         Example usage:
-            >>> reorder_system = FutureReorderMassiveComplete(
+            >>> reorder_system = FutureReorder(
             ...     df_inv=inventory_df,
             ...     df_lead_time=lead_time_df,
             ...     df_prep=prep_df,
             ...     df_fcst=forecast_df,
-            ...     periods=6,
+            ...     periods=6,        # For items with ReorderFreq > 20
             ...     start_date=None,  # Use current date
+            ...     period2=2,        # For items with ReorderFreq <= 20
             ...     batch_size=100,   # Optional: auto-configured if None
             ...     n_workers=4       # Optional: auto-configured if None
             ... )
@@ -1169,41 +1567,24 @@ class FutureReorder():
         
         self._log("🚀 FutureReorder Massive Complete - Processing Started")
         
-        # Generate future dates
-        self._log("📅 Generando fechas futuras...")
-        item_dates = self.future_date()
-        
-        if not item_dates:
-            columns = ['Date', 'Item'] + (['Location'] if self.location else [])
-            return pd.DataFrame(columns=columns)
-        
-        # Prepare batch data first to get accurate count of items that will actually be processed
-        batch_data = self._prepare_batch_data(item_dates)
+        # Prepare batch data without pre-generating dates
+        self._log("🔧 Preparando datos por lotes...")
+        batch_data = self._prepare_batch_data()
         
-        # Calculate accurate statistics based on items that will actually be processed
+        # Calculate statistics based on items that will be processed
         total_items = len(batch_data)
-        if batch_data:
-            # Get dates for items that will actually be processed
-            processed_item_dates = {item_data[0]: item_data[1] for item_data in batch_data}
-            avg_periods = np.mean([len(dates) for dates in processed_item_dates.values()])
-            total_calculations = sum(len(dates) for dates in processed_item_dates.values())
-        else:
-            avg_periods = 0
-            total_calculations = 0
         
         self._log(f"📊 Dataset Info:")
         self._log(f"   • Total Items: {total_items}")
-        self._log(f"   • Average Periods per Item: {avg_periods:.1f}")
-        self._log(f"   • Total Calculations: {total_calculations}")
+        self._log(f"   • Periods (ReorderFreq > 20): {self.periods}")
+        self._log(f"   • Period2 (ReorderFreq <= 20): {self.period2}")
+        self._log(f"   • Estimated Total Calculations: {total_items * self.periods}")
         
-        # batch_data already prepared above for accurate counting
         if not batch_data:
             self._log("⚠️  No items to process after filtering")
             columns = ['Date', 'Item'] + (['Location'] if self.location else [])
             return pd.DataFrame(columns=columns)
         
-        self._log("🔧 Datos preparados por lotes...")
-        
         # Split into batches for parallel processing
         batches = []
         for i in range(0, len(batch_data), self.batch_size):
@@ -1211,7 +1592,9 @@ class FutureReorder():
             batch_args = (
                 batch, self.df_fcst, self.df_prep, self.metadata,
                 self.location, self.default_coverage, self.complete_suggested,
-                self.security_stock_ref, self.integer, self.verbose, self.df_transit
+                self.security_stock_ref, self.integer, self.verbose, self.df_transit,
+                self.periods, self.period2, self.start_date.strftime('%Y-%m-%d') if self.start_date else None,
+                self.start_date_zero
             )
             batches.append(batch_args)
         

{datupapi-1.112.0 → datupapi-1.112.1}/datupapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datupapi
-Version: 1.112.0
+Version: 1.112.1
 Summary: Utility library to support Datup AI MLOps processes
 Author: Datup AI
 Author-email: ramiro@datup.ai

{datupapi-1.112.0 → datupapi-1.112.1}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 setup(name='datupapi',
-      version='1.112.0',
+      version='1.112.1',
       description='Utility library to support Datup AI MLOps processes',
       long_description_content_type="text/markdown",
       long_description="foo bar baz",