Add typing to supermarket kata

Author: tmaurin

src/supermarket_receipt/src/catalog.py

@@ -1,9 +1,13 @@
+from src.model_objects import Product
+
 
 class SupermarketCatalog:
+    def __init__(self):
+        self.products: dict[str, Product] = {}
+        self.prices: dict[str, float] = {}
 
-    def add_product(self, product, price):
+    def add_product(self, product: Product, price: float) -> None:
         raise Exception("cannot be called from a unit test - it accesses the database")
 
-    def unit_price(self, product):
+    def unit_price(self, product: Product) -> float:
         raise Exception("cannot be called from a unit test - it accesses the database")
-

src/supermarket_receipt/src/model_objects.py

@@ -1,14 +1,15 @@
+from __future__ import annotations
 from enum import Enum
 
 
 class Product:
-    def __init__(self, name, unit):
+    def __init__(self, name, unit: ProductUnit):
         self.name = name
         self.unit = unit
 
 
 class ProductQuantity:
-    def __init__(self, product, quantity):
+    def __init__(self, product, quantity: float):
         self.product = product
         self.quantity = quantity
 
@@ -24,15 +25,16 @@ class SpecialOfferType(Enum):
     TWO_FOR_AMOUNT = 3
     FIVE_FOR_AMOUNT = 4
 
+
 class Offer:
-    def __init__(self, offer_type, product, argument):
+    def __init__(self, offer_type: SpecialOfferType, product: Product, argument: float) -> None:
         self.offer_type = offer_type
         self.product = product
         self.argument = argument
 
 
 class Discount:
-    def __init__(self, product, description, discount_amount):
+    def __init__(self, product: Product, description: str, discount_amount: float) -> None:
         self.product = product
         self.description = description
         self.discount_amount = discount_amount

src/supermarket_receipt/src/receipt.py

@@ -1,35 +1,37 @@
+from src.model_objects import Discount, Product
+
 
 class ReceiptItem:
-    def __init__(self, product, quantity, price, total_price):
+    def __init__(self, product: Product, quantity: float, price: float, total_price: float) -> None:
         self.product = product
         self.quantity = quantity
         self.price = price
         self.total_price = total_price
 
 
 class Receipt:
-    def __init__(self):
-        self._items = []
-        self._discounts = []
+    def __init__(self) -> None:
+        self._items: list[ReceiptItem] = []
+        self._discounts: list[Discount] = []
 
-    def total_price(self):
+    def total_price(self) -> float:
         total = 0
         for item in self.items:
             total += item.total_price
         for discount in self.discounts:
             total += discount.discount_amount
         return total
 
-    def add_product(self, product, quantity, price, total_price):
+    def add_product(self, product: Product, quantity: float, price: float, total_price: float) -> None:
         self._items.append(ReceiptItem(product, quantity, price, total_price))
 
-    def add_discount(self, discount):
+    def add_discount(self, discount: Discount) -> None:
         self._discounts.append(discount)
 
     @property
-    def items(self):
+    def items(self) -> list[ReceiptItem]:
         return self._items[:]
 
     @property
-    def discounts(self):
+    def discounts(self) -> list[Discount]:
         return self._discounts[:]

src/supermarket_receipt/src/shopping_cart.py

@@ -1,33 +1,38 @@
+from __future__ import annotations
 import math
 
-from src.model_objects import ProductQuantity, SpecialOfferType, Discount
+from src.model_objects import Offer, Product, ProductQuantity, SpecialOfferType, Discount
+from src.receipt import Receipt
+from src.catalog import SupermarketCatalog
 
 
 class ShoppingCart:
+    _items: list[ProductQuantity]
+    _product_quantities: dict[Product, float]
 
     def __init__(self):
         self._items = []
         self._product_quantities = {}
 
     @property
-    def items(self):
+    def items(self) -> list[ProductQuantity]:
         return self._items
 
-    def add_item(self, product):
+    def add_item(self, product: Product) -> None:
         self.add_item_quantity(product, 1.0)
 
     @property
-    def product_quantities(self):
+    def product_quantities(self) -> dict[Product, float]:
         return self._product_quantities
 
-    def add_item_quantity(self, product, quantity):
+    def add_item_quantity(self, product: Product, quantity: float) -> None:
         self._items.append(ProductQuantity(product, quantity))
         if product in self._product_quantities.keys():
             self._product_quantities[product] = self._product_quantities[product] + quantity
         else:
             self._product_quantities[product] = quantity
 
-    def handle_offers(self, receipt, offers, catalog):
+    def handle_offers(self, receipt: Receipt, offers: dict[Product, Offer], catalog: SupermarketCatalog) -> None:
         for p in self._product_quantities.keys():
             quantity = self._product_quantities[p]
             if p in offers.keys():

src/supermarket_receipt/src/teller.py

