S010 · Inheritance, Composition & Polymorphism

"""s010_inheritance_composition.py — the four re-use tools, side by side."""
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Protocol, runtime_checkable
 
# =========================
# Part 1 · Single inheritance done right
# =========================
print("--- Part 1 · single inheritance ---")
 
class Animal:
    def __init__(self, name: str) -> None:
        self.name = name
 
    def speak(self) -> str:
        raise NotImplementedError(f"{type(self).__name__} must implement speak()")
 
    def __repr__(self) -> str:
        return f"{type(self).__name__}(name={self.name!r})"
 
class Dog(Animal):
    def speak(self) -> str:
        return "woof"
 
class Cat(Animal):
    def speak(self) -> str:
        return "meow"
 
for a in [Dog("rex"), Cat("whiskers")]:
    print(a, a.speak())
 
# =========================
# Part 2 · super() and the MRO
# =========================
print("\n--- Part 2 · MRO ---")
 
class A:
    def greet(self): return "A"
 
class B(A):
    def greet(self): return "B → " + super().greet()
 
class C(A):
    def greet(self): return "C → " + super().greet()
 
class D(B, C):
    def greet(self): return "D → " + super().greet()
 
print(D().greet())
print("MRO:", [c.__name__ for c in D.__mro__])
 
# The MRO explains WHY B's super() ends up calling C's greet(), not A's.
 
# =========================
# Part 3 · Composition — the flexible alternative
# =========================
print("\n--- Part 3 · composition ---")
 
class Engine:
    def start(self) -> str: return "gas engine running"
 
class ElectricMotor:
    def start(self) -> str: return "silent electric motor running"
 
class Car:
    """Car HAS-A drivetrain. Swap the piece — the Car is unaffected."""
    def __init__(self, drivetrain) -> None:
        self.drivetrain = drivetrain
 
    def start(self) -> str:
        return f"key turned; {self.drivetrain.start()}"
 
gas_car   = Car(Engine())
tesla     = Car(ElectricMotor())
print(gas_car.start())
print(tesla.start())
 
# Contrast with inheritance:
# class GasCar(Engine): ...
# class TeslaCar(ElectricMotor): ...
# Now GasCar IS-A Engine, which is weird and locks you in.
 
# =========================
# Part 4 · Duck typing — the Python default
# =========================
print("\n--- Part 4 · duck typing ---")
 
def summarize(source) -> str:
    """Anything with .read() works — no declarations required."""
    text = source.read()
    return f"read {len(text)} chars starting {text[:30]!r}"
 
from io import StringIO
print(summarize(StringIO("hello from stringio " * 5)))
print(summarize(open(__file__)))    # a real file also has .read()
 
# =========================
# Part 5 · Protocol — duck typing + static check
# =========================
print("\n--- Part 5 · Protocol ---")
 
@runtime_checkable
class Readable(Protocol):
    def read(self) -> str: ...
 
def summarize_typed(source: Readable) -> str:
    return f"typed: read {len(source.read())} chars"
 
print(summarize_typed(StringIO("typed stringio")))
print(isinstance(StringIO(), Readable))   # runtime check enabled by @runtime_checkable
print(isinstance(42, Readable))            # False — no .read()
 
# =========================
# Part 6 · ABC — when you MUST enforce a contract
# =========================
print("\n--- Part 6 · ABC ---")
 
class Storage(ABC):
    """Contract that every backend MUST implement."""
    @abstractmethod
    def save(self, key: str, value: bytes) -> None: ...
    @abstractmethod
    def load(self, key: str) -> bytes: ...
 
class InMemoryStorage(Storage):
    def __init__(self) -> None: self._data: dict[str, bytes] = {}
    def save(self, key: str, value: bytes) -> None: self._data[key] = value
    def load(self, key: str) -> bytes: return self._data[key]
 
class BrokenStorage(Storage):
    def save(self, key: str, value: bytes) -> None:
        self._data = value    # forgot to implement load — instantiation will FAIL
 
try:
    BrokenStorage()
except TypeError as e:
    print("caught abstract-not-implemented:", e)
 
s = InMemoryStorage()
s.save("hello", b"world")
print("loaded:", s.load("hello"))
 
# =========================
# Part 7 · Mixins — orthogonal behaviour
# =========================
print("\n--- Part 7 · mixins ---")
 
class LoggingMixin:
    """Adds .log(). Does NOT stand alone — pairs with a concrete class."""
    def log(self, msg: str) -> None:
        print(f"[{type(self).__name__}] {msg}")
 
class SerializableMixin:
    def to_dict(self) -> dict:
        return {k: v for k, v in vars(self).items() if not k.startswith("_")}
 
class User(LoggingMixin, SerializableMixin):
    def __init__(self, name: str, role: str) -> None:
        self.name = name
        self.role = role
 
u = User("ada", "engineer")
u.log("created")
print(u.to_dict())
# Django's class-based views are 20 layers of this. Use sparingly.
 
# =========================
# Part 8 · Composition vs inheritance — same problem, both solutions
# =========================
print("\n--- Part 8 · trade-off ---")
 
# Inheritance
class Bird:
    def move(self) -> str: return "walks"
 
class FlyingBird(Bird):
    def move(self) -> str: return "flies"
 
class Penguin(Bird):
    pass   # inherits ‘walks’ — is that right? What about Ostrich? What about a bird that swims?
           # Every new behaviour = new subclass or override. Combinatorial mess.
 
# Composition
class Movement:
    def __init__(self, verb: str) -> None: self.verb = verb
    def describe(self, name: str) -> str: return f"{name} {self.verb}"
 
class Bird2:
    def __init__(self, name: str, movement: Movement) -> None:
        self.name = name
        self.movement = movement
    def describe(self) -> str: return self.movement.describe(self.name)
 
print(Bird2("eagle", Movement("flies")).describe())
print(Bird2("penguin", Movement("swims")).describe())
print(Bird2("ostrich", Movement("runs fast")).describe())
# Composition scales linearly with behaviours; inheritance scales combinatorially.