Hands-on lab — Day 67: Classes and Objects

"""The 'before' version: a dict of state plus a pile of loose functions.

This is how you have modelled a bank account with everything you knew up to
Day 66. It works, but notice the friction:

* every function must be handed the same dict as its first argument;
* the rules ("balance is never negative", "every movement is recorded")
  live in the functions, not with the data, so nothing stops a caller from
  writing account["balance"] = -500 and breaking them;
* the state and the behaviour are only related by convention and by you
  remembering which functions belong to which dict.

Day 67 turns exactly this file into a class. Run it directly to see it work:

    python3 examples/account_dict.py
"""


def make_account(owner, balance=0.0):
    """owner, starting balance -> a new account dict with its own history."""
    if float(balance) < 0:
        raise ValueError("balance cannot be negative")
    return {"owner": owner, "balance": float(balance), "history": []}


def deposit(account, amount):
    """Add a positive amount, record it, and return the new balance."""
    if amount <= 0:
        raise ValueError("deposit amount must be positive")
    account["balance"] += float(amount)
    account["history"].append(("deposit", float(amount)))
    return account["balance"]


def withdraw(account, amount):
    """Remove a positive amount that the balance can cover."""
    if amount <= 0:
        raise ValueError("withdrawal amount must be positive")
    if amount > account["balance"]:
        raise ValueError("insufficient funds")
    account["balance"] -= float(amount)
    account["history"].append(("withdraw", float(amount)))
    return account["balance"]


def describe(account):
    """A one-line human summary of the account dict."""
    return (
        f"{account['owner']}: {account['balance']:.2f} "
        f"({len(account['history'])} entries)"
    )


def main():
    ada = make_account("ada", 100)
    deposit(ada, 50)
    withdraw(ada, 30)
    print(describe(ada))
    try:
        withdraw(ada, 1000)
    except ValueError as err:
        print(f"rejected: {err}")
    # Nothing protects the invariant when a caller edits the dict directly.
    ada["balance"] = -500
    print("after a direct edit:", describe(ada))


if __name__ == "__main__":
    main()

"""The 'after' version: one class binding the state to the behaviour.

Same program as account_dict.py, expressed as a class. The state (owner,
balance, history) and the rules that keep it valid now live in one named
thing, and the balance can no longer be set to a negative number by anyone,
inside the class or outside it.

Run it directly to see the same session as the dict version:

    python3 examples/account.py
"""


class Account:
    """A bank account: an owner, a balance, and a history of movements.

    Invariant (the rule this class exists to keep): the balance is never
    negative, and every movement is recorded in *this instance's own*
    history list.
    """

    currency = "USD"        # class attribute: one value shared by every account
    accounts_opened = 0     # class attribute: a counter, rebound (not mutated)

    def __init__(self, owner, balance=0.0):
        """Initialize an account that Python has already created for us."""
        self.owner = owner
        self.balance = balance      # goes through the property setter below
        self.history = []           # a FRESH list for every instance
        Account.accounts_opened += 1

    # --- the property: a computed, validated attribute -------------------
    @property
    def balance(self):
        """The current balance. Assigning a negative value is rejected."""
        return self._balance

    @balance.setter
    def balance(self, value):
        amount = float(value)
        if amount < 0:
            raise ValueError(f"balance cannot be negative (got {amount:.2f})")
        self._balance = amount

    # --- a staticmethod: a rule that needs neither instance nor class ----
    @staticmethod
    def is_valid_amount(amount):
        """True when amount is a positive number. Takes no self and no cls."""
        return isinstance(amount, (int, float)) and amount > 0

    # --- a classmethod: an alternative constructor -----------------------
    @classmethod
    def from_csv_row(cls, row):
        """Build an account from one CSV line: 'ada,120.50' (ties to Day 65)."""
        parts = [field.strip() for field in row.split(",")]
        if len(parts) != 2:
            raise ValueError(f"expected 'owner,balance', got {row!r}")
        owner, balance = parts
        return cls(owner, float(balance))

    # --- ordinary methods: behaviour that maintains the invariant --------
    def deposit(self, amount):
        """Add a positive amount, record it, and return the new balance."""
        if not self.is_valid_amount(amount):
            raise ValueError("deposit amount must be positive")
        self.balance = self.balance + amount
        self.history.append(("deposit", float(amount)))
        return self.balance

    def withdraw(self, amount):
        """Remove a positive amount the balance can cover."""
        if not self.is_valid_amount(amount):
            raise ValueError("withdrawal amount must be positive")
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance = self.balance - amount
        self.history.append(("withdraw", float(amount)))
        return self.balance

    def describe(self):
        """A one-line human summary, the same text the dict version prints."""
        return f"{self.owner}: {self.balance:.2f} ({len(self.history)} entries)"

    def __repr__(self):
        """What you see in the debugger and the REPL. Every class deserves one."""
        return f"Account(owner={self.owner!r}, balance={self.balance:.2f})"


