"""Runnable check for OPT-11 P4, part 6a: the sunny day, the 0.20 gap between 1x and 1.5x, the dark day. `python3 test_modes_p4b.py` Split out of test_modes_p4.py by CI-18 so the slow part 6 runs in pieces (CI runs files side by side; the one file took ~13 min). The docstring there describes the whole. Same fake Home Assistant, same engine (tools/opt11p3_replay.py), same checks, none dropped: the four files print exactly the check lines the one file did. Read MUTATION.md before you report a survivor.""" import asyncio import logging import os import random import sys 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) from named_absence import nth, present # noqa: E402 import main_files # noqa: E402 import opt11p3_replay as rp # noqa: E402 from app import arbitrage, dayplan, homeview, modetrade, packmode # noqa from app import priceruns, solarfc, validate # noqa: E402 from app.tariff import BILLING_TZ # noqa: E402 fails = [] def check(name, cond): print(f" {'ok ' if cond else 'FAIL'} {name}") if not cond: fails.append(name) L = timezone(timedelta(hours=2)) A, B = "inverter-a", "inverter-b" D0 = datetime(2026, 9, 21, tzinfo=L) UTC0 = D0.astimezone(timezone.utc) # ============================================================================ # def profile(day_w=None, days=1, evening=None, start=UTC0 - timedelta(days=1)): hp = dayplan.HouseProfile() t = start end = start + timedelta(days=days) while t < end: h = t.astimezone(L).hour w = (evening if evening is not None and 17 <= h < 22 else day_w if day_w is not None else 600.0) hp.add(t, w) t += timedelta(seconds=5) hp.add(t, None) return hp P = modetrade.Pack def pk(name, mode, soc, cap=10.0, **kw): return P(name, True, mode, False, 2500.0, soc, cap, **kw) # Prices: cheap 01:00-03:00, dear 19:00-20:00 local (as in test_modes_p3). DAYW = [0.20] * 96 * 2 for i in list(range(4, 12)) + list(range(100, 108)): DAYW[i] = 0.02 for i in list(range(76, 80)) + list(range(172, 176)): DAYW[i] = 0.40 WPTS = [(UTC0 + timedelta(minutes=15 * i), 900, p) for i, p in enumerate(DAYW)] from app.price import PricePoint # noqa: E402 # ============================================================================ # print("6. the real controller over a night and a day") AIM = rp.PEAK_CAP - 50 FC_KWH = [None] # today's forecast in the fake sensor (None: down) async def _sensor(self, e): now = rp_start[0] + timedelta(seconds=self.t) kwh = FC_KWH[0](now) if callable(FC_KWH[0]) else FC_KWH[0] if kwh is None: return {"state": "unavailable", "attributes": {}, "last_updated": now.isoformat()} if e.endswith("tomorrow"): return None loc = now.astimezone(L) d0 = loc.replace(hour=0, minute=0, second=0, microsecond=0) wh = {(d0 + timedelta(hours=h)).astimezone(timezone.utc).isoformat(): (kwh * 100.0 if 8 <= h < 18 else 0.0) for h in range(24)} left = sum(v for k, v in wh.items() if datetime.fromisoformat(k) >= now) / 1000.0 return {"state": f"{left:.3f}", "attributes": {"unit_of_measurement": "kWh", "wh_period": wh}, "last_updated": now.isoformat(), "last_reported": now.isoformat()} rp.Hass.state = _sensor rp_start = [UTC0] FC_OPTS = {"pv_forecast_entity": "sensor.energy_production_today_remaining", "cycle_cost_threshold_eur": 0.20} # TARIFF-24 round 2: with a forecast read, a price mode needs the cycle cost # itself (0.20 here), no longer 1.5 times it (0.30). These scenarios were # written for a 0.30 gap, and a midday 0.21 gap now plans a grid top-up they # are not about, so they ask for 0.30 with the forecast; the no-forecast leg # (`rows_nf`) keeps 0.20, which is 0.30 widened: the same gate on both sides. GATE_030 = {"cycle_cost_threshold_eur": 0.30} def seed_profile(c): if c.house_profile is not None: c.house_profile = profile(day_w=600.0, evening=3000.0) def house_flat(w): return [(UTC0.timestamp() - 10, float(w))] def run_day(choice, *, fc, soc0, hours=21.0, start_h=0.75, house_w=800.0, refuse=(), extra=None, patch=seed_profile): FC_KWH[0] = fc start = UTC0 + timedelta(hours=start_h) rp_start[0] = start rows = [] def cb(c, h, now, pr): sh = dict(c.allocation.shares) if c.allocation is not None and \ c.allocation.shares else {} rows.append(dict( now=now, grid=h.grid(), shares=sh, action=getattr(c.arb, "action", None), roles=dict(c.mode_tick.roles) if c.mode_tick else {}, soc={u: p.soc for u, p in h.plants.items()}, targets=c.plan_targets(), plan=c.day_plan, runs=c.mode_runs)) st_, c = rp.run("p3_ls", house_flat(house_w), WPTS, start, 3600 * hours, check=cb, soc0=soc0, choice=choice, refuse=refuse, extra=dict(FC_OPTS, **(extra or {})), patch=patch) return rows, st_, c SF_LS = {"a": (True, "solar_first", False), "b": (True, "leftover_solar", False)} SF_CH = {"a": (True, "solar_first", False), "b": (True, "cheap_hours", False)} def invariants(tag, rows, c): charge = [r for r in rows if r["action"] == arbitrage.CHARGE] mixed = [r for r in rows if any(v > 0 for v in r["shares"].values()) and any(v < 0 for v in r["shares"].values())] check(f"{tag}: no opposite-direction split on any cycle", not mixed) check(f"{tag}: Solar first never charges from the grid (A's share >= 0 " "while the site charges)", all(r["shares"].get(A, 0) >= 0 for r in charge)) q = {int(r["now"].timestamp() // 900) for r in charge} banked = [b.offtake_avg_w for b in c.p1.blocks if int(b.start.timestamp() // 900) in q] check(f"{tag}: every banked quarter with a grid charge <= cap - margin " f"(max {max(banked, default=0):.1f} W, aim {AIM})", not banked or max(banked) <= AIM + 0.5) return charge # Sunny: 40 kWh forecast. B (Leftover solar) at 30 % needs nothing. rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0}, extra=GATE_030) charge = invariants("sunny", rows, c) _last = nth(rows, -1, "a cycle") print(f" sunny: verdict {present(_last) and _last['plan'] and _last['plan'].verdict}, " f"{len(charge)} charge cycles") check("sunny: a day plan is made, and says sunny", any(r["plan"] is not None and r["plan"].verdict == dayplan.SUNNY for r in rows)) check("sunny: no grid charge at all", not charge) # TARIFF-24 round 2: the same day at the cycle cost 0.20 itself. With the # forecast read the gap needed is 0.20 (not 1.5 x = 0.30), so the midday # quarter 0.339 against the evening 0.551 (gap 0.21, between 1x and 1.5x) is # a planned top-up for B (Leftover solar) up to its planned level. rows_g, st_, c_g = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0}) charge_g = invariants("gap between 1x and 1.5x", rows_g, c_g) _first_g = nth(charge_g, 0, "a charge cycle") _gaps = [min(g.mean_eur_kwh for g in r["runs"].give) - r["runs"].cheap.mean_eur_kwh for r in charge_g if r["runs"] is not None and r["runs"].give] print(f" gap 0.20 <= gap < 0.30: {len(charge_g)} charge cycles, run gap " f"{min(_gaps, default=0):.3f}, B to " f"{max((r['soc']['b'] for r in rows_g), default=0):.1f} %") check("a forecast day whose price gap lies between 1x and 1.5x the cycle " "cost (0.20 < 0.21 < 0.30) plans a cheap run: B charges from the grid " "inside it, only B, and only up to its planned level", present(_first_g) and len(_gaps) == len(charge_g) and all(0.20 <= g < 0.30 for g in _gaps) and all(r["runs"].cheap.holds(r["now"]) for r in charge_g) and all(r["roles"][B] == modetrade.CHARGE for r in charge_g) and all(r["roles"][A] != modetrade.CHARGE for r in charge_g) and max(r["soc"]["b"] for r in rows_g) <= 45.64 + 2.0) check("...and the same day with no forecast read does not (it needs 0.30): " "the old gate, kept for a day without a forecast", not [r for r in run_day(SF_LS, fc=None, soc0={"a": 60.0, "b": 30.0})[0] if r["action"] == arbitrage.CHARGE and r["now"].astimezone(L).hour == 12]) # Dark: 1 kWh. B buys the evening's shortfall only, in the cheap run. rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0}) charge = invariants("dark", rows, c) tgt = nth([r["targets"][B] for r in rows if r["targets"]], 0, "a level") top = max(r["soc"]["b"] for r in rows) print(f" dark: B level {tgt:.1f} %, B reached {top:.1f} %, " f"{len(charge)} charge cycles") check("dark: Leftover solar charges from the grid in the cheap run", charge and all(r["runs"].cheap.holds(r["now"]) for r in charge) and all(r["roles"][B] == modetrade.CHARGE for r in charge)) check("dark: ...only up to its level (the shortfall), not 95 %", present(tgt) and tgt < 60.0 and top <= tgt + 2.0) check("dark: A rests while B charges", all(r["roles"][A] == modetrade.REST for r in charge)) print() if fails: print(f"FAILED: {len(fails)}") for f in fails: print(" -", f) sys.exit(1) print("all checks passed")