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>
243 lines
7.9 KiB
Python
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"]
|