def main():
    ada = Account("ada", 100)
    ada.deposit(50)
    ada.withdraw(30)
    print(ada.describe())
    try:
        ada.withdraw(1000)
    except ValueError as err:
        print(f"rejected: {err}")
    # The direct edit that broke the dict version is refused here.
    try:
        ada.balance = -500
    except ValueError as err:
        print(f"rejected: {err}")
    print("after the refused edit:", ada.describe())
    print("repr:", repr(ada))


if __name__ == "__main__":
    main()

ada,100.00
bob,250.50
cleo,0.00
dev,1875.25

"""Build a minimal object system from scratch, with dicts and closures.

A class is not a new kind of thing in the language; it is state plus
functions-that-share-that-state, with syntax on top. Here is the same
account built twice: once by hand (a dict of closures over a captured
variable, using only Day 58 knowledge) and once with `class`.

Run it:

    python3 examples/closure_object.py
"""


def make_account(owner, balance=0.0):
    """Return a dict of closures that all share one hidden `state` dict.

    This IS an object: `state` is the instance's private attribute storage,
    and the returned dict is the method table. There is no `class` keyword
    anywhere, and no `self` -- the closure captures the state instead.
    """
    state = {"owner": owner, "balance": float(balance), "history": []}

    def deposit(amount):
        if amount <= 0:
            raise ValueError("deposit amount must be positive")
        state["balance"] += float(amount)
        state["history"].append(("deposit", float(amount)))
        return state["balance"]

    def withdraw(amount):
        if amount <= 0:
            raise ValueError("withdrawal amount must be positive")
        if amount > state["balance"]:
            raise ValueError("insufficient funds")
        state["balance"] -= float(amount)
        state["history"].append(("withdraw", float(amount)))
        return state["balance"]

    def describe():
        return f"{state['owner']}: {state['balance']:.2f} ({len(state['history'])} entries)"

    return {"deposit": deposit, "withdraw": withdraw, "describe": describe,
            "state": state}


class ClassAccount:
    """The same thing, with the language doing the wiring for you."""

    def __init__(self, owner, balance=0.0):
        self.owner = owner
        self.balance = float(balance)
        self.history = []

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("deposit amount must be positive")
        self.balance += float(amount)
        self.history.append(("deposit", float(amount)))
        return self.balance

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("withdrawal amount must be positive")
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance -= float(amount)
        self.history.append(("withdraw", float(amount)))
        return self.balance

    def describe(self):
        return f"{self.owner}: {self.balance:.2f} ({len(self.history)} entries)"


def main():
    print("--- hand-built object (dicts + closures, no class keyword) ---")
    hand = make_account("ada", 100)
    hand["deposit"](50)
    hand["withdraw"](30)
    print("describe():", hand["describe"]())
    print("method table keys:", sorted(hand))
    print("hidden state:", hand["state"])
    print("each call needs its dict:  hand['deposit'](50)")

    print()
    print("--- the same thing with `class` ---")
    sugar = ClassAccount("ada", 100)
    sugar.deposit(50)
    sugar.withdraw(30)
    print("describe():", sugar.describe())
    print("method table keys:",
          sorted(n for n in vars(ClassAccount) if not n.startswith("__")))
    print("hidden state:", vars(sugar))
    print("each call finds its object: sugar.deposit(50)")

    print()
    print("--- same answers, different amount of sugar ---")
    print("outputs identical:", hand["describe"]() == sugar.describe())
    print("hand-built keeps state in a captured dict; the class keeps it in "
          "the instance __dict__")
    print("hand-built copies every function per account; the class stores "
          "one function per method, shared")
    print("two hand-built accounts share no functions:",
          make_account('x')['deposit'] is make_account('y')['deposit'])
    print("two class instances share one function:",
          ClassAccount('x').deposit.__func__ is ClassAccount('y').deposit.__func__)


if __name__ == "__main__":
    main()

