In previous chapters, you explored how to represent supply chain transportation networks using Python dictionaries, with nodes (such as warehouses and delivery points) and edges (routes with associated costs). You also learned about route optimization techniques, including **Dijkstra's algorithm** for finding the shortest path in a network. These concepts allow you to model real-world logistics scenarios, compute the most cost-effective delivery routes, and analyze transportation costs across a network.

# Example transportation network and delivery locations

# The network is represented as a dictionary where each key is a node,
# and its value is a dictionary of neighboring nodes with the cost to reach them.
network = {
    "Warehouse": {"A": 4, "B": 2},
    "A": {"Warehouse": 4, "C": 3, "D": 2},
    "B": {"Warehouse": 2, "C": 1},
    "C": {"A": 3, "B": 1, "D": 4, "E": 2},
    "D": {"A": 2, "C": 4, "E": 1},
    "E": {"C": 2, "D": 1}
}

# List of delivery locations you need to reach from the Warehouse
delivery_locations = ["A", "C", "D", "E"]

Your challenge is to use the provided transportation network and delivery locations to implement a complete delivery route optimization workflow. You should:

- Apply **Dijkstra's algorithm** to find the shortest route from the `"Warehouse"` to each delivery location;
- Calculate the **total transportation cost** for delivering to all locations;
- Determine which delivery location is the **most expensive to reach** based on the optimal route costs;
- **Visualize** the entire network using `matplotlib`, with nodes as points and routes as lines. Highlight the optimal route to each delivery location in a distinct color for clarity;
- Print a **summary** for each delivery location, showing the optimal route and its cost.

Remember to use only the libraries and techniques introduced in earlier chapters, and ensure your code is clear and well-documented. This challenge will help reinforce your understanding of **network modeling**, **route optimization**, **cost analysis**, and **visualization** in supply chain logistics.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.network = {
            "Warehouse": {"A": 4, "B": 2},
            "A": {"Warehouse": 4, "C": 3, "D": 2},
            "B": {"Warehouse": 2, "C": 1},
            "C": {"A": 3, "B": 1, "D": 4, "E": 2},
            "D": {"A": 2, "C": 4, "E": 1},
            "E": {"C": 2, "D": 1}
        }
        self.delivery_locations = ["A", "C", "D", "E"]

    def test_dijkstra_shortest_paths(self):
        import user_code
        importlib.reload(user_code)
        dijkstra = getattr(user_code, "dijkstra", None)
        _dynamic_test(
            self,
            callable(dijkstra),
            "dijkstra function exists",
            "dijkstra function is missing or not callable"
        )
        answers = {
            "A": (4, ["Warehouse", "A"]),
            "C": (3, ["Warehouse", "B", "C"]),
            "D": (6, ["Warehouse", "A", "D"]),
            "E": (5, ["Warehouse", "B", "C", "E"]),
        }
        for loc in self.delivery_locations:
            cost, route = dijkstra(self.network, "Warehouse", loc)
            expected_cost, expected_route = answers[loc]
            _dynamic_test(
                self,
                cost == expected_cost and route == expected_route,
                f"Correct shortest path and cost for {loc}",
                f"Expected: cost={expected_cost}, route={expected_route}; got: cost={cost}, route={route}"
            )

    def test_total_cost_and_most_expensive(self):
        import user_code
        importlib.reload(user_code)
        optimize_routes = getattr(user_code, "optimize_routes", None)
        _dynamic_test(
            self,
            callable(optimize_routes),
            "optimize_routes function exists",
            "optimize_routes function is missing or not callable"
        )
        f = io.StringIO()
        with redirect_stdout(f):
            optimize_routes(self.network, self.delivery_locations)
        output = f.getvalue()
        output_norm = normalize_text(output)
        # Check for summary lines
        expected_summaries = [
            "location: a, optimal route: warehouse -> a, cost: 4",
            "location: c, optimal route: warehouse -> b -> c, cost: 3",
            "location: d, optimal route: warehouse -> a -> d, cost: 6",
            "location: e, optimal route: warehouse -> b -> c -> e, cost: 5",
        ]
        for summary in expected_summaries:
            _dynamic_test(
                self,
                summary in output_norm,
                f"Summary for {summary}",
                f"Expected summary line '{summary}' not found in output"
            )
        # Check for total cost
        _dynamic_test(
            self,
            "total transportation cost: 18" in output_norm,
            "Correct total transportation cost printed",
            f"Expected total cost 18 in output: {output_norm}"
        )
        # Check for most expensive location
        _dynamic_test(
            self,
            "most expensive location to reach: d (cost: 6)" in output_norm,
            "Correct most expensive location identified",
            f"Expected most expensive location D in output: {output_norm}"
        )

    def test_visualization_function_exists(self):
        import user_code
        importlib.reload(user_code)
        visualize_network = getattr(user_code, "visualize_network", None)
        _dynamic_test(
            self,
            callable(visualize_network),
            "visualize_network function exists",
            "visualize_network function is missing or not callable"
        )

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: Optimize Delivery Routes

Solution