As you have seen throughout this course, **Python** is an invaluable tool for automating routine reporting tasks in operations management. By leveraging Python's ability to quickly process and summarize data, you can create scripts that save time, reduce errors, and provide actionable insights to help you manage daily warehouse activities more efficiently.

# Example of a daily operations summary report output format

print("=== Daily Operations Report ===")
print("Total orders: 15")
print("Completed orders: 10")
print("Pending orders: 5")
print("Highest-priority pending order: {'item': 'Printer Paper', 'quantity': 2, 'status': 'pending', 'priority': 1}")
print("===============================")

When working with lists of dictionaries in Python, you can iterate through each dictionary (representing, for example, an order) and extract the fields you need for your summary. Use loops to count items that meet certain criteria, such as completed or pending orders, and use the `min()` or `max()` function with a custom key to find the order with the highest priority. Remember that lower numbers can represent higher priority if that's how your data is structured.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        self.orders = [
            {'item': 'Laptop', 'quantity': 4, 'status': 'completed', 'priority': 2},
            {'item': 'Mouse', 'quantity': 10, 'status': 'pending', 'priority': 1},
            {'item': 'Keyboard', 'quantity': 5, 'status': 'completed', 'priority': 3},
            {'item': 'Monitor', 'quantity': 2, 'status': 'pending', 'priority': 2},
            {'item': 'Printer Paper', 'quantity': 2, 'status': 'pending', 'priority': 1},
        ]
        self.module = importlib.import_module("user_code")

    def test_total_orders_count(self):
        # Check if the function prints the correct total number of orders
        f = io.StringIO()
        with redirect_stdout(f):
            self.module.generate_daily_report(self.orders)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "total orders: 5" in output,
            "Correct total order count is reported",
            f"Output does not include correct total orders: {output}"
        )

    def test_completed_orders_count(self):
        f = io.StringIO()
        with redirect_stdout(f):
            self.module.generate_daily_report(self.orders)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "completed orders: 2" in output,
            "Correct completed orders count is reported",
            f"Output does not include correct completed orders: {output}"
        )

    def test_pending_orders_count(self):
        f = io.StringIO()
        with redirect_stdout(f):
            self.module.generate_daily_report(self.orders)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "pending orders: 3" in output,
            "Correct pending orders count is reported",
            f"Output does not include correct pending orders: {output}"
        )

    def test_highest_priority_pending_order(self):
        # There are two pending orders with priority 1: Mouse and Printer Paper
        # The function should return the first one it finds with priority 1
        f = io.StringIO()
        with redirect_stdout(f):
            self.module.generate_daily_report(self.orders)
        output = normalize_text(f.getvalue())
        # Accept either Mouse or Printer Paper as valid
        found = ("{'item': 'mouse', 'quantity': 10, 'status': 'pending', 'priority': 1}" in output) or ("{'item': 'printer paper', 'quantity': 2, 'status': 'pending', 'priority': 1}" in output)
        _dynamic_test(
            self,
            found,
            "Correct highest-priority pending order is reported",
            f"Output does not include correct highest-priority pending order: {output}"
        )

    def test_report_format(self):
        f = io.StringIO()
        with redirect_stdout(f):
            self.module.generate_daily_report(self.orders)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "daily operations report" in output and "===============================" in output,
            "Report format includes header and footer",
            f"Report format is missing header or footer: {output}"
        )

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

This course empowers operations managers to leverage Python for streamlining workflows, analyzing operational data, and making data-driven decisions. Through practical examples and real-world challenges, you'll learn how to automate repetitive tasks, visualize key metrics, and optimize processes using Python's powerful libraries.

Learn how to use Python to automate repetitive tasks, streamline data handling, and improve efficiency in daily operations management.

Master the use of Python for analyzing operational data, identifying trends, and supporting data-driven decision-making.

Apply Python to solve classic operations management problems such as process optimization, demand forecasting, and resource allocation.

Challenge: Automate Daily Operations Report

Løsning