"""Prove the class version behaves exactly like the dict version.

Refactoring is only safe when you can show the behaviour did not change.
This script drives account_dict.py and account.py through the same script of
moves and compares what each produced -- then loads a whole CSV file through
the classmethod constructor. Run it:

    python3 examples/compare.py
"""

import os

import account_dict as old
from account import Account

MOVES = [("deposit", 50), ("withdraw", 30), ("deposit", 12.5), ("withdraw", 2.5)]
HERE = os.path.dirname(os.path.abspath(__file__))


def run_dict_version():
    """Drive the dict + functions version and return (description, history)."""
    acct = old.make_account("ada", 100)
    for move, amount in MOVES:
        if move == "deposit":
            old.deposit(acct, amount)
        else:
            old.withdraw(acct, amount)
    return old.describe(acct), acct["history"]


def run_class_version():
    """Drive the class version through the identical script of moves."""
    acct = Account("ada", 100)
    for move, amount in MOVES:
        getattr(acct, move)(amount)
    return acct.describe(), acct.history


def main():
    dict_text, dict_history = run_dict_version()
    class_text, class_history = run_class_version()

    print("--- same behaviour, two designs ---")
    print("dict version :", dict_text)
    print("class version:", class_text)
    print("descriptions identical:", dict_text == class_text)
    print("histories identical:   ", dict_history == class_history)

    print()
    print("--- what changed is what happens when a rule is broken ---")
    broken = old.make_account("bob", 10)
    broken["balance"] = -500
    print("dict version accepted a negative balance:", broken["balance"])
    guarded = Account("bob", 10)
    try:
        guarded.balance = -500
    except ValueError as err:
        print("class version refused it:", err)
    print("class balance unchanged:", guarded.balance)

    print()
    print("--- loading a CSV file through the alternative constructor ---")
    path = os.path.join(HERE, "accounts.csv")
    with open(path, "r", encoding="utf-8") as handle:
        accounts = [Account.from_csv_row(line) for line in handle if line.strip()]
    for acct in accounts:
        print("  ", repr(acct))
    total = sum(acct.balance for acct in accounts)
    print(f"loaded {len(accounts)} accounts, total {total:.2f} {Account.currency}")


if __name__ == "__main__":
    main()

"""Open the hood: type(), vars(), __dict__, dir(), and bound methods.

Nothing here is magic. A class is an object holding functions; an instance
is an object holding its own attribute dict; attribute lookup checks the
instance first and the class second. Run it:

    python3 examples/machinery.py

Note: this script never prints id() values or a default repr, because those
contain a memory address that changes on every run. It prints comparisons
instead, so the output is identical every time.
"""

from account import Account


class Card:
    """A tiny class showing the two encapsulation conventions side by side."""

    def __init__(self, holder, pin):
        self._holder = holder   # single underscore: "internal, please leave alone"
        self.__pin = pin        # double underscore: renamed by the compiler

    def check(self, guess):
        return guess == self.__pin


def main():
    ada = Account("ada", 100)
    bob = Account("bob", 100)

    print("--- two instances, one class ---")
    print("type(ada):", type(ada).__name__)
    print("type(Account):", type(Account).__name__)
    print("ada is bob:", ada is bob)
    print("id(ada) == id(bob):", id(ada) == id(bob))
    print("type(ada) is type(bob):", type(ada) is type(bob))
    print("ada == bob (no __eq__ defined, so identity is used):", ada == bob)

    print()
    print("--- state lives on the instance ---")
    ada.deposit(50)
    print("vars(ada):", vars(ada))
    print("vars(bob):", vars(bob))
    print("ada.__dict__ is vars(ada):", ada.__dict__ is vars(ada))
    print("'history' in ada.__dict__:", "history" in ada.__dict__)
    print("'deposit' in ada.__dict__:", "deposit" in ada.__dict__)

    print()
    print("--- behaviour lives on the class ---")
    print("class attributes and methods:")
    for name in sorted(vars(Account)):
        if not name.startswith("__"):
            print("   ", name, "->", type(vars(Account)[name]).__name__)
    print("Account.currency:", Account.currency)
    print("ada.currency (found on the class):", ada.currency)
    print("'currency' in ada.__dict__:", "currency" in ada.__dict__)

    print()
    print("--- a method call is a function call with self supplied ---")
    print("type(Account.deposit):", type(Account.deposit).__name__)
    print("type(ada.deposit):", type(ada.deposit).__name__)
    print("ada.deposit.__self__ is ada:", ada.deposit.__self__ is ada)
    print("ada.deposit.__func__ is Account.deposit:",
          ada.deposit.__func__ is Account.deposit)
    before = ada.balance
    Account.deposit(ada, 10)          # the unsugared form
    print(f"Account.deposit(ada, 10) moved the balance {before:.2f} -> {ada.balance:.2f}")

    print()
    print("--- name mangling and the property ---")
    print("'_balance' in ada.__dict__:", "_balance" in ada.__dict__)
    print("type(Account.balance):", type(Account.balance).__name__)
    print("Account.__dict__['is_valid_amount'] type:",
          type(Account.__dict__["is_valid_amount"]).__name__)
    print("Account.__dict__['from_csv_row'] type:",
          type(Account.__dict__["from_csv_row"]).__name__)
    card = Card("ada", "1234")
    print("vars(card):", vars(card))
    print("card.check('1234'):", card.check("1234"))
    print("hasattr(card, '__pin'):", hasattr(card, "__pin"))
    print("hasattr(card, '_Card__pin'):", hasattr(card, "_Card__pin"))

    print()
    print("--- the alternative constructor ---")
    cleo = Account.from_csv_row("cleo, 250.00")
    print("from_csv_row ->", repr(cleo))
    print("built by the same class:", type(cleo) is Account)


