Her Preferences

# labs/preferences.py
DEFAULT_PREFS = {
    "user_name": "Test Subject",
    "greeting_enabled": True,
    "response_length": "brief",
    "voice": "piper",
    "speaking_rate": 1.0,
}

def load_preferences() -> dict:
    return DEFAULT_PREFS.copy()

prefs = load_preferences()
print(f"{len(prefs)} preferences, every one a default")
print(f"name={prefs['user_name']}  voice={prefs['voice']}")

$ uv run python labs/preferences.py
5 preferences, every one a default
name=Test Subject  voice=piper

Five keys, each with a value she can run on before you have chosen anything. The .copy() is load-bearing: returning DEFAULT_PREFS directly would hand every caller the same object, so the first prefs["voice"] = "f5" anywhere would rewrite the defaults for the rest of the process. Chapter 2 called that the aliasing bug; here it would corrupt the one dict whose job is to stay pristine. Each load gets its own copy, and the contract stays clean.

import json
from pathlib import Path

PREFS_PATH = Path("configs/preferences.json")

def load_preferences(path: Path) -> dict:
    if path.exists():
        saved = json.loads(path.read_text())
        return {**DEFAULT_PREFS, **saved}
    return DEFAULT_PREFS.copy()

def save_preferences(prefs: dict, path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(prefs, indent=2) + "\n")

prefs = load_preferences(PREFS_PATH)
save_preferences(prefs, PREFS_PATH)
print(f"wrote {len(prefs)} keys to {PREFS_PATH}")

# simulate a save file from an older version: one key, four missing
PREFS_PATH.write_text('{"user_name": "Chell"}')
prefs = load_preferences(PREFS_PATH)
print(f"name={prefs['user_name']}  rate={prefs['speaking_rate']}")

$ uv run python labs/preferences.py
wrote 5 keys to configs/preferences.json
name=Chell  rate=1.0

The merge is the chapter: {**DEFAULT_PREFS, **saved} lays the defaults down first and the saved file over them, so the result always carries every key the code might read. The simulation at the end is the proof. That one-key file stands in for a config written before speaking_rate existed, and the load returns the saved name and the default rate with no special-case code. On the saving side, mkdir(parents=True, exist_ok=True) means a fresh clone creates configs/ on first run, and indent=2 keeps the file editable by hand, since you are allowed to open your own preferences in a text editor.

def set_preference(prefs: dict, key: str, value: object) -> bool:
    if key not in DEFAULT_PREFS:
        return False
    prefs[key] = value
    return True

def greeting(prefs: dict) -> str:
    if not prefs.get("greeting_enabled", True):
        return ""
    name = prefs.get("user_name", "Test Subject")
    return f"Oh. It's you, {name}. Welcome back."

prefs = load_preferences(PREFS_PATH)
print(greeting(prefs))
for key, value in [("response_length", "verbose"), ("colour", "amber")]:
    ok = set_preference(prefs, key, value)
    print(f"{key}: {'updated' if ok else 'rejected (no such preference)'}")
save_preferences(prefs, PREFS_PATH)

$ uv run python labs/preferences.py
Oh. It's you, Chell. Welcome back.
response_length: updated
colour: rejected (no such preference)

The guard checks DEFAULT_PREFS, not prefs, and the difference matters. A merged dict can carry orphan keys inherited from older files; checking membership there would let a typo like "colour" slip in as a new key that nothing ever reads, and the file would drift one misspelling at a time. The contract is the defaults, so writes are validated against the defaults. greeting keeps chapter 12's .get fallbacks even though the merge should make them redundant: this function will eventually be handed dicts from tests and event-bus payloads that never went through the loader, and a second net costs nothing.

# labs/preferences.py — full file
import json
from pathlib import Path

PREFS_PATH = Path("configs/preferences.json")

DEFAULT_PREFS = {
    "user_name": "Test Subject",
    "greeting_enabled": True,
    "response_length": "brief",
    "voice": "piper",
    "speaking_rate": 1.0,
}

def load_preferences(path: Path) -> dict:
    if path.exists():
        saved = json.loads(path.read_text())
        return {**DEFAULT_PREFS, **saved}
    return DEFAULT_PREFS.copy()

def save_preferences(prefs: dict, path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(prefs, indent=2) + "\n")

def set_preference(prefs: dict, key: str, value: object) -> bool:
    if key not in DEFAULT_PREFS:
        return False
    prefs[key] = value
    return True

def greeting(prefs: dict) -> str:
    if not prefs.get("greeting_enabled", True):
        return ""
    name = prefs.get("user_name", "Test Subject")
    return f"Oh. It's you, {name}. Welcome back."

def main() -> None:
    prefs = load_preferences(PREFS_PATH)
    line = greeting(prefs)
    if line:
        print(line)
    print(f"replies={prefs['response_length']}  voice={prefs['voice']}  "
          f"rate={prefs['speaking_rate']}")
    save_preferences(prefs, PREFS_PATH)

if __name__ == "__main__":
    main()

$ uv run python labs/preferences.py
Oh. It's you, Chell. Welcome back.
replies=verbose  voice=piper  rate=1.0

Note what survived on disk across three runs: the name from the simulated old file, the verbosity you set in stage 3, defaults for everything else. Every function returns a value and main owns the printing, the same split the whole book runs on, because the point of this module is to be imported. The voice loop reads response_length when it builds her prompt, the speech step will read voice and speaking_rate, and the save-after-change habit means a crash never costs more than the current session's edits.