#!/usr/bin/env python3
"""Web page to aim the two cabaret movers and save pan/tilt positions.
Drives the Small Eye 7 heads over Art-Net while the sliders move, then
writes named looks to a JSON file. Stop QLC+ Art-Net output first so the
two sources do not fight. Ctrl+C blackout.
pipenv run positions
open http://127.0.0.1:8765
Saved file (default shows/mover_positions.json):
{
"positions": {
"wall": {
"m1": {"pan": 179, "tilt": 36},
"m2": {"pan": 179, "tilt": 36}
}
}
}
"""
from __future__ import annotations
import argparse
import ipaddress
import json
import socket
import threading
import urllib.request
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import urlparse
from cabaret_movers import (
DEFAULT_NODE,
FOCUS_DEFAULT,
M1_ADDR,
M2_ADDR,
PALETTE,
POSITIONS,
ArtNetSender,
Mover,
clamp,
discover_artnet_nodes,
)
# Aiming colours. White is listed first because it shows the beam clearly.
COLORS: dict[str, tuple[int, int, int]] = {"white": (255, 255, 255), **PALETTE}
COLOR_NAMES = ("white", "amber", "red", "orange", "yellow", "green", "blue", "pink", "purple")
PAGE = """
Mover positions
Mover positions
Connecting…
Art-Net to DMX
Both movers share this DMX output.
M1 and M2 are aimed differently. Moving a slider sets both.
Color
Pan
Tilt
Dimmer
Saved
Aim the beam, name it, then add the position.
Arrow keys nudge pan and tilt. Shift moves by 10. Up sends the beam toward tilt 0.
"""
def read_positions(path: Path) -> dict[str, dict]:
if not path.exists():
return {}
try:
data = json.loads(path.read_text(encoding="utf-8"))
except json.JSONDecodeError as exc:
raise SystemExit(f"{path} is not valid JSON: {exc}") from exc
raw = data.get("positions", data) if isinstance(data, dict) else None
if not isinstance(raw, dict):
raise SystemExit(f"{path} must contain a positions object")
out: dict[str, dict] = {}
for name, entry in raw.items():
if not isinstance(entry, dict) or "m1" not in entry or "m2" not in entry:
raise SystemExit(f"{path}: position {name!r} needs m1 and m2 pan/tilt")
out[str(name)] = {"m1": point(entry["m1"]), "m2": point(entry["m2"])}
return out
def point(entry) -> dict[str, int]:
if isinstance(entry, (list, tuple)) and len(entry) == 2:
pan, tilt = entry
elif isinstance(entry, dict) and "pan" in entry and "tilt" in entry:
pan, tilt = entry["pan"], entry["tilt"]
else:
raise SystemExit("each mover needs pan and tilt")
return {"pan": clamp(pan), "tilt": clamp(tilt)}
def write_positions(path: Path, positions: dict[str, dict]) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
text = json.dumps({"positions": positions}, indent=2) + "\n"
tmp = path.with_suffix(path.suffix + ".tmp")
tmp.write_text(text, encoding="utf-8")
tmp.replace(path)
def position_list(positions: dict[str, dict]) -> list[dict]:
return [{"name": name, "m1": entry["m1"], "m2": entry["m2"]} for name, entry in positions.items()]
def clean_name(value) -> str:
name = " ".join(str(value).split())
if not name:
raise ValueError("Enter a position name")
if len(name) > 48:
raise ValueError("Name must be 48 characters or fewer")
return name
class Store:
def __init__(self, path: Path):
self.path = path
self._lock = threading.Lock()
self.positions = read_positions(path)
def snapshot(self) -> list[dict]:
with self._lock:
return position_list(self.positions)
def upsert(self, name: str, m1: dict, m2: dict) -> None:
with self._lock:
self.positions[name] = {
"m1": {"pan": m1["pan"], "tilt": m1["tilt"]},
"m2": {"pan": m2["pan"], "tilt": m2["tilt"]},
}
write_positions(self.path, self.positions)
def get(self, name: str) -> dict | None:
with self._lock:
entry = self.positions.get(name)
if entry is None:
return None
return {"m1": dict(entry["m1"]), "m2": dict(entry["m2"])}
def delete(self, name: str) -> bool:
with self._lock:
if name not in self.positions:
return False
del self.positions[name]
write_positions(self.path, self.positions)
return True
def clean_ip(value) -> str:
text = str(value).strip()
try:
addr = ipaddress.ip_address(text)
except ValueError as exc:
raise ValueError("Enter an Art-Net address") from exc
if not isinstance(addr, ipaddress.IPv4Address):
raise ValueError("Art-Net needs an IPv4 address")
return str(addr)
def clean_color(value) -> str:
name = str(value).strip().lower()
if name not in COLORS:
raise ValueError("Unknown color")
return name
GATEWAY_HOST = "dmx-gateway.local"
def lookup_gateway() -> dict[str, str] | None:
"""The LuxDMX Art-Net to DMX box at dmx-gateway.local, if it answers."""
ip = ""
name = GATEWAY_HOST
universe = ""
try:
with urllib.request.urlopen(f"http://{GATEWAY_HOST}/info.json", timeout=1.5) as res:
info = json.loads(res.read().decode("utf-8"))
if isinstance(info, dict):
ip = str(info.get("ip") or "")
host = str(info.get("hostname") or "dmx-gateway").strip()
name = host if "." in host else f"{host}.local"
for output in info.get("outputs") or []:
if isinstance(output, dict) and output.get("en"):
universe = str(int(output.get("uni", 0)))
break
except (OSError, json.JSONDecodeError, ValueError, TypeError):
pass
if not ip:
try:
ip = socket.getaddrinfo(GATEWAY_HOST, 6454, socket.AF_INET, socket.SOCK_DGRAM)[0][4][0]
except OSError:
return None
try:
ip = str(ipaddress.IPv4Address(ip))
except ValueError:
return None
node = {"ip": ip, "name": name}
if universe != "":
node["universe"] = universe
return node
def pin_gateway(nodes: list[dict[str, str]]) -> list[dict[str, str]]:
gateway = lookup_gateway()
if gateway is None:
return nodes
rest = [
node
for node in nodes
if node["ip"] != gateway["ip"] and node.get("name") != "no reply"
]
return [gateway] + rest
def include_ip(nodes: list[dict[str, str]], ip: str) -> list[dict[str, str]]:
kept = [node for node in nodes if node.get("name") != "no reply" or node["ip"] == ip]
if any(node["ip"] == ip for node in kept):
return kept
return [{"ip": ip, "name": ""}] + kept
class Rig:
def __init__(self, movers: dict[str, Mover]):
self.movers = movers
down_m1, down_m2 = POSITIONS["down"]
self.pan = {"m1": down_m1[0], "m2": down_m2[0]}
self.tilt = {"m1": down_m1[1], "m2": down_m2[1]}
self.color = {"m1": "white", "m2": "white"}
self.dimmer = 255
self._lock = threading.Lock()
self.push()
def push(self):
with self._lock:
self._push_locked()
def _push_locked(self):
for key, mover in self.movers.items():
mover.apply(
pan=self.pan[key],
tilt=self.tilt[key],
rgb=COLORS[self.color[key]],
dimmer=self.dimmer,
focus=FOCUS_DEFAULT,
speed=0,
)
def set_color(self, target: str, name: str):
if target not in ("m1", "m2", "both"):
raise ValueError("target must be m1, m2, or both")
name = clean_color(name)
with self._lock:
keys = ("m1", "m2") if target == "both" else (target,)
for key in keys:
self.color[key] = name
if self.dimmer == 0:
self.dimmer = 255
self._push_locked()
def update(self, *, target: str, pan: int, tilt: int, dimmer: int):
if target not in ("m1", "m2", "both"):
raise ValueError("target must be m1, m2, or both")
with self._lock:
keys = ("m1", "m2") if target == "both" else (target,)
for key in keys:
self.pan[key] = clamp(pan)
self.tilt[key] = clamp(tilt)
self.dimmer = clamp(dimmer)
self._push_locked()
def recall(self, entry: dict):
with self._lock:
self.pan["m1"] = entry["m1"]["pan"]
self.tilt["m1"] = entry["m1"]["tilt"]
self.pan["m2"] = entry["m2"]["pan"]
self.tilt["m2"] = entry["m2"]["tilt"]
self._push_locked()
def live(self) -> dict:
with self._lock:
return {
"m1": {"pan": self.pan["m1"], "tilt": self.tilt["m1"]},
"m2": {"pan": self.pan["m2"], "tilt": self.tilt["m2"]},
"color": {"m1": self.color["m1"], "m2": self.color["m2"]},
"dimmer": self.dimmer,
}
class App:
def __init__(
self,
rig: Rig,
store: Store,
sender: ArtNetSender,
nodes: list[dict[str, str]],
universe: int,
):
self.rig = rig
self.store = store
self.sender = sender
self.nodes = nodes
self.universe = universe
self._lock = threading.Lock()
def state(self, *, saved: str | None = None) -> dict:
payload = self.rig.live()
artnet = self.sender.destination()
with self._lock:
payload["nodes"] = [dict(node) for node in self.nodes]
payload["artnet"] = artnet
payload["colors"] = [{"name": name, "rgb": list(COLORS[name])} for name in COLOR_NAMES]
payload["file"] = str(self.store.path)
payload["positions"] = self.store.snapshot()
if saved is not None:
payload["saved"] = saved
return payload
def _universe_for(self, ip: str) -> int:
match = next((node for node in self.nodes if node["ip"] == ip), None)
if match and match.get("universe", "") != "":
return int(match["universe"])
return self.universe
def select_node(self, ip: str):
ip = clean_ip(ip)
with self._lock:
nodes = include_ip(self.nodes, ip)
nodes = pin_gateway(nodes)
with self._lock:
self.nodes = nodes
universe = self._universe_for(ip)
label = next((node["name"] for node in self.nodes if node["ip"] == ip and node.get("name")), "")
self.sender.set_dest(ip)
self.sender.set_universe(universe)
self.rig.push()
print(f"Art-Net → {ip} {label} universe {universe}".rstrip(), flush=True)
def refresh_nodes(self):
found = pin_gateway(discover_artnet_nodes())
current = self.sender.destination()
with self._lock:
self.nodes = include_ip(found, current)
def make_handler(app: App):
class Handler(BaseHTTPRequestHandler):
def log_request(self, code="-", size="-"):
if str(code).startswith("2"):
return
super().log_request(code, size)
def _body(self) -> dict:
length = int(self.headers.get("Content-Length", "0") or 0)
raw = self.rfile.read(length) if length else b"{}"
data = json.loads(raw.decode("utf-8") or "{}")
if not isinstance(data, dict):
raise ValueError("JSON object required")
return data
def _send(self, code: int, payload, content_type: str):
if isinstance(payload, str):
raw = payload.encode("utf-8")
else:
raw = json.dumps(payload).encode("utf-8")
self.send_response(code)
self.send_header("Content-Type", content_type)
self.send_header("Content-Length", str(len(raw)))
self.send_header("Cache-Control", "no-store")
self.end_headers()
self.wfile.write(raw)
def _json(self, code: int, payload: dict):
self._send(code, payload, "application/json")
def _error(self, code: int, message: str):
self._json(code, {"error": message})
def do_GET(self):
path = urlparse(self.path).path
if path == "/":
self._send(200, PAGE, "text/html; charset=utf-8")
return
if path == "/api/state":
self._json(200, app.state())
return
if path == "/favicon.ico":
self.send_response(204)
self.end_headers()
return
self._error(404, "Not found")
def do_POST(self):
path = urlparse(self.path).path
try:
data = self._body()
except (json.JSONDecodeError, UnicodeDecodeError, ValueError):
self._error(400, "Need a JSON object")
return
try:
if path == "/api/aim":
app.rig.update(
target=str(data.get("target", "both")),
pan=data["pan"],
tilt=data["tilt"],
dimmer=data.get("dimmer", app.rig.dimmer),
)
self._json(200, {"ok": True})
return
if path == "/api/color":
app.rig.set_color(str(data.get("target", "both")), data.get("color", ""))
self._json(200, app.state())
return
if path == "/api/node":
app.select_node(data.get("ip", ""))
self._json(200, app.state())
return
if path == "/api/nodes":
app.refresh_nodes()
self._json(200, app.state())
return
if path == "/api/positions":
name = clean_name(data.get("name", ""))
live = app.rig.live()
app.store.upsert(name, live["m1"], live["m2"])
self._json(200, app.state(saved=name))
return
if path == "/api/recall":
name = clean_name(data.get("name", ""))
entry = app.store.get(name)
if entry is None:
self._error(404, f"No position named {name}")
return
app.rig.recall(entry)
self._json(200, app.state())
return
if path == "/api/delete":
name = clean_name(data.get("name", ""))
if not app.store.delete(name):
self._error(404, f"No position named {name}")
return
self._json(200, app.state())
return
except KeyError:
self._error(400, "Need pan and tilt")
return
except ValueError as exc:
self._error(400, str(exc))
return
except OSError as exc:
self._error(500, f"Could not write positions: {exc}")
return
self._error(404, "Not found")
return Handler
def parse_args():
root = Path(__file__).resolve().parents[1]
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("--host", default="127.0.0.1", help="Web bind address")
parser.add_argument("--port", type=int, default=8765)
parser.add_argument(
"--file",
type=Path,
default=root / "shows" / "mover_positions.json",
help="JSON file for saved positions",
)
parser.add_argument("--ip", default=None, help=f"Art-Net destination (default: poll, else {DEFAULT_NODE})")
parser.add_argument("--universe", type=int, default=0)
parser.add_argument("--address", type=int, default=M1_ADDR, help="M1 DMX start, 1-based")
parser.add_argument("--address2", type=int, default=M2_ADDR, help="M2 DMX start, 1-based")
return parser.parse_args()
def main():
args = parse_args()
store = Store(args.file)
nodes = pin_gateway(discover_artnet_nodes())
if args.ip:
ip = clean_ip(args.ip)
nodes = include_ip(nodes, ip)
else:
ip = nodes[0]["ip"]
universe = args.universe
chosen = next((node for node in nodes if node["ip"] == ip), None)
if chosen and chosen.get("universe", "") != "" and args.universe == 0:
universe = int(chosen["universe"])
name = chosen["name"] if chosen and chosen.get("name") else ""
print(f"Art-Net → {ip} {name} universe {universe}".replace(" ", " ").strip(), flush=True)
for node in nodes:
label = f" {node['ip']}"
if node["name"]:
label += f" {node['name']}"
print(label, flush=True)
print(f"Positions → {args.file}", flush=True)
print("Stop QLC+ Art-Net output first. Ctrl+C blackout.", flush=True)
sender = ArtNetSender(ip, universe=universe)
rig = Rig(
{
"m1": Mover(sender, args.address, "M1"),
"m2": Mover(sender, args.address2, "M2"),
}
)
app = App(rig, store, sender, nodes, args.universe)
httpd = ThreadingHTTPServer((args.host, args.port), make_handler(app))
url_host = "127.0.0.1" if args.host in ("0.0.0.0", "::") else args.host
print(f"Open http://{url_host}:{args.port}", flush=True)
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("\nstopped")
finally:
httpd.server_close()
sender.close()
if __name__ == "__main__":
main()