if __name__ == "__main__":
    main()

"""The classic mutable-class-attribute bug, reproduced and then fixed.

A list written at class level belongs to the CLASS, not to any instance, so
every instance mutates the same list. Run it:

    python3 examples/shared_bug.py
"""


class BuggyAccount:
    """BUG ON PURPOSE: history is created once, at class-definition time."""

    history = []  # one list, shared by every instance ever created

    def __init__(self, owner):
        self.owner = owner

    def deposit(self, amount):
        # self.history finds no instance attribute, so it falls back to the
        # CLASS attribute -- and .append() mutates that one shared list.
        self.history.append((self.owner, amount))


class FixedAccount:
    """FIXED: the list is created inside __init__, once per instance."""

    def __init__(self, owner):
        self.owner = owner
        self.history = []  # a fresh list, bound to THIS instance

    def deposit(self, amount):
        self.history.append((self.owner, amount))


def main():
    print("--- buggy: one list shared by every instance ---")
    ada = BuggyAccount("ada")
    bob = BuggyAccount("bob")
    ada.deposit(10)
    bob.deposit(20)
    print("ada.history:", ada.history)
    print("bob.history:", bob.history)
    print("same list object?", ada.history is bob.history)
    print("it lives on the class:", BuggyAccount.history)
    print("instance __dict__ of ada:", vars(ada))

    print()
    print("--- fixed: one list per instance ---")
    cleo = FixedAccount("cleo")
    dev = FixedAccount("dev")
    cleo.deposit(10)
    dev.deposit(20)
    print("cleo.history:", cleo.history)
    print("dev.history:", dev.history)
    print("same list object?", cleo.history is dev.history)
    print("instance __dict__ of cleo:", vars(cleo))


if __name__ == "__main__":
    main()

lesson_id: D067
day: 67
kind: coding
languages: [python, bash]
setup_commands:
  - cd labs/sections/programming-with-python/day-067-classes-and-objects
  - python3 --version
run_commands:
  - python3 examples/account_dict.py
  - python3 examples/account.py
  - python3 examples/compare.py
  - python3 examples/shared_bug.py
  - python3 examples/closure_object.py
  - python3 examples/machinery.py
  - python3 starter/account.py
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/account.py starter/inspection-notes.md  # optional: reset your work'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-19'
executed_on: 'macOS (Apple Silicon), Python 3.14.0, bash 3.2 — bash tests/run_tests.sh -> 28 checks, 0 failure(s), exit 0 (34 checks, 0 failure(s) with the starter exercises completed)'

# Dependencies — Day 067 lab

**Python 3 only. No third-party packages.**

- `python3` (3.8 or newer; tested on 3.14.0). You installed this on Day 43.
- `bash` for the test runner (preinstalled on macOS and Linux).
- Standard library only — in fact only `os` (in `examples/compare.py`, to
  find `accounts.csv` next to the script). The classes themselves import
  nothing at all.

There is deliberately no `requirements.txt` and no virtual environment step.
Classes are part of the Python language, not a package: `class`, `self`,
`@property`, `@staticmethod`, `@classmethod`, `vars()`, and `type()` are all
built in, which is why every framework you meet later can assume them.

