cantabile_edge, cantabile_modbus, cantabile_eebus 0.1.400: full source

This commit is contained in:
Setti Solutions S.R.L committed 2026-10-30 08:26:45 +02:00
1 parent 343331d234
commit d5fbcacaa4
176 files changed
+32511 -19

No files matched your search

+438
View File
@@ -0,0 +1,438 @@
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
"""The add-on's page (ingress): a list of devices, and per device (#<id>, so a
reload stays there) its values in sets, its channels as tiles, an inverter's
power flow, sparklines of the last hour, and its controls with their
protection. Plain HTML, CSS and SVG; HA's light and dark; English and German
(the browser's language).
Value sets: a register's "group", else its key's first word; a set of one
value is a line, not a card. Registers with "bits" are under "details"
unless not zero. Keys ending _<n> on two or more channels are a channel grid
(SPM circuits). The bridge's derived values (modbus.derived) come like
registers. A profile's "view": {"headline": [refs], "flow": {"pv", "grid",
"load", "battery", "soc", "bypass": ref}, "energy": [refs]}; a ref is a
register key or a quantity (the register that gives it). The rest of the
view (card, values, channels) is for the dashboard in Home Assistant.
In HA's app panel the page is in an iframe whose own address has no
#<device>: the parent's hash is read at start and kept in step.
"""
import html
import re
import time
e = html.escape
HIST_MIN = 60 # sparklines: the last hour, a value a minute
T = {
"en": {"title": "Cantabile devices", "back": "All devices", "online": "online", "offline": "offline",
"ro": "read only", "sim": "simulated", "every": "every {} s", "ha": "Home Assistant",
"prot_sum": "{} of {} controls protected", "no_controls": "no controls", "values": "Values",
"controls": "Controls", "details": "Details", "total": "Total", "on_of": "{} of {} on",
"protected": "protected", "none": "not protected", "sealed": "sealed", "lift": "Lift",
"protect": "Protect", "protect_all": "Protect all", "never_off": "Off refused", "all_refused": "every command refused",
"confirm": "Lift the protection of {}? Cantabile may then switch it.", "history": "Protection changes",
"none_yet": "none yet", "lock": "set by Cantabile, locked", "pv": "Solar", "grid": "Grid", "load": "Output",
"battery": "Battery", "inverter": "Inverter", "charging": "charging", "discharging": "discharging",
"energy": "Energy", "intro": "A <b>protected</b> control refuses the commands that would switch it off; "
"only you lift a protection, here, one control at a time. <b>Sealed</b> ones are set by Cantabile and locked.",
"ro_note": "Read only: commands are checked and logged, never written.", "voltage": "Voltage", "circuit": "Circuit {}", "all": "All:",
"bypass": "bypass", "bypass_est": "via bypass, estimated"},
"de": {"title": "Cantabile-Geräte", "back": "Alle Geräte", "online": "online", "offline": "offline",
"ro": "nur lesen", "sim": "simuliert", "every": "alle {} s", "ha": "Home Assistant",
"prot_sum": "{} von {} Steuerungen geschützt", "no_controls": "keine Steuerungen", "values": "Werte",
"controls": "Steuerungen", "details": "Details", "total": "Gesamt", "on_of": "{} von {} an",
"protected": "geschützt", "none": "nicht geschützt", "sealed": "versiegelt", "lift": "Aufheben",
"protect": "Schützen", "protect_all": "Alle schützen", "never_off": "Aus wird abgelehnt", "all_refused": "jeder Befehl abgelehnt",
"confirm": "Schutz von {} aufheben? Cantabile darf es dann schalten.", "history": "Änderungen am Schutz",
"none_yet": "noch keine", "lock": "von Cantabile gesetzt, gesperrt", "pv": "Solar", "grid": "Netz", "load": "Ausgang",
"battery": "Batterie", "inverter": "Wechselrichter", "charging": "lädt", "discharging": "entlädt",
"energy": "Energie", "intro": "Eine <b>geschützte</b> Steuerung lehnt Befehle ab, die sie ausschalten würden; "
"nur Sie heben einen Schutz auf, hier, je Steuerung. <b>Versiegelte</b> setzt Cantabile, sie sind gesperrt.",
"ro_note": "Nur lesen: Befehle werden geprüft und protokolliert, nie geschrieben.", "voltage": "Spannung",
"circuit": "Stromkreis {}", "all": "Alle:",
"bypass": "Bypass", "bypass_est": "über Bypass, geschätzt"},
}
CSS = """:root{--bg:#f6f8f7;--fg:#1d2a24;--card:#fff;--line:#d5ded9;--soft:#e3e9e5;--mute:#5a6b62;--acc:#2f6f55;--prot:#1f6b45;--warn:#7a4b00;--bar:#cfe3d8}
@media (prefers-color-scheme:dark){:root{--bg:#111915;--fg:#e3ebe6;--card:#18221d;--line:#2b3a32;--soft:#22302a;--mute:#9fb0a6;--acc:#5fb38c;--prot:#7fd1a6;--warn:#e0a54a;--bar:#2c4a3b}}
body{font-family:system-ui,sans-serif;margin:0;padding:16px;overflow-wrap:anywhere;max-width:56rem;color:var(--fg);background:var(--bg)}
h2{margin:.2rem 0 1rem}h3{margin:0 0 .4rem;font-size:1rem}a{color:inherit}
.card{background:var(--card);border:1px solid var(--line);border-radius:8px;padding:.7rem .8rem;margin:.5rem 0}
a.card{display:block;text-decoration:none}a.card:hover{border-color:var(--acc)}
.row{display:flex;flex-wrap:wrap;gap:.3rem .9rem;align-items:baseline}.grow{flex:1}
.note{color:var(--mute);font-size:.88rem}.big{font-size:1.5rem;font-weight:600}.small{font-size:.82rem;color:var(--mute)}
.badge{display:inline-block;font-size:.75rem;padding:.05rem .45rem;border-radius:9px;background:var(--soft);color:var(--mute)}
.ok{color:var(--prot)}.bad{color:var(--warn)}.prot{background:var(--bar);color:var(--prot);font-weight:600}.lock{color:var(--warn)}
.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(10.5rem,100%),1fr));gap:.5rem}
.tiles{grid-template-columns:repeat(auto-fill,minmax(min(8rem,100%),1fr))}.tiles .card{padding:.45rem .6rem}
table.sparks td{border:0;padding:.15rem .4rem;vertical-align:middle}table.sparks td:first-child{width:40%}
.sets{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(14rem,100%),1fr));gap:.5rem}
.bar{height:6px;border-radius:3px;background:var(--soft);margin:.3rem 0}.bar i{display:block;height:100%;border-radius:3px;background:var(--acc)}
table{border-collapse:collapse;width:100%}td,th{text-align:left;padding:.3rem .4rem;border-bottom:1px solid var(--soft);font-size:.9rem}
td.v{text-align:right;white-space:nowrap}
button{font:inherit;font-size:.82rem;padding:.2rem .7rem;border:0;border-radius:6px;background:var(--acc);color:#fff;cursor:pointer}
button.off{background:var(--soft);color:var(--fg)}form{display:inline;margin:0}
details summary{cursor:pointer;color:var(--mute);font-size:.88rem}pre{white-space:pre-wrap;font-size:.8rem}
section.dev{display:none}section.dev:target{display:block}body:has(section.dev:target) #list{display:none}
svg text{fill:var(--fg);font-size:12px}svg text.sub{font-size:9.5px}svg .mute{fill:var(--mute)}svg .ln{stroke:var(--acc);fill:none}svg .box{fill:var(--card);stroke:var(--line)}
svg .soc{fill:var(--acc)}svg .spark{stroke:var(--acc);fill:none;stroke-width:1.5}"""
# HA's app panel shows the page in an iframe (same origin) without the
# #<device> of its own address: take the parent's at start and keep both in
# step, so a link, back and reload land on the device. Reload every 30 s.
SCRIPT = """(function(){var P=null;try{if(window.parent!==window){P=window.parent;P.location.hash}}catch(x){P=null}
function dev(h){return h&&h.length>1&&document.getElementById(decodeURIComponent(h.slice(1)))?h:''}
if(P&&!location.hash){var h=dev(P.location.hash);if(h)location.replace(h)}
if(P){window.addEventListener('hashchange',function(){try{var h=location.hash;if(P.location.hash!==h&&!(h===''&&P.location.hash==='#'))P.location.hash=h}catch(x){}});
P.addEventListener('hashchange',function(){var h=dev(P.location.hash);if(h!==location.hash&&!(h===''&&location.hash==='#'))location.hash=h})}
setTimeout(function(){location.reload()},30000)})();"""
def lang_of(accept):
return "de" if (accept or "").lower().startswith("de") else "en"
def num(s):
try:
return float(s)
except (TypeError, ValueError):
return None
def fmt(v, unit):
"""A value for people: W to kW and Wh to kWh above 1000, sensible digits."""
x = num(v)
if x is None:
return "–" if v is None else e(str(v))
if unit == "Wh":
return f"{x / 1000:,.1f} kWh" if abs(x) >= 1000 else f"{x:.0f} Wh"
if unit == "W":
return f"{x / 1000:.2f} kW" if abs(x) >= 1000 else f"{x:.0f} W" if abs(x) >= 100 or x == 0 else f"{x:.1f} W"
digits = {"V": 1, "A": 2, "%": 0, "°C": 1, "Hz": 2}.get(unit, 2)
s = f"{x:.{digits}f}"
return f"{s} {e(unit)}" if unit else s
def channel_of(key):
m = re.fullmatch(r"(.+)_(\d+)", key)
return (m.group(1), int(m.group(2))) if m else (None, None)
def is_switch(r):
return set((r.get("write") or {}).get("options") or {}) == {"0", "1"}
class View:
"""One device's values for the page: the registers' and the derived ones
(the bridge publishes both; energy comes in kWh, kept here in Wh), and
their last hour."""
def __init__(self, dev, values, hist):
self.dev, self.hist = dev, hist
self.regs = {r["key"]: r for r in dev["registers"]}
self.regs.update({d["key"]: dict(d, type="derived") for d in dev.get("derived") or []})
self.v = {k: values.get(f"{dev['id']}/{k}") for k in self.regs}
for k, r in self.regs.items():
if r.get("unit") == "Wh" and num(self.v[k]) is not None:
self.v[k] = num(self.v[k]) * 1000
# the view's references as register keys (a quantity: its register)
by_q = {}
for k, r in self.regs.items():
if r.get("quantity"):
by_q.setdefault(r["quantity"], k)
v = dev.get("view") or {}
ref = lambda x: by_q.get(x, x) if isinstance(x, str) else x # noqa: E731
self.view = dict(v, headline=[ref(x) for x in v.get("headline") or []],
energy=[ref(x) for x in v.get("energy") or []])
if v.get("flow"):
self.view["flow"] = {k: ref(x) for k, x in v["flow"].items()}
def series(self, key):
"""[value per minute] of the last hour."""
now = int(time.time() // 60)
return [self.hist.get(f"{self.dev['id']}/{key}", {}).get(m) for m in range(now - HIST_MIN + 1, now + 1)]
def channels(self):
"""{n: {base: key}} when two or more channels carry values."""
ch = {}
for k, r in self.regs.items():
base, n = channel_of(k)
if n is not None:
ch.setdefault(n, {})[base] = k
valued = {n: c for n, c in ch.items() if any(not self.regs[k].get("write") for k in c.values())}
return valued if len(valued) >= 2 else {}
def headline(self, t):
out = []
for k in self.view.get("headline") or []:
if k in self.regs:
out.append((self.regs[k].get("name") or k, fmt(self.v.get(k), self.regs[k].get("unit", ""))))
ch = self.channels()
if not out and ch:
tot = sum(num(self.v.get(c.get("power"))) or 0 for c in ch.values())
out.append((t["total"], fmt(tot, "W")))
sw = [k for k, r in self.regs.items() if is_switch(r)]
if len(sw) >= 3 and not ch:
on = sum(1 for k in sw if str(self.v.get(k)) == (self.regs[k]["write"]["options"]["1"]))
out.append(("", t["on_of"].format(on, len(sw))))
return out
def spark(vals, w=120, h=26):
pts = [(i, v) for i, v in enumerate(vals) if v is not None]
if len(pts) < 2:
return ""
lo, hi = min(v for _, v in pts), max(v for _, v in pts)
span = (hi - lo) or 1
xy = " ".join(f"{i * w / (len(vals) - 1):.1f},{h - 2 - (v - lo) / span * (h - 4):.1f}" for i, v in pts)
return f"<svg width={w} height={h} viewBox='0 0 {w} {h}' aria-hidden=true><polyline class=spark points='{xy}'/></svg>"
def flow(vw):
"""The flow's powers: pv, grid (into the inverter +), load, battery
(charge +), soc, and whether the grid figure is estimated: with the
bypass on the utility feeds the output directly, which no register
counts (the grid register is the utility's charging power only)."""
f = vw.view["flow"]
p = {k: num(vw.v.get(f.get(k))) for k in ("pv", "grid", "load", "battery", "soc")}
p["bypass"] = bool(num(vw.v.get(f.get("bypass")))) # the grid's value then includes the output (estimated)
return p
def flow_svg(vw, t):
"""Four nodes around the inverter: solar above, grid left, output right,
battery below (its charge as a bar inside); each arrow along the flow."""
p = flow(vw)
bp, soc = p["battery"], p["soc"]
def width(x):
return 1.5 + min(6, abs(x or 0) / 300)
def line(x1, y1, x2, y2, power):
"""From (x1, y1) to (x2, y2) when power > 0, the other way when < 0."""
if not power or abs(power) < 1:
return f"<line x1={x1} y1={y1} x2={x2} y2={y2} class=ln stroke-width=1 stroke-dasharray='3 4' opacity=.5 />"
if power < 0:
x1, y1, x2, y2 = x2, y2, x1, y1
return f"<line x1={x1} y1={y1} x2={x2} y2={y2} class=ln stroke-width={width(power):.1f} marker-end='url(#arr)'/>"
def node(cx, cy, label, value, sub=""):
return (f"<rect x={cx - 56} y={cy - 26} width=112 height=52 rx=8 class=box />"
f"<text x={cx} y={cy - 8} text-anchor=middle class=mute>{e(label)}</text>"
f"<text x={cx} y={cy + 9} text-anchor=middle font-weight=600>{value}</text>"
+ (f"<text x={cx} y={cy + 22} text-anchor=middle class='mute sub'>{e(sub)}</text>" if sub else ""))
grid_sub = t["bypass_est"] if p["bypass"] else ""
bat_sub = t["charging"] if (bp or 0) >= 1 else t["discharging"] if (bp or 0) <= -1 else ""
bat_label = t["battery"] + (f" · {soc:.0f} %" if soc is not None else "")
socbar = ""
if soc is not None:
w = max(0, min(100, soc)) * 0.96
socbar = (f"<rect x=132 y=299 width=96 height=5 rx=2 class=box /><rect x=132 y=299 width={w:.1f} height=5 rx=2 class=soc />")
# inverter 130..230 x 124..176 (centre 180,150); nodes 46 px away from it on each side
return "".join([
"<svg viewBox='0 0 360 316' width=100% style='max-width:30rem' role=img>",
"<defs><marker id=arr viewBox='0 0 10 10' refX=9 refY=5 markerWidth=5 markerHeight=5 orient=auto>"
"<path d='M0,0L10,5L0,10z' class=soc /></marker></defs>",
line(180, 54, 180, 124, p["pv"]), # solar -> inverter
line(112, 150, 130, 150, p["grid"]), # grid -> inverter (+)
line(230, 150, 248, 150, p["load"]), # inverter -> output
line(180, 176, 180, 246, bp), # inverter -> battery (charge +)
node(180, 28, t["pv"], fmt(p["pv"], "W")),
node(56, 150, t["grid"], ("≈ " if p["bypass"] else "") + fmt(p["grid"], "W"), grid_sub),
f"<rect x=130 y=124 width=100 height=52 rx=8 class=box /><text x=180 y={148 if not p['bypass'] else 144} text-anchor=middle font-weight=600>{t['inverter']}</text>"
+ (f"<text x=180 y=162 text-anchor=middle class='mute sub'>{t['bypass']}</text>" if p["bypass"] else ""),
node(304, 150, t["load"], fmt(p["load"], "W")),
f"<rect x=124 y=246 width=112 height=64 rx=8 class=box />"
f"<text x=180 y=264 text-anchor=middle class=mute>{e(bat_label)}</text>"
f"<text x=180 y=281 text-anchor=middle font-weight=600>{fmt(abs(bp) if bp is not None else None, 'W')}</text>"
f"<text x=180 y=294 text-anchor=middle class='mute sub'>{e(bat_sub)}</text>",
socbar, "</svg>"])
def badge(level, refuse, t):
if level == "sealed":
return f"<span class='badge lock'>🔒 {t['sealed']}</span>"
if level == "protected":
what = t["never_off"] if refuse is not None and set(refuse) == {0.0} else t["all_refused"]
return f"<span class='badge prot' title='{e(what)}'>{t['protected']} · {e(what)}</span>"
return f"<span class=badge>{t['none']}</span>"
def toggle(dev, r, level, t):
if level == "sealed":
return f"<span class='small lock'>{t['lock']}</span>"
name = r.get("name") or r["key"]
if level == "protected":
msg = t["confirm"].format(name).replace("'", "’")
return (f"<form method=post action=protect onsubmit=\"return confirm('{e(msg)}')\"><input type=hidden name=dev value='{e(dev['id'])}'>"
f"<input type=hidden name=key value='{e(r['key'])}'><input type=hidden name=level value=none>"
f"<button class=off>{t['lift']}</button></form>")
return (f"<form method=post action=protect><input type=hidden name=dev value='{e(dev['id'])}'>"
f"<input type=hidden name=key value='{e(r['key'])}'><input type=hidden name=level value=protected>"
f"<button>{t['protect']}</button></form>")
def controls(dev, vw, level_of, refuse_of, t):
ctl = [r for r in dev["registers"] if r.get("write")]
if not ctl:
return ""
prot = dev.get("protection") or {}
notes = {(prot.get(r["key"]) or prot.get("*") or {}).get("note", "") for r in ctl}
out = [f"<div class=card><h3>{t['controls']}</h3>"]
if len(notes) == 1 and next(iter(notes)):
out.append(f"<p class=note>{e(next(iter(notes)))}</p>")
if dev.get("read_only"):
out.append(f"<p class=note>{t['ro_note']}</p>")
levels = {r["key"]: level_of(dev, r["key"]) for r in ctl}
if len(ctl) >= 8 and all(is_switch(r) for r in ctl):
same = len({(levels[r["key"]], str(refuse_of(dev, r["key"]))) for r in ctl}) == 1
if same:
out.append(f"<p>{t['all']} {badge(levels[ctl[0]['key']], refuse_of(dev, ctl[0]['key']), t)}</p>")
out.append("<div class='grid tiles'>")
for r in ctl:
on = str(vw.v.get(r["key"])) == r["write"]["options"]["1"]
out.append(f"<div class=card style='margin:0'><div class=row><b class=grow>{e(r.get('name') or r['key'])}</b>"
f"<span class={'ok' if on else 'small'}>{e(str(vw.v.get(r['key']) or '–'))}</span></div>"
f"<div class=row style='margin-top:.2rem'>{'' if same else badge(levels[r['key']], refuse_of(dev, r['key']), t)}"
f"<span class=grow></span>{toggle(dev, r, levels[r['key']], t)}</div></div>")
out.append("</div>")
else:
out.append("<table>")
for r in ctl:
n = (prot.get(r["key"]) or {}).get("note", "") if len(notes) > 1 else ""
out.append(f"<tr><td>{e(r.get('name') or r['key'])}" + (f"<br><span class=small>{e(n)}</span>" if n else "")
+ f"</td><td>{e(str(vw.v.get(r['key']) or '–'))}</td><td>{badge(levels[r['key']], refuse_of(dev, r['key']), t)}</td>"
f"<td class=v>{toggle(dev, r, levels[r['key']], t)}</td></tr>")
out.append("</table>")
if sum(1 for lv in levels.values() if lv == "none") >= 2:
out.append(f"<p><form method=post action=protect><input type=hidden name=dev value='{e(dev['id'])}'>"
f"<input type=hidden name=key value='*'><input type=hidden name=level value=protected>"
f"<button>{t['protect_all']}</button></form></p>")
out.append("</div>")
return "".join(out)
def value_sets(vw, skip, t):
"""The values not shown elsewhere, in sets; one value: a line."""
groups, bits = {}, []
for k, r in vw.regs.items():
if r.get("write") or k in skip or r.get("type") == "string":
continue
if r.get("bits"):
x = num(vw.v.get(k))
if not x:
bits.append((r, vw.v.get(k)))
continue
groups.setdefault(r.get("group") or k.split("_")[0].capitalize(), []).append(r)
cards, lines = [], []
for g, rs in groups.items():
if len(rs) == 1:
r = rs[0]
lines.append(f"<div class=row><span class=grow>{e(r.get('name') or r['key'])}</span><b>{fmt(vw.v.get(r['key']), r.get('unit', ''))}</b></div>")
continue
rows = "".join(f"<tr><td>{e(r.get('name') or r['key'])}</td><td class=v>{fmt(vw.v.get(r['key']), r.get('unit', ''))}"
+ (f"<br>{spark(vw.series(r['key']), 80, 18)}" if r.get("unit") == "W" else "") + "</td></tr>" for r in rs)
cards.append(f"<div class=card style='margin:0'><h3>{e(g)}</h3><table>{rows}</table></div>")
out = ""
if cards:
out += f"<div class=sets>{''.join(cards)}</div>"
if lines:
out += f"<div class=card>{''.join(lines)}</div>"
if bits:
out += (f"<details class=card><summary>{t['details']}</summary><table>"
+ "".join(f"<tr><td>{e(r.get('name') or r['key'])}</td><td class=v>{e(str(v if v is not None else '–'))}</td></tr>" for r, v in bits)
+ "</table></details>")
return out
def channel_grid(vw, t):
ch = vw.channels()
pw = {n: num(vw.v.get(c.get("power"))) for n, c in ch.items()}
total = sum(x or 0 for x in pw.values())
volts = [num(vw.v.get(c.get("voltage"))) for c in ch.values() if c.get("voltage")]
volts = [x for x in volts if x is not None]
one_v = volts and max(volts) - min(volts) <= 5
head = (f"<div class=card><div class=row><span class=grow>{t['total']}</span><span class=big>{fmt(total, 'W')}</span>"
f"{spark([sum(x or 0 for x in s) if any(x is not None for x in s) else None for s in zip(*[vw.series(c['power']) for c in ch.values() if c.get('power')])])}</div>"
+ (f"<div class=small>{t['voltage']} {fmt(sum(volts) / len(volts), 'V')}</div>" if one_v else "") + "</div>")
tiles = []
for n in sorted(ch):
c = ch[n]
sw = c.get("circuit") or next((k for k in c.values() if vw.regs[k].get("write")), None)
name = (vw.regs[sw].get("name") if sw else None) or t["circuit"].format(n)
state = f" <span class=small>{e(str(vw.v.get(sw) or '–'))}</span>" if sw else ""
share = (pw[n] or 0) / total * 100 if total else 0
small = [fmt(vw.v.get(c[b]), vw.regs[c[b]].get("unit", "")) for b in ("current", "energy") if c.get(b)]
if c.get("voltage") and not one_v:
small.append(fmt(vw.v.get(c["voltage"]), "V"))
tiles.append(f"<div class=card style='margin:0'><div class=row><b class=grow>{e(name)}</b>{state}</div>"
f"<div class=big>{fmt(pw[n], 'W')}</div><div class=bar><i style='width:{share:.0f}%'></i></div>"
f"<div class=small>{' · '.join(small)}</div></div>")
return head + f"<div class=grid>{''.join(tiles)}</div>", {k for c in ch.values() for k in c.values()}
def device_view(dev, vw, status, level_of, refuse_of, t):
out = [f"<section class=dev id='{e(dev['id'])}'><p><a href='#'>← {t['back']}</a></p>",
f"<h2>{e(dev['name'])}</h2><p class=note>{e(dev['manufacturer'])} {e(dev['model'])} · {where(dev, t)} · "
f"{t['every'].format(dev.get('poll_s', 10))} {state_badges(dev, status, t)}</p>"]
skip = set()
if vw.view.get("flow"):
f = vw.view["flow"]
skip |= {f.get(k) for k in ("pv", "grid", "load", "battery", "soc", "bypass")}
for d in vw.dev.get("derived") or []:
skip |= set(d.get("product") or [])
sparks = "<table class=sparks>" + "".join(
f"<tr><td>{e(vw.regs[k].get('name') or k)}</td><td class=v>{fmt(vw.v.get(k), 'W')}</td><td>{spark(vw.series(k), 160, 32)}</td></tr>"
for k in (f.get("pv"), f.get("load"), f.get("battery"), f.get("grid")) if k in vw.regs) + "</table>"
energy = " · ".join(f"{e(vw.regs[k].get('name') or k)} {fmt(vw.v.get(k), 'Wh')}" for k in vw.view.get("energy") or [] if k in vw.regs)
skip |= set(vw.view.get("energy") or [])
out.append(f"<div class=card>{flow_svg(vw, t)}{sparks}" + (f"<p class=small>{t['energy']}: {energy}</p>" if energy else "") + "</div>")
if vw.channels():
grid, used = channel_grid(vw, t)
out.append(grid)
skip |= used
out.append(value_sets(vw, skip, t))
out.append(controls(dev, vw, level_of, refuse_of, t))
out.append("</section>")
return "".join(out)
def where(dev, t):
if dev.get("source") == "ha":
return f"{t['ha']} ({e(dev.get('device', ''))})"
return f"{e(dev['host'])}:{dev['port']} · unit {dev['unit_id']}"
def state_badges(dev, status, t):
b = [f"<span class='badge {'ok' if status == 'online' else 'bad'}'>{t['online'] if status == 'online' else t['offline']}</span>"] \
if status else []
if dev.get("read_only"):
b.append(f"<span class=badge>{t['ro']}</span>")
if dev.get("simulated"):
b.append(f"<span class=badge>{t['sim']}</span>")
return " ".join(b)
def render(devs, values, statuses, hist, level_of, refuse_of, lang="en", plog=()):
t = T.get(lang, T["en"])
out = [f"<!doctype html><html lang={lang}><meta charset=utf-8><meta name=viewport content='width=device-width,initial-scale=1'>"
f"<title>{t['title']}</title><style>{CSS}</style><body><div id=list><h2>{t['title']}</h2><p class=note>{t['intro']}</p>"]
views = {d["id"]: View(d, values, hist) for d in devs}
for d in devs:
vw = views[d["id"]]
ctl = [r for r in d["registers"] if r.get("write")]
n_prot = sum(1 for r in ctl if level_of(d, r["key"]) in ("protected", "sealed"))
heads = " · ".join((f"{e(k)} <b>{v}</b>" if k else f"<b>{v}</b>") for k, v in vw.headline(t))
summary = t["prot_sum"].format(n_prot, len(ctl)) if ctl else t["no_controls"]
out.append(f"<a class=card href='#{e(d['id'])}'><div class=row><h3 class=grow>{e(d['name'])}</h3>"
f"{state_badges(d, statuses.get(d['id']), t)}</div>"
f"<div class=note>{e(d['model'])} · {where(d, t)}</div>"
+ (f"<div style='margin:.3rem 0'>{heads}</div>" if heads else "")
+ f"<div class=small>{summary}</div></a>")
out.append(f"<details class=card><summary>{t['history']}</summary><pre>{e(chr(10).join(plog)) or t['none_yet']}</pre></details></div>")
for d in devs:
out.append(device_view(d, views[d["id"]], statuses.get(d["id"]), level_of, refuse_of, t))
out.append("<script>" + SCRIPT + "</script></body></html>")
return "".join(out).encode()