Project: a drinks kiosk

Version 1: dictionaries and functions

Start with plain data and small functions. The menu and the stock are dictionaries:

MENU = {
    "cocoa": {"recipe": {"water": 200, "cocoa": 30}, "price": 250},
    "chai": {"recipe": {"water": 180, "milk": 70, "chai": 20}, "price": 300},
}
stock = {"water": 500, "milk": 60, "cocoa": 100, "chai": 40}

def missing_for(recipe, stock):
    return [item for item, amount in recipe.items() if stock.get(item, 0) < amount]

def use(recipe, stock):
    for item, amount in recipe.items():
        stock[item] = stock[item] - amount

print(missing_for(MENU["cocoa"]["recipe"], stock))
print(missing_for(MENU["chai"]["recipe"], stock))
use(MENU["cocoa"]["recipe"], stock)
print(stock)

missing_for returns every ingredient that's short, not just the first, so the kiosk can say "Sorry, not enough milk" accurately. use changes the stock dictionary it's given, which is what a machine that pours drinks should do.

This version works, and for a tiny program it's fine. But notice how the stock gets passed into every function, and how nothing stops some other code from changing it carelessly. As the kiosk grows, with money and reports, everything ends up depending on everything.

Version 2: classes with one job each

The fix is to give each kind of state an owner: a class that holds the data and the only functions allowed to change it.

• Inventory owns the stock. It answers "what's missing for this recipe?" and uses ingredients.
• Till owns the money. It takes payment and works out change.
• Kiosk owns neither. It holds a menu, an inventory and a till, and decides what happens for each command.

Here's the inventory as a class:

class Inventory:
    def __init__(self, stock):
        self.stock = dict(stock)

    def missing_for(self, recipe):
        return [item for item, amount in recipe.items() if self.stock.get(item, 0) < amount]

    def use(self, recipe):
        for item, amount in recipe.items():
            self.stock[item] = self.stock[item] - amount

shelf = Inventory({"water": 500, "cocoa": 20})
print(shelf.missing_for({"water": 200, "cocoa": 30}))

dict(stock) makes the inventory its own copy, so changing it can't change the dictionary it was built from. Now nothing outside the class needs to touch stock directly. That's the main gain of a class: one place for each rule, and one place to look when that rule seems broken.

class Till:
    """Holds the kiosk's money, in cents.

    pay(coins, price): coins is a list of coin values in cents. Returns the
    change in cents, or None (and keeps nothing) if the coins don't cover the price.
    takings: the total kept so far, in cents.
    """
    def __init__(self):
        self.takings = 0

    def pay(self, coins, price):
        paid = sum(coins)
        if paid < price:
            return None
        self.takings = self.takings + price
        return paid - price


help(Till)
change = None
takings = None

The kiosk decides; the parts do the work

With an inventory and a till, the kiosk's order method reads almost like the brief:

def order(self, name, coins):
    if name not in self.menu:
        return f"Sorry, we don't make {name}."
    recipe, price = self.menu[name]["recipe"], self.menu[name]["price"]
    missing = self.inventory.missing_for(recipe)
    if missing:
        return "Sorry, not enough " + ", ".join(missing) + "."
    change = self.till.pay(coins, price)
    if change is None:
        return "That's not enough money. Refunded."
    self.inventory.use(recipe)
    return f"Here's your {name}. Change: ${change / 100:.2f}"

Each line asks a part a question or tells it to act. The order of the checks carries the business rules: the stock is checked before any money is taken, and the ingredients are used only after the payment succeeds.

The method returns its message instead of printing it. The loop that talks to the customer prints it. That keeps order easy to check with known coins, the same split as in the word game.

MENU = {"cocoa": {"recipe": {"water": 200, "cocoa": 30}, "price": 250}}
stock = {"water": 500, "cocoa": 100}
takings = 0

def missing_for(recipe):
    return [i for i, a in recipe.items() if stock.get(i, 0) < a]

while True:
    command = input("What would you like? ").strip().lower()
    if command == "off":
        print("Goodbye.")
        break
    if command == "report":
        print(stock, f"takings ${takings / 100:.2f}")
        continue
    if command not in MENU:
        print("Sorry, we don't make that.")
        continue
    drink = MENU[command]
    if missing_for(drink["recipe"]):
        print("Sorry, sold out.")
        continue
    coins = [int(c) for c in input("Coins: ").split()]
    if sum(coins) < drink["price"]:
        print("Not enough. Refunded.")
        continue
    takings = takings + drink["price"]
    for item, amount in drink["recipe"].items():
        stock[item] = stock[item] - amount
    print(f"Here's your cocoa. Change: ${(sum(coins) - drink['price']) / 100:.2f}")

Go further

Some ideas for growing the kiosk:

• Add a restock(item, amount) method to Inventory, and a hidden restock command for staff.
• Give exact change in coins: work out how many dollars, quarters, dimes and nickels make up the change, starting with the biggest coin.
• Add a fourth drink by adding one menu entry, and check that nothing else needs changing. If something does, that's a sign a rule lives in the wrong place.

The habit to keep from this project: before adding a feature, ask which part owns it. Restocking belongs to the inventory, refunds belong to the till, and deciding what a command means belongs to the kiosk. When the answer is "several parts at once", the feature is probably two smaller features, each with an obvious home.