A Mood With a Dial

# labs/mood_state.py
from dataclasses import dataclass

EMOTION_COLORS = {
    "neutral":    "#4a9eff",
    "satisfied":  "#39ff14",
    "curious":    "#ffcc00",
    "hostile":    "#ff4444",
    "melancholy": "#9966cc",
}


@dataclass
class MoodState:
    mood: str = "neutral"
    intensity: float = 0.5

    def display_color(self) -> str:
        return EMOTION_COLORS.get(self.mood, "#ffffff")


if __name__ == "__main__":
    state = MoodState()
    print(f"{state.mood:10} {state.display_color()} @ {state.intensity}")
    state.mood = "curious"      # nothing stops this yet
    print(f"{state.mood:10} {state.display_color()} @ {state.intensity}")
    state.mood = "curius"       # nor this
    print(f"{state.mood:10} {state.display_color()} @ {state.intensity}")

$ uv run python labs/mood_state.py
neutral    #4a9eff @ 0.5
curious    #ffcc00 @ 0.5
curius     #ffffff @ 0.5

One dict does two jobs. Its values are the colors, and its keys are the set of moods that legally exist, so validation and rendering can never disagree about what a mood is. Adding "amused" to the palette adds it to the vocabulary in the same edit. The third line of output is the deliberate hole in this stage: a typo assigned without complaint, and .get with a white default kept the lookup from raising, so the only evidence is an LED quietly showing the wrong color. Stage 2 closes the hole at the source.

from datetime import datetime
from dataclasses import dataclass, field


def clamp01(value: float) -> float:
    return max(0.0, min(1.0, value))


@dataclass
class MoodState:
    mood: str = "neutral"
    intensity: float = 0.5
    history: list = field(default_factory=list)

    def transition(self, new_mood: str, intensity: float = 0.5) -> bool:
        if new_mood not in EMOTION_COLORS:
            return False
        self.history.append({
            "from": self.mood,
            "to": new_mood,
            "at": datetime.now().isoformat(timespec="seconds"),
        })
        self.mood = new_mood
        self.intensity = clamp01(intensity)
        return True


if __name__ == "__main__":
    state = MoodState()
    print(state.transition("curious", 0.7), state.mood, state.intensity)
    print(state.transition("angry", 0.9), state.mood, state.intensity)
    print(state.transition("hostile", 1.4), state.mood, state.intensity)
    print("recorded:", len(state.history))

$ uv run python labs/mood_state.py
True curious 0.7
False curious 0.7
True hostile 1.0
recorded: 2

Read the middle line first. "angry" is not in the palette, so the guard returns False before anything is written: the mood stays curious, the intensity stays 0.7, and no phantom entry lands in the history. Returning a bool instead of failing silently means the caller can log the rejection, which is how you find out that a behavior handler has been asking for a mood you never defined. The last line pairs with it: three calls, two records, because history counts accepted moves. And clamp01 is chapter 27's trick at a different scale. There it kept a servo angle inside 0 to 180 degrees at the point of use; here it keeps a mood inside 0.0 to 1.0, so 1.4 is stored as 1.0 and the LED code downstream never has to wonder.

from labs.emotional_state import MOOD_TRANSITIONS

NUDGE_STEP = 0.2

    def nudge(self, delta: float) -> float:
        self.intensity = clamp01(self.intensity + delta)
        return self.intensity


def apply_sentiment(state: MoodState, sentiment: str) -> None:
    target = MOOD_TRANSITIONS.get(state.mood, {}).get(sentiment)
    if target is None:
        return
    if target == state.mood:
        state.nudge(NUDGE_STEP)
    else:
        state.transition(target)


if __name__ == "__main__":
    state = MoodState()
    for sentiment in ["negative", "negative", "negative", "positive"]:
        apply_sentiment(state, sentiment)
        print(f"{sentiment:9} -> {state.mood:10} @ {state.intensity:.2f}")

$ uv run python labs/mood_state.py
negative  -> hostile    @ 0.50
negative  -> hostile    @ 0.70
negative  -> hostile    @ 0.90
positive  -> neutral    @ 0.50

