Files
led-controller/tests/engine_tests/test_player.py
T
jimmyandClaude Opus 5.5 a5a7fc575f feat(engine): Pi-side animation engine with protocol outputs and sequencer
Add src/engine, modelled on technicalkiwi/portal's player and sequence runner:

- Pixel generator: runs the unchanged led-driver patterns under CPython
  (utime shim + NeoPixel-like buffer) on a per-zone render thread and
  streams frames to pixel outputs, with keepalive for static frames.
- Output drivers: DDP, Art-Net (ArtDMX/ArtSync), sACN/E1.31, USB-DMX
  (Enttec Pro / Open DMX), plus an ESP32 preset output that reuses the
  existing preset + select delivery path. Registry in db/output.json,
  CRUD and test pattern at /outputs.
- Sequencer: timed preset chains per zone (portal step shape), deadline
  scheduling, loop/repeat, resume after restart; legacy sequence records
  are migrated. Zone play/stop, sequence and scene play/stop endpoints.
- CLI (python -m engine.cli), Outputs and Sequences modals, preset tiles
  drive pixel outputs, API/README docs, engine test suite.

ESP32 firmware is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 13:24:14 +13:00

243 lines
7.9 KiB
Python

"""ZonePlayer + Engine: frames reach pixel outputs, presets reach ESP32 drivers."""
import asyncio
import pytest
from engine.core import Engine, EngineError
from engine.outputs.base import FrameOutput
from engine.pattern_loader import PatternLibrary
from engine.player import ZonePlayer
from engine.zone_targets import ZoneTargets, resolve_zone
LIB = PatternLibrary()
class RecordingOutput(FrameOutput):
protocol = "test"
keepalive_s = 0.2
def __init__(self, cfg):
super().__init__(cfg)
self.sent = []
self.levels = []
self.closed = False
async def send(self, rgb, global_brightness=255):
self.levels.append(global_brightness)
await super().send(rgb, global_brightness)
async def _send_prepared(self, payload):
self.sent.append(payload)
async def close(self):
await super().close()
self.closed = True
class RecordingDriver:
kind = "preset"
def __init__(self, names):
self.names = names
self.applied = []
self.closed = False
async def apply(self, preset_id, payload):
self.applied.append((preset_id, payload))
async def close(self):
self.closed = True
def status(self):
return {"name": ",".join(self.names), "kind": "preset", "frames": len(self.applied),
"packets": 0, "errors": 0, "last_error": None}
def make_player(cfgs, drivers=(), brightness=255):
made = {"outputs": [], "driver": None}
def output_factory(cfg):
out = RecordingOutput(cfg)
made["outputs"].append(out)
return out
def driver_factory(names):
made["driver"] = RecordingDriver(names)
return made["driver"]
targets = ZoneTargets("z1", cfgs, list(drivers))
player = ZonePlayer(targets, LIB, lambda: brightness, output_factory=output_factory,
driver_factory=driver_factory)
return player, made
def test_frames_split_per_output_offset_and_brightness():
async def go():
player, made = make_player(
[{"name": "a", "pixel_count": 2, "fps": 60},
{"name": "b", "pixel_count": 1, "pixel_offset": 2, "color_order": "grb", "fps": 60}],
brightness=128,
)
assert player.targets.frame_length == 3
await player.start()
await player.apply("1", {"p": "on", "c": ["#ff8000"], "b": 255})
await asyncio.sleep(0.15)
await player.stop()
return made
made = asyncio.run(go())
a, b = made["outputs"]
assert a.sent[0] == bytes((128, 64, 0)) * 2
assert b.sent[0] == bytes((64, 128, 0)) # grb
assert set(a.levels[:-1]) == {128} # last send is the black frame from close()
assert a.closed and b.closed and a.sent[-1] == bytes(6) # black on stop
def test_animated_pattern_streams_and_keepalive_resends_static():
async def go():
player, made = make_player([{"name": "a", "pixel_count": 8, "fps": 60}])
await player.start()
await player.apply("1", {"p": "rainbow", "c": [], "d": 10, "b": 255, "n1": 8})
await asyncio.sleep(0.4)
rainbow_frames = len(made["outputs"][0].sent)
await player.apply("2", {"p": "on", "c": ["#00ff00"], "b": 255})
await asyncio.sleep(0.1)
before = len(made["outputs"][0].sent)
await asyncio.sleep(0.5) # static frame -> keepalive resends (0.2 s)
after = len(made["outputs"][0].sent)
await player.stop()
return rainbow_frames, before, after, made
rainbow_frames, before, after, made = asyncio.run(go())
assert rainbow_frames >= 10
assert after - before >= 2
assert made["outputs"][0].sent[before] == bytes((0, 255, 0)) * 8
def test_mixed_zone_drives_esp32_and_pixels_together():
async def go():
player, made = make_player([{"name": "ddp", "pixel_count": 4}], drivers=["dj"])
await player.start()
await player.apply("7", {"p": "on", "c": ["#ffffff"], "b": 255})
await asyncio.sleep(0.1)
status = player.status()
await player.stop()
return made, status
made, status = asyncio.run(go())
assert made["driver"].applied == [("7", {"p": "on", "c": ["#ffffff"], "b": 255})]
assert made["outputs"][0].sent
assert status["preset_id"] == "7" and len(status["outputs"]) == 2
assert made["driver"].closed
def test_drivers_false_skips_esp32():
async def go():
player, made = make_player([{"name": "ddp", "pixel_count": 1}], drivers=["dj"])
await player.start()
await player.apply("1", {"p": "on", "c": ["#ffffff"], "b": 255}, drivers=False)
await asyncio.sleep(0.05)
await player.stop()
return made
made = asyncio.run(go())
assert made["driver"].applied == [] and made["outputs"][0].sent
def test_driver_only_zone_has_no_render_thread():
async def go():
player, made = make_player([], drivers=["roof"])
await player.start()
await player.apply("1", {"p": "rainbow"})
await player.stop()
return player, made
player, made = asyncio.run(go())
assert player.renderer is None and made["driver"].applied
# -- Engine --------------------------------------------------------------------
class FakeZones(dict):
def read(self, id):
return self.get(str(id))
class FakeOutputs(dict):
def by_name(self, name):
return [o for o in self.values() if o.get("name") == name]
def test_resolve_zone_splits_outputs_and_drivers():
zones = FakeZones({"1": {"names": ["roof", "wall", "wall", "dj"]}})
outputs = FakeOutputs({
"1": {"id": "1", "name": "wall", "pixel_count": 100, "enabled": True},
"2": {"id": "2", "name": "wall", "pixel_count": 50, "pixel_offset": 100, "enabled": True},
"3": {"id": "3", "name": "dj", "pixel_count": 10, "enabled": False},
})
t = resolve_zone("1", zones, outputs)
assert [c["id"] for c in t.frame_cfgs] == ["1", "2"]
assert t.driver_names == ["roof", "dj"] # disabled output falls back to device name
assert t.frame_length == 150
assert resolve_zone("9", zones, outputs) is None
def make_engine(targets_by_zone, payloads):
created = []
def factory(targets, library, brightness):
player, made = make_player(targets.frame_cfgs, targets.driver_names)
created.append((player, made))
return player
eng = Engine(
library=LIB,
zone_resolver=lambda zid: targets_by_zone.get(zid),
payload_resolver=lambda pid: payloads.get(pid),
player_factory=factory,
sequences_model=FakeSequences(),
)
return eng, created
class FakeSequences(dict):
def read(self, id):
return self.get(str(id))
def update(self, id, data):
if str(id) not in self:
return False
self[str(id)].update(data)
return True
def list(self):
return list(self.keys())
def test_engine_play_reuses_player_and_rebuilds_on_target_change():
targets = {"1": ZoneTargets("1", [{"name": "a", "pixel_count": 2}], ["dj"])}
payloads = {"10": {"p": "on", "c": ["#ff0000"]}, "11": {"p": "off"}}
async def go():
eng, created = make_engine(targets, payloads)
await eng.play("1", "10")
await eng.play("1", "11")
assert len(created) == 1
targets["1"] = ZoneTargets("1", [{"name": "a", "pixel_count": 3}], ["dj"])
await eng.play("1", "10")
assert len(created) == 2 and created[0][1]["outputs"][0].closed
with pytest.raises(EngineError):
await eng.play("1", "missing")
with pytest.raises(EngineError):
await eng.play("nozone", "10")
status = eng.status()
assert status["zones"]["1"]["preset_id"] == "10"
assert await eng.stop("1") is True
assert eng.status()["zones"] == {}
await eng.stop_all()
return created
created = asyncio.run(go())
assert [p for p, _ in created[0][1]["driver"].applied] == ["10", "11"]