@@ -1,17 +1,19 @@
-from src.model_objects import Offer
+from src.model_objects import Offer, Product, SpecialOfferType
+from src.catalog import SupermarketCatalog
 from src.receipt import Receipt
+from src.shopping_cart import ShoppingCart
 
 
 class Teller:
 
     def __init__(self, catalog):
-        self.catalog = catalog
-        self.offers = {}
+        self.catalog: SupermarketCatalog = catalog
+        self.offers: dict[Product, Offer] = {}
 
-    def add_special_offer(self, offer_type, product, argument):
+    def add_special_offer(self, offer_type: SpecialOfferType, product: Product, argument: float) -> None:
         self.offers[product] = Offer(offer_type, product, argument)
 
-    def checks_out_articles_from(self, the_cart):
+    def checks_out_articles_from(self, the_cart: ShoppingCart) -> Receipt:
         receipt = Receipt()
         product_quantities = the_cart.items
         for pq in product_quantities:
@@ -25,5 +27,5 @@ def checks_out_articles_from(self, the_cart):
 
         return receipt
 
-    def product_with_name(self, name):
-        return self.catalog.products.get(name, None)
+    def product_with_name(self, name: str):
+        return self.catalog.products.get(name, None)

src/supermarket_receipt/tests/conftest.py

@@ -7,25 +7,25 @@
 
 
 @pytest.fixture
-def toothbrush():
+def toothbrush() -> Product:
     return Product("toothbrush", ProductUnit.EACH)
 
 
 @pytest.fixture
-def apples():
+def apples() -> Product:
     return Product("apples", ProductUnit.KILO)
 
 
 @pytest.fixture
-def catalog(toothbrush, apples):
+def catalog(toothbrush: Product, apples: Product) -> FakeCatalog:
     catalog = FakeCatalog()
     catalog.add_product(toothbrush, 0.99)
     catalog.add_product(apples, 1.99)
     return catalog
 
 
 @pytest.fixture
-def teller(catalog):
+def teller(catalog: FakeCatalog) -> Teller:
     return Teller(catalog)
 
 

src/supermarket_receipt/tests/fake_catalog.py

@@ -1,15 +1,11 @@
 from src.catalog import SupermarketCatalog
+from src.model_objects import Product
 
 
 class FakeCatalog(SupermarketCatalog):
-    def __init__(self):
-        self.products = {}
-        self.prices = {}
-
-    def add_product(self, product, price):
+    def add_product(self, product: Product, price: float) -> None:
         self.products[product.name] = product
         self.prices[product.name] = price
 
-    def unit_price(self, product):
+    def unit_price(self, product: Product) -> float:
         return self.prices[product.name]
-

src/supermarket_receipt/tests/receipt_printer.py

@@ -1,11 +1,13 @@
 from src.model_objects import ProductUnit
+from src.receipt import Receipt, ReceiptItem
+
 
 class ReceiptPrinter:
 
-    def __init__(self, columns=40):
+    def __init__(self, columns: int = 40) -> None:
         self.columns = columns
 
-    def print_receipt(self, receipt):
+    def print_receipt(self, receipt: Receipt) -> str:
         result = ""
         for item in receipt.items:
             receipt_item = self.print_receipt_item(item)
@@ -19,15 +21,15 @@ def print_receipt(self, receipt):
         result += self.present_total(receipt)
         return str(result)
 
-    def print_receipt_item(self, item):
+    def print_receipt_item(self, item: ReceiptItem) -> str:
         total_price_printed = self.print_price(item.total_price)
         name = item.product.name
         line = self.format_line_with_whitespace(name, total_price_printed)
         if item.quantity != 1:
             line += f"  {self.print_price(item.price)} * {self.print_quantity(item)}\n"
         return line
 
-    def format_line_with_whitespace(self, name, value):
+    def format_line_with_whitespace(self, name: str, value: str) -> str:
         line = name
         whitespace_size = self.columns - len(name) - len(value)
         for i in range(whitespace_size):
@@ -36,21 +38,21 @@ def format_line_with_whitespace(self, name, value):
         line += "\n"
         return line
 
-    def print_price(self, price):
+    def print_price(self, price: float) -> str:
         return "%.2f" % price
 
-    def print_quantity(self, item):
+    def print_quantity(self, item: ReceiptItem) -> str:
         if ProductUnit.EACH == item.product.unit:
             return str(item.quantity)
         else:
             return '%.3f' % item.quantity
 
-    def print_discount(self, discount):
+    def print_discount(self, discount: Discount) -> str:
         name = f"{discount.description} ({discount.product.name})"
         value = self.print_price(discount.discount_amount)
         return self.format_line_with_whitespace(name, value)
 
-    def present_total(self, receipt):
+    def present_total(self, receipt: Receipt) -> str:
         name = "Total: "
         value = self.print_price(receipt.total_price())
         return self.format_line_with_whitespace(name, value)

