Inheritance, Composition & Dunder Methods¶

class Animal:
    def __init__(self, name: str):
        self.name = name

    def speak(self) -> str:
        raise NotImplementedError(f"{type(self).__name__} must implement speak()")

    def describe(self) -> str:
        return f"I am {self.name}, a {type(self).__name__}"

class Dog(Animal):
    def speak(self) -> str:
        return f"{self.name}: Woof!"

    def fetch(self) -> str:
        return f"{self.name} fetches the ball"

class Cat(Animal):
    def speak(self) -> str:
        return f"{self.name}: Meow!"

class Kitten(Cat):
    def speak(self) -> str:
        parent_sound = super().speak()         # super() delegates to Cat
        return f"{parent_sound} (tiny)"

# Polymorphism: same call, different behavior
animals: list[Animal] = [Dog("Rex"), Cat("Mia"), Kitten("Dot")]
for a in animals:
    print(a.speak())

# Multiple inheritance
class Pet:
    def is_pet(self) -> bool:
        return True

class PetDog(Dog, Pet):        # inherits from both
    pass

pd = PetDog("Buddy")
pd.speak()     # "Buddy: Woof!"  — from Dog
pd.is_pet()    # True            — from Pet
pd.fetch()     # "Buddy fetches the ball"  — from Dog

# Inspect MRO
PetDog.__mro__
# (<class 'PetDog'>, <class 'Dog'>, <class 'Animal'>, <class 'Pet'>, <class 'object'>)

from functools import total_ordering

@total_ordering   # fill in missing comparison methods given __eq__ and one ordering method
class Money:
    """Immutable monetary amount with currency."""
    __slots__ = ("_amount", "_currency")   # save memory, prevent arbitrary attrs

    def __init__(self, amount: float, currency: str = "USD"):
        object.__setattr__(self, "_amount",   round(float(amount), 2))
        object.__setattr__(self, "_currency", currency.upper())

    @property
    def amount(self): return self._amount

    @property
    def currency(self): return self._currency

    # ── String representations ───────────────────────────────────────────────
    def __repr__(self) -> str:
        """Unambiguous developer representation — used in REPL and logs."""
        return f"Money({self._amount!r}, {self._currency!r})"

    def __str__(self) -> str:
        """Human-friendly display — used by print() and str()."""
        return f"{self._currency} {self._amount:,.2f}"

    # ── Equality and hashing ─────────────────────────────────────────────────
    def __eq__(self, other) -> bool:
        if not isinstance(other, Money):
            return NotImplemented   # let Python try the other side
        return self._amount == other._amount and self._currency == other._currency

    def __hash__(self) -> int:
        """If you define __eq__, also define __hash__ or the object becomes unhashable."""
        return hash((self._amount, self._currency))

    # ── Ordering (total_ordering fills in <=, >, >= from these two) ───────────
    def __lt__(self, other) -> bool:
        if not isinstance(other, Money):
            return NotImplemented
        if self._currency != other._currency:
            raise ValueError(f"Cannot compare {self._currency} and {other._currency}")
        return self._amount < other._amount

    # ── Arithmetic ────────────────────────────────────────────────────────────
    def __add__(self, other: "Money") -> "Money":
        if self._currency != other._currency:
            raise ValueError("Cannot add different currencies")
        return Money(self._amount + other._amount, self._currency)

    def __mul__(self, factor: float) -> "Money":
        return Money(self._amount * factor, self._currency)

    def __rmul__(self, factor: float) -> "Money":
        """Right multiplication: 3 * money works too."""
        return self.__mul__(factor)

    def __neg__(self) -> "Money":
        return Money(-self._amount, self._currency)

    # ── Setattr guard for immutability ────────────────────────────────────────
    def __setattr__(self, name, value):
        raise AttributeError("Money is immutable")

# Rich, native-feeling API
price  = Money(19.99, "USD")
tax    = Money(1.60,  "USD")
total  = price + tax           # Money(21.59, 'USD')
print(total)                   # USD 21.59
repr(price)                    # "Money(19.99, 'USD')"
3 * price                      # Money(59.97, 'USD')
sorted([Money(5), Money(2), Money(9)])   # [Money(2.0, 'USD'), Money(5.0, ...), ...]
{price, total}                 # works: Money is hashable

from typing import Protocol

# Inheritance approach — tightly couples Notifier logic into OrderService
class EmailService:
    def send(self, to: str, subject: str, body: str): ...

class OrderServiceWithEmail(EmailService):   # IS-A EmailService? No!
    def place_order(self, order):
        # ...process order...
        self.send(order.email, "Order confirmed", f"Order {order.id}")
# Problem: OrderService now depends on email internals; can't use SMS; can't mock easily

# ─────────────────────────────────────────────────────────────────────────────
# Composition approach — inject the dependency

class Notifier(Protocol):                    # define the contract
    def notify(self, recipient: str, message: str) -> None: ...

class EmailNotifier:
    def notify(self, recipient: str, message: str) -> None:
        print(f"Email to {recipient}: {message}")

class SMSNotifier:
    def notify(self, recipient: str, message: str) -> None:
        print(f"SMS to {recipient}: {message}")

class OrderService:
    def __init__(self, notifier: Notifier):  # HAS-A notifier; don't care which
        self._notifier = notifier

    def place_order(self, order):
        # ...process order...
        self._notifier.notify(order.email, f"Order {order.id} confirmed")

# At the call site, swap the implementation
service = OrderService(EmailNotifier())      # production
service = OrderService(SMSNotifier())        # for SMS channels

# For testing: inject a mock
class FakeNotifier:
    def __init__(self): self.sent = []
    def notify(self, recipient, message): self.sent.append((recipient, message))

fake = FakeNotifier()
service = OrderService(fake)
service.place_order(order)
assert len(fake.sent) == 1    # easy to test, no email actually sent