cantabile_edge, cantabile_modbus, cantabile_eebus 0.1.1030: full source

This commit is contained in:
Setti Solutions S.R.L committed 2026-11-06 00:13:12 +02:00
1 parent e2c7085d2c
commit cddd34dcbc
30 files changed
+2141 -51

No files matched your search

+567
View File
@@ -0,0 +1,567 @@
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
"""The household's own energy costs on the box (docs/methods.md A12; the
owner, 2026-11-05: a tenant/inhabitant-facing "My energy costs" view on the
box's own Home Assistant dashboard; the console is staff-only).
Only the household's own figures: its meter, the prices of its own tariff
bundle and its own plan. Never the building operator's margin, other flats
or building totals (the box has none of them: the bundle carries only this
site's prices).
What is kept (<state dir>/costs.db, SQLite; survives restarts):
slots per quarter-hour and carrier (electricity, gas, heat): the metered
kWh (from the agent's own 1-minute windows: a counter's delta,
else a power's mean), what they cost at the price that applied
(the tariff bundle in force at the minute), the kWh without a
price, the same kWh at the own supplier's price, the kWh, cost and
own-supplier cost of slots priced by a building's or community's
offer (Mieterstrom, GGV, §42c), and the plan's estimate for the
slot (optimizer.step_costs: with and without the plan, the same
prices) as saved (mode auto, a billed price) or would-have-saved
(shadow, advisory, or an unbilled tenant price). 400 days.
months the same sums per local month (the site's time zone): the
monthly accumulators, plus the fixed charges per month the bundle
said (when it carries them).
prices per quarter-hour the import price, the own supplier's and whether
the offer priced it, as the bundle said (today's past hours after
the bundle has moved on). 3 days.
Nothing here is ever sent anywhere: it is shown in HA only (announce.py,
dashboards.py). Missing data is never a 0: each figure is None with the
reason in report()["gaps"] (the dashboard's alarm box)."""
from __future__ import annotations
import html
import logging
import math
import os
import sqlite3
import threading
import time
from datetime import datetime, timedelta, timezone
from zoneinfo import ZoneInfo
from . import names
from .devprofiles import part_of
log = logging.getLogger(__name__)
SLOT_S = 900
KEEP_DAYS = 400 # slots: this month and last, and a year back for a later view
KEEP_PRICE_DAYS = 3
CARRIERS = ("electricity", "gas", "heat")
# the meters the costs are read from: carrier, kind (a part, grid.1.import_energy, counts as its quantity)
ASSETS = {"grid.import_energy": ("electricity", "counter"), "grid.import_power": ("electricity", "gauge"),
"grid.power": ("electricity", "gauge"), # signed (import +): its positive part
"gas.energy": ("gas", "counter"), "heat.energy": ("heat", "counter")}
PREFER = ("grid.import_energy", "grid.import_power", "grid.power") # electricity: the counter first
PARAM_FORECAST = "costs.forecast_days" # the Parameters page (fleet), in the tariff bundle's params
FORECAST_DAYS = (1, 62) # the parameter's valid range
REPORT_EVERY_S = 60 # HA's figures made again at most this often (announce.py)
COLS = ("kwh", "cost_eur", "unpriced_kwh", "own_eur", "offer_kwh", "offer_eur", "offer_own_eur",
"plan_eur", "base_eur", "saved_eur", "would_eur", "plan_slots", "minutes")
def quantity(asset: str) -> str:
p = part_of(asset)
return p[0] if p else asset
def wanted(asset: str) -> bool:
return quantity(asset) in ASSETS
def meters_of(mapping) -> dict[str, bool]:
"""Per carrier whether the mapping has a meter for it."""
out = {c: False for c in CARRIERS}
for a in mapping.assets:
q = quantity(a.asset)
if q in ASSETS:
out[ASSETS[q][0]] = True
return out
def _finite(v) -> bool:
return isinstance(v, (int, float)) and not isinstance(v, bool) and math.isfinite(v)
def amounts(records: list[dict], span_s: float) -> dict[str, float | None]:
"""A closed window's kWh per carrier from the cost aggregator's records
(telemetry.Aggregator): the counters' deltas (Wh) where the carrier has
a counter that has a reading, else its power's mean (W) over the
window; None: no meter value for the carrier in this window. Parts
(two meters) add up."""
by: dict[str, dict[str, list]] = {}
for r in records:
q = quantity(r.get("asset", ""))
if q not in ASSETS:
continue
carrier, kind = ASSETS[q]
if kind == "counter":
v = r.get("delta") if r.get("last") is not None else None
v = v / 1000.0 if _finite(v) else None
else:
m = r.get("mean")
v = (max(m, 0.0) if q == "grid.power" else m) * span_s / 3600.0 / 1000.0 if _finite(m) else None
by.setdefault(carrier, {}).setdefault(q, []).append(v)
out = {}
for carrier, qs in by.items():
order = [q for q in PREFER if q in qs] if carrier == "electricity" else list(qs)
got = None
for q in order:
vals = qs[q]
if vals and all(v is not None for v in vals):
got = sum(vals)
break
out[carrier] = got
return out
class Ledger:
"""The household's costs. bundles: the agent's tariff bundle reader
(bundles.Bundles); mode: the control mode now (None: no planner on this
box); tz: the site's time zone now (HA's)."""
def __init__(self, state_dir: str, bundles, mode=lambda: None, tz=lambda: "UTC", clock=time.time):
self.bundles, self.mode, self.tz, self.clock = bundles, mode, tz, clock
self.lock = threading.Lock()
self.path = os.path.join(state_dir, "costs.db")
self.db = sqlite3.connect(self.path, isolation_level=None, check_same_thread=False)
self.db.execute("PRAGMA journal_mode=WAL")
self.db.execute("PRAGMA synchronous=NORMAL")
cols = ", ".join(f"{c} REAL NOT NULL DEFAULT 0" for c in COLS)
self.db.execute(f"CREATE TABLE IF NOT EXISTS slots (slot INTEGER NOT NULL, carrier TEXT NOT NULL, {cols}, "
"billed INTEGER NOT NULL DEFAULT 1, PRIMARY KEY (slot, carrier)) WITHOUT ROWID")
self.db.execute(f"CREATE TABLE IF NOT EXISTS months (month TEXT NOT NULL, carrier TEXT NOT NULL, {cols}, "
"fixed_eur REAL, fixed_incomplete INTEGER NOT NULL DEFAULT 0, unbilled_kwh REAL NOT NULL DEFAULT 0, "
"PRIMARY KEY (month, carrier)) WITHOUT ROWID")
self.db.execute("CREATE TABLE IF NOT EXISTS prices (slot INTEGER PRIMARY KEY, price_ct REAL, own_ct REAL, "
"offer INTEGER NOT NULL DEFAULT 0) WITHOUT ROWID")
self.pending: dict[int, dict] = {} # slot -> the latest plan's estimate for it (step 0)
self._booked = 0 # the last slot whose plan estimate is booked
def close(self):
with self.lock:
self.db.close()
# -- time -------------------------------------------------------------------
def zone(self) -> ZoneInfo:
try:
return ZoneInfo(self.tz() or "UTC")
except Exception: # an unknown zone: UTC, said in the report
return ZoneInfo("UTC")
def month_of(self, ts: float) -> str:
return datetime.fromtimestamp(ts, timezone.utc).astimezone(self.zone()).strftime("%Y-%m")
def month_bounds(self, ts: float) -> tuple[int, int]:
d = datetime.fromtimestamp(ts, timezone.utc).astimezone(self.zone())
a = d.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
b = (a + timedelta(days=32)).replace(day=1)
# a new datetime at midnight in the zone (DST: the offset of that day)
a = datetime(a.year, a.month, 1, tzinfo=self.zone())
b = datetime(b.year, b.month, 1, tzinfo=self.zone())
return int(a.timestamp()), int(b.timestamp())
# -- writing ----------------------------------------------------------------
def _add(self, slot: int, carrier: str, vals: dict, billed: bool | None = None, month_extra: dict | None = None):
keys = [k for k in COLS if k in vals]
month = self.month_of(slot)
if keys:
sets = ", ".join(f"{k} = {k} + excluded.{k}" for k in keys)
q = ", ".join("?" for _ in keys)
self.db.execute(f"INSERT INTO slots (slot, carrier, {', '.join(keys)}{', billed' if billed is not None else ''}) "
f"VALUES (?, ?, {q}{', ?' if billed is not None else ''}) ON CONFLICT (slot, carrier) DO UPDATE SET "
f"{sets}{', billed = excluded.billed' if billed is not None else ''}",
[slot, carrier] + [vals[k] for k in keys] + ([int(billed)] if billed is not None else []))
self.db.execute(f"INSERT INTO months (month, carrier, {', '.join(keys)}) VALUES (?, ?, {q}) "
f"ON CONFLICT (month, carrier) DO UPDATE SET {sets}", [month, carrier] + [vals[k] for k in keys])
for k, v in (month_extra or {}).items():
self.db.execute("INSERT INTO months (month, carrier) VALUES (?, ?) ON CONFLICT DO NOTHING", (month, carrier))
if k == "unbilled_kwh":
self.db.execute("UPDATE months SET unbilled_kwh = unbilled_kwh + ? WHERE month = ? AND carrier = ?",
(v, month, carrier))
else:
self.db.execute(f"UPDATE months SET {k} = ? WHERE month = ? AND carrier = ?", (v, month, carrier))
def add_window(self, start: float, end: float, records: list[dict]) -> dict:
"""A closed window of the cost aggregator: its kWh per carrier at the
prices in force at its start, into its slot and month; the plan's
estimate of slots that ended. Returns the kWh booked per carrier."""
span = max(0.0, end - start)
slot = int(start // SLOT_S * SLOT_S)
got = amounts(records, span)
sp = self.bundles.slot_prices(start, self.clock())
fixed = self.bundles.fixed_charges(start)
with self.lock:
self.db.execute("BEGIN")
try:
self._book_plans(slot)
el = (sp or {}).get("electricity") or {}
if el:
self.db.execute("INSERT OR REPLACE INTO prices (slot, price_ct, own_ct, offer) VALUES (?, ?, ?, ?)",
(slot, el.get("price"), el.get("own"), int(bool(el.get("offer")))))
for carrier, kwh in got.items():
if kwh is None or kwh < 0:
continue
p = (sp or {}).get(carrier) or {}
price, own = p.get("price"), p.get("own")
v = {"kwh": kwh, "minutes": span / 60.0}
if price is None:
v["unpriced_kwh"] = kwh
else:
v["cost_eur"] = kwh * price / 100.0
if own is not None:
v["own_eur"] = kwh * own / 100.0
if p.get("offer") and price is not None and own is not None:
v.update(offer_kwh=kwh, offer_eur=kwh * price / 100.0, offer_own_eur=kwh * own / 100.0)
extra = {}
f = (fixed or {}).get(carrier)
if f is not None:
extra.update(fixed_eur=f["eur_month"], fixed_incomplete=int(bool(f.get("incomplete"))))
if p.get("offer") and not p.get("billed"):
extra["unbilled_kwh"] = kwh
self._add(slot, carrier, v, None if not p else bool(p.get("billed", True)), extra)
self.db.execute("COMMIT")
except Exception:
self.db.execute("ROLLBACK")
raise
return got
def take_plan(self, plan: dict):
"""A new plan: its estimate for the quarter-hour under way (step 0,
optimizer.step_costs), booked when the quarter-hour ends; a later
plan in the same quarter-hour replaces it."""
se, start, step = plan.get("steps_eur"), plan.get("start"), plan.get("step_s") or SLOT_S
if not isinstance(se, dict) or not _finite(start):
return
now = self.clock()
k = int((now - start) // step)
if k < 0:
return
slot = int(start + k * step)
est = {}
for carrier, d in se.items():
try:
est[carrier] = (float(d["plan"][k]), float(d["base"][k]))
except (KeyError, IndexError, TypeError, ValueError):
continue
if est:
self.pending[slot] = {"est": est, "mode": self.mode() or ""}
def _book_plans(self, now_slot: int):
for slot in sorted(s for s in self.pending if s < now_slot):
p = self.pending.pop(slot)
if slot <= self._booked:
continue
sp = self.bundles.slot_prices(slot, self.clock()) or {}
for carrier, (plan_eur, base_eur) in p["est"].items():
saving = base_eur - plan_eur
billed = carrier != "electricity" or not (sp.get("electricity") or {}).get("offer") or \
bool((sp.get("electricity") or {}).get("billed"))
acted = p["mode"] == "auto" and billed
self._add(slot, carrier, {"plan_eur": plan_eur, "base_eur": base_eur,
"saved_eur" if acted else "would_eur": saving, "plan_slots": 1})
self._booked = slot
def prune(self, now: float | None = None):
now = self.clock() if now is None else now
with self.lock:
self.db.execute("DELETE FROM slots WHERE slot < ?", (int(now) - KEEP_DAYS * 86400,))
self.db.execute("DELETE FROM prices WHERE slot < ?", (int(now) - KEEP_PRICE_DAYS * 86400,))
# -- reading ----------------------------------------------------------------
def month_row(self, month: str, carrier: str) -> dict | None:
with self.lock:
cur = self.db.execute(f"SELECT {', '.join(COLS)}, fixed_eur, fixed_incomplete, unbilled_kwh FROM months "
"WHERE month = ? AND carrier = ?", (month, carrier))
row = cur.fetchone()
if row is None:
return None
return dict(zip(COLS + ("fixed_eur", "fixed_incomplete", "unbilled_kwh"), row))
def window(self, carrier: str, since: int, until: int) -> dict:
with self.lock:
row = self.db.execute("SELECT count(*), sum(cost_eur), sum(unpriced_kwh), sum(minutes) FROM slots "
"WHERE carrier = ? AND slot >= ? AND slot < ? AND minutes > 0",
(carrier, since, until)).fetchone()
return {"slots": row[0] or 0, "cost_eur": row[1] or 0.0, "unpriced_kwh": row[2] or 0.0, "minutes": row[3] or 0.0}
def stored_prices(self, since: int, until: int) -> dict[int, tuple]:
with self.lock:
rows = self.db.execute("SELECT slot, price_ct, own_ct, offer FROM prices WHERE slot >= ? AND slot < ?",
(since, until)).fetchall()
return {int(s): (p, o, bool(f)) for s, p, o, f in rows}
def carriers(self, now: float) -> list[str]:
"""The carriers this home has: electricity always; gas and heat with
a meter value kept or a price in the bundle."""
out = ["electricity"]
with self.lock:
kept = {c for (c,) in self.db.execute("SELECT DISTINCT carrier FROM months")}
sp = self.bundles.slot_prices(now, now) or {}
for c in ("gas", "heat"):
if c in kept or (sp.get(c) or {}).get("price") is not None:
out.append(c)
return out
# -- the report HA shows ------------------------------------------------------------
def _eur(v: float | None, lang: str) -> str:
return "–" if v is None else f"{names.number(v, lang, 2)} €"
def _ct(v: float | None, lang: str) -> str:
return "–" if v is None else names.number(v, lang, 1)
def report(ledger: Ledger, now: float | None, lang: str, meters: dict[str, bool], has_plan: bool) -> dict:
"""What the dashboard shows, in HA's language (names.py): per section
its figures and markdown, and the gaps (missing data: a figure is None
and why). meters: per carrier whether the mapping has a meter for it.
A section that fails is a gap of its own; the others stay."""
now = ledger.clock() if now is None else now
out = {"gaps": [], "made": int(now)}
def gap(section: str, why: str):
out["gaps"].append({"section": section, "why": why})
for key, fn in (("prices", lambda: prices_section(ledger, now, lang, gap)),
("costs", lambda: costs_section(ledger, now, lang, meters, gap)),
("savings", lambda: savings_section(ledger, now, lang, has_plan, gap))):
try:
out[key] = fn()
except Exception as e: # one section's failure never takes the others with it
log.warning("costs: the %s section: %s", key, e)
out[key] = None
gap(key, names.name("cg_failed", lang, str(e)[:120]))
out["md_gaps"] = "\n".join(f"- **{names.name('cs_' + g['section'], lang)}**: {g['why']}" for g in out["gaps"])
return out
def prices_section(ledger: Ledger, now: float, lang: str, gap) -> dict:
"""Today and tomorrow per hour (local): the price (mean of its
quarter-hours), where it came from (the building's or community's offer,
or the own supplier) and, where an offer exists, the own supplier's
price beside it."""
zone = ledger.zone()
b = ledger.bundles
tenant = b.tenant_now(now)
d0 = datetime.fromtimestamp(now, timezone.utc).astimezone(zone).replace(hour=0, minute=0, second=0, microsecond=0)
d0 = datetime(d0.year, d0.month, d0.day, tzinfo=zone)
days = []
stored = ledger.stored_prices(int(d0.timestamp()), int(d0.timestamp()) + 2 * 86400 + 7200)
for di, key in ((0, "today"), (1, "tomorrow")):
day = (d0 + timedelta(days=di))
day = datetime(day.year, day.month, day.day, tzinfo=zone)
nxt = day + timedelta(days=1)
nxt = datetime(nxt.year, nxt.month, nxt.day, tzinfo=zone)
hours = []
t = int(day.timestamp())
while t < int(nxt.timestamp()):
qs = []
for q in range(4):
s = t + q * SLOT_S
sp = (b.slot_prices(s, now) or {}).get("electricity")
if sp and sp.get("price") is not None:
qs.append((sp["price"], sp.get("own"), bool(sp.get("offer"))))
elif s in stored and stored[s][0] is not None:
qs.append(stored[s])
local = datetime.fromtimestamp(t, timezone.utc).astimezone(zone)
if qs:
own = [o for _, o, _ in qs if o is not None]
hours.append({"h": local.strftime("%H"), "t": t, "ct": round(sum(p for p, _, _ in qs) / len(qs), 2),
"own": round(sum(own) / len(own), 2) if len(own) == len(qs) else None,
"offer": sum(1 for *_, f in qs if f), "of": len(qs)})
else:
hours.append({"h": local.strftime("%H"), "t": t, "ct": None, "own": None, "offer": 0, "of": 0})
t += 3600
days.append({"key": key, "date": day.strftime("%Y-%m-%d"), "hours": hours})
any_offer = tenant is not None or any(h["offer"] for d in days for h in d["hours"])
who = names.name("cs_offer_of", lang, tenant_label(tenant)) if tenant else names.name("cs_offer", lang)
for d in days:
priced = [h for h in d["hours"] if h["ct"] is not None]
label = names.name("cs_" + d["key"], lang)
if not priced:
d["md"] = f"**{label}**: {names.name('cg_no_prices_day', lang)}"
if d["key"] == "today":
gap("prices", names.name("cg_no_prices_today", lang))
continue
lo, hi = min(h["ct"] for h in priced), max(h["ct"] for h in priced)
n_off = sum(1 for h in priced if h["offer"])
head = f"<b>{label}</b>: {_ct(lo, lang)}–{_ct(hi, lang)} ct/kWh" # HTML: a summary is no markdown
if any_offer:
head += " · " + html.escape(names.name("cs_hours_offer", lang, n_off, who))
rows = []
hdr = f"| {names.name('cs_hour', lang)} | ct/kWh | {names.name('cs_from', lang)} |"
sep = "|---|---:|---|"
if any_offer:
hdr += f" {names.name('cs_own', lang)} |"
sep += "---:|"
for h in d["hours"]:
src = "–" if h["ct"] is None else (names.name("cs_src_offer", lang) if h["offer"] == h["of"] and h["of"]
else names.name("cs_src_part", lang) if h["offer"]
else names.name("cs_src_own", lang))
row = f"| {h['h']} | {_ct(h['ct'], lang)} | {src} |"
if any_offer:
row += f" {_ct(h['own'], lang) if h['offer'] else ''} |"
rows.append(row)
d["md"] = (f"<details><summary>{head}</summary>\n\n{hdr}\n{sep}\n" + "\n".join(rows) + "\n\n</details>")
# now: the price, its source and the own supplier's beside it
sp = (b.slot_prices(now, now) or {}).get("electricity") or {}
now_md = ""
if sp.get("price") is not None:
now_md = f"{names.name('price_now', lang)} **{_ct(sp['price'], lang)} ct/kWh**"
if sp.get("offer"):
now_md += " · " + who
if sp.get("own") is not None:
now_md += f" · {names.name('cs_own_now', lang)} {_ct(sp['own'], lang)} ct/kWh"
else:
now_md += " · " + names.name("cs_src_own_long", lang)
if tenant and not tenant.get("billed"):
now_md += f" \n<small>{names.name('cs_offer_shadow', lang)}</small>"
else:
gap("prices", names.name("cg_no_price_now", lang))
if tenant and not tenant.get("own_known"):
gap("prices", names.name("cg_no_own_curve", lang))
return {"now_md": now_md, "days": days, "tenant": tenant, "offer": any_offer}
def tenant_label(t: dict | None) -> str:
if not t:
return ""
model = {"mieterstrom": "Mieterstrom", "ggv": "GGV", "sharing": "§42c"}.get(t.get("model"), t.get("model") or "")
return f"{t.get('name') or t.get('plant') or ''} ({model})".strip()
def costs_section(ledger: Ledger, now: float, lang: str, meters: dict[str, bool], gap) -> dict:
"""Per carrier: this month so far, the forecast to its end, last month;
each with the fixed charges where the bundle carries them."""
month = ledger.month_of(now)
a, b = ledger.month_bounds(now)
last = ledger.month_of(a - 1)
params = ledger.bundles.box_params(now)
days = params.get(PARAM_FORECAST)
if not _finite(days) or not FORECAST_DAYS[0] <= days <= FORECAST_DAYS[1]:
days = None
gap("costs", names.name("cg_no_forecast_param", lang, PARAM_FORECAST))
fixed_now = ledger.bundles.fixed_charges(now)
if fixed_now is None:
gap("costs", names.name("cg_no_fixed", lang))
out = {"month": month, "last_month": last, "carriers": {}}
rows = []
for c in ledger.carriers(now):
cur, prev = ledger.month_row(month, c), ledger.month_row(last, c)
r = {"so_far": None, "forecast": None, "last": None, "kwh": None, "fixed_month": None, "why": []}
fx = (fixed_now or {}).get(c)
if fx is not None:
r["fixed_month"] = round(fx["eur_month"], 2)
if not meters.get(c) and not (cur and cur["kwh"]):
r["why"].append(names.name("cg_no_meter_" + c, lang))
gap("costs", names.name("cg_no_meter_" + c, lang))
elif cur is None or not cur["minutes"]:
r["why"].append(names.name("cg_no_meter_data", lang))
else:
elapsed = max(0.0, min(1.0, (now - a) / (b - a)))
fixed_so_far = fx["eur_month"] * elapsed if fx else 0.0
r["kwh"] = round(cur["kwh"], 2)
r["so_far"] = round(cur["cost_eur"] + fixed_so_far, 2)
if cur["unpriced_kwh"] > 0.0005:
r["why"].append(names.name("cg_unpriced", lang, names.number(cur["unpriced_kwh"], lang, 1)))
gap("costs", names.name("cg_unpriced_of", lang, names.name("carrier_" + c, lang),
names.number(cur["unpriced_kwh"], lang, 1)))
if days is not None:
w = ledger.window(c, int(now - days * 86400), int(now))
if w["minutes"] >= 60:
per_min = w["cost_eur"] / w["minutes"]
rest = max(0.0, (b - now) / 60.0)
r["forecast"] = round(cur["cost_eur"] + per_min * rest + (fx["eur_month"] if fx else 0.0), 2)
r["forecast_basis_h"] = round(w["minutes"] / 60.0, 1)
else:
r["why"].append(names.name("cg_forecast_short", lang))
if prev is not None and prev["minutes"]:
pf = prev.get("fixed_eur")
r["last"] = round(prev["cost_eur"] + (pf or 0.0), 2)
r["last_kwh"] = round(prev["kwh"], 2)
if cur and cur.get("unbilled_kwh", 0) > 0.0005:
r["own_eur"] = round(cur["own_eur"], 2)
r["note"] = names.name("cs_unbilled_note", lang, _eur(cur["own_eur"], lang))
r["incomplete"] = bool(cur and (cur["unpriced_kwh"] > 0.0005 or cur.get("fixed_incomplete")))
out["carriers"][c] = r
star = "*" if r["incomplete"] else ""
rows.append(f"| {names.name('carrier_' + c, lang)} | {_eur(r['so_far'], lang)}{star} | "
f"{_eur(r['forecast'], lang)} | {_eur(r['last'], lang)} |")
hdr = (f"| | {names.name('cs_so_far', lang)} | {names.name('cs_forecast', lang)} | "
f"{names.name('cs_last_month', lang)} |\n|---|---:|---:|---:|\n")
notes = []
if fixed_now is not None:
notes.append(names.name("cs_fixed_in", lang))
else:
notes.append(names.name("cs_fixed_out", lang))
if any(r["incomplete"] for r in out["carriers"].values()):
notes.append(names.name("cs_incomplete", lang))
notes += [r["note"] for r in out["carriers"].values() if r.get("note")]
if days is not None:
notes.append(names.name("cs_forecast_how", lang, int(days)))
out["md"] = hdr + "\n".join(rows) + "\n\n<small>" + " ".join(notes) + "</small>"
return out
def savings_section(ledger: Ledger, now: float, lang: str, has_plan: bool, gap) -> dict:
"""Per carrier, this month and last: (a) where the household buys: the
building's or community's offer against its own supplier for the same
kWh (electricity only: there is no tenant gas or heat); (b) the plan's
actions: with against without the plan, the same prices (its estimate).
Shadow (control mode shadow or advisory, or a tenant price not billed):
"would have saved", never money saved."""
month = ledger.month_of(now)
a, _ = ledger.month_bounds(now)
last = ledger.month_of(a - 1)
tenant = ledger.bundles.tenant_now(now)
out = {"carriers": {}}
lines = []
for c in ledger.carriers(now):
cur, prev = ledger.month_row(month, c) or {}, ledger.month_row(last, c) or {}
r = {}
if c == "electricity":
if cur.get("offer_kwh") or prev.get("offer_kwh") or tenant:
billed = not cur.get("unbilled_kwh") and bool(cur.get("offer_kwh"))
r["offer"] = {"month": round(cur.get("offer_own_eur", 0) - cur.get("offer_eur", 0), 2) if cur.get("offer_kwh") else None,
"last": round(prev.get("offer_own_eur", 0) - prev.get("offer_eur", 0), 2) if prev.get("offer_kwh") else None,
"kwh": round(cur.get("offer_kwh", 0), 2), "billed": billed}
key = "cs_offer_saved" if billed else "cs_offer_would"
if r["offer"]["month"] is None:
lines.append(f"- {names.name('cs_offer_none_yet', lang, tenant_label(tenant))}")
else:
lines.append(f"- {names.name(key, lang, _eur(r['offer']['month'], lang), names.number(r['offer']['kwh'], lang, 1))}"
+ (f" · {names.name('cs_last_month', lang)} {_eur(r['offer']['last'], lang)}"
if r["offer"]["last"] is not None else ""))
else:
lines.append(f"- {names.name('cs_offer_no', lang)}")
p_cur = (cur.get("saved_eur", 0), cur.get("would_eur", 0), cur.get("plan_slots", 0))
p_prev = (prev.get("saved_eur", 0), prev.get("would_eur", 0), prev.get("plan_slots", 0))
if p_cur[2] or p_prev[2]:
r["plan"] = {"saved": round(p_cur[0], 2) if p_cur[2] else None, "would": round(p_cur[1], 2) if p_cur[2] else None,
"hours": round(p_cur[2] / 4.0, 1),
"last_saved": round(p_prev[0], 2) if p_prev[2] else None,
"last_would": round(p_prev[1], 2) if p_prev[2] else None}
parts = []
if p_cur[2] and abs(p_cur[0]) >= 0.005:
parts.append(names.name("cs_plan_saved", lang, _eur(p_cur[0], lang)))
if p_cur[2] and (abs(p_cur[1]) >= 0.005 or not parts):
parts.append(names.name("cs_plan_would", lang, _eur(p_cur[1], lang)))
if not p_cur[2]:
parts.append(names.name("cs_plan_none_month", lang))
tail = ""
if p_prev[2]:
tail = f" · {names.name('cs_last_month', lang)} {_eur(p_prev[0] + p_prev[1], lang)}"
lines.append(f"- {names.name('cs_plan_of', lang, names.name('carrier_' + c, lang))}: " + ", ".join(parts) + tail)
elif c == "electricity" or has_plan:
why = names.name("cg_no_plan" if not has_plan else "cg_no_plan_yet", lang)
lines.append(f"- {names.name('cs_plan_of', lang, names.name('carrier_' + c, lang))}: {why}")
if c == "electricity":
gap("savings", why)
out["carriers"][c] = r
out["md"] = "\n".join(lines) + "\n\n<small>" + names.name("cs_savings_how", lang) + "</small>"
return out