Full Price → First Markdown (10-25%) → Second Markdown (30-50%) →
Final Clearance (50-75%) → Liquidation/Donation

import numpy as np
import pandas as pd
from scipy.optimize import minimize
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

class PriceElasticityAnalyzer:
    """
    Analyze price elasticity of demand for markdown optimization

    Measure how demand changes with price reductions
    """

    def __init__(self, historical_pricing_data):
        """
        Parameters:
        - historical_pricing_data: DataFrame with historical price/sales
          columns: ['sku', 'date', 'price', 'units_sold', 'original_price']
        """
        self.data = historical_pricing_data

    def calculate_price_elasticity(self, sku):
        """
        Calculate price elasticity of demand

        Elasticity = % change in quantity / % change in price

        E > 1: Elastic (demand very sensitive to price)
        E = 1: Unit elastic
        E < 1: Inelastic (demand not very sensitive)
        """

        sku_data = self.data[self.data['sku'] == sku].copy()

        if len(sku_data) < 10:
            return {'error': 'Insufficient data', 'elasticity': None}

        # Calculate discount percentage
        sku_data['discount_pct'] = (
            (sku_data['original_price'] - sku_data['price']) /
            sku_data['original_price'] * 100
        )

        # Log transformation for elasticity calculation
        sku_data['log_price'] = np.log(sku_data['price'])
        sku_data['log_quantity'] = np.log(sku_data['units_sold'] + 1)

        # Linear regression: log(Q) = a + b * log(P)
        # b is the price elasticity
        X = sku_data[['log_price']].values
        y = sku_data['log_quantity'].values

        model = LinearRegression()
        model.fit(X, y)

        elasticity = model.coef_[0]
        r_squared = model.score(X, y)

        return {
            'sku': sku,
            'elasticity': abs(elasticity),  # Report as positive
            'r_squared': r_squared,
            'interpretation': self._interpret_elasticity(abs(elasticity)),
            'model': model
        }

    def _interpret_elasticity(self, elasticity):
        """Interpret elasticity value"""

        if elasticity > 2:
            return 'Highly elastic - very price sensitive'
        elif elasticity > 1:
            return 'Elastic - price sensitive'
        elif elasticity > 0.5:
            return 'Moderately elastic'
        else:
            return 'Inelastic - not very price sensitive'

    def estimate_demand_at_price(self, sku, target_price):
        """
        Estimate demand at a specific price point

        Uses fitted elasticity model
        """

        elasticity_result = self.calculate_price_elasticity(sku)

        if elasticity_result.get('error'):
            return None

        model = elasticity_result['model']
        log_price = np.log(target_price)

        log_quantity_pred = model.predict([[log_price]])[0]
        estimated_quantity = np.exp(log_quantity_pred) - 1

        return max(0, estimated_quantity)

    def find_optimal_markdown(self, sku, cost, current_price, current_inventory,
                             weeks_remaining=8):
        """
        Find optimal markdown to maximize revenue recovery

        Balances:
        - Higher prices = higher margin but slower sell-through
        - Lower prices = faster sell-through but lower margin
        """

        elasticity_result = self.calculate_price_elasticity(sku)

        if elasticity_result.get('error'):
            return {'error': 'Cannot optimize without elasticity data'}

        # Test different price points
        price_range = np.linspace(cost * 1.1, current_price, 20)  # Don't go below cost
        results = []

        for test_price in price_range:
            # Estimate weekly demand at this price
            estimated_weekly_demand = self.estimate_demand_at_price(sku, test_price)

            # Estimate total units sold over remaining weeks
            estimated_total_sold = min(
                estimated_weekly_demand * weeks_remaining,
                current_inventory
            )

            # Calculate revenue
            revenue = estimated_total_sold * test_price

            # Calculate margin
            margin = test_price - cost
            margin_pct = margin / test_price * 100 if test_price > 0 else 0

            # Calculate weeks to sell out
            if estimated_weekly_demand > 0:
                weeks_to_sellout = current_inventory / estimated_weekly_demand
            else:
                weeks_to_sellout = 999

            results.append({
                'price': test_price,
                'discount_pct': (current_price - test_price) / current_price * 100,
                'estimated_weekly_demand': estimated_weekly_demand,
                'estimated_total_sold': estimated_total_sold,
                'revenue': revenue,
                'margin_pct': margin_pct,
                'weeks_to_sellout': weeks_to_sellout
            })

        results_df = pd.DataFrame(results)

        # Find optimal price (maximize revenue)
        optimal_idx = results_df['revenue'].idxmax()
        optimal = results_df.iloc[optimal_idx]

        return {
            'current_price': current_price,
            'optimal_price': optimal['price'],
            'recommended_discount': optimal['discount_pct'],
            'expected_revenue': optimal['revenue'],
            'expected_sellthrough': optimal['estimated_total_sold'] / current_inventory * 100,
            'weeks_to_sellout': optimal['weeks_to_sellout'],
            'all_scenarios': results_df
        }

