Inheritance & Method Overriding

class NotificationSender:
    def send(self, recipient, message):
        return f"[GENERIC] To: {recipient} | Msg: {message}"

class EmailSender(NotificationSender):
    def send(self, recipient, message):
        # Overriding base method with email-specific formatting
        return f"[EMAIL SMTP] Sending '{message}' to <{recipient}>"

class SMSSender(NotificationSender):
    def send(self, recipient, message):
        # Overriding with SMS-specific formatting
        return f"[SMS GATEWAY] Sending '{message}' to phone {recipient}"

services = [
    EmailSender(),
    SMSSender(),
    NotificationSender()
]

for s in services:
    print(s.send("user@pylabs.dev", "Welcome aboard!"))

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

    def calculate_pay(self):
        return self.base_salary

class Manager(Employee):
    def __init__(self, emp_id, name, base_salary, bonus):
        # 1. Delegate core initialization to Employee superclass
        super().__init__(emp_id, name, base_salary)
        # 2. Add Manager-specific state
        self.bonus = bonus

    def calculate_pay(self):
        # 3. Extend base pay calculation
        return super().calculate_pay() + self.bonus

mgr = Manager(101, "Elena Rostova", 95000, 15000)
print(f"{mgr.name} (ID #{mgr.emp_id}) total pay: ${mgr.calculate_pay()}")

class StorageEngine:
    def save(self, key, data): raise NotImplementedError

class MemoryStorage(StorageEngine):
    def __init__(self): self.store = {}
    def save(self, key, data): self.store[key] = data

class CloudStorage(StorageEngine):
    def save(self, key, data): print(f"Uploading {key} to S3/R2")

def persist_record(engine, key, data):
    # Verify nominal subtype polymorphism
    if not isinstance(engine, StorageEngine):
        raise TypeError(f"Expected StorageEngine, got {type(engine).__name__}")
    engine.save(key, data)

mem = MemoryStorage()
persist_record(mem, "user:1", {"name": "Kaelen"})
print("Memory store contents:", mem.store)
print("Is MemoryStorage subclass of StorageEngine?", issubclass(MemoryStorage, StorageEngine))
print("Is mem an instance of (CloudStorage, MemoryStorage)?", isinstance(mem, (CloudStorage, MemoryStorage)))

class Vehicle:
    def move(self):
        return "Moving forward"

class Airplane(Vehicle):
    def move(self):
        return "Flying through the sky"

plane = Airplane()
print("Plane movement:", plane.move())

# Service integration layer
def handle_request(payload: dict) -> dict:
    return {"status": "success", "processed": True}

# High-resilience production pattern
import time

def process_stream(events: list) -> int:
    processed = 0
    for event in events:
        if event:
            processed += 1
    return processed