Before you tackle a real-world inventory health analysis, it is important to recall why tracking stock levels is essential for supply chain efficiency. Monitoring inventory across warehouses helps you spot products at risk of stockouts, avoid costly delays, and prioritize restocking efforts. Being proactive with restocking ensures that customer demand can be met without interruption and reduces the risk of lost sales or excess expedited shipping costs. By analyzing inventory data and visualizing low-stock products, you can quickly identify which items require urgent attention and communicate these findings clearly to your team.

import pandas as pd

# Example inventory DataFrame
data = {
    'Product': ['Widget A', 'Widget B', 'Widget C', 'Widget D'],
    'Warehouse 1': [15, 30, 8, 45],
    'Warehouse 2': [3, 12, 6, 5],
    'Warehouse 3': [2, 7, 4, 10]
}

inventory_df = pd.DataFrame(data)
print(inventory_df)

Your challenge is to use the inventory DataFrame above to perform a comprehensive inventory health analysis. Calculate the total stock for each product by summing inventory across all warehouses. Identify which products have a total stock below a threshold of 20 units—these are considered low-inventory items that may require urgent restocking. Create a bar chart visualizing the stock levels of only these low-inventory products, making it easy to compare which products are most at risk. Finally, print a summary listing the names of products that need urgent restocking, so that stakeholders can take immediate action. Use the **pandas** and **matplotlib** libraries as demonstrated previously.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io
import pandas as pd
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'Product': ['Widget A', 'Widget B', 'Widget C', 'Widget D'],
            'Warehouse 1': [15, 30, 8, 45],
            'Warehouse 2': [3, 12, 6, 5],
            'Warehouse 3': [2, 7, 4, 10]
        }
        self.inventory_df = pd.DataFrame(self.data)
        self.user_code = importlib.import_module('user_code')

    def test_total_stock_column(self):
        df = self.inventory_df.copy()
        # Run user function
        try:
            self.user_code.analyze_inventory_health(df)
        except Exception:
            pass
        total_stock = df.get('Total Stock', None)
        expected = [20, 49, 18, 60]
        _dynamic_test(
            self,
            isinstance(total_stock, pd.Series) and total_stock.tolist() == expected,
            "'Total Stock' column correctly calculated.",
            f"Expected 'Total Stock' values {expected}, got {total_stock.tolist() if isinstance(total_stock, pd.Series) else total_stock}."
        )

    def test_low_inventory_identification(self):
        df = self.inventory_df.copy()
        # Capture printed output
        buf = io.StringIO()
        sys.stdout = buf
        try:
            self.user_code.analyze_inventory_health(df)
        except Exception:
            pass
        sys.stdout = sys.__stdout__
        # Check if correct products are identified
        low_stock = df[df['Total Stock'] <= 20]
        expected_products = ['Widget A', 'Widget C']
        _dynamic_test(
            self,
            set(low_stock['Product'].tolist()) == set(expected_products),
            f"Correctly identified products with low inventory: {expected_products}.",
            f"Expected products {expected_products}, got {low_stock['Product'].tolist()}"
        )

    def test_bar_chart_created(self):
        df = self.inventory_df.copy()
        # Patch plt.show to avoid opening window
        show_called = {'called': False}
        orig_show = plt.show
        def fake_show():
            show_called['called'] = True
        plt.show = fake_show
        try:
            self.user_code.analyze_inventory_health(df)
        except Exception:
            pass
        plt.show = orig_show
        _dynamic_test(
            self,
            show_called['called'],
            "Bar chart was displayed for low-inventory products.",
            "Bar chart for low-inventory products was not displayed."
        )

    def test_summary_printed(self):
        df = self.inventory_df.copy()
        buf = io.StringIO()
        sys.stdout = buf
        try:
            self.user_code.analyze_inventory_health(df)
        except Exception:
            pass
        sys.stdout = sys.__stdout__
        output = normalize_text(buf.getvalue())
        expected = normalize_text("Products needing urgent restocking: Widget A, Widget C")
        _dynamic_test(
            self,
            expected in output,
            "Summary correctly lists products that need urgent restocking.",
            f"Expected summary '{expected}' not found in output: {output}"
        )

    def test_no_products_below_threshold(self):
        df = pd.DataFrame({
            'Product': ['Widget X', 'Widget Y'],
            'Warehouse 1': [25, 40],
            'Warehouse 2': [10, 12],
            'Warehouse 3': [5, 8]
        })
        buf = io.StringIO()
        sys.stdout = buf
        try:
            self.user_code.analyze_inventory_health(df, threshold=10)
        except Exception:
            pass
        sys.stdout = sys.__stdout__
        output = normalize_text(buf.getvalue())
        expected = normalize_text("No products require urgent restocking.")
        _dynamic_test(
            self,
            expected in output,
            "Prints correct message when no products are below threshold.",
            f"Expected summary '{expected}' not found in output: {output}"
        )

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

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: Analyze Inventory Health

Ratkaisu