# Demand increases as price decreases (elasticity ~1.5)
base_demand = 20
price_factor = (base_price / price) ** 1.5
units_sold = base_demand * price_factor + np.random.normal(0, 5)
units_sold = max(0, units_sold)

historical_data.append({
    'sku': 'SKU123',
    'date': dates[week],
    'price': price,
    'units_sold': units_sold,
    'original_price': base_price
})

---

class MarkdownScheduler:
    """
    Optimize markdown timing to maximize revenue recovery

    Decides when to markdown based on:
    - Current sell-through rate
    - Time remaining in season
    - Inventory level
    - Competitive pressure
    """

    def __init__(self, season_end_date, current_date):
        self.season_end = pd.to_datetime(season_end_date)
        self.current_date = pd.to_datetime(current_date)
        self.weeks_remaining = (self.season_end - self.current_date).days / 7

    def calculate_sell_through_rate(self, units_sold, initial_inventory, weeks_elapsed):
        """
        Calculate sell-through rate (STR)

        STR = units sold / initial inventory
        Weekly STR = STR / weeks
        """

        if initial_inventory == 0:
            return 0

        str_total = units_sold / initial_inventory * 100
        str_weekly = str_total / weeks_elapsed if weeks_elapsed > 0 else 0

        return {
            'total_str': str_total,
            'weekly_str': str_weekly,
            'units_sold': units_sold,
            'initial_inventory': initial_inventory
        }

    def should_markdown(self, sku_data):
        """
        Decide if SKU should be marked down now

        Factors:
        - Sell-through rate below target
        - Weeks of supply too high
        - End of season approaching
        """

        current_inventory = sku_data['current_inventory']
        weekly_sales_rate = sku_data['weekly_sales_rate']
        target_str = sku_data.get('target_str', 70)  # Target 70% sell-through

        # Calculate current trajectory
        projected_str = (weekly_sales_rate * self.weeks_remaining) / sku_data['initial_inventory'] * 100

        # Calculate weeks of supply
        if weekly_sales_rate > 0:
            weeks_of_supply = current_inventory / weekly_sales_rate
        else:
            weeks_of_supply = 999

        # Decision rules
        reasons = []
        should_md = False

        # Rule 1: Projected sell-through below target
        if projected_str < target_str:
            should_md = True
            reasons.append(f"Projected STR ({projected_str:.1f}%) below target ({target_str}%)")

        # Rule 2: Excessive weeks of supply
        if weeks_of_supply > self.weeks_remaining * 1.5:
            should_md = True
            reasons.append(f"Weeks of supply ({weeks_of_supply:.1f}) exceeds season ({self.weeks_remaining:.1f})")

        # Rule 3: End of season urgency
        if self.weeks_remaining < 4 and projected_str < 80:
            should_md = True
            reasons.append(f"Season ending soon ({self.weeks_remaining:.1f} weeks) with low STR")

        # Rule 4: No sales momentum
        if weekly_sales_rate < sku_data['initial_inventory'] * 0.01:  # <1% per week
            should_md = True
            reasons.append("Very slow sales rate")

        return {
            'should_markdown': should_md,
            'reasons': reasons,
            'projected_str': projected_str,
            'weeks_of_supply': weeks_of_supply,
            'weeks_remaining': self.weeks_remaining,
            'urgency': 'High' if self.weeks_remaining < 4 else 'Medium' if self.weeks_remaining < 8 else 'Low'
        }

    def recommend_markdown_depth(self, sku_data):
        """
        Recommend markdown percentage

        Deeper discounts for:
        - Lower sell-through
        - More weeks of supply
        - End of season
        - Low price elasticity (need big discount to move)
        """

        decision = self.should_markdown(sku_data)

        if not decision['should_markdown']:
            return {
                'recommended_markdown': 0,
                'reason': 'On track, no markdown needed'
            }

        weeks_of_supply = decision['weeks_of_supply']
        projected_str = decision['projected_str']
        elasticity = sku_data.get('price_elasticity', 1.0)

        # Base markdown on severity
        if projected_str < 40 or weeks_of_supply > 20:
            base_markdown = 50  # Aggressive
        elif projected_str < 55 or weeks_of_supply > 15:
            base_markdown = 30  # Moderate
        else:
            base_markdown = 20  # Conservative

        # Adjust for elasticity
        if elasticity < 0.8:  # Inelastic
            base_markdown *= 1.3  # Need bigger discount
        elif elasticity > 1.5:  # Elastic
            base_markdown *= 0.8  # Smaller discount works

        # Adjust for urgency
        if self.weeks_remaining < 3:
            base_markdown *= 1.4

        # Round to standard increments
        markdown_increments = [10, 20, 25, 30, 40, 50, 60, 70]
        recommended_markdown = min(markdown_increments, key=lambda x: abs(x - base_markdown))

        return {
            'recommended_markdown': recommended_markdown,
            'reason': f"Projected STR {projected_str:.1f}%, {weeks_of_supply:.1f} weeks supply",
            'urgency': decision['urgency']
        }

    def create_markdown_cadence(self, sku_data, markdown_stages=[20, 40, 60]):
        """
        Create multi-stage markdown plan

        Progressive markdowns over time
        """

        weeks_left = self.weeks_remaining
        cadence = []

        # Determine if we need aggressive or conservative cadence
        decision = self.should_markdown(sku_data)

        if decision['urgency'] == 'High':
            # Fast cadence - markdown every 1-2 weeks
            week_intervals = [0, 1, 3]
        elif decision['urgency'] == 'Medium':
            # Moderate cadence - markdown every 2-3 weeks
            week_intervals = [0, 2, 5]
        else:
            # Slow cadence - markdown every 3-4 weeks
            week_intervals = [0, 3, 7]

        for i, (markdown_pct, week_offset) in enumerate(zip(markdown_stages, week_intervals)):
            if week_offset < weeks_left:
                markdown_date = self.current_date + pd.Timedelta(weeks=week_offset)

                cadence.append({
                    'stage': i + 1,
                    'markdown_date': markdown_date,
                    'markdown_pct': markdown_pct,
                    'price': sku_data['original_price'] * (1 - markdown_pct/100),
                    'weeks_from_now': week_offset
                })

        return cadence

