Design Patterns

Need to create objects?
├── Only ONE instance needed? ───────────────────► SINGLETON
├── Don't know exact class at compile time? ────► FACTORY
├── Object has many optional parameters? ───────► BUILDER
└── Need to copy existing objects? ─────────────► PROTOTYPE

Need to compose/structure objects?
├── Incompatible interfaces? ───────────────────► ADAPTER
├── Add behavior without subclassing? ──────────► DECORATOR
├── Simplify complex subsystem? ────────────────► FACADE
├── Tree-like hierarchies? ─────────────────────► COMPOSITE
└── Control access to object? ──────────────────► PROXY

Need to manage object behavior/communication?
├── Swap algorithms at runtime? ────────────────► STRATEGY
├── Notify multiple objects of changes? ────────► OBSERVER
├── Object behavior changes with state? ────────► STATE
├── Queue and undo operations? ─────────────────► COMMAND
├── Traverse collection without exposing internals? ► ITERATOR
└── Reduce coupling between objects? ───────────► MEDIATOR

from abc import ABC, abstractmethod

# Product interface -- all notifications share this contract (Abstraction)
class Notification(ABC):
    @abstractmethod
    def send(self, message: str):
        pass

# Concrete products
class EmailNotification(Notification):
    def send(self, message: str):
        print(f"Sending email: {message}")

class SMSNotification(Notification):
    def send(self, message: str):
        print(f"Sending SMS: {message}")

class PushNotification(Notification):
    def send(self, message: str):
        print(f"Sending push: {message}")

# Factory
class NotificationFactory:
    @staticmethod
    def create(channel: str) -> Notification:
        factories = {
            "email": EmailNotification,
            "sms": SMSNotification,
            "push": PushNotification
        }
        if channel not in factories:
            raise ValueError(f"Unknown channel: {channel}")
        return factories[channel]()

# Usage
notification = NotificationFactory.create("email")
notification.send("Hello!")

class Pizza:
    def __init__(self):
        self.size = None
        self.cheese = False
        self.pepperoni = False
        self.mushrooms = False
    
    def __str__(self):
        toppings = []
        if self.cheese: toppings.append("cheese")
        if self.pepperoni: toppings.append("pepperoni")
        if self.mushrooms: toppings.append("mushrooms")
        return f"{self.size} pizza with {', '.join(toppings)}"

class PizzaBuilder:
    def __init__(self):
        self.pizza = Pizza()
    
    def set_size(self, size: str):
        self.pizza.size = size
        return self
    
    def add_cheese(self):
        self.pizza.cheese = True
        return self
    
    def add_pepperoni(self):
        self.pizza.pepperoni = True
        return self
    
    def add_mushrooms(self):
        self.pizza.mushrooms = True
        return self
    
    def build(self) -> Pizza:
        return self.pizza

# Usage - fluent interface
pizza = (PizzaBuilder()
         .set_size("large")
         .add_cheese()
         .add_pepperoni()
         .build())
print(pizza)  # large pizza with cheese, pepperoni

# Existing interface (what client expects)
class ModernPayment(ABC):
    @abstractmethod
    def pay(self, amount: float) -> bool:
        pass

# Legacy system (what we have)
class LegacyPaymentGateway:
    def make_payment(self, dollars: int, cents: int) -> str:
        return f"Paid ${dollars}.{cents:02d}"

# Adapter
class PaymentAdapter(ModernPayment):
    def __init__(self, legacy: LegacyPaymentGateway):
        self.legacy = legacy
    
    def pay(self, amount: float) -> bool:
        dollars = int(amount)
        cents = int((amount - dollars) * 100)
        result = self.legacy.make_payment(dollars, cents)
        return "Paid" in result

# Usage
legacy_gateway = LegacyPaymentGateway()
payment = PaymentAdapter(legacy_gateway)
payment.pay(29.99)

class Coffee(ABC):
    @abstractmethod
    def cost(self) -> float:
        pass
    
    @abstractmethod
    def description(self) -> str:
        pass