Check your Python is present and new enough:

```bash
python3 --version
```

If that prints `Python 3.8` or higher, you are ready. Windows users: run the
commands inside WSL, or use `python` in place of `python3` if that is how
Python is exposed on your system. The code is pure standard-library Python
and behaves identically everywhere.

"""YOUR WORKING FILE — Day 67: turn a dict + functions into a class.

The 'before' version you are converting is `examples/account_dict.py`: a
dict holding owner/balance/history plus loose functions that all take that
dict as their first argument. Your job is to bind that state and that
behaviour into one named thing.

Work through the five numbered exercises below in order. Each one names the
exact command to run when you finish it. When every exercise is done, no
`NotImplementedError` remains and the test suite holds your class to the
same standard as the reference.

Run this file at any time to see how far you have got:

    python3 starter/account.py

Run the full suite when you think you are finished:

    bash tests/run_tests.sh
"""


class Account:
    """A bank account: an owner, a balance, and a history of movements.

    Invariant (the rule this class exists to keep): the balance is never
    negative, and every movement is recorded in this instance's own history.
    """

    currency = "USD"        # class attribute: one value shared by every account

    # ---------------------------------------------------------------
    # EXERCISE 2 (do this one AFTER exercise 1)
    #
    # The line below is a deliberate bug: a list written at class level is
    # created ONCE, at class-definition time, and every instance shares it.
    # First see the bug for yourself:
    #
    #     python3 examples/shared_bug.py
    #
    # Then prove it in your own class:
    #
    #     python3 -c "import sys; sys.path.insert(0, 'starter'); from account import Account; a = Account('ada', 10); b = Account('bob', 10); a.deposit(5); print(b.history)"
    #
    # If b.history is not empty, ada's deposit landed in bob's history.
    # FIX: delete the line below and create `self.history = []` inside
    # __init__ instead, so each instance gets a fresh list.
    # ---------------------------------------------------------------
    history = []

    def __init__(self, owner, balance=0.0):
        """EXERCISE 1 — initialize the object Python has already created.

        Set three attributes on `self`:
          * self.owner   -> the owner argument
          * self.balance -> the balance argument (this goes through the
                            property setter you write in exercise 4; until
                            then it just stores the value)
          * self.history -> a NEW empty list (this is also the fix for
                            exercise 2)

        Then run:  python3 starter/account.py
        """
        raise NotImplementedError("exercise 1: set owner, balance, and history on self")

    def deposit(self, amount):
        """EXERCISE 1 (continued) — add a positive amount and record it.

        Mirror examples/account_dict.py's deposit(): reject amounts that are
        not positive with ValueError("deposit amount must be positive"), add
        the amount to self.balance, append ("deposit", float(amount)) to
        self.history, and return the new balance.
        """
        raise NotImplementedError("exercise 1: implement deposit")

    def withdraw(self, amount):
        """EXERCISE 1 (continued) — remove an amount the balance can cover.

        Reject a non-positive amount with
        ValueError("withdrawal amount must be positive"), reject an amount
        larger than the balance with ValueError("insufficient funds"),
        otherwise subtract it, append ("withdraw", float(amount)) to
        self.history, and return the new balance.
        """
        raise NotImplementedError("exercise 1: implement withdraw")

    def describe(self):
        """A one-line summary — provided, so you can compare with the dict version.

        This must print exactly what examples/account_dict.py's describe()
        prints for the same moves. That is how you prove the conversion did
        not change the behaviour:

            python3 examples/compare.py
        """
        return f"{self.owner}: {self.balance:.2f} ({len(self.history)} entries)"

    def __repr__(self):
        """EXERCISE 3 — give the class a useful debugging representation.

        Return the string  Account(owner='ada', balance=120.00)  for an
        account owned by 'ada' holding 120. Use !r on the owner so the
        quotes appear, and :.2f on the balance.

        Before and after, compare what the REPL shows:

            python3 -c "import sys; sys.path.insert(0, 'starter'); from account import Account; print(repr(Account('ada', 120)))"

        Without a __repr__ you get a default like <account.Account object at
        0x...>, whose hex number is a memory address that changes every run
        and tells you nothing about the account.
        """
        raise NotImplementedError("exercise 3: return a useful repr string")

    # ---------------------------------------------------------------
    # EXERCISE 4 — a property that validates.
    #
    # Turn `balance` into a computed attribute backed by self._balance:
    #
    #   @property
    #   def balance(self):
    #       return self._balance
    #
    #   @balance.setter
    #   def balance(self, value):
    #       amount = float(value)
    #       if amount < 0:
    #           raise ValueError(f"balance cannot be negative (got {amount:.2f})")
    #       self._balance = amount
    #
    # Write those two blocks here (delete this comment when you do), then
    # confirm a bad value is refused and the exception is catchable:
    #
    #     python3 -c "import sys; sys.path.insert(0, 'starter'); from account import Account; a = Account('ada', 10)
    #     try:
    #         a.balance = -500
    #     except ValueError as err:
    #         print('rejected:', err)
    #     print('balance still', a.balance)"
    # ---------------------------------------------------------------

    @staticmethod
    def is_valid_amount(amount):
        """Provided: a rule that needs neither the instance nor the class."""
        return isinstance(amount, (int, float)) and amount > 0

    @classmethod
    def from_csv_row(cls, row):
        """EXERCISE 5 — an alternative constructor (ties to Day 65).

        Turn one CSV line, 'ada, 120.50', into an Account:
          * split the row on ',' and strip whitespace from each field;
          * if there are not exactly two fields, raise
            ValueError(f"expected 'owner,balance', got {row!r}");
          * otherwise return cls(owner, float(balance)).

        Use `cls(...)`, not `Account(...)` — that is what makes it an
        alternative constructor rather than a hard-coded factory.

        Then load a whole file with it:

            python3 -c "import sys; sys.path.insert(0, 'starter'); from account import Account; print([Account.from_csv_row(line) for line in open('examples/accounts.csv') if line.strip()])"
        """
        raise NotImplementedError("exercise 5: build an instance from a CSV row")


