"""Runnable check for OPT-11 P4, part 6c and 7: a refusal, Off, no house profile, a forecast arriving mid-period, battery modes off; then the Batteries screen and the Simple view. `python3 test_modes_p4d.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 # A refusal wins over the plan. rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0}, refuse=("b",), extra=GATE_030) invariants("refusal", rows, c) check("refusal: B refuses to charge, so the plan's charge ends and B is " "never a charger after it", rows and not [ r for r in rows[len(rows) // 3:] if r["roles"].get(B) == modetrade.CHARGE]) # Off wins over the plan. rows, st_, c = run_day({"a": (True, "solar_first", False), "b": (False, "leftover_solar", False)}, fc=1.0, soc0={"a": 60.0, "b": 30.0}) check("Off: an Off battery never charges from the grid, whatever the plan", not [r for r in rows if r["action"] == arbitrage.CHARGE] and all(abs(r["shares"].get(B, 0)) < 1e-6 for r in rows)) # No house profile yet (first day): no plan, P3 option A. rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0}, patch=None) check("no house profile yet: no plan, and Leftover solar takes solar only", all(r["plan"] is None for r in rows) and not [r for r in rows if r["action"] == arbitrage.CHARGE]) check("...while the profile learns and the store keeps each closed hour", c.house_profile is not None and len( c.store.data.get("house_profile") or {}) >= 1) check("selling stays off (option A)", packmode.SELLING_ENABLED is False) # A forecast arriving mid-period makes the plan at once, not at the next # 15-minute period. COME = datetime(2026, 9, 21, 1, 3, tzinfo=L).astimezone(timezone.utc) rows, st_, c = run_day(SF_LS, fc=lambda now: None if now < COME else 1.0, soc0={"a": 60.0, "b": 30.0}, hours=0.5) first = next((r["now"] for r in rows if r["targets"]), None) check("a forecast that arrives at 01:03 makes the plan before 01:15", first is not None and first < COME + timedelta(minutes=3)) # Battery modes off: the forecast is never read. READS = [0] _real_sensor = rp.Hass.state async def _counted(self, e): READS[0] += 1 return await _real_sensor(self, e) rp.Hass.state = _counted FC_KWH[0] = 1.0 rp.run("modes_off", house_flat(800.0), WPTS, UTC0 + timedelta(hours=1), 600.0, extra=dict(FC_OPTS)) rp.Hass.state = _real_sensor check("battery modes off: the forecast sensor is never read", READS[0] == 0) # ============================================================================ # print("7. the Batteries screen and the Simple view") rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0}, hours=0.6) main_files.live.datetime = datetime sb = homeview.solar_block(c, c.solar_fc.at) check("the forecast line names the forecast, what is counted and when", sb["line"].startswith("Solar still to come today:") and "we count on" in sb["line"] and sb["state"] == "plan") why = homeview.day_key(c, B) check("B's Why key (plan, dark) is tops_up", why == "tops_up") check("...and says so in plain words, with the level and what it covers " "(OPT-28)", homeview.why_words(why, pct="82 %", kwh="9.4 kWh") == "It charges from the grid to 82 %. That covers 9.4 kWh of " "expensive hours the sun will not.") _d0, _d1 = homeview.local_day(c.solar_fc.at) _blocks, _ = homeview.mode_runs(c, _d0, _d1, c.solar_fc.at, False) _grid = [b for b in _blocks if b["kind"] == "grid" and b["battery"] == 1] _need = homeview.plan_need(c, B) check(f"Today: B's grid block is the planned shortfall ({_need:.2f} kWh), " "not its room to 95 %", _grid and abs(_grid[0]["kwh"] - _need) < 0.01 and _need < 3.0) _run = c.mode_runs.cheap _packs = c._mode_packs() _m1 = c._run_mark("charge", _run, _packs, lambda p: True, ((B, 40.0),)) _m2 = c._run_mark("charge", _run, _packs, lambda p: False, ((B, 50.0),)) check("a level the hysteresis moved opens the run to that battery again", _m1 and not _m2) latch, c._charge_latch = c._charge_latch, None c.solar_fc = None check("with no charge under way, the levels are dropped as soon as the " "forecast goes, even before the plan is rebuilt", c._plan_targets and c.plan_targets() is None) check("a lost forecast says so: no forecast, Leftover solar solar only", homeview.solar_block(c, datetime.now(timezone.utc))["state"] == "no_forecast" and homeview.day_key(c, B) == "no_forecast") c._charge_latch = latch # the latch ends at its end time; this replay ran in September, so ask at a # moment inside it _real_dt = main_files.live.datetime main_files.live.datetime = type("_DT", (datetime,), {"now": classmethod( lambda cls, tz=None: latch[0] - timedelta(hours=1))}) check("OPT-34: with a charge under way (B charged in this run), the level " "stays: plan_targets() gives it (the line: test_opt34.py)", latch is not None and c.plan_targets() is not None and B in c.plan_targets() and c.plan_targets()[B] == c._plan_targets[B]) main_files.live.datetime = _real_dt check("the Why line wins over 'saves its power' only while holding", homeview.battery_why(modes_on=True, mode="leftover_solar", off=False, reading=True, phase="idle", shadow=False, running=True, held=False, refused=0, peak=False, sf_ahead=True, role="hold", has_at=True, day="sun_fills") == "sun_fills" and homeview.battery_why(modes_on=True, mode="leftover_solar", off=False, reading=True, phase="idle", shadow=False, running=True, held=False, refused=0, peak=False, sf_ahead=True, role="charge", has_at=True, day="tops_up") == "grid_charge") for lang in ("en", "nl"): homeview._LANG[0] = lang t = [homeview.why_words(k, pct="82 %", kwh="9.4 kWh") for k in ("sun_fills", "tops_up", "no_forecast")] t += [homeview._t("solar.no_forecast"), homeview._t("solar.learning"), homeview.line_solar(9.2, 6.4, "10:15")] check(f"{lang}: every P4 sentence is there and short (<= 2 x 12 words)", all(t) and all(len(s.split()) <= 24 for s in t)) homeview._LANG[0] = "en" from app import uilayout # noqa: E402 simple = [f.key for _g, _p, f in uilayout.fields() if f.simple] check("the Simple view has the solar forecast card", "pv_forecast_entity" in simple) print() if fails: print(f"FAILED: {len(fails)}") for f in fails: print(" -", f) sys.exit(1) print("all checks passed")