Rules, Not Branches

# labs/automation.py
RULES: list[dict] = [
    {"trigger": "lights off", "action": "turn_off_lights"},
    {"trigger": "set timer", "action": "set_timer"},
    {"trigger": "play music", "action": "play_music"},
]

def match_rules(text: str, rules: list[dict]) -> list[dict]:
    lower = text.lower()
    return [r for r in rules if r["trigger"] in lower]

if __name__ == "__main__":
    for hit in match_rules("Hey GLaDOS, lights off please.", RULES):
        print("matched:", hit["trigger"], "->", hit["action"])

$ uv run python labs/automation.py
matched: lights off -> turn_off_lights

A rule is a dict with two strings, and nothing else lives here: no functions, no branching, no imports. The matcher lowercases once and returns every rule whose trigger appears, because "lights off and play music" legitimately matches two. Notice what the matcher does not know: what any action does. It traffics in names. That ignorance is the design.

from typing import Callable

ACTION_REGISTRY: dict[str, Callable] = {}

def register_action(name: str):
    def decorator(fn: Callable):
        ACTION_REGISTRY[name] = fn
        return fn
    return decorator

@register_action("turn_off_lights")
def turn_off_lights(text: str):
    print("[ACTION] Turning off lights.")

@register_action("set_timer")
def set_timer(text: str):
    print("[ACTION] Setting a timer.")

@register_action("play_music")
def play_music(text: str):
    print("[ACTION] Playing music.")

if __name__ == "__main__":
    print("registered:", list(ACTION_REGISTRY))
    ACTION_REGISTRY["set_timer"]("test")

$ uv run python labs/automation.py
registered: ['turn_off_lights', 'set_timer', 'play_music']
[ACTION] Setting a timer.

Your first decorator with a job. @register_action("name") runs at import time, receives the function below it, stores it in the registry under the name, and returns it unchanged, so the function still works normally and is now also findable by string. Dispatch stops being a branch you read top to bottom and becomes a dictionary lookup. Adding behavior means writing one function and decorating it; the engine does not know or care.

def run_automation(text: str) -> None:
    matched = match_rules(text, RULES)
    if not matched:
        print(f"No automation matched for: '{text}'")
        return
    for rule in matched:
        action_fn = ACTION_REGISTRY.get(rule["action"])
        if action_fn:
            action_fn(text)
        else:
            print(f"[WARN] No handler for action: {rule['action']}")

if __name__ == "__main__":
    run_automation("Hey GLaDOS, lights off please.")
    run_automation("GLaDOS, set timer for 5 minutes.")
    run_automation("Turn on the fan.")

$ uv run python labs/automation.py
[ACTION] Turning off lights.
[ACTION] Setting a timer.
No automation matched for: 'Turn on the fan.'

The whole engine is a dozen lines, and every edge has a decided behavior. No match: say so and return, informative and calm. A rule naming a handler that was never registered: .get() hands back None instead of raising, so one broken row warns and the loop continues to the next rule. An engine that crashes on its worst rule loses all its good ones, and this one refuses to. "Turn on the fan" failing is also the correct result today; it becomes a one-dict fix the moment you own a smart fan, which is the entire pitch.