OOP Basics - Optimization Exercises¶

class OrderManager:
    """Does EVERYTHING related to orders."""

    def __init__(self):
        self.orders = {}
        self.db_connection = self._connect_to_db()
        self.email_client = self._setup_email()
        self.payment_gateway = self._setup_payment()

    def _connect_to_db(self): pass
    def _setup_email(self): pass
    def _setup_payment(self): pass

    # Order CRUD
    def create_order(self, user_id, items): pass
    def get_order(self, order_id): pass
    def update_order(self, order_id, data): pass
    def delete_order(self, order_id): pass

    # Payment
    def charge_customer(self, order_id): pass
    def refund_order(self, order_id): pass
    def check_payment_status(self, order_id): pass

    # Notifications
    def send_confirmation_email(self, order_id): pass
    def send_shipping_notification(self, order_id): pass
    def send_refund_notification(self, order_id): pass

    # Reporting
    def generate_daily_report(self): pass
    def calculate_revenue(self, start_date, end_date): pass
    def export_to_csv(self, filepath): pass

    # Inventory
    def check_inventory(self, item_id): pass
    def reserve_inventory(self, items): pass
    def release_inventory(self, items): pass

    # 500+ more lines...

class OrderService:
    """Handles order lifecycle only."""
    def __init__(self, repo: "OrderRepository", payment: "PaymentService",
                 notifier: "NotificationService", inventory: "InventoryService"):
        self.repo = repo
        self.payment = payment
        self.notifier = notifier
        self.inventory = inventory

    def create_order(self, user_id: str, items: list) -> "Order":
        self.inventory.reserve(items)
        order = Order(user_id=user_id, items=items)
        self.repo.save(order)
        self.notifier.send_confirmation(order)
        return order

    def cancel_order(self, order_id: str) -> None:
        order = self.repo.find_by_id(order_id)
        self.payment.refund(order)
        self.inventory.release(order.items)
        self.notifier.send_cancellation(order)
        self.repo.delete(order_id)


class OrderRepository:
    """Database operations for orders."""
    def save(self, order: "Order") -> None: pass
    def find_by_id(self, order_id: str) -> "Order": pass
    def delete(self, order_id: str) -> None: pass


class PaymentService:
    """Payment operations."""
    def charge(self, order: "Order") -> None: pass
    def refund(self, order: "Order") -> None: pass


class NotificationService:
    """All notification types."""
    def send_confirmation(self, order: "Order") -> None: pass
    def send_cancellation(self, order: "Order") -> None: pass
    def send_shipping(self, order: "Order") -> None: pass


class InventoryService:
    """Inventory management."""
    def reserve(self, items: list) -> None: pass
    def release(self, items: list) -> None: pass
    def check(self, item_id: str) -> int: pass


class ReportService:
    """Reporting and analytics."""
    def daily_report(self) -> str: pass
    def revenue(self, start_date, end_date) -> float: pass
    def export_csv(self, filepath: str) -> None: pass

from dataclasses import dataclass

@dataclass(frozen=True)  # frozen=True makes it immutable
class Config:
    host: str = "localhost"
    port: int = 8080
    database: str = ""
    debug: bool = False

cfg = Config(host="prod.example.com", port=443)
# cfg.port = 9999  # FrozenInstanceError!

# To "change", create a new one:
from dataclasses import replace
new_cfg = replace(cfg, port=8443)  # New Config with different port

def calculate_area(shape):
    if isinstance(shape, Circle):
        return math.pi * shape.radius ** 2
    elif isinstance(shape, Rectangle):
        return shape.width * shape.height
    elif isinstance(shape, Triangle):
        s = (shape.a + shape.b + shape.c) / 2
        return math.sqrt(s * (s - shape.a) * (s - shape.b) * (s - shape.c))
    else:
        raise ValueError(f"Unknown shape: {type(shape)}")

def calculate_perimeter(shape):
    if isinstance(shape, Circle):
        return 2 * math.pi * shape.radius
    elif isinstance(shape, Rectangle):
        return 2 * (shape.width + shape.height)
    elif isinstance(shape, Triangle):
        return shape.a + shape.b + shape.c
    else:
        raise ValueError(f"Unknown shape: {type(shape)}")