def main():
    """A short session you can run as you go: python3 starter/account.py"""
    ada = Account("ada", 100)
    ada.deposit(50)
    ada.withdraw(30)
    print(ada.describe())
    print("repr:", repr(ada))
    try:
        ada.balance = -500
    except ValueError as err:
        print("rejected:", err)
    print("from_csv_row:", repr(Account.from_csv_row("cleo, 250.00")))


if __name__ == "__main__":
    main()

# Exercise 6 — inspect the machinery and write down what you see

A class is not magic. It is an object that holds functions; an instance is
an object that holds its own attribute dictionary; and attribute lookup
checks the instance first, then the class. This exercise makes you *look* at
that instead of taking it on faith.

Run the reference inspector first, from the lab directory:

```bash
python3 examples/machinery.py
```

Then run each command below against **your own** class and fill in the
"What I saw" column with the literal output. Every command is one line; copy
it whole.

## 6.1 — Two instances are two different objects

```bash
python3 -c "import sys; sys.path.insert(0, 'starter'); from account import Account; a = Account('ada', 100); b = Account('bob', 100); print(type(a).__name__, a is b, id(a) == id(b), type(a) is type(b))"
```

| Question | What I saw |
| --- | --- |
| What does `type(a).__name__` print? | _fill in_ |
| Is `a is b` true or false, and why? | _fill in_ |
| Is `type(a) is type(b)` true, and what does that tell you? | _fill in_ |

## 6.2 — State lives on the instance

```bash
python3 -c "import sys; sys.path.insert(0, 'starter'); from account import Account; a = Account('ada', 100); b = Account('bob', 100); a.deposit(50); print(vars(a)); print(vars(b))"
```

| Question | What I saw |
| --- | --- |
| Which keys are in `vars(a)`? | _fill in_ |
| Do the two instances hold different values for the same keys? | _fill in_ |
| Is `deposit` one of the keys? Where does it live instead? | _fill in_ |

## 6.3 — Behaviour lives on the class

```bash
python3 -c "import sys; sys.path.insert(0, 'starter'); from account import Account; print(sorted(n for n in vars(Account) if not n.startswith('__')))"
```

| Question | What I saw |
| --- | --- |
| Which names does the class dictionary hold? | _fill in_ |
| Which of them are functions, and which are plain values? | _fill in_ |
| `Account.currency` is not in `vars(a)` — so how does `a.currency` work? | _fill in_ |

## 6.4 — A method call is a function call with `self` supplied

```bash
python3 -c "import sys; sys.path.insert(0, 'starter'); from account import Account; a = Account('ada', 100); print(type(Account.deposit).__name__, type(a.deposit).__name__, a.deposit.__self__ is a, a.deposit.__func__ is Account.deposit)"
```

