GRASP: assigning responsibilities

booking/decisions.py

"""Five "who should do this?" decisions in the cinema model, each checked by running the code."""

from cinema import Booking, BookingService, PaymentDeclined, Seat, SeatTaken, Show, TicketPrinter


class RecordingGateway:
    def __init__(self):
        self.charges = []

    def charge(self, amount, reference):
        self.charges.append((amount, reference))
        return f"pay-{len(self.charges)}"


class DecliningGateway:
    def charge(self, amount, reference):
        raise PaymentDeclined("card declined")


def new_show():
    seats = [Seat("A1", "recliner"), Seat("A2", "recliner"), Seat("B4", "regular")]
    return Show("show-7", seats, prices={"recliner": 220, "regular": 100})


def check(name, passed, detail):
    print(f"{'ok' if passed else 'FAILED':6} {name}: {detail}")


show = new_show()
booking = show.book(["A1", "A2", "B4"], "Asha")
check("Information Expert", booking.total() == 540, f"Booking.total() adds its own lines: {booking.total()}")
check("Creator", isinstance(booking, Booking) and not show.is_free("A1"), "Show.book() creates the Booking from its seats and prices")

gateway = RecordingGateway()
service = BookingService([new_show()], gateway, TicketPrinter())
ticket = service.book_seats("show-7", ["B4"], "Ravi")
check("Controller", gateway.charges == [(100, "show-7:Ravi")], "BookingService.book_seats() takes the event, delegates and charges once")
check("Pure Fabrication", ticket == "show-7 | Ravi | seats B4 | paid 100" and not hasattr(Booking, "render"), "TicketPrinter formats the ticket; Booking has no layout code")

show = new_show()
declining = BookingService([show], DecliningGateway(), TicketPrinter())
try:
    declining.book_seats("show-7", ["A1"], "Meera")
except PaymentDeclined:
    pass
check("Protected Variations", show.is_free("A1"), "any PaymentGateway fits; after a declined card the seat is free again")

try:
    new_show().book(["A1", "A1"], "Kabir")
    duplicate = "accepted"
except SeatTaken:
    duplicate = "refused"
print(f"booking the same seat twice in one request: {duplicate}")

ok     Information Expert: Booking.total() adds its own lines: 540
ok     Creator: Show.book() creates the Booking from its seats and prices
ok     Controller: BookingService.book_seats() takes the event, delegates and charges once
ok     Pure Fabrication: TicketPrinter formats the ticket; Booking has no layout code
ok     Protected Variations: any PaymentGateway fits; after a declined card the seat is free again
booking the same seat twice in one request: refused

booking/cinema.py

"""A small cinema booking model. Each responsibility sits where a GRASP pattern puts it (comments name the pattern)."""

from dataclasses import dataclass
from typing import Protocol


class SeatTaken(Exception):
    pass


class PaymentDeclined(Exception):
    pass


@dataclass(frozen=True)
class Seat:
    seat_id: str
    category: str  # "recliner" or "regular"


@dataclass(frozen=True)
class BookedSeat:
    seat: Seat
    price: int


class Booking:
    def __init__(self, customer, show_id, lines):
        self.customer = customer
        self.show_id = show_id
        self.lines = list(lines)

    def total(self):
        # Information Expert: the booking holds its lines, so it adds them up.
        return sum(line.price for line in self.lines)

    def seat_ids(self):
        return [line.seat.seat_id for line in self.lines]


class Show:
    def __init__(self, show_id, seats, prices):
        self.show_id = show_id
        self._seats = {seat.seat_id: seat for seat in seats}
        self._prices = dict(prices)  # category -> price
        self._taken = set()

    def is_free(self, seat_id):
        # Information Expert: the show knows which of its seats are taken.
        return seat_id not in self._taken

    def book(self, seat_ids, customer):
        # Creator: the show has the data a booking starts from (its seats and prices), so it creates the Booking.
        if len(set(seat_ids)) != len(seat_ids):
            raise SeatTaken("the same seat appears twice in one request")
        taken = [seat_id for seat_id in seat_ids if not self.is_free(seat_id)]
        if taken:
            raise SeatTaken(", ".join(taken))
        self._taken.update(seat_ids)
        seats = [self._seats[seat_id] for seat_id in seat_ids]
        return Booking(customer, self.show_id, [BookedSeat(seat, self._prices[seat.category]) for seat in seats])

    def release(self, booking):
        self._taken.difference_update(booking.seat_ids())


