Before you tackle a full challenge, it's important to recap the key concepts you'll need. **Moving average forecasting** is a simple but powerful technique where you predict future demand by averaging actual demand over a fixed window of previous days. This helps smooth out fluctuations and provides a reasonable short-term forecast. In **inventory simulation**, you track how stock levels change over time, considering daily demand and replenishment rules. A common approach is to set a **reorder point**: when inventory drops below this threshold, you replenish up to a desired level. By combining forecasting and inventory simulation, you can better anticipate stockouts and optimize replenishment decisions.

# Example list of daily demand values (30 days)
daily_demand = [
    20, 22, 19, 23, 25, 18, 20, 24, 21, 19, 22, 20, 23, 21, 18,
    20, 25, 22, 19, 21, 24, 23, 22, 20, 18, 19, 21, 23, 20, 22
]

# Initial inventory parameters
initial_stock = 50
replenishment_quantity = 40
window_size = 3  # For moving average forecast
# Reorder point will be calculated in the challenge


For this challenge, you will use the provided daily demand list and inventory parameters to build a complete forecasting and inventory management workflow. Start by implementing a moving average forecast using the specified window size. For each day after the initial window, calculate the average of the preceding days to produce the forecasted demand. Next, simulate inventory levels: begin with the initial stock, subtract daily demand, and whenever the inventory falls below the reorder point, replenish by the fixed quantity. The reorder point should be calculated as the average demand over the moving average window, multiplied by the window size. Throughout the 30-day period, keep track of both actual and forecasted demand, inventory levels, and any days when a stockout (inventory dropping below zero) occurs. Finally, visualize the actual and forecasted demand as well as the inventory levels on a line plot, and print a summary listing all days when stockouts happened.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io
import matplotlib
matplotlib.use('Agg')

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.user_code = user_code
        self.daily_demand = [
            20, 22, 19, 23, 25, 18, 20, 24, 21, 19, 22, 20, 23, 21, 18,
            20, 25, 22, 19, 21, 24, 23, 22, 20, 18, 19, 21, 23, 20, 22
        ]
        self.window_size = 3
        self.initial_stock = 50
        self.replenishment_quantity = 40

    def test_moving_average_forecast(self):
        importlib.reload(self.user_code)
        func = getattr(self.user_code, 'moving_average_forecast', None)
        _dynamic_test(
            self,
            callable(func),
            "moving_average_forecast is defined and callable",
            "moving_average_forecast is missing or not callable",
        )
        forecast = func(self.daily_demand, self.window_size) if callable(func) else None
        expected = [None, None, None, (20+22+19)/3, (22+19+23)/3, (19+23+25)/3, (23+25+18)/3, (25+18+20)/3, (18+20+24)/3, (20+24+21)/3, (24+21+19)/3, (21+19+22)/3, (19+22+20)/3, (22+20+23)/3, (20+23+21)/3, (23+21+18)/3, (21+18+20)/3, (18+20+25)/3, (20+25+22)/3, (25+22+19)/3, (22+19+21)/3, (19+21+24)/3, (21+24+23)/3, (24+23+22)/3, (23+22+20)/3, (22+20+18)/3, (20+18+19)/3, (18+19+21)/3, (19+21+23)/3, (21+23+20)/3, (23+20+22)/3]
        _dynamic_test(
            self,
            isinstance(forecast, list) and len(forecast) == len(self.daily_demand),
            "Forecast list has correct length",
            f"Forecast list length incorrect: got {len(forecast) if forecast else None}",
        )
        _dynamic_test(
            self,
            forecast[:self.window_size] == [None]*self.window_size,
            f"First {self.window_size} values are None",
            f"First {self.window_size} values are not None: {forecast[:self.window_size]}",
        )
        # Check a few forecast values with rounding for floating point tolerance
        for i in [3, 10, 20, 29]:
            if forecast[i] is not None:
                _dynamic_test(
                    self,
                    abs(forecast[i] - expected[i]) < 1e-6,
                    f"Forecast value at day {i+1} correct",
                    f"Forecast value at day {i+1} incorrect: expected {expected[i]}, got {forecast[i]}",
                )

    def test_calculate_reorder_point(self):
        importlib.reload(self.user_code)
        func = getattr(self.user_code, 'calculate_reorder_point', None)
        _dynamic_test(
            self,
            callable(func),
            "calculate_reorder_point is defined and callable",
            "calculate_reorder_point is missing or not callable",
        )
        value = func(self.daily_demand, self.window_size) if callable(func) else None
        expected_avg = sum(self.daily_demand[:self.window_size]) / self.window_size
        expected_reorder = expected_avg * self.window_size
        _dynamic_test(
            self,
            isinstance(value, (int, float)) and abs(value - expected_reorder) < 1e-6,
            "Reorder point is correctly calculated",
            f"Expected reorder point {expected_reorder}, got {value}",
        )

    def test_simulate_inventory(self):
        importlib.reload(self.user_code)
        forecast_func = getattr(self.user_code, 'moving_average_forecast', None)
        reorder_func = getattr(self.user_code, 'calculate_reorder_point', None)
        sim_func = getattr(self.user_code, 'simulate_inventory', None)
        forecast = forecast_func(self.daily_demand, self.window_size) if callable(forecast_func) else None
        reorder_point = reorder_func(self.daily_demand, self.window_size) if callable(reorder_func) else None
        _dynamic_test(
            self,
            callable(sim_func),
            "simulate_inventory is defined and callable",
            "simulate_inventory is missing or not callable",
        )
        result = sim_func(self.daily_demand, forecast, self.initial_stock, self.replenishment_quantity, reorder_point) if callable(sim_func) else None
        _dynamic_test(
            self,
            isinstance(result, tuple) and len(result) == 2 and isinstance(result[0], list) and isinstance(result[1], list),
            "simulate_inventory returns correct types",
            f"simulate_inventory returned: {result}",
        )
        if isinstance(result, tuple) and len(result) == 2:
            inventory, stockouts = result
            # Check length
            _dynamic_test(
                self,
                len(inventory) == len(self.daily_demand),
                "Inventory list length is correct",
                f"Inventory list length incorrect: {len(inventory)}",
            )
            # Check inventory simulation logic for a few days
            stock = self.initial_stock
            reorder_point = reorder_func(self.daily_demand, self.window_size)
            for i in range(len(self.daily_demand)):
                stock -= self.daily_demand[i]
                if stock < reorder_point:
                    stock += self.replenishment_quantity
                _dynamic_test(
                    self,
                    abs(inventory[i] - stock) < 1e-6,
                    f"Inventory at day {i+1} matches simulation",
                    f"Inventory at day {i+1} expected {stock}, got {inventory[i]}",
                )
            # Check stockout detection (should be empty for provided data)
            _dynamic_test(
                self,
                isinstance(stockouts, list),
                "Stockout days is a list",
                f"Stockout days not a list: {stockouts}",
            )

    def test_print_summary_output(self):
        importlib.reload(self.user_code)
        # Capture output
        f = io.StringIO()
        sys.stdout = f
        try:
            importlib.reload(self.user_code)
        finally:
            sys.stdout = sys.__stdout__
        output = normalize_text(f.getvalue())
        expected_msg = "no stockouts occurred during the period"
        _dynamic_test(
            self,
            expected_msg in output,
            "Prints correct summary when no stockouts occurred",
            f"Expected summary: '{expected_msg}' but got: '{output}'",
        )

    def test_visualization_lines(self):
        # Check that the code attempts to plot three lines
        import ast
        with open('user_code.py', 'r') as f:
            code = f.read()
        tree = ast.parse(code)
        plot_calls = [n for n in ast.walk(tree) if isinstance(n, ast.Call) and hasattr(n.func, 'attr') and n.func.attr == 'plot']
        _dynamic_test(
            self,
            len(plot_calls) >= 3,
            "Three plot lines are present for visualization",
            f"Expected at least 3 plot calls, found {len(plot_calls)}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Learn how to leverage Python to solve real-world supply chain problems, from inventory management to demand forecasting and logistics optimization. This course blends practical coding with supply chain theory, using hands-on examples and engaging challenges.

Explore the fundamentals of supply chain data, learn how to represent and analyze it in Python, and gain insights using data visualization.

Delve into inventory control techniques and demand forecasting methods, applying Python to model and predict supply chain needs.

Apply Python to optimize logistics operations, including route planning, shipment scheduling, and cost analysis.

Challenge: Forecast and Replenish

Oplossing