# Every new shape requires modifying EVERY function that handles shapes
# Easy to forget one, leading to runtime errors

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: pass

    @abstractmethod
    def perimeter(self) -> float: pass

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius
    def area(self) -> float:
        return math.pi * self.radius ** 2
    def perimeter(self) -> float:
        return 2 * math.pi * self.radius

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
    def perimeter(self) -> float:
        return 2 * (self.width + self.height)

# Adding new shape: create ONE class, implement TWO methods. Done.
class Pentagon(Shape):
    def __init__(self, side: float):
        self.side = side
    def area(self) -> float:
        return (math.sqrt(5 * (5 + 2 * math.sqrt(5))) / 4) * self.side ** 2
    def perimeter(self) -> float:
        return 5 * self.side

# No existing code modified!
def total_area(shapes: list[Shape]) -> float:
    return sum(s.area() for s in shapes)  # Works with Pentagon automatically

class Logger:
    def log(self, message: str) -> None:
        print(f"[LOG] {message}")

    def format_error(self, error: Exception) -> str:
        return f"ERROR: {type(error).__name__}: {error}"

    def write_to_file(self, path: str, content: str) -> None:
        with open(path, "a") as f:
            f.write(content + "\n")


# BAD: UserService IS-A Logger? No! It just needs logging.
class UserService(Logger):
    def create_user(self, name: str) -> None:
        self.log(f"Creating user: {name}")  # Reuses Logger.log
        # But UserService also inherits write_to_file, format_error, etc.
        # UserService can be used anywhere a Logger is expected — WRONG!

# Type confusion:
def process_log(logger: Logger) -> None:
    logger.write_to_file("out.log", "test")

process_log(UserService())  # Works but makes no sense!

class Logger:
    def log(self, message: str) -> None:
        print(f"[LOG] {message}")


class UserService:
    def __init__(self, logger: Logger):
        self._logger = logger  # HAS-A Logger

    def create_user(self, name: str) -> None:
        self._logger.log(f"Creating user: {name}")
        # UserService is NOT a Logger
        # Clean separation of concerns

# Can't accidentally use UserService as a Logger
# process_log(UserService(Logger()))  # TypeError — correct!

class Order:
    def __init__(self):
        self.status = "pending"

    def update_status(self, new_status: str) -> None:
        valid_transitions = {
            "pending": ["confirmed", "cancelled"],
            "confirmed": ["processing", "cancelled"],
            "processing": ["shipped"],
            "shipped": ["delivered"],
        }
        if new_status not in valid_transitions.get(self.status, []):
            raise ValueError(f"Can't go from {self.status} to {new_status}")
        self.status = new_status

order = Order()
order.update_status("confirmed")   # OK
order.update_status("confrimed")   # Typo → ValueError at runtime, hard to catch

from enum import Enum, auto

class OrderStatus(Enum):
    PENDING = auto()
    CONFIRMED = auto()
    PROCESSING = auto()
    SHIPPED = auto()
    DELIVERED = auto()
    CANCELLED = auto()

VALID_TRANSITIONS: dict[OrderStatus, set[OrderStatus]] = {
    OrderStatus.PENDING: {OrderStatus.CONFIRMED, OrderStatus.CANCELLED},
    OrderStatus.CONFIRMED: {OrderStatus.PROCESSING, OrderStatus.CANCELLED},
    OrderStatus.PROCESSING: {OrderStatus.SHIPPED},
    OrderStatus.SHIPPED: {OrderStatus.DELIVERED},
}

class Order:
    def __init__(self):
        self.status = OrderStatus.PENDING

    def update_status(self, new_status: OrderStatus) -> None:
        allowed = VALID_TRANSITIONS.get(self.status, set())
        if new_status not in allowed:
            raise ValueError(f"Can't go from {self.status.name} to {new_status.name}")
        self.status = new_status

order = Order()
order.update_status(OrderStatus.CONFIRMED)    # OK, type-safe
# order.update_status(OrderStatus.CONFRIMED)  # AttributeError — typo caught immediately!

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

# Auto-generates __init__, __repr__, __eq__
p = Point(3, 4)
print(p)  # Point(x=3, y=4)