kishorkukreja/awesome-supply-chain/order-fulfillment

import numpy as np
import pandas as pd
def discrete_picking_capacity(orders_per_day, lines_per_order,
                              pick_rate_per_hour=100,
                              working_hours=8):
    """
    Calculate labor requirements for discrete picking
    Parameters:
    - orders_per_day: Daily order volume
    - lines_per_order: Average lines per order
    - pick_rate_per_hour: Picks per person per hour (includes travel)
    - working_hours: Working hours per shift
    """
    picks_per_day = orders_per_day * lines_per_order
    # Labor hours needed
    labor_hours_needed = picks_per_day / pick_rate_per_hour
    # Pickers needed
    pickers_needed = labor_hours_needed / working_hours
    # Orders per picker per day
    orders_per_picker = orders_per_day / pickers_needed
    return {
        'picks_per_day': picks_per_day,
        'labor_hours_needed': round(labor_hours_needed, 1),
        'pickers_needed': round(pickers_needed, 1),
        'orders_per_picker_per_day': round(orders_per_picker, 0),
        'picks_per_picker_per_hour': pick_rate_per_hour
    }
# Example
discrete = discrete_picking_capacity(
    orders_per_day=500,
    lines_per_order=5,
    pick_rate_per_hour=100,
    working_hours=8
)
print(f"Pickers needed: {discrete['pickers_needed']}")
print(f"Orders per picker: {discrete['orders_per_picker_per_day']}")

def batch_picking_optimization(orders_df, batch_size=10, sort_time_per_unit=3):
    """
    Optimize batch picking
    Parameters:
    - orders_df: DataFrame with columns ['order_id', 'sku', 'quantity', 'location']
    - batch_size: Orders per batch
    - sort_time_per_unit: Seconds to sort each unit to order
    Returns:
    - Batch assignments and performance metrics
    """
    # Create batches
    orders_df = orders_df.copy()
    orders_df['batch'] = (orders_df.index // batch_size) + 1
    # Calculate picks per batch
    batch_summary = orders_df.groupby('batch').agg({
        'order_id': 'nunique',
        'sku': 'count',
        'quantity': 'sum',
        'location': 'nunique'
    }).rename(columns={
        'order_id': 'orders',
        'sku': 'pick_lines',
        'location': 'unique_locations'
    })
    # Estimate time savings
    # Discrete: visit each location for each order
    # Batch: visit each location once per batch
    discrete_picks = len(orders_df)
    batch_picks = batch_summary['unique_locations'].sum()
    pick_reduction_pct = (discrete_picks - batch_picks) / discrete_picks
    # Sort time required
    total_units = batch_summary['quantity'].sum()
    sort_time_hours = (total_units * sort_time_per_unit) / 3600
    return {
        'total_batches': len(batch_summary),
        'avg_orders_per_batch': batch_summary['orders'].mean(),
        'discrete_picks': discrete_picks,
        'batch_picks': batch_picks,
        'pick_reduction_%': round(pick_reduction_pct * 100, 1),
        'sort_time_hours': round(sort_time_hours, 2),
        'batch_summary': batch_summary
    }
# Example
orders_df = pd.DataFrame({
    'order_id': [f'ORD_{i}' for i in range(1, 101)],
    'sku': np.random.choice(['SKU_A', 'SKU_B', 'SKU_C', 'SKU_D'], 100),
    'quantity': np.random.randint(1, 5, 100),
    'location': np.random.choice(['A1', 'A2', 'B1', 'B2', 'C1'], 100)
})
batch_result = batch_picking_optimization(orders_df, batch_size=10)
print(f"Pick reduction: {batch_result['pick_reduction_%']}%")
print(f"Sort time required: {batch_result['sort_time_hours']} hours")

def zone_picking_design(warehouse_sq_ft, num_pickers, orders_per_day,
                       lines_per_order, sku_distribution):
    """
    Design zone picking system
    Parameters:
    - warehouse_sq_ft: Total picking area
    - num_pickers: Available pickers
    - orders_per_day: Daily order volume
    - lines_per_order: Average lines per order
    - sku_distribution: Dict with zone: % of picks
    """
    picks_per_day = orders_per_day * lines_per_order
    # Allocate zones based on pick volume
    zone_allocation = {}
    for zone, pct in sku_distribution.items():
        picks_in_zone = picks_per_day * pct
        pickers_needed = picks_in_zone / (100 * 8)  # 100 picks/hr, 8 hrs
        zone_allocation[zone] = {
            'pick_volume': round(picks_in_zone, 0),
            'pickers_needed': round(pickers_needed, 1),
            'sq_ft': round(warehouse_sq_ft * pct, 0)
        }
    return zone_allocation
# Example
sku_dist = {
    'Zone_A_Fast': 0.40,  # 40% of picks
    'Zone_B_Medium': 0.35,
    'Zone_C_Slow': 0.25
}
zones = zone_picking_design(
    warehouse_sq_ft=50000,
    num_pickers=20,
    orders_per_day=2000,
    lines_per_order=5,
    sku_distribution=sku_dist
)
print("Zone Allocation:")
for zone, data in zones.items():
    print(f"\n  {zone}:")
    print(f"    Pick volume: {data['pick_volume']}")
    print(f"    Pickers needed: {data['pickers_needed']}")
    print(f"    Square footage: {data['sq_ft']}")

def wave_planning(orders_df, waves_per_day=4, target_wave_size=500):
    """
    Plan picking waves
    Parameters:
    - orders_df: DataFrame with ['order_id', 'priority', 'lines', 'carrier', 'cutoff_time']
    - waves_per_day: Number of waves per day
    - target_wave_size: Target orders per wave
    Returns:
    - Wave assignments
    """
    orders_df = orders_df.copy()
    # Sort by priority and cutoff time
    orders_df = orders_df.sort_values(['priority', 'cutoff_time'], ascending=[False, True])
    # Assign to waves
    orders_df['wave'] = (orders_df.index // target_wave_size) % waves_per_day + 1
    # Wave summary
    wave_summary = orders_df.groupby('wave').agg({
        'order_id': 'count',
        'lines': 'sum',
        'cutoff_time': 'max'
    }).rename(columns={
        'order_id': 'orders',
        'lines': 'total_picks'
    })
    # Estimate time required per wave
    wave_summary['pick_hours'] = wave_summary['total_picks'] / 100  # 100 picks/hr
    wave_summary['pickers_needed'] = np.ceil(wave_summary['pick_hours'] / 2)  # 2 hr wave
    return orders_df[['order_id', 'wave', 'priority']], wave_summary
# Example
orders_data = pd.DataFrame({
    'order_id': [f'ORD_{i}' for i in range(1, 2001)],
    'priority': np.random.choice([1, 2, 3], 2000, p=[0.1, 0.3, 0.6]),
    'lines': np.random.poisson(5, 2000),
    'carrier': np.random.choice(['UPS', 'FedEx', 'USPS'], 2000),
    'cutoff_time': np.random.choice(['12:00', '15:00', '17:00'], 2000)
})
wave_assignments, wave_summary = wave_planning(orders_data, waves_per_day=4)
print("Wave Summary:")
print(wave_summary)

def calculate_pick_path_distance(pick_locations, aisle_length_ft=100,
                                aisle_width_ft=10, routing='s-shape'):
    """
    Calculate travel distance for pick path
    Parameters:
    - pick_locations: List of tuples [(aisle, position_pct), ...]
    - aisle_length_ft: Length of aisle
    - aisle_width_ft: Width between aisles
    - routing: 's-shape', 'return', 'largest-gap'
    Returns:
    - Total travel distance
    """