SOLID Introduction

# ❌ BAD: UserManager does EVERYTHING
class UserManager:
    def create_user(self): pass
    def send_email(self): pass      # Email is a different job!
    def generate_report(self): pass  # Reporting is different too!

# ✅ GOOD: Each class has ONE job
class UserService:
    def create_user(self): pass

class EmailService:
    def send_email(self): pass

class ReportService:
    def generate_report(self): pass

# ❌ BAD: Must modify when adding new shapes
class AreaCalculator:
    def calculate(self, shape):
        if shape.type == "circle":
            return 3.14 * shape.radius ** 2
        elif shape.type == "rectangle":  # Must keep adding elif!
            return shape.width * shape.height

# ✅ GOOD: Add new shapes without changing existing code
class Shape:
    def area(self): pass

class Circle(Shape):
    def area(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def area(self):
        return self.width * self.height

# Adding Triangle? Just create new class, don't touch existing!

# ❌ BAD: Penguin breaks the Bird contract
class Bird:
    def fly(self): pass

class Penguin(Bird):  # But penguins can't fly! 🐧
    def fly(self):
        raise Exception("I can't fly!")  # Surprise!

# ✅ GOOD: Separate flying and non-flying birds
class Bird:
    def eat(self): pass

class FlyingBird(Bird):
    def fly(self): pass

class Penguin(Bird):  # No fly() method to break
    def swim(self): pass

# ❌ BAD: Forces all workers to implement every method
class Worker:
    def work(self): pass
    def eat(self): pass
    def sleep(self): pass

class Robot(Worker):  # Robots don't eat or sleep!
    def eat(self): raise Exception("I don't eat!")
    def sleep(self): raise Exception("I don't sleep!")

# ✅ GOOD: Separate interfaces
class Workable:
    def work(self): pass

class Eatable:
    def eat(self): pass

class Robot(Workable):  # Only implements what it needs
    def work(self): pass

# ❌ BAD: High-level depends on low-level details
class PaymentProcessor:
    def __init__(self):
        self.stripe = StripeAPI()  # Directly tied to Stripe!
    
    def pay(self, amount):
        self.stripe.charge(amount)  # What if we switch to PayPal?

# ✅ GOOD: Depend on abstraction
class PaymentGateway:  # Abstract
    def charge(self, amount): pass

class PaymentProcessor:
    def __init__(self, gateway: PaymentGateway):  # Accept ANY gateway
        self.gateway = gateway
    
    def pay(self, amount):
        self.gateway.charge(amount)  # Works with Stripe, PayPal, anything!