---

from scipy.optimize import minimize, LinearConstraint

class MarkdownOptimizer:
    """
    Optimize markdowns across multiple SKUs

    Maximize total revenue while meeting clearance targets
    """

    def __init__(self, skus_data, constraints):
        """
        Parameters:
        - skus_data: DataFrame with SKU information
          columns: ['sku', 'inventory', 'cost', 'current_price', 'elasticity',
                   'weekly_demand_base']
        - constraints: Dict with budget/target constraints
        """
        self.skus = skus_data
        self.constraints = constraints

    def estimate_demand_at_discount(self, base_demand, elasticity, discount_pct):
        """
        Estimate demand at a given discount level

        Uses price elasticity to project demand lift
        """

        # Demand increases as price decreases
        # New_Demand = Base_Demand * (1 / (1 - discount))^elasticity
        if discount_pct >= 100:
            return base_demand * 10  # Arbitrary large number

        price_ratio = 1 / (1 - discount_pct/100)
        demand_multiplier = price_ratio ** elasticity

        return base_demand * demand_multiplier

    def calculate_revenue(self, discount_percentages):
        """
        Calculate total revenue for given discount strategy

        Parameters:
        - discount_percentages: Array of discount % for each SKU
        """

        total_revenue = 0

        for i, row in self.skus.iterrows():
            discount_pct = discount_percentages[i]

            # New price after discount
            new_price = row['current_price'] * (1 - discount_pct/100)

            # Estimated demand at this price
            estimated_demand = self.estimate_demand_at_discount(
                row['weekly_demand_base'],
                row['elasticity'],
                discount_pct
            )

            # Units sold (capped at inventory)
            units_sold = min(estimated_demand * 8, row['inventory'])  # 8 weeks

            # Revenue
            revenue = units_sold * new_price

            total_revenue += revenue

        return total_revenue

    def optimize_markdowns(self, max_avg_discount=40, min_clearance_rate=70):
        """
        Find optimal markdown strategy

        Constraints:
        - Average discount across SKUs <= max_avg_discount
        - Achieve min_clearance_rate sell-through
        """

        n_skus = len(self.skus)

        # Objective: Maximize revenue (minimize negative revenue)
        def objective(discounts):
            return -self.calculate_revenue(discounts)

        # Constraints
        constraints_list = []

        # Constraint 1: Average discount <= max
        def avg_discount_constraint(discounts):
            return max_avg_discount - np.mean(discounts)

        constraints_list.append({
            'type': 'ineq',
            'fun': avg_discount_constraint
        })

        # Constraint 2: Achieve minimum clearance rate
        def clearance_constraint(discounts):
            total_cleared = 0
            total_inventory = 0

            for i, row in self.skus.iterrows():
                discount_pct = discounts[i]
                new_price = row['current_price'] * (1 - discount_pct/100)

                estimated_demand = self.estimate_demand_at_discount(
                    row['weekly_demand_base'],
                    row['elasticity'],
                    discount_pct
                )

                units_sold = min(estimated_demand * 8, row['inventory'])
                total_cleared += units_sold
                total_inventory += row['inventory']

            clearance_rate = total_cleared / total_inventory * 100
            return clearance_rate - min_clearance_rate

        constraints_list.append({
            'type': 'ineq',
            'fun': clearance_constraint
        })

        # Bounds: 0% to 70% discount
        bounds = [(0, 70) for _ in range(n_skus)]

        # Initial guess: uniform discount
        x0 = np.full(n_skus, 30.0)

        # Optimize
        result = minimize(
            objective,
            x0,
            method='SLSQP',
            bounds=bounds,
            constraints=constraints_list
        )

        optimal_discounts = result.x

        # Calculate results
        results = []
        for i, row in self.skus.iterrows():
            discount = optimal_discounts[i]
            new_price = row['current_price'] * (1 - discount/100)

            estimated_demand = self.estimate_demand_at_discount(
                row['weekly_demand_base'],
                row['elasticity'],
                discount
            )

            units_sold = min(estimated_demand * 8, row['inventory'])
            revenue = units_sold * new_price
            clearance_rate = units_sold / row['inventory'] * 100

            results.append({
                'sku': row['sku'],
                'current_price': row['current_price'],
                'optimal_discount': discount,
                'new_price': new_price,
                'estimated_units_sold': units_sold,
                'revenue': revenue,
                'clearance_rate': clearance_rate
            })

        results_df = pd.DataFrame(results)

        return results_df, result