class SimpleCoffee(Coffee):
    def cost(self) -> float:
        return 2.0
    
    def description(self) -> str:
        return "Coffee"

class CoffeeDecorator(Coffee):
    def __init__(self, coffee: Coffee):
        self._coffee = coffee

class MilkDecorator(CoffeeDecorator):
    def cost(self) -> float:
        return self._coffee.cost() + 0.5
    
    def description(self) -> str:
        return self._coffee.description() + ", Milk"

class SugarDecorator(CoffeeDecorator):
    def cost(self) -> float:
        return self._coffee.cost() + 0.2
    
    def description(self) -> str:
        return self._coffee.description() + ", Sugar"

# Usage - stack decorators
coffee = SimpleCoffee()
coffee = MilkDecorator(coffee)
coffee = SugarDecorator(coffee)
print(f"{coffee.description()}: ${coffee.cost()}")
# Coffee, Milk, Sugar: $2.7

# Complex subsystems
class VideoFile:
    def __init__(self, filename):
        self.filename = filename

class CodecFactory:
    def extract(self, file):
        return "codec"

class AudioMixer:
    def fix(self, audio):
        return "fixed_audio"

class VideoConverter:
    def convert(self, video, codec):
        return "converted_video"

# Facade - simple interface
class VideoConversionFacade:
    def convert(self, filename: str, format: str) -> str:
        file = VideoFile(filename)
        codec = CodecFactory().extract(file)
        audio = AudioMixer().fix(file)
        result = VideoConverter().convert(file, codec)
        return f"Converted {filename} to {format}"

# Usage - client doesn't know about subsystems
facade = VideoConversionFacade()
result = facade.convert("video.mp4", "avi")

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount: float) -> str:
        pass

class CreditCardPayment(PaymentStrategy):
    def __init__(self, card_number: str):
        self.card_number = card_number
    
    def pay(self, amount: float) -> str:
        return f"Paid ${amount} with card ending {self.card_number[-4:]}"

class PayPalPayment(PaymentStrategy):
    def __init__(self, email: str):
        self.email = email
    
    def pay(self, amount: float) -> str:
        return f"Paid ${amount} via PayPal ({self.email})"

class CryptoPayment(PaymentStrategy):
    def __init__(self, wallet: str):
        self.wallet = wallet
    
    def pay(self, amount: float) -> str:
        return f"Paid ${amount} in crypto to {self.wallet[:8]}..."

# Context
class ShoppingCart:
    def __init__(self):
        self.items = []
        self.payment_strategy = None
    
    def set_payment_strategy(self, strategy: PaymentStrategy):
        self.payment_strategy = strategy
    
    def checkout(self) -> str:
        total = sum(item.price for item in self.items)
        return self.payment_strategy.pay(total)

# Usage - swap strategies at runtime
cart = ShoppingCart()
cart.set_payment_strategy(CreditCardPayment("1234567890123456"))
cart.checkout()

class Subject(ABC):
    @abstractmethod
    def attach(self, observer):
        pass
    
    @abstractmethod
    def detach(self, observer):
        pass
    
    @abstractmethod
    def notify(self):
        pass

class Observer(ABC):
    @abstractmethod
    def update(self, subject):
        pass

class Stock(Subject):
    def __init__(self, symbol: str, price: float):
        self.symbol = symbol
        self._price = price
        self._observers = []
    
    @property
    def price(self):
        return self._price
    
    @price.setter
    def price(self, value):
        self._price = value
        self.notify()
    
    def attach(self, observer):
        self._observers.append(observer)
    
    def detach(self, observer):
        self._observers.remove(observer)
    
    def notify(self):
        for observer in self._observers:
            observer.update(self)

class StockAlert(Observer):
    def __init__(self, name: str):
        self.name = name
    
    def update(self, subject):
        print(f"{self.name}: {subject.symbol} is now ${subject.price}")

# Usage
apple = Stock("AAPL", 150.0)
investor1 = StockAlert("Investor 1")
investor2 = StockAlert("Investor 2")

apple.attach(investor1)
apple.attach(investor2)

