"""Runnable check for SAFETY-125, a part. `python3 test_safety125b.py` Split out of test_safety125.py by CI-18 so CI can run the pieces side by side (the one file took ~10 min). The docstring there describes the whole. It holds parts 3-7 (a price trade and a maintenance charge, a healthy meter, the words, one inverter, N=2 and shadow). Same helpers, same checks, none dropped: the pieces print exactly the check lines the one file did. Read MUTATION.md before you report a survivor.""" import asyncio import logging import os import sys import tempfile import types from datetime import datetime, timedelta, timezone HERE = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, HERE) sys.path.insert(0, os.path.join(HERE, "tools")) logging.disable(logging.WARNING) import opt11_identity as rig # noqa: E402 import opt11p3_replay as rp # noqa: E402 import safety84_identity as s84 # noqa: E402 import main_files # noqa: E402 import app.main as m # noqa: E402 import app.p1 as p1mod # noqa: E402 from named_absence import first, nth, present # noqa: E402 from app import homeview, messages, peakguard, tariff # noqa: E402 from app import price as _price, static_tariff as _st # noqa: E402 from app.main import Controller # noqa: E402 from app.p1 import make_sample, split_signed # noqa: E402 from app.store import unit_key # noqa: E402 from app.tariff import QUARTER_S, Projection # noqa: E402 fails = [] def check(name, cond): print(f" {'ok ' if cond else 'FAIL'} {name}") if not cond: fails.append(name) PEAK = 5413.17 # October's banked peak on the live site AIM_PEAK = PEAK - 50.0 AIM_CAP = 3500.0 - 50.0 TOL = 10.0 # W over the aim a quarter may land (SAFETY-81) FC = "sensor.piek_prognose_kwartier" L = timezone(timedelta(hours=1)) START = datetime(2026, 10, 29, 0, 0, tzinfo=L).astimezone(timezone.utc) PROFILE = ('{"periods": [' '{"name": "night", "days": "all", "from": "22:00", "to": "07:00",' ' "eur_per_kwh": 0.2333},' '{"name": "day", "days": "all", "from": "07:00", "to": "22:00",' ' "eur_per_kwh": 0.2801}]}') def opts(*, fc=False, modes=True, arb=False): o = dict(rp.options(modes, arb, 2)) o.update(cycle_cost_threshold_eur=0.03, static_profile=PROFILE, peak_cap_w=3500, peak_margin_w=50) o["inverters"][0].update(max_w=5000, capacity_kwh=15.36) o["inverters"][1].update(max_w=4600, capacity_kwh=20.48) if fc: o["peak_forecast_entity"] = FC return o class Harder(rp.Plant): """Charges harder than asked, as inverter-a did live (asked -4271 W, measured about -4750 W; asked -5000 W, about -5210 W).""" def step(self, dt, floor): c = self.cmd if c < 0: self.cmd = max(c * 1.11, -5216.0) try: super().step(dt, floor) finally: self.cmd = c async def _no_fetch(*a, **k): raise AssertionError("the tariff task reached for a price feed") class OnItsOwn(rp.Plant): """Charges 5000 W whatever it is asked (shadow mode: nothing is written, the inverter charges on its own).""" def step(self, dt, floor): self.cmd = -5000.0 super().step(dt, floor) def drive(o, *, peak=None, late=0.0, minutes=31, every=0, start=None, period=0.0, fc_unit="kW", plant=Harder): """The real Controller from `start` (00:00 local) for `minutes` at a 1 s cycle (OPT-15's lag). `late`: no P1 telegram in each quarter's last `late` s; `period`: one telegram every `period` s (0: every cycle). -> (controller, rows, {quarter start: true grid average}, samples), the samples taken every `every` cycles from the second quarter (the first starts before the first reading): (projection, ceiling, engaged, peak_guard row, month-peak line).""" store = rp._Store() for u, mode in (("a", "cheap_hours"), ("b", "solar_first")): store.data[unit_key(f"inverter-{u}", "pack_use")] = True store.data[unit_key(f"inverter-{u}", "pack_mode")] = mode store.data[unit_key(f"inverter-{u}", "pack_sell")] = False rows, samples, sums = [], [], {} t0 = start or START async def go(): lag = rp.Lag() hass = rp.Hass(("a", "b"), lambda t: 1000.0, {"a": 11.0, "b": 10.0}, limits={"a": (-5000.0, 5000.0), "b": (-4600.0, 4600.0)}, lag=lag) hass.plants["a"].__class__ = plant fc_kw = [0.0] async def state(e): # The HA quarter projection, in kW like the live template. return None if e != FC else { "state": (f"{fc_kw[0]:.3f}" if fc_unit == "kW" else f"{fc_kw[0] * 1000.0:.0f}"), "attributes": {"unit_of_measurement": fc_unit}} hass.state = state tmp = tempfile.mkdtemp(prefix="s125-") db = os.path.join(tmp, "tariff.db") if peak is not None: tariff.PeakStore(db)._db.execute( "INSERT INTO monthly_peak VALUES (?, ?, ?, NULL)", (tariff.month_key(t0), peak, "2026-10-21T20:15:00+00:00")).connection.commit() c = Controller(dict(o), hass, store, rp._Pub(), stop=asyncio.Event(), peak_db_path=db, price_history_path=os.path.join(tmp, "ph.json")) c.inverters[0].dev_min, c.inverters[0].dev_max = -5000.0, 5000.0 c.inverters[1].dev_min, c.inverters[1].dev_max = -4600.0, 4600.0 c.auto = True real = main_files.live.datetime, homeview.datetime, p1mod.time clock, simt = [t0], [0.0] class _DT(real[0]): @classmethod def now(cls, tz=None): return clock[0] if tz is None else clock[0].astimezone(tz) main_files.live.datetime = homeview.datetime = _DT p1mod.time = types.SimpleNamespace(monotonic=lambda: 1e6 + simt[0]) real_load = _price.load_prices, _st.load_prices _price.load_prices = _st.load_prices = _no_fetch task = asyncio.create_task(c.run_tariff_refresh()) try: hass.advance(0.0, 10.0) t, n = 0.0, 0 while t < minutes * 60: now = t0 + timedelta(seconds=t) hass.t, simt[0], clock[0] = t, t, now if t == 0.0: for _ in range(500): if c.tariff_plan is not None: break await asyncio.sleep(0) q = int(now.timestamp() // QUARTER_S) acc = sums.setdefault(q, [0.0, 0]) g_now = hass.grid() fc_kw[0] = (acc[0] + g_now * (QUARTER_S - acc[1])) \ / QUARTER_S / 1000.0 if now.timestamp() % QUARTER_S < QUARTER_S - late \ and t >= lag.p1_s \ and (not period or t % period < 1e-9): imp, exp = split_signed(hass._past(lag.meter_s + lag.p1_s)[0]) c.p1.submit(make_sample( "ha_signed", imp, exp, phases=1, ingest_ts=now - timedelta(seconds=lag.p1_s), ingest_mono=1e6 + t)) await c.read_inputs(now_mono=t) await c.cycle() hass.advance(lag.tick, 10.0) acc[0] += max(0.0, hass.grid()) acc[1] += 1 rows.append((now, c.target, hass.plants["a"].p, getattr(c.arb, "action", None))) pg = c.peak_guard if every and n % every == 0 and t >= QUARTER_S \ and pg is not None and pg.projected_w is not None: row = first((r["text"] for r in c.checks(now) if r["id"] == "peak_guard"), "guard row") samples.append((pg.projected_w, pg.ceiling_w, pg.engaged, row, homeview.month_peak(c, now)["line"])) t += lag.tick n += 1 finally: task.cancel() try: await task except asyncio.CancelledError: pass main_files.live.datetime, homeview.datetime, p1mod.time = real _price.load_prices, _st.load_prices = real_load return c c = asyncio.run(go()) full = {datetime.fromtimestamp(q * QUARTER_S, L).strftime("%H:%M"): s / k for q, (s, k) in sorted(sums.items()) if k >= QUARTER_S} return c, rows, full, samples def into(now): return now.timestamp() % QUARTER_S # ============================================================================ # def graded(label, full, aim): print(f" {label}: quarters " f"{ {k: round(v, 1) for k, v in full.items()} } W, aim {aim:.0f}") return len(full) >= 2 and all(v <= aim + TOL for v in full.values()) def cut_and_back(rows): """The charge is off in each quarter's last 5 s, and back (A charging over 2 kW) within the next quarter's first minute.""" ends = [r for r in rows if into(r[0]) >= QUARTER_S - 5] starts = {} for r in rows: if into(r[0]) < 60: q = int(r[0].timestamp() // QUARTER_S) starts[q] = starts.get(q, False) or r[2] < -2000.0 return (present(first(iter(ends), "a quarter end")) and all(r[1] > -1.0 for r in ends) and len(starts) >= 2 and all(starts.values())) # ============================================================================ # print("\n3. the same for a price trade (modes off) and a maintenance charge") _ca, _ra, _fa = drive(opts(modes=False, arb=True), peak=PEAK, late=30.0)[:3] check("modes off, price trading on, a reading 30 s late: every quarter at " "or under the aim", graded("trade", _fa, AIM_PEAK) and any(r[3] == "ARBITRAGE_CHARGE" for r in _ra)) def late_feed(gap, every=0.0, look=None): """safety84's cheap-window feed, no telegram in each quarter's last `gap` s, and one only every `every` s (0: every cycle). `look(c, t)` runs first, on the state the previous cycle left.""" feed = s84.feed(True) def before(c, t): if look is not None: look(c, t) if ((rig.BASE.timestamp() + t) % QUARTER_S < QUARTER_S - gap and (not every or t % every < 1e-9)) \ or not getattr(c.hass, "_s84", False): feed(c, t) return before def rig_quarters(rows, load): """The safety84 rig's whole quarters: the true average import (W).""" qs = {} for r in rows: q = int((rig.BASE.timestamp() + r[0]) // QUARTER_S) a = qs.setdefault(q, [0.0, 0]) a[0] += max(0.0, load(r[0]) - sum(v for _u, v in r[2])) a[1] += 1 return {datetime.fromtimestamp(q * QUARTER_S, L).strftime("%H:%M"): s / k for q, (s, k) in sorted(qs.items()) if k * rig.TICK >= QUARTER_S} for peak, house, aim in ((5413.0, 4000.0, 5363.0), (None, 2500.0, AIM_CAP)): _mr, _mc = s84.run(2, load=lambda t, h=house: h, dur=2700.0, month_peak=peak, before=late_feed(30.0)) _mf = rig_quarters(_mr, lambda t, h=house: h) check(f"N=2 maintenance charge, house {house:.0f} W, " f"{'peak banked' if peak else 'no peak banked'}, a reading 30 s " f"late: every quarter at or under the aim", graded("maintenance", _mf, aim) and any(mm.phase == "charge" for mm in _mc.maints)) # ============================================================================ # print("\n4. a healthy meter: the quarters, and the words") for name, kw, aim, kw_text in (("month peak banked", dict(peak=PEAK), AIM_PEAK, "5.4 kW"), ("no peak banked", dict(), AIM_CAP, "3.5 kW")): _c, _rows, _full, _s = drive(opts(), every=10, **kw) check(f"{name}: every quarter at or under the aim", graded(name, _full, aim)) over = [s for s in _s if not s[2] and s[0] > s[1]] under = [s for s in _s if not s[2] and s[0] <= s[1]] _o, _u = first(iter(over), "an over sample"), \ first(iter(under), "an under sample") print(f" over the limit at this rate ({len(over)} samples): " f"{_o[3] if present(_o) else _o!s} / " f"{_o[4] if present(_o) else _o!s}") print(f" under it ({len(under)}): " f"{_u[3] if present(_u) else _u!s} / " f"{_u[4] if present(_u) else _u!s}") check(f"{name}: over the limit at this rate the guard row never says " f"'under'; it says the grid charge is limited", present(_o) and all( "under" not in s[3] and "Peak guard: grid charge limited, " "at this rate" in s[3] and " over " in s[3] for s in over)) check(f"{name}: ...and the month-peak line says the rate, and that the " f"grid charge is cut back to stay under {kw_text}", present(_o) and all( s[4].startswith("At this rate this 15-minute period reaches") and s[4].endswith("The grid charge is cut back to stay " f"under {kw_text}.") for s in over)) check(f"{name}: under the limit both read as before", present(_u) and all( s[3].startswith("Peak guard: idle, heading for") and " under " in s[3] and s[4].startswith("This 15-minute period is heading for") and s[4].endswith(f"The batteries step in above {kw_text}.") for s in under)) # ============================================================================ # print("\n5. the words on their own") _en = messages.row_peak_guard_idle(5814.0, 5413.0, month_peak=True) _cut = messages.row_peak_guard_idle(5814.0, 5413.0, month_peak=True, cut=True) _ok = messages.row_peak_guard_idle(5200.0, 5413.0, month_peak=True) print(f" {_en}\n {_cut}\n {_ok}") check("over, nothing cut: 'idle, at this rate ..., over ...'", _en == "Peak guard: idle, at this rate 5 814 W, over 5 413 W") check("over, a grid charge cut", _cut == "Peak guard: grid charge limited, at this rate 5 814 W, " "over 5 413 W") check("under: the 0.19.1 sentence, unchanged", _ok == "Peak guard: idle, heading for 5 200 W, under this month's " "5 413 W peak") check("the Dutch forms say the same", _cut.nl == "Piekbewaking: laden beperkt, aan dit tempo 5 814 W, " "boven 5 413 W" and _en.nl.startswith("Piekbewaking: in rust, aan dit tempo")) check("the month-peak line in shadow mode says 'would'", homeview.line_period(5814.0, 5413.0, True, cut=True).endswith( "The grid charge would be cut back to stay under 5.4 kW.") and homeview.line_period(5814.0, 5413.0, False).endswith( "The batteries step in above 5.4 kW.")) # ============================================================================ # print("\n6. one inverter: the maintenance charge is sized to the room too") # The start-up quarter on a 10 s meter: the charge's first step is not seen # until the second reading, so it may land up to START_TOL over the aim; the # same at N=2 and before this fix. Every later quarter is graded at TOL. START_TOL = 15.0 N1 = {} for peak, house, aim in ((5413.0, 4000.0, 5363.0), (None, 2500.0, AIM_CAP)): for late, every in ((0.0, 0.0), (30.0, 0.0), (20.0, 10.0)): _r, _c = s84.run(1, load=lambda t, h=house: h, dur=2700.0, month_peak=peak, before=late_feed(late, every)) _q = rig_quarters(_r, lambda t, h=house: h) N1[peak, late, every] = (_r, _c) _vals = list(_q.values()) _tag = (f"N=1, {'peak banked' if peak else 'no peak banked'}, " f"{'10 s' if every else '5 s'} meter, " f"{'late ' + format(late, '.0f') + ' s' if late else 'healthy'}") print(f" {_tag}: quarters " f"{ {k: round(v, 1) for k, v in _q.items()} } W, aim {aim:.0f}") check(f"{_tag}: every quarter at or under the aim", len(_vals) == 3 and all(v <= aim + TOL for v in _vals[1:]) and nth(_vals, 0, "a first quarter") <= aim + (START_TOL if every else TOL) and any(mm.phase == "charge" for mm in _c.maints)) _hr, _hc = N1[5413.0, 0.0, 0.0] _eng = sum(1 for r in _hr if r[-1][1] and r[-1][1][0]) print(f" healthy, peak banked: guard engaged on {_eng} of {len(_hr)} " f"cycles; A charges on " f"{sum(1 for r in _hr if dict(r[2])['a'] < -1.0)} cycles") check("N=1: the guard no longer steps in during the charge (no hand-back), " "and the battery charges on every cycle, at no more than its rate", _eng == 0 and all(-2000.0 <= dict(r[2])["a"] < -1.0 for r in _hr) and not any("suspended" in e for e in _hc.events)) # ============================================================================ # print("\n7. the row during an N=2 maintenance charge and in shadow mode") _rows7 = [] def _look(c, t): pg = c.peak_guard if t >= QUARTER_S and pg is not None and pg.projected_w is not None \ and not pg.engaged and pg.projected_w > pg.ceiling_w: _rows7.append(first((r["text"] for r in c.checks() if r["id"] == "peak_guard"), "guard row")) def _steps(t): """4000 W, 800 W more for the first 30 s of every minute.""" return 4000.0 + (800.0 if t % 60.0 < 30.0 else 0.0) _m2r, _m2c = s84.run(2, load=_steps, dur=1800.0, month_peak=5413.0, before=late_feed(0.0, look=_look)) _m2q = rig_quarters(_m2r, _steps) print(f" N=2 maintenance charge, house steps 4000/4800 W: " f"{len(_rows7)} over-the-limit rows, e.g. " f"{first(iter(_rows7), 'a row')}; quarters " f"{ {k: round(v, 1) for k, v in _m2q.items()} } W") check("N=2 maintenance charge, over the limit at this rate: the row says the " "grid charge is limited", present(first(iter(_rows7), "a row")) and all( r.startswith("Peak guard: grid charge limited, at this rate") for r in _rows7) and all(v <= 5363.0 + TOL for v in _m2q.values())) _sh_o = dict(opts(), shadow_mode="on") _csh, _rsh, _fsh, _ssh = drive(_sh_o, peak=PEAK, minutes=17, every=10, plant=OnItsOwn) _sh_over = [s for s in _ssh if not s[2] and s[0] > s[1]] _sh1 = first(iter(_sh_over), "an over sample") print(f" shadow mode, the inverter charging 5000 W on its own: " f"{len(_sh_over)} over samples, e.g. " f"{_sh1[3] if present(_sh1) else _sh1!s} / " f"{_sh1[4] if present(_sh1) else _sh1!s}") check("shadow mode: nothing is cut on the wire, so the row says 'idle', " "never 'grid charge limited', and the line says 'would'", _csh.shadow and present(_sh1) and all( s[3].startswith("Peak guard: idle, at this rate") and "would" in s[4] for s in _sh_over)) print() if fails: print(f"{len(fails)} FAILED:") for f in fails: print(f" - {f}") sys.exit(1) print("all checks passed")