"""Play a show's animations without QLC+. Dry-run returns DMX samples. Pass an IP to send Art-Net. A Python script exposes this by defining build() -> Show and calling script_main(build). """ from __future__ import annotations import argparse import importlib.util import json import socket import sys import time from pathlib import Path from typing import Any from patternstudio.artnet import ARTNET_PORT, build_artdmx from .model import Show from .spec import SpecError, from_spec def active_keys(show: Show, keys: list[str] | None = None) -> list[str]: if keys is not None: return list(keys) if show.playback: return list(show.playback) return [fn.key for fn in show.functions if getattr(fn, "primary", False)] def frame_at(show: Show, elapsed_ms: float, keys: list[str] | None = None) -> dict[str, dict[int, int]]: """Fixture key → channel → value at `elapsed_ms` for the functions being played.""" into: dict[int, dict[int, int]] = {} for key in active_keys(show, keys): show.functions_by_key[key].apply(show, elapsed_ms, into) names = {fx.id: fx.key for fx in show.fixtures} return {names[fid]: dict(channels) for fid, channels in into.items() if fid in names} def dmx_frames(show: Show, values: dict[str, dict[int, int]]) -> dict[int, bytearray]: """QLC+ universe → 512-channel frame.""" frames: dict[int, bytearray] = {} for key, channels in values.items(): fixture = show.fixtures_by_key[key] frame = frames.setdefault(fixture.universe, bytearray(512)) for channel, value in channels.items(): slot = fixture.address + int(channel) if 0 <= slot < 512: frame[slot] = max(0, min(255, int(value))) return frames def sample_playback(show: Show, *, seconds: float | None = None, hz: float = 40.0) -> dict[str, Any]: keys = active_keys(show) if seconds is None: duration = max((show.functions_by_key[key].duration_ms(show) for key in keys), default=0) times = [0] if duration <= 0 else [int(duration * i / 4) for i in range(4)] if duration > 0: times.append(max(0, duration - 1)) else: count = max(1, int(float(seconds) * hz)) times = [int(i * (1000.0 / hz)) for i in range(min(count, 500))] duration = int(float(seconds) * 1000) return { "ok": True, "functions": keys, "duration_ms": duration, "samples": [{"time_ms": t, "values": frame_at(show, t, keys)} for t in times], } def play( show: Show, *, seconds: float | None = None, ip: str | None = None, universe: int = 0, hz: float = 40.0, ) -> dict[str, Any]: """Sample the running functions, or stream them as Art-Net when `ip` is set.""" if not ip: return sample_playback(show, seconds=seconds, hz=hz) return _send(show, ip=ip, universe=universe, seconds=seconds, hz=hz) def load_show(path: Path | str) -> Show: """Load a show from a build() script or a JSON spec.""" source = Path(path).resolve() if source.suffix == ".json": return from_spec(json.loads(source.read_text(encoding="utf-8"))) spec = importlib.util.spec_from_file_location(f"showfile_script_{source.stem}", source) if spec is None or spec.loader is None: raise SpecError([{"path": str(source), "message": "could not load the script"}]) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) if not hasattr(module, "build"): raise SpecError([{"path": str(source), "message": "script must define build() -> Show"}]) show = module.build() if not isinstance(show, Show): raise SpecError([{"path": str(source), "message": "build() must return a Show"}]) return show def script_main(build: Any, argv: list[str] | None = None) -> None: """Entry point for `python animation.py`. Prints one JSON object.""" args = _parser().parse_args(argv) _emit(play(build(), seconds=args.seconds, ip=args.ip, universe=args.universe, hz=args.hz)) def _parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description="Play this animation and print DMX samples, or send Art-Net.") parser.add_argument("--ip", help="Art-Net destination. Omit to print samples and exit.") parser.add_argument("--seconds", type=float, help="How long to play. Omit with --ip to run until Ctrl+C.") parser.add_argument("--hz", type=float, default=40.0) parser.add_argument("--universe", type=int, default=0, help="Art-Net universe for QLC+ universe 0.") return parser def _emit(payload: dict[str, Any]) -> None: json.dump(payload, sys.stdout, indent=2) sys.stdout.write("\n") def _send(show: Show, *, ip: str, universe: int, seconds: float | None, hz: float) -> dict[str, Any]: keys = active_keys(show) period = 1.0 / hz if hz > 0 else 0.025 print( f"Art-Net {ip} universe {universe} {', '.join(keys) or '(no functions)'} (Ctrl+C to stop)", file=sys.stderr, ) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) sequence = 1 sent = 0 stopped = False started = time.monotonic() try: while True: elapsed_ms = (time.monotonic() - started) * 1000.0 if seconds is not None and elapsed_ms >= seconds * 1000.0: break frames = dmx_frames(show, frame_at(show, elapsed_ms, keys)) if not frames: frames = {0: bytearray(512)} for qlc_universe, frame in frames.items(): packet = build_artdmx(bytes(frame), universe + qlc_universe, sequence) sock.sendto(packet, (ip, ARTNET_PORT)) sequence = 1 if sequence >= 255 else sequence + 1 sent += 1 time.sleep(period) except KeyboardInterrupt: stopped = True finally: for qlc_universe in dmx_frames(show, frame_at(show, 0, keys)) or {0: bytearray()}: for _ in range(3): sock.sendto(build_artdmx(bytes(512), universe + qlc_universe, sequence), (ip, ARTNET_PORT)) sequence = 1 if sequence >= 255 else sequence + 1 sock.close() return {"ok": True, "ip": ip, "universe": universe, "functions": keys, "frames": sent, "stopped": stopped}