---

class StoreMarkdownManager:
    """
    Manage store-level markdown decisions

    Some stores need different markdown strategies than others
    """

    def __init__(self, stores_data):
        self.stores = stores_data

    def should_markdown_locally(self, sku, store_id, chain_markdown_pct=0):
        """
        Decide if store should markdown locally vs. follow chain

        Factors:
        - Local inventory level (excess?)
        - Local sell-through performance
        - Local competitive pressure
        """

        store = self.stores[self.stores['store_id'] == store_id].iloc[0]

        # Get SKU-specific data at store
        sku_inventory = store.get(f'{sku}_inventory', 0)
        sku_weekly_sales = store.get(f'{sku}_weekly_sales', 0)
        weeks_of_supply = sku_inventory / sku_weekly_sales if sku_weekly_sales > 0 else 999

        # Decision criteria
        local_markdown_needed = False
        reasons = []

        # Criterion 1: Excessive local inventory
        chain_avg_wos = 8  # Example chain average
        if weeks_of_supply > chain_avg_wos * 1.5:
            local_markdown_needed = True
            reasons.append(f"Excess inventory: {weeks_of_supply:.1f} weeks (chain avg: {chain_avg_wos})")

        # Criterion 2: Poor local performance
        chain_avg_str = 65  # Example
        local_str = store.get(f'{sku}_str', 50)
        if local_str < chain_avg_str * 0.8:
            local_markdown_needed = True
            reasons.append(f"Low STR: {local_str:.1f}% (chain avg: {chain_avg_str}%)")

        # Criterion 3: Competitive pressure
        if store.get('high_competition', False):
            local_markdown_needed = True
            reasons.append("High local competitive pressure")

        # Recommend local markdown depth
        if local_markdown_needed:
            # Go deeper than chain markdown
            recommended_markdown = max(chain_markdown_pct + 10, 30)
        else:
            # Follow chain markdown
            recommended_markdown = chain_markdown_pct

        return {
            'local_markdown_needed': local_markdown_needed,
            'reasons': reasons,
            'recommended_markdown': recommended_markdown,
            'weeks_of_supply': weeks_of_supply,
            'follow_chain': not local_markdown_needed
        }

    def identify_stores_for_clearance_transfer(self, sku, min_inventory=50):
        """
        Identify stores with excess inventory to transfer to outlet/clearance stores

        Better than heavy markdowns in regular stores
        """

        stores_with_excess = []

        for idx, store in self.stores.iterrows():
            sku_inventory = store.get(f'{sku}_inventory', 0)
            sku_weekly_sales = store.get(f'{sku}_weekly_sales', 0.1)

            if sku_inventory > min_inventory:
                weeks_of_supply = sku_inventory / sku_weekly_sales

                if weeks_of_supply > 15:  # Way too much
                    stores_with_excess.append({
                        'store_id': store['store_id'],
                        'inventory': sku_inventory,
                        'weeks_of_supply': weeks_of_supply,
                        'recommended_transfer_qty': int(sku_inventory * 0.5)  # Transfer half
                    })

        return pd.DataFrame(stores_with_excess)

---