This is the behavior the discrete version could not express. Chapter 24's table maps hostile plus a negative signal back to hostile, and treating that as a transition means three insults in a row leave her exactly as hostile as one did. Reading the same entry as "same kind, more of it" turns the second and third into nudge calls, and the number climbs while the name holds still. The last line shows the other half staying intact: kindness moves hostile to neutral, and a change of kind resets the dial to the default 0.5, because how deeply she felt the old mood says nothing about the new one. Note that nudge writes no history entry. History is a record of moves between moods, and a run of nudges is one mood getting louder.

import json
from pathlib import Path

STATE_PATH = Path("glados/data/mood_state.json")

    def save(self, path: Path) -> None:
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(json.dumps({
            "mood": self.mood,
            "intensity": round(self.intensity, 3),
            "history": self.history[-10:],
        }, indent=2))

    @classmethod
    def load(cls, path: Path) -> "MoodState":
        if not path.exists():
            return cls()
        data = json.loads(path.read_text())
        mood = data.get("mood", "neutral")
        if mood not in EMOTION_COLORS:
            mood = "neutral"
        return cls(
            mood=mood,
            intensity=clamp01(float(data.get("intensity", 0.5))),
            history=data.get("history", []),
        )

load revalidates everything, and that is not paranoia about your own save. The JSON file is outside the door. You will hand-edit it while debugging, a half-written file will survive a power cut mid-write, and a future version of the palette will drop a mood some old file still names. Any of those hands load a value the guard would have rejected, so the guard runs again on the way in: unknown mood falls back to neutral, intensity goes through the same clamp, and a missing file returns plain defaults instead of raising. The [-10:] slice on save is the bounded-log habit from chapter 29 applied to emotions: a month of running produces thousands of transitions, and the ten most recent are the ones that explain how she got here.

# labs/mood_state.py — the demo, at the bottom of the file
DEVICES: dict = {
    "eye_led": {"pin": 12, "type": "rgb", "enabled": False, "color": "#000000"},
}


def simulate_set_led_color(config: dict, device_name: str, color: str) -> None:
    if device_name not in config:
        print(f"Device not found: {device_name}")
        return
    config[device_name]["color"] = color
    print(f"[SIM] {device_name} set to {color}")


def main() -> None:
    state = MoodState.load(STATE_PATH)
    print(f"restored:  {state.mood} @ {state.intensity:.2f}")
    for sentiment in ["negative", "negative", "curious", "positive"]:
        apply_sentiment(state, sentiment)
        simulate_set_led_color(DEVICES, "eye_led", state.display_color())
        print(f"           {sentiment:9} -> {state.mood:10} @ {state.intensity:.2f}")
    state.save(STATE_PATH)
    print(f"saved {len(state.history)} transitions to {STATE_PATH}")


if __name__ == "__main__":
    main()

$ uv run python labs/mood_state.py
restored:  neutral @ 0.50
[SIM] eye_led set to #ff4444
           negative  -> hostile    @ 0.50
[SIM] eye_led set to #ff4444
           negative  -> hostile    @ 0.70
[SIM] eye_led set to #ffcc00
           curious   -> curious    @ 0.50
[SIM] eye_led set to #39ff14
           positive  -> satisfied  @ 0.50
saved 3 transitions to glados/data/mood_state.json

$ head -8 glados/data/mood_state.json
{
  "mood": "satisfied",
  "intensity": 0.5,
  "history": [
    {
      "from": "neutral",
      "to": "hostile",
      "at": "2026-08-22T21:14:07"
    },

Run it a second time and the first line reads restored: satisfied @ 0.50, because the session before it ended pleased. Your timestamps will differ from the ones above, and so will the mood you find on disk. The LED writes follow chapter 27's pattern exactly: a device dict with a pin and a current value, a function that mutates the entry and announces it, no GPIO library anywhere in this file. When the light ring arrives in volume 7 the real driver replaces the body of simulate_set_led_color and nothing else moves, because everything above the call already speaks in hex colors. Three transitions and one nudge produced four LED writes: the repaint follows every update, since intensity will eventually control brightness even when the color holds.