| Question | What I saw |
| --- | --- |
| What is `type(Account.deposit)`? What is `type(a.deposit)`? | _fill in_ |
| What is `a.deposit.__self__`? | _fill in_ |
| Write out what `a.deposit(50)` becomes in unsugared form. | _fill in_ |

## 6.5 — Write it in your own words

Answer in two or three sentences each, from what you saw above:

1. Where does an instance's state live, and where does its behaviour live?
2. What exactly does `self` refer to, and who passes it?
3. Why did the class version refuse `a.balance = -500` when the dict
   version happily accepted `account["balance"] = -500`?
4. Name one thing in this lab that convinced you a class is "a dict of
   state plus a dict of functions, with syntax on top."

#!/usr/bin/env bash
# Tests for the Day 067 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# These checks exercise real behaviour, not file existence: a class is
# built, its invariant is attacked, its property rejects a bad value, its
# __repr__ is compared to an exact string, and its classmethod builds an
# instance from a CSV row. The dict version and the class version are then
# driven through the same moves and their results compared, which is what
# "the refactor changed nothing" actually means.
#
# Nothing here prints a default object repr, because that contains a memory
# address which differs on every run; the suite compares custom reprs and
# boolean facts instead, so the output is deterministic.
#
# No network, no pip, no sudo, non-interactive. Exits 0 only if every check
# passes.
set -u

export PYTHONDONTWRITEBYTECODE=1

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
failures=0
checks=0

check() {
  local label="$1" ok="$2"
  checks=$((checks + 1))
  if [ "${ok}" = "yes" ]; then
    echo "  ok: ${label}"
  else
    echo "  FAIL: ${label}"
    failures=$((failures + 1))
  fi
}

# check_py <label> <import_dir> <python-body>
# Runs an assertion body with `account` importable from import_dir.
# A clean exit (every assert holds) is a pass.
check_py() {
  local label="$1" import_dir="$2" body="$3"
  if PYTHONPATH="${import_dir}:${lab_dir}/examples" python3 -c "
import sys
sys.path.insert(0, '${import_dir}')
from account import Account
${body}
" 2>/dev/null; then
    check "${label}" "yes"
  else
    check "${label}" "no"
  fi
}

# check_script <label> <script> <needle>
check_script() {
  local label="$1" script="$2" needle="$3"
  local out code
  out="$(cd "${lab_dir}" && python3 "${script}" 2>&1)"
  code=$?
  if [ "${code}" -eq 0 ] && printf '%s' "${out}" | grep -qF "${needle}"; then
    check "${label}" "yes"
  else
    check "${label}" "no"
    echo "    (exit ${code}; output: ${out})"
  fi
}

run_class_checks() {
  local import_dir="$1"
  echo "Testing the Account class in ${import_dir} ..."

  check_py "two instances hold separate state" "${import_dir}" \
    "a = Account('ada', 100)
b = Account('bob', 100)
a.deposit(50)
assert a is not b
assert type(a) is type(b)
assert a.balance == 150.0 and b.balance == 100.0"

  check_py "history is per instance, not shared on the class" "${import_dir}" \
    "a = Account('ada', 100)
b = Account('bob', 100)
a.deposit(50)
assert a.history is not b.history
assert b.history == [], f'shared list bug: {b.history}'
assert a.history == [('deposit', 50.0)]"

  check_py "deposit and withdraw maintain the balance" "${import_dir}" \
    "a = Account('ada', 100)
assert a.deposit(50) == 150.0
assert a.withdraw(30) == 120.0
assert a.describe() == 'ada: 120.00 (2 entries)'"

  check_py "the invariant is defended: overdraft is refused" "${import_dir}" \
    "a = Account('ada', 100)
try:
    a.withdraw(1000)
    raise SystemExit(1)
except ValueError as err:
    assert 'insufficient funds' in str(err)
assert a.balance == 100.0"

  check_py "the property rejects a negative balance" "${import_dir}" \
    "a = Account('ada', 100)
try:
    a.balance = -500
    raise SystemExit(1)
except ValueError as err:
    assert 'negative' in str(err)
assert a.balance == 100.0"

  check_py "balance is a property on the class, backed by _balance" "${import_dir}" \
    "a = Account('ada', 100)
assert isinstance(Account.__dict__['balance'], property)
assert '_balance' in vars(a)
assert 'balance' not in vars(a)"

  check_py "__repr__ is custom and shows the state" "${import_dir}" \
    "a = Account('ada', 120)
assert repr(a) == \"Account(owner='ada', balance=120.00)\", repr(a)
assert 'object at 0x' not in repr(a)"

  check_py "from_csv_row is a classmethod that builds an instance" "${import_dir}" \
    "a = Account.from_csv_row('cleo, 250.00')
assert type(a) is Account
assert a.owner == 'cleo' and a.balance == 250.0
assert isinstance(Account.__dict__['from_csv_row'], classmethod)
try:
    Account.from_csv_row('nonsense')
    raise SystemExit(1)
except ValueError:
    pass"

  check_py "is_valid_amount is a staticmethod" "${import_dir}" \
    "assert isinstance(Account.__dict__['is_valid_amount'], staticmethod)
assert Account.is_valid_amount(5) is True
assert Account.is_valid_amount(-5) is False
assert Account.is_valid_amount('5') is False"

  check_py "a method call is Class.method(instance, ...)" "${import_dir}" \
    "a = Account('ada', 100)
assert a.deposit.__self__ is a
assert a.deposit.__func__ is Account.deposit
Account.deposit(a, 10)
assert a.balance == 110.0"

  check_py "currency is a class attribute seen by every instance" "${import_dir}" \
    "a = Account('ada', 100)
assert 'currency' not in vars(a)
assert a.currency == Account.currency == 'USD'"

  check_py "the class reproduces the dict version's behaviour exactly" "${import_dir}" \
    "import account_dict as old
moves = [('deposit', 50), ('withdraw', 30), ('deposit', 12.5), ('withdraw', 2.5)]
d = old.make_account('ada', 100)
c = Account('ada', 100)
for move, amount in moves:
    (old.deposit if move == 'deposit' else old.withdraw)(d, amount)
    getattr(c, move)(amount)
assert old.describe(d) == c.describe()
assert d['history'] == c.history"
}

