OOP Pair Programming

Step 1: Implement a BankAccount class with deposit and withdraw

Step 2: Add transaction history — track every deposit/withdrawal with a timestamp

Step 3: Add a transfer method between two accounts. Ensure atomicity — if the sender has insufficient funds, neither account changes.

Step 4 (if time): Add interest accrual — a method that applies a given interest rate to the balance.

from datetime import datetime
from dataclasses import dataclass, field


@dataclass
class Transaction:
    kind: str        # "deposit" | "withdraw" | "transfer_in" | "transfer_out"
    amount: float
    timestamp: datetime = field(default_factory=datetime.now)
    note: str = ""


class InsufficientFundsError(Exception):
    pass


class BankAccount:
    def __init__(self, owner: str, initial_balance: float = 0.0):
        self.owner = owner
        self._balance = initial_balance
        self._history: list[Transaction] = []

    @property
    def balance(self) -> float:
        return self._balance

    def deposit(self, amount: float) -> None:
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self._balance += amount
        self._history.append(Transaction("deposit", amount))

    def withdraw(self, amount: float) -> None:
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        if amount > self._balance:
            raise InsufficientFundsError(f"Insufficient funds: balance is {self._balance}")
        self._balance -= amount
        self._history.append(Transaction("withdraw", amount))

    def transfer(self, target: "BankAccount", amount: float) -> None:
        if amount > self._balance:
            raise InsufficientFundsError(f"Insufficient funds for transfer")
        # Deduct first, then credit — keeps atomicity in single-threaded context
        self._balance -= amount
        self._history.append(Transaction("transfer_out", amount, note=f"to {target.owner}"))
        target._balance += amount
        target._history.append(Transaction("transfer_in", amount, note=f"from {self.owner}"))

    def apply_interest(self, rate: float) -> None:
        interest = self._balance * rate
        self._balance += interest
        self._history.append(Transaction("deposit", interest, note="interest"))

    def statement(self) -> list[Transaction]:
        return list(self._history)