apple.price = 155.0  # Both investors notified

class OrderState(ABC):
    @abstractmethod
    def next(self, order):
        pass
    
    @abstractmethod
    def prev(self, order):
        pass
    
    @abstractmethod
    def status(self) -> str:
        pass

class PendingState(OrderState):
    def next(self, order):
        order.state = ProcessingState()
    
    def prev(self, order):
        print("Already at initial state")
    
    def status(self) -> str:
        return "Pending"

class ProcessingState(OrderState):
    def next(self, order):
        order.state = ShippedState()
    
    def prev(self, order):
        order.state = PendingState()
    
    def status(self) -> str:
        return "Processing"

class ShippedState(OrderState):
    def next(self, order):
        order.state = DeliveredState()
    
    def prev(self, order):
        order.state = ProcessingState()
    
    def status(self) -> str:
        return "Shipped"

class DeliveredState(OrderState):
    def next(self, order):
        print("Already delivered")
    
    def prev(self, order):
        print("Cannot go back from delivered")
    
    def status(self) -> str:
        return "Delivered"

class Order:
    def __init__(self):
        self.state = PendingState()
    
    def next_state(self):
        self.state.next(self)
    
    def prev_state(self):
        self.state.prev(self)
    
    def status(self):
        return self.state.status()

# Usage
order = Order()
print(order.status())  # Pending
order.next_state()
print(order.status())  # Processing
order.next_state()
print(order.status())  # Shipped

SINGLETON                    FACTORY                      STRATEGY
┌─────────────┐             ┌─────────────┐             ┌─────────────┐
│  Singleton  │             │   Creator   │             │   Context   │
├─────────────┤             ├─────────────┤             ├─────────────┤
│ -instance   │             │+createProd()│──creates──▷│ -strategy   │
├─────────────┤             └─────────────┘             ├─────────────┤
│+getInstance │                   │                    │+setStrategy │
└─────────────┘                   ▽                    │+execute()   │
                           ┌─────────────┐             └──────┬──────┘
                           │   Product   │                    │
                           └─────────────┘                    ▽
                                 △                   ┌────────────────┐
                          ┌──────┴──────┐            │ <<interface>>  │
                     ┌────┴────┐   ┌────┴────┐       │   Strategy     │
                     │ProductA │   │ProductB │       ├────────────────┤
                     └─────────┘   └─────────┘       │+execute()      │
                                                     └────────────────┘
                                                            △
                                                     ┌──────┴──────┐
                                                 ┌───┴───┐   ┌───┴───┐
                                                 │StratA │   │StratB │
                                                 └───────┘   └───────┘

OBSERVER                     STATE                        DECORATOR
┌─────────────┐             ┌─────────────┐             ┌─────────────┐
│   Subject   │             │   Context   │             │  Component  │
├─────────────┤             ├─────────────┤             ├─────────────┤
│ -observers  │             │ -state      │             │+operation() │
├─────────────┤             ├─────────────┤             └──────┬──────┘
│+attach()    │             │+setState()  │                    △
│+notify()    │             │+request()   │             ┌──────┴──────┐
└──────┬──────┘             └──────┬──────┘        ┌────┴────┐   ┌────┴────┐
       │                           │               │Concrete │   │Decorator│
       ▽                           ▽               │Component│   ├─────────┤
┌────────────────┐         ┌───────────────┐       └─────────┘   │-wrapped │
│ <<interface>>  │         │ <<interface>> │                     │+op()    │
│   Observer     │         │    State      │                     └────┬────┘
├────────────────┤         ├───────────────┤                          △
│+update()       │         │+handle()      │                   ┌──────┴──────┐
└────────────────┘         └───────────────┘               ┌───┴───┐   ┌───┴───┐
       △                          △                        │DecorA │   │DecorB │
   ┌───┴───┐               ┌──────┴──────┐                 └───────┘   └───────┘
   │ConcObs│           ┌───┴───┐   ┌───┴───┐
   └───────┘           │StateA │   │StateB │
                       └───────┘   └───────┘