src/supermarket_receipt/tests/test_supermarket.py

@@ -1,16 +1,20 @@
 import approvaltests
 import pytest
 
-from src.model_objects import SpecialOfferType
+from src.model_objects import SpecialOfferType, Product
 from tests.receipt_printer import ReceiptPrinter
 
+from src.teller import Teller
+from src.shopping_cart import ShoppingCart
 
-def test_empty_basket(teller, cart, toothbrush, apples):
+
+def test_empty_basket(teller: Teller, cart: ShoppingCart, toothbrush: Product, apples: Product) -> None:
     receipt = teller.checks_out_articles_from(cart)
 
     approvaltests.verify(ReceiptPrinter().print_receipt(receipt))
 
-def test_no_discount(teller, cart, toothbrush, apples):
+
+def test_no_discount(teller: Teller, cart: ShoppingCart, toothbrush: Product, apples: Product) -> None:
     teller.add_special_offer(SpecialOfferType.TEN_PERCENT_DISCOUNT, toothbrush, 10.0)
     cart.add_item_quantity(apples, 2.5)
 
@@ -19,7 +23,7 @@ def test_no_discount(teller, cart, toothbrush, apples):
     approvaltests.verify(ReceiptPrinter().print_receipt(receipt))
 
 
-def test_ten_percent_discount(teller, cart, toothbrush):
+def test_ten_percent_discount(teller: Teller, cart: ShoppingCart, toothbrush: Product) -> None:
     teller.add_special_offer(SpecialOfferType.TEN_PERCENT_DISCOUNT, toothbrush, 10.0)
     cart.add_item_quantity(toothbrush, 2)
 
@@ -28,15 +32,16 @@ def test_ten_percent_discount(teller, cart, toothbrush):
     approvaltests.verify(ReceiptPrinter().print_receipt(receipt))
 
 
-def test_three_for_two_discount(teller, cart, toothbrush):
+def test_three_for_two_discount(teller: Teller, cart: ShoppingCart, toothbrush: Product) -> None:
     teller.add_special_offer(SpecialOfferType.THREE_FOR_TWO, toothbrush, 10.0)
     cart.add_item_quantity(toothbrush, 3)
 
     receipt = teller.checks_out_articles_from(cart)
 
     approvaltests.verify(ReceiptPrinter().print_receipt(receipt))
 
-def test_three_for_two_discount_too_few(teller, cart, toothbrush):
+
+def test_three_for_two_discount_too_few(teller: Teller, cart: ShoppingCart, toothbrush: Product) -> None:
     teller.add_special_offer(SpecialOfferType.THREE_FOR_TWO, toothbrush, 10.0)
     cart.add_item_quantity(toothbrush, 2)
 
@@ -45,31 +50,34 @@ def test_three_for_two_discount_too_few(teller, cart, toothbrush):
     approvaltests.verify(ReceiptPrinter().print_receipt(receipt))
 
 
-def test_five_for_amount_discount(teller, cart, toothbrush):
+def test_five_for_amount_discount(teller: Teller, cart: ShoppingCart, toothbrush: Product) -> None:
     teller.add_special_offer(SpecialOfferType.FIVE_FOR_AMOUNT, toothbrush, 4.0)
     cart.add_item_quantity(toothbrush, 5)
 
     receipt = teller.checks_out_articles_from(cart)
 
     approvaltests.verify(ReceiptPrinter().print_receipt(receipt))
 
-def test_five_for_amount_discount_bought_too_few(teller, cart, toothbrush):
+
+def test_five_for_amount_discount_bought_too_few(teller: Teller, cart: ShoppingCart, toothbrush: Product) -> None:
     teller.add_special_offer(SpecialOfferType.FIVE_FOR_AMOUNT, toothbrush, 4.0)
     cart.add_item_quantity(toothbrush, 4)
 
     receipt = teller.checks_out_articles_from(cart)
 
     approvaltests.verify(ReceiptPrinter().print_receipt(receipt))
 
-def test_two_for_amount_discount(teller, cart, toothbrush):
+
+def test_two_for_amount_discount(teller: Teller, cart: ShoppingCart, toothbrush: Product) -> None:
     teller.add_special_offer(SpecialOfferType.TWO_FOR_AMOUNT, toothbrush, 1.80)
     cart.add_item_quantity(toothbrush, 5)
 
     receipt = teller.checks_out_articles_from(cart)
 
     approvaltests.verify(ReceiptPrinter().print_receipt(receipt))
 
-def test_two_for_amount_discount_bought_too_few(teller, cart, toothbrush):
+
+def test_two_for_amount_discount_bought_too_few(teller: Teller, cart: ShoppingCart, toothbrush: Product):
     teller.add_special_offer(SpecialOfferType.TWO_FOR_AMOUNT, toothbrush, 1.80)
     cart.add_item_quantity(toothbrush, 1)