Inheritance —
Building on What
Already Works.

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

    def speak(self) -> str:
        return f"{self.name} says {self.sound}"

    def describe(self) -> str:
        return f"{self.name} is an animal."

# Dog inherits everything Animal has — and adds its own behavior
class Dog(Animal):
    def __init__(self, name: str, breed: str):
        super().__init__(name, sound="Woof")
        self.breed = breed

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

# Cat overrides describe() with its own version
class Cat(Animal):
    def __init__(self, name: str):
        super().__init__(name, sound="Meow")

    def describe(self) -> str:
        return f"{self.name} is an independent cat."

dog = Dog("Rex", "Labrador")
cat = Cat("Whiskers")
print(dog.speak())
print(dog.fetch())
print(dog.describe())
print(cat.speak())
print(cat.describe())

# Hierarchical: Car and Motorcycle both extend Vehicle independently
class Vehicle:
    def __init__(self, brand: str, top_speed: int):
        self.brand = brand
        self.top_speed = top_speed

    def info(self) -> str:
        return f"{self.brand} — top speed {self.top_speed} km/h"

class Car(Vehicle):
    def honk(self) -> str:
        return "Beep beep!"

class Motorcycle(Vehicle):
    def wheelie(self) -> str:
        return f"{self.brand} pops a wheelie!"

# Multiple: Amphibious combines Car and Boat capabilities
class Boat:
    def float_on_water(self) -> str:
        return "Floating smoothly."

class AmphibiousVehicle(Car, Boat):
    pass

splash = AmphibiousVehicle("Gibbs Aquada", 160)
print(splash.info())
print(splash.honk())
print(splash.float_on_water())
print(AmphibiousVehicle.__mro__)

class Employee:
    def __init__(self, name: str, base_salary: float):
        self.name = name
        self.base_salary = base_salary

    def pay(self) -> float:
        return self.base_salary

    def summary(self) -> str:
        return f"{self.name}: ${self.pay():,.2f}"

class Manager(Employee):
    def __init__(self, name: str, base_salary: float, team_size: int):
        super().__init__(name, base_salary)
        self.team_size = team_size

    def pay(self) -> float:
        base = super().pay()
        bonus = self.team_size * 150
        return base + bonus

    def summary(self) -> str:
        base_summary = super().summary()
        return f"{base_summary} (manages {self.team_size} people)"

emp = Employee("Alex", 4000)
mgr = Manager("Jordan", 6000, team_size=5)
print(emp.summary())
print(mgr.summary())

class Shape:
    def area(self) -> float:
        raise NotImplementedError("Subclasses must implement area()")

    def describe(self) -> str:
        return f"{type(self).__name__} with area {self.area():.2f}"

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return 3.14159 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    def area(self) -> float:
        return self.width * self.height

class Square(Rectangle):
    def __init__(self, side: float):
        super().__init__(width=side, height=side)

shapes = [Circle(4), Rectangle(3, 5), Square(6)]
for shape in shapes:
    print(shape.describe())

class BaseAgent:
    def __init__(self, name: str):
        self.name = name
        self.memory = []

    def remember(self, event: str) -> None:
        self.memory.append(event)

    def act(self, task: str) -> str:
        self.remember(f"Received task: {task}")
        return self.plan(task)

    def plan(self, task: str) -> str:
        raise NotImplementedError("Subclasses must implement plan()")

class ChatAgent(BaseAgent):
    def plan(self, task: str) -> str:
        return f"[{self.name}] Responding conversationally to: '{task}'"

class RetrieverAgent(BaseAgent):
    def __init__(self, name: str, index_size: int):
        super().__init__(name)
        self.index_size = index_size

    def plan(self, task: str) -> str:
        return f"[{self.name}] Searching {self.index_size} documents for: '{task}'"

agents = [ChatAgent("Chatty"), RetrieverAgent("Finder", index_size=50000)]
for agent in agents:
    print(agent.act("Summarize today's OOP lesson"))
    print(f"Memory size: {len(agent.memory)}")

from abc import ABC, abstractmethod

class Serializer(ABC):
    @abstractmethod
    def to_dict(self) -> dict:
        ...

class JsonMixin:
    def to_json(self) -> str:
        import json
        return json.dumps(self.to_dict())

class User(Serializer, JsonMixin):
    def __init__(self, username: str, active: bool):
        self.username = username
        self.active = active

    def to_dict(self) -> dict:
        return {"username": self.username, "active": self.active}

user = User("glenn", True)
print(user.to_json())