# --- Reference implementation: always tested strictly ---
run_class_checks "${lab_dir}/examples"

echo "Testing the supporting example scripts ..."
check_script "account_dict.py runs and shows the unguarded edit" \
  "examples/account_dict.py" "after a direct edit: ada: -500.00"
check_script "account.py runs and refuses the same edit" \
  "examples/account.py" "after the refused edit: ada: 120.00"
check_script "shared_bug.py reproduces the shared list" \
  "examples/shared_bug.py" "same list object? True"
check_script "shared_bug.py shows the per-instance fix" \
  "examples/shared_bug.py" "cleo.history: [('cleo', 10)]"
check_script "compare.py proves the two versions agree" \
  "examples/compare.py" "descriptions identical: True"
check_script "compare.py loads accounts.csv through the classmethod" \
  "examples/compare.py" "loaded 4 accounts, total 2225.75 USD"
check_script "closure_object.py builds an object without the class keyword" \
  "examples/closure_object.py" "outputs identical: True"
check_script "machinery.py shows the bound-method mechanism" \
  "examples/machinery.py" "ada.deposit.__self__ is ada: True"
check_script "machinery.py shows name mangling" \
  "examples/machinery.py" "hasattr(card, '_Card__pin'): True"

# --- Learner starter ---
echo "Testing starter/account.py ..."
starter_file="${lab_dir}/starter/account.py"
if python3 -c "compile(open('${starter_file}').read(), '${starter_file}', 'exec')" 2>/dev/null; then
  check "starter is valid Python" "yes"
else
  check "starter is valid Python" "no"
fi

if grep -q 'NotImplementedError' "${starter_file}"; then
  echo "Note: starter/account.py still has unfinished exercises — testing structure only."
  grep -q 'class Account' "${starter_file}" && check "starter defines class Account" "yes" || check "starter defines class Account" "no"
  grep -q 'def __init__' "${starter_file}" && check "starter defines __init__" "yes" || check "starter defines __init__" "no"
  grep -q 'def deposit' "${starter_file}" && check "starter defines deposit" "yes" || check "starter defines deposit" "no"
  grep -q 'def withdraw' "${starter_file}" && check "starter defines withdraw" "yes" || check "starter defines withdraw" "no"
  grep -q 'def __repr__' "${starter_file}" && check "starter defines __repr__" "yes" || check "starter defines __repr__" "no"
  grep -q 'def from_csv_row' "${starter_file}" && check "starter defines from_csv_row" "yes" || check "starter defines from_csv_row" "no"
else
  run_class_checks "${lab_dir}/starter"
fi

echo
echo "${checks} checks, ${failures} failure(s)."
[ "${failures}" -eq 0 ]