class PaymentGateway(Protocol):
    # Protected Variations and Indirection: payment providers change, so the service depends on this interface.
    def charge(self, amount: int, reference: str) -> str: ...


class TicketPrinter:
    # Pure Fabrication: no cinema concept "prints"; this class exists so that Booking stays free of text layout.
    def render(self, booking):
        seats = ", ".join(booking.seat_ids())
        return f"{booking.show_id} | {booking.customer} | seats {seats} | paid {booking.total()}"


class BookingService:
    # Controller: the first object behind the user interface that receives the "book seats" system event. It
    # coordinates and decides nothing that another object knows better.
    def __init__(self, shows, gateway: PaymentGateway, printer: TicketPrinter):
        self._shows = {show.show_id: show for show in shows}
        self._gateway = gateway
        self._printer = printer

    def book_seats(self, show_id, seat_ids, customer):
        show = self._shows[show_id]
        booking = show.book(seat_ids, customer)
        try:
            self._gateway.charge(booking.total(), reference=f"{show_id}:{customer}")
        except PaymentDeclined:
            show.release(booking)
            raise
        return self._printer.render(booking)

expert/same_checks.py

"""The same checks against both versions, and where each version keeps the discount rule."""

import ast
from pathlib import Path

import after
import before


def run_checks(module):
    controller = module.CheckoutController()
    order = module.Order([module.Line("Godan", 300, 1), module.Line("Malgudi Days", 250, 4)])
    results = [
        controller.total(module.Order([])) == 0,
        controller.total(module.Order([module.Line("Godan", 300, 2)])) == 600,
        controller.total(order) == 300 + 900,  # 4 x 250 = 1000, less 10 %
        controller.summary(order) == "2 titles, total 1200",
    ]
    return sum(results), len(results)


def where_the_rule_lives(module):
    """The class and method that compare a quantity with 3: the discount rule."""
    tree = ast.parse(Path(module.__file__).read_text(encoding="utf-8"))
    for cls in (node for node in tree.body if isinstance(node, ast.ClassDef)):
        for method in (node for node in cls.body if isinstance(node, ast.FunctionDef)):
            for node in ast.walk(method):
                if isinstance(node, ast.Compare) and any(getattr(c, "value", None) == 3 for c in node.comparators):
                    return f"{cls.name}.{method.name}()"


for module in (before, after):
    passed, total = run_checks(module)
    print(f"{module.__name__}.py: {passed} of {total} checks pass; the discount rule is in {where_the_rule_lives(module)}")

before.py: 4 of 4 checks pass; the discount rule is in CheckoutController.total()
after.py: 4 of 4 checks pass; the discount rule is in Line.subtotal()

expert/before.py

"""A bookshop's checkout, first version: the controller computes the total from the order's data."""


class Line:
    def __init__(self, title, price, quantity):
        self.title = title
        self.price = price
        self.quantity = quantity


class Order:
    def __init__(self, lines):
        self.lines = list(lines)


class CheckoutController:
    def total(self, order):
        total = 0
        for line in order.lines:
            amount = line.price * line.quantity
            if line.quantity >= 3:
                amount -= amount // 10  # 10 % off a line of three or more copies
            total += amount
        return total

    def summary(self, order):
        return f"{len(order.lines)} titles, total {self.total(order)}"

expert/after.py

"""The same checkout after moving each calculation to the class that has the data (Information Expert)."""


class Line:
    def __init__(self, title, price, quantity):
        self.title = title
        self.price = price
        self.quantity = quantity

    def subtotal(self):
        amount = self.price * self.quantity
        if self.quantity >= 3:
            amount -= amount // 10  # 10 % off a line of three or more copies
        return amount


class Order:
    def __init__(self, lines):
        self.lines = list(lines)

    def total(self):
        return sum(line.subtotal() for line in self.lines)


class CheckoutController:
    def total(self, order):
        return order.total()

    def summary(self, order):
        return f"{len(order.lines)} titles, total {order.total()}"