EV-14: Car Why says what happens in shadow mode and after a phase change that did not happen

Display only: shadow mode over-limit Why speaks in would-terms; read phases that
differ from the setting say the charger stays; a writer hold says something
else set the charger. EN and NL texts, test_ev14.py.

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Claude
2026-11-22 13:45:30 +01:00
parent c8f529273f
commit d0285470cb
4 changed files with 862 additions and 2 deletions
+30 -2
View File
@@ -1318,14 +1318,34 @@ def _over_why_is_floor(c, pg) -> bool:
return bool(pg is not None and pg.floor_limited and pg.soc is not None)
def _real_phases(c):
"""EV-14: the phases the charger reports (1 or 3), or None: no fresh
reading, or none read. Reads only; unknown is never a difference."""
car = getattr(c, "car", None)
r = getattr(car, "reading", None)
fresh = getattr(car, "fresh", None)
if r is None or fresh is None or not getattr(r, "available", False):
return None
if not fresh(c.car_now()):
return None
n = getattr(r, "phases_allowed", None)
return n if n in (1, 3) else None
def _car_manual_why(c, key):
"""The Why of Manual: what you set, and what the peak limit does about it.
Plan lines: two sentences of at most 12 words."""
Plan lines: two sentences of at most 12 words. EV-14: in shadow mode it
says what the add-on would set; after a phase change that did not happen
it says what the charger does."""
a = f"{float(c.car_a):.0f}"
w = c.car_writer
pct = _pct(c.o.get("peak_soc_floor", peakguard.PEAK_OPTION_DEFAULTS[
"peak_soc_floor"]))
if c.car_over:
if c.shadow:
t, n = w.would if w.would is not None else (c.car_a, c.car_n)
return _t("car.why.manual_shadow_over", a=f"{float(t):.0f}",
phases=car_phases_word(n))
pg = getattr(c, "peak_guard", None)
if not c.car_cover:
return _t("car.why.manual_nocover", a=a)
@@ -1337,6 +1357,8 @@ def _car_manual_why(c, key):
phases=car_phases_word(n))
if not c.auto:
return _t("car.why.manual_stopped")
if w.hold:
return _t("car.why.manual_other")
if key in ("none", "full"):
return _t("car.why.manual_wait", a=a)
if w.blocked:
@@ -1344,6 +1366,11 @@ def _car_manual_why(c, key):
if c.car_cover and peak_engaged(c):
giving = max(0.0, float(c.site_batt_w or 0.0))
return _t("car.why.manual_cover", a=a, kw=_kw(giving), pct=pct)
real = _real_phases(c)
if real is not None and real != c.car_n and w.seq is None:
return _t("car.why.manual_phases", a=a,
phases=car_phases_word(c.car_n),
real=car_phases_word(real))
return _t("car.why.manual_set", a=a, phases=car_phases_word(c.car_n))
@@ -1900,7 +1927,8 @@ def _samples() -> list:
out += [("plan", _t("car.big." + k, t="09:12")) for k in
words["car"]["big"]]
out += [("plan", _t("car.why." + k, a="10", brand="Alfen", kw="8.6 kW",
pct="20 %", phases=car_phases_word(3)))
pct="20 %", phases=car_phases_word(3),
real=car_phases_word(1)))
for k in words["car"]["why"]]
out += [("plan", _t("peak.car", kw="12.1 kW", car="11.0 kW",
cov="8.6 kW")),
+3
View File
@@ -329,6 +329,9 @@
"manual_wait": "You set {a} A. It is set when a car is connected.",
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
"manual_shadow_over": "Shadow mode: the add-on would set {a} A, {phases}. This charge would set the peak.",
"manual_phases": "You set {a} A, {phases}. The charger stays on {real}.",
"manual_other": "Something else set the charger. The add-on leaves it until you change something.",
"manual_blocked": "The phases change once per 10 minutes at most. This waits."
}
},
+3
View File
@@ -283,6 +283,9 @@
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
"manual_shadow_over": "Schaduwmodus: de add-on zou {a} A instellen, {phases}. Deze lading zou de piek bepalen.",
"manual_phases": "U stelde {a} A in, {phases}. De laadpaal blijft op {real}.",
"manual_other": "Iets anders heeft de laadpaal ingesteld. De add-on laat dit zo tot u iets wijzigt.",
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht."
}
},
+826
View File
@@ -0,0 +1,826 @@
"""EV-14: the Car Why says what happens, not only what the user set.
`python3 -B test_ev14.py`
Display only (homeview._car_manual_why, ui_text en/nl):
E1 shadow mode: no Why says "You set"; with the car over the limit it says
what the add-on WOULD set and that this charge would set the peak.
E2 a phase change that did not happen (read phases differ from the setting):
"The charger stays on {real}", never "keeps it".
E3 the writer holds for another writer: "Something else set the charger".
E4 phases equal or unknown, no hold: exactly as before.
E5 texts in en and nl, same keys, UX-08 limits.
N2 the render writes nothing; N3 it never sends to the charger.
Mutants: see the dev report (M1-M14).
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import asyncio
import copy
import dataclasses
import itertools
import json
import logging
import os
import re
import sys
from datetime import datetime, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "tools"))
from app import carmode, chargers as CH, ctl_car, homeview, uitext # noqa: E402
from app.carmode import PHASE_GAP_S, ManualWriter # noqa: E402
from app.main import Controller # noqa: E402
from app import freshness # noqa: E402
from chargersim import FakeHa, SimCharger # noqa: E402
from named_absence import nth, present # noqa: E402
fails = []
logging.getLogger("goodwe").setLevel(logging.CRITICAL)
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
def run(coro):
return asyncio.run(coro)
# =========================================================================== #
# The texts the test holds the page to, written out (T34: base is byte-equal).
# =========================================================================== #
BASE_EN = {
"manual_set": "You set {a} A, {phases}. The charger keeps it, whatever the peak limit does.",
"manual_cover": "You set {a} A. The batteries give {kw} and help down to {pct}.",
"manual_over": "You set {a} A. The batteries are at {pct}, so this charge sets the peak.",
"manual_full": "You set {a} A. The batteries give all they can, so this charge sets the peak.",
"manual_nocover": "You set {a} A. The guard ignores the car, so this charge can set the peak.",
"manual_wait": "You set {a} A. It is set when a car is connected.",
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
"manual_blocked": "The phases change once per 10 minutes at most. This waits.",
}
BASE_NL = {
"manual_set": "U stelde {a} A in, {phases}. De laadpaal houdt dit aan, wat de piekgrens ook doet.",
"manual_cover": "U stelde {a} A in. De batterijen leveren {kw} en helpen tot {pct}.",
"manual_over": "U stelde {a} A in. De batterijen staan op {pct}, dus deze lading bepaalt de piek.",
"manual_full": "U stelde {a} A in. De batterijen geven alles, dus deze lading bepaalt de piek.",
"manual_nocover": "U stelde {a} A in. De bewaking negeert de auto, dus deze lading kan de piek bepalen.",
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht.",
}
NEW_KEYS = ("manual_shadow_over", "manual_phases", "manual_other")
LANGS = ("en", "nl")
YOU = {"en": "You set", "nl": "U stelde"}
KEEPS = {"en": "The charger keeps it,", "nl": "De laadpaal houdt dit aan"}
WOULD = {"en": "would set", "nl": "zou"}
PEAK = {"en": "would set the peak", "nl": "zou de piek bepalen"}
STAYS = {"en": "stays on", "nl": "blijft op"}
OTHER = {"en": "Something else set the charger.", "nl": "Iets anders heeft de laadpaal ingesteld."}
def jwords(lang):
return uitext.words(lang)["home_words"]["car"]["why"]
def tx(lang, key, **kw):
"""Render a car.why text the way the page does (a missing key is a text
of its own, so a check on it is a FAIL, not a crash)."""
homeview._LANG[0] = uitext.lang_of(lang)
try:
return homeview._t("car.why." + key, **kw)
except Exception as e: # noqa: BLE001
return f"<EXC {type(e).__name__} {key}>"
finally:
homeview._LANG[0] = "en"
def pw(n):
homeview._LANG[0] = "en"
return homeview.car_phases_word(n)
def pw_l(lang, n):
homeview._LANG[0] = uitext.lang_of(lang)
try:
return homeview.car_phases_word(n)
finally:
homeview._LANG[0] = "en"
# =========================================================================== #
# A stub site for the unit rows: what _car_manual_why reads, nothing else.
# =========================================================================== #
@dataclasses.dataclass
class G:
floor_limited: bool = True
soc: object = 19.0
saturated: bool = False
floor_w: float = 300.0
able_w: object = None
ceiling_w: float = 4500.0
engaged: bool = True
blind: object = None
wanted_w: float = 300.0
within_aim: bool = False
class Car:
def __init__(self, reading, fresh, last_good=None):
self.reading, self._fresh, self.last_good = reading, fresh, last_good
def fresh(self, _now):
return self._fresh
def status(self, *_a):
return "charging"
class U(ctl_car.CarMixin):
"""The attributes `_car_manual_why` and `_car_why_tick` read."""
def __init__(self, **kw):
self.o = {"ev_batt_cover": kw.get("cover", True)}
self._now = 0.0
self.w = 11000.0
self.site_batt_w, self.site_rating_w = 8100.0, 9600.0
self.shadow = kw.get("shadow", False)
self.auto = kw.get("auto", True)
self.peak_guard = kw.get("pg", G(
floor_limited=kw.get("floor", True),
floor_w=300.0 if kw.get("eng") else 0.0))
self.state = "charging"
self.car_init({}, type("St", (), {"data": {}, "set": lambda s, k, v: 0})())
self.car_a = kw.get("a", 10.0)
self.car_n = kw.get("n", 3)
self.car_over = kw.get("over", False)
wr = self.car_writer
wr.hold = wr.other = kw.get("hold", False)
wr.blocked = kw.get("blocked", False)
wr.seq = kw.get("seq", None)
wr.would = kw.get("would", None)
wr.phases_gave_up = kw.get("gave_up", False)
if "car" in kw:
self.car = kw["car"]
else:
real = kw.get("real", None)
rd = CH.ChargerReading(available=True, state="C", power_w=2300.0,
setpoint_a=10.0, allowed_a=10.0,
phases_allowed=real)
self.car = Car(rd, kw.get("fresh", True))
def car_now(self):
return self._now
def snap(c):
"""Everything N2 says a render must not move."""
keep = {k: v for k, v in vars(c).items()
if k.startswith(("car_", "_car")) and k != "car"}
car = getattr(c, "car", None)
return repr((vars(c.car_writer), vars(car) if hasattr(car, "__dict__")
else None, keep, c.shadow, c.auto))
N2_BAD = []
EXC = []
def why(c, lang="en", key="charging"):
"""The Why text; an exception becomes a text; N2 is checked on every call."""
before = snap(c)
homeview._LANG[0] = uitext.lang_of(lang)
try:
out = homeview._car_manual_why(c, key)
except Exception as e: # noqa: BLE001
EXC.append(repr(e))
out = f"<EXC {type(e).__name__} {e}>"
finally:
homeview._LANG[0] = "en"
if snap(c) != before:
N2_BAD.append(out)
return out
def exp(lang, key, **kw):
return tx(lang, key, **kw)
def a_(c):
return f"{float(c.car_a):.0f}"
# --------------------------------------------------------------------------- #
print("1. E1: shadow mode says what the add-on WOULD set")
# --------------------------------------------------------------------------- #
SHADOW_BAD_CASES = {
"T1 floor": dict(floor=True, cover=True),
"T2 full": dict(floor=False, cover=True),
"T3 cover off": dict(floor=True, cover=False),
}
for label, kw in SHADOW_BAD_CASES.items():
for lang in LANGS:
c = U(shadow=True, over=True, a=16.0, n=3, would=(10.0, 3), **kw)
t = why(c, lang)
check(f"{label} ({lang}): would set 10 A and would set the peak; no "
f"'You set', no 16 A: {t!r}",
present(t) and WOULD[lang] in t and "10 A" in t
and PEAK[lang] in t and YOU[lang] not in t and "16 A" not in t)
check(f"{label} ({lang}): exactly the shadow-over text",
t == exp(lang, "manual_shadow_over", a="10",
phases=pw_l(lang, 3)))
for lang in LANGS:
c = U(shadow=True, over=True, a=12.0, n=3, would=None)
t = why(c, lang)
check(f"T4 ({lang}): writer not stepped: falls back to (car_a, car_n), "
f"12 A, 3 phases, no 'You set': {t!r}",
t == exp(lang, "manual_shadow_over", a="12", phases=pw_l(lang, 3))
and YOU[lang] not in t)
c = U(shadow=True, over=False, a=16.0, n=3, would=(10.0, 3))
check(f"T5 ({lang}): shadow, not over: exactly today's manual_would",
why(c, lang) == BASE_EN["manual_would"].format(
a="10", phases="3 phases") if lang == "en" else
why(c, lang) == BASE_NL["manual_would"].format(
a="10", phases="3 fasen"))
# T6/T7: the EV-16 episode, 5 s cycles, floor flipping every 10 s.
STEP = 5.0
def tick(c, g, t, shadow=None):
c._now = t
c.peak_guard = g
if shadow is not None:
c.shadow = shadow
c._car_why_tick(g, t)
def episode(c, secs, flip=10.0, shadow_off_at=None):
out, t = [], 0.0
while t < secs:
g = G(floor_limited=(int(t // flip) % 2 == 0))
off = shadow_off_at is not None and t >= shadow_off_at
tick(c, g, t, shadow=False if off else None)
out.append((t, why(c)))
t += STEP
return out
c = U(shadow=True, over=True, a=16.0, would=(10.0, 3))
ep = episode(c, 180.0)
texts = {t for _, t in ep}
check(f"T6: shadow over, floor flips for 180 s: one constant text, 0 changes "
f"({len(ep)} cycles)", len(ep) == 36 and len(texts) == 1
and all(PEAK["en"] in t for t in texts))
c = U(shadow=True, over=True, a=16.0, would=(10.0, 3))
ep = episode(c, 180.0, flip=1000.0, shadow_off_at=90.0)
first = [t for tt, t in ep if tt < 90.0]
later = [t for tt, t in ep if tt >= 90.0]
check("T7: shadow switched off mid-episode with the floor held: the shadow "
"text, then exactly today's manual_over (EV-16 hold)",
len(first) == 18 and len(later) == 18 and len(set(first)) == 1
and PEAK["en"] in nth(first)
and set(later) == {BASE_EN["manual_over"].format(a="16", pct=homeview._pct(
c.o.get("peak_soc_floor", 20)))})
# --------------------------------------------------------------------------- #
print("\n2. E2 / E3: units")
# --------------------------------------------------------------------------- #
for lang in LANGS:
c = U(real=1, n=3, a=10.0)
t = why(c, lang)
check(f"T9 ({lang}): 3 set, charger on 1: 'stays on 1 phase', not 'keeps "
f"it': {t!r}",
t == exp(lang, "manual_phases", a="10", phases=pw_l(lang, 3),
real=pw_l(lang, 1))
and STAYS[lang] in t and KEEPS[lang] not in t
and pw_l(lang, 1) in t)
c = U(real=3, n=1, a=10.0)
t = why(c, lang)
check(f"T10 ({lang}): 1 set, charger on 3: 'stays on 3 phases': {t!r}",
t == exp(lang, "manual_phases", a="10", phases=pw_l(lang, 1),
real=pw_l(lang, 3)) and pw_l(lang, 3) in t.split(". ")[-1]
and KEEPS[lang] not in t)
check("T9: the words are the brief's (EN and NL)",
why(U(real=1, n=3)) == "You set 10 A, 3 phases. The charger stays on 1 phase."
and why(U(real=1, n=3), "nl") ==
"U stelde 10 A in, 3 fasen. De laadpaal blijft op 1 fase.")
def sett(lang, c):
return exp(lang, "manual_set", a=a_(c), phases=pw_l(lang, c.car_n))
for lang in LANGS:
c = U(real=1, n=3, auto=False)
check(f"T13a ({lang}): phases differ, control stopped: manual_stopped",
why(c, lang) == exp(lang, "manual_stopped"))
c = U(real=1, n=3, shadow=True, would=(10.0, 3))
check(f"T13b ({lang}): phases differ, shadow: manual_would",
why(c, lang) == exp(lang, "manual_would", a="10",
phases=pw_l(lang, 3)))
for stage in ("zero", "settle"):
c = U(real=1, n=3, seq={"stage": stage})
check(f"T14 ({lang}): phases differ, sequence at {stage}: manual_set",
why(c, lang) == sett(lang, c))
c = U(real=1, n=3, blocked=True)
check(f"T15 ({lang}): phases differ, blocked: manual_blocked",
why(c, lang) == exp(lang, "manual_blocked"))
for key in ("none", "full"):
c = U(real=1, n=3)
check(f"T16 ({lang}): phases differ, key {key}: manual_wait",
why(c, lang, key) == exp(lang, "manual_wait", a="10"))
c = U(real=1, n=3, eng=True)
giving = max(0.0, float(c.site_batt_w))
homeview._LANG[0] = uitext.lang_of(lang)
kw_ = homeview._kw(giving)
pct_ = homeview._pct(20)
homeview._LANG[0] = "en"
check(f"T17 ({lang}): phases differ, cover engaged, not over: manual_cover",
why(c, lang) == exp(lang, "manual_cover", a="10", kw=kw_, pct=pct_))
for label, kw in (("floor", dict(floor=True)), ("full", dict(floor=False)),
("nocover", dict(cover=False))):
c = U(real=1, n=3, over=True, **kw)
want = ("manual_nocover" if label == "nocover" else
"manual_over" if label == "floor" else "manual_full")
check(f"T18 ({lang}): phases differ, car over ({label}): {want}",
why(c, lang) == exp(lang, want, a="10", pct=pct_))
# T19/T20 are in the World section. T21-T26: the hold, units.
for lang in LANGS:
c = U(hold=True, real=1, n=3)
t = why(c, lang)
check(f"T21 ({lang}): hold, phases differ, not given up: the hold text "
f"{t!r}", t == exp(lang, "manual_other") and OTHER[lang] in t
and STAYS[lang] not in t and YOU[lang] not in t)
for key in ("none", "full"):
c = U(hold=True, real=3, n=3)
check(f"T22 ({lang}): hold, key {key}: the hold text, not 'set when a "
f"car is connected'",
why(c, lang, key) == exp(lang, "manual_other"))
c = U(hold=True, blocked=True, real=3, n=3)
check(f"T23a ({lang}): hold with a stale blocked: the hold text",
why(c, lang) == exp(lang, "manual_other"))
c = U(hold=True, real=3, n=3, eng=True)
check(f"T23b ({lang}): hold with the cover engaged: the hold text",
why(c, lang) == exp(lang, "manual_other"))
for label, kw in (("floor", dict(floor=True)), ("full", dict(floor=False)),
("nocover", dict(cover=False))):
c = U(hold=True, over=True, real=3, n=3, **kw)
want = ("manual_nocover" if label == "nocover" else
"manual_over" if label == "floor" else "manual_full")
check(f"T24 ({lang}): hold and car over ({label}): {want}, no hold "
f"text", why(c, lang) == exp(lang, want, a="10", pct=pct_)
and OTHER[lang] not in why(c, lang))
for key in ("charging", "none"):
c = U(hold=True, auto=False, real=3, n=3)
check(f"T25 ({lang}): hold, control stopped, key {key}: manual_stopped",
why(c, lang, key) == exp(lang, "manual_stopped"))
c = U(hold=True, shadow=True, over=False, would=(10.0, 3))
check(f"T26a ({lang}): hold, shadow, not over: manual_would",
why(c, lang) == exp(lang, "manual_would", a="10",
phases=pw_l(lang, 3)))
c = U(hold=True, shadow=True, over=True, would=(10.0, 3))
check(f"T26b ({lang}): hold, shadow, over: the shadow-over text",
why(c, lang) == exp(lang, "manual_shadow_over", a="10",
phases=pw_l(lang, 3)))
# T29-T32: E4.
for lang in LANGS:
for n in (1, 3):
c = U(real=n, n=n)
want = (BASE_EN if lang == "en" else BASE_NL)["manual_set"].format(
a="10", phases=pw_l(lang, n))
check(f"T29 ({lang}): {n}/{n} phases: byte-identical manual_set",
why(c, lang) == want)
c = U(real=None, n=3)
check(f"T30 ({lang}): phases_allowed None: manual_set, no exception",
why(c, lang) == sett(lang, c))
c = U(real=3, n=1, fresh=False)
check(f"T32 ({lang}): reading not fresh: manual_set (stale is unknown)",
why(c, lang) == sett(lang, c))
c = U(car=Car(None, True))
check("T31a: reading None: today's text, no exception",
why(c) == sett("en", c))
rd = CH.ChargerReading(available=False, phases_allowed=1)
c = U(car=Car(rd, True, last_good=None), n=3)
check("T31b: reading unavailable (phases 1 vs 3): today's text",
why(c) == sett("en", c))
c = U(real=1, n=3, pg=None)
check("T31c: peak_guard None: no exception, the E2 text",
why(c) == exp("en", "manual_phases", a="10", phases="3 phases",
real="1 phase"))
c = U(real=1, n=3)
del c.car
check("T31d: no car object at all: no exception, today's text",
why(c) == sett("en", c))
check("T31: no exception from any of the above", not EXC)
# --------------------------------------------------------------------------- #
print("\n3. E5: the texts")
# --------------------------------------------------------------------------- #
PH = re.compile(r"\{(\w+)\}")
JARGON = {
"en": r"controllers?|control loop|setpoints?|SoC|state of charge|BMS|PV|"
r"failsafe|trip(?:ped)?|parked|discharg\w*|P1 feed|quarter-hour|"
r"payload|endpoint|JSON|API|timeout|boolean|config|commands?|"
r"charge level|ceiling|billed quarter|quarters?|banked|soft limit|"
r"open block|actuator|ESP32|master|meter source|circulating|"
r"sign disagreement|rail",
"nl": r"setpoints?|setpunt\w*|SoC|laadtoestand|BMS|PV|failsafe|regelaar|"
r"regellus|controller|latch|ontlad\w*|payload|endpoint|JSON|API|"
r"time-?out|boolean|config|kwartuur\w*|commando\w*|geparkeerd|"
r"ESP32|master",
}
JARGON = {k: re.compile(r"\b(?:" + v + r")\b", re.I) for k, v in JARGON.items()}
samples = {lang: [t for k, t in homeview.text_samples(lang) if k == "plan"]
for lang in LANGS}
for key in NEW_KEYS:
en_t, nl_t = jwords("en").get(key), jwords("nl").get(key)
check(f"T33 {key}: in en.json and nl.json with the same placeholders",
isinstance(en_t, str) and isinstance(nl_t, str)
and set(PH.findall(en_t)) == set(PH.findall(nl_t)))
for lang in LANGS:
raw = jwords(lang).get(key, "")
vals = {k: "10" for k in PH.findall(raw)}
vals.update(phases=pw_l(lang, 3), real=pw_l(lang, 1))
shown = tx(lang, key, **vals)
sents = re.split(r"(?<=[.!?])\s+", shown)
nwords = [len(s.split()) for s in sents]
check(f"T33 {key} ({lang}): in text_samples as a plan line, no '{{', "
f"<=2 sentences of <=12 words ({nwords}), no jargon: {shown!r}",
shown in samples[lang] and "{" not in shown
and len(sents) <= 2 and max(nwords) <= 12
and not JARGON[lang].search(PH.sub("X", shown)))
for lang in LANGS:
base = BASE_EN if lang == "en" else BASE_NL
words = jwords(lang)
check(f"T34 ({lang}): the 9 existing manual_* texts are byte-identical",
all(words.get(k) == v for k, v in base.items()) and len(base) == 9)
# --------------------------------------------------------------------------- #
print("\n4. T35: the property sweep (both languages)")
# --------------------------------------------------------------------------- #
n_calls = 0
viol = {"i": [], "ii": [], "iii": [], "iv": []}
for (sh, ov, cv, fl, hd, au, bl, eg, sq, key, pa, cn, fr) in itertools.product(
(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1),
(None, {"stage": "zero"}), ("charging", "waiting", "none", "full"),
(None, 1, 3), (1, 3), (0, 1)):
for lang in LANGS:
c = U(shadow=bool(sh), over=bool(ov), cover=bool(cv), floor=bool(fl),
hold=bool(hd), auto=bool(au), blocked=bool(bl), eng=bool(eg),
seq=sq, real=pa,
n=cn, fresh=bool(fr), would=(10.0, 3))
t = why(c, lang, key)
n_calls += 1
if sh and YOU[lang] in t:
viol["i"].append((lang, t))
known = pa is not None and fr
if (not sh and au and not ov
and (hd or (known and pa != cn and sq is None))
and KEEPS[lang] in t):
viol["ii"].append((lang, t))
if "{" in t or "<EXC" in t:
viol["iii"].append((lang, t))
sents = re.split(r"(?<=[.!?])\s+", t)
if len(sents) > 2 or max(len(s.split()) for s in sents) > 12:
viol["iv"].append((lang, t))
check(f"T35 (i): shadow mode, no 'You set' anywhere ({n_calls} calls)",
n_calls == 2 * 24576 and not viol["i"])
check("T35 (ii): no 'keeps it' under hold or a known, fresh phase difference",
not viol["ii"])
check("T35 (iii): no '{' left, no exception", not viol["iii"] and not EXC)
check("T35 (iv): at most 2 sentences of 12 words (the new texts' share)",
not [v for v in viol["iv"]
if any(k in v[1] for k in ("stays on", "blijft op", "Something else",
"Iets anders", "would set the peak",
"zou de piek"))])
check("T35 (vi)/N2: no render changed the writer, the car or the controller "
f"({len(N2_BAD)} did)", not N2_BAD)
# =========================================================================== #
print("\n5. Integration: a real Controller on the charger model")
# =========================================================================== #
SET = "number.wallbox_power_connector_max_current_socket_1"
BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
"soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
"meter_source": "off", "max_w": 5000, "gain": 0.6, "slew_w": 500,
"deadband_w": 15, "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10,
"stale_input_s": 15, "shadow_mode": "off", "peak_cap_w": 3500,
"pv_entities": ["sensor.pv"]}
CAR = dict(BASE, ev_charger="alfen_ha", ev_max_a=16, ev_phases="auto",
ev_current_entity=SET)
CLOCK = [1000.0]
freshness.monotonic = lambda: CLOCK[0]
class _Store:
def __init__(self):
self.data = {}
def set(self, k, v):
self.data[k] = v
def get(self, k, d=None):
return self.data.get(k, d)
def set_time(self, k, v):
self.data[k] = v.isoformat()
def get_time(self, k):
v = self.data.get(k)
return None if v is None else datetime.fromisoformat(v)
class _Pub:
enabled = False
def publish(self, v):
pass
def close(self):
pass
class Site(FakeHa):
def __init__(self, charger, grid=500.0, batt=0.0, pv=2000.0):
super().__init__(charger, None)
self.grid, self.batt, self.pv = grid, batt, pv
async def limits(self, _e):
return (-5000.0, 5000.0, 1.0)
def _all(self):
out = super()._all()
for eid, val, unit_ in (("sensor.grid", self.grid, "W"),
("sensor.soc", 50.0, "%"),
("sensor.batt", self.batt, "W"),
("sensor.pv", self.pv, "W")):
out[eid] = {"entity_id": eid, "state": str(val),
"attributes": {"unit_of_measurement": unit_}}
return out
async def number(self, entity_id, invert=False):
s = self._all().get(entity_id)
try:
v = float(s["state"])
except (TypeError, ValueError, KeyError):
return None
return -v if invert else v
async def set_number(self, entity_id, value):
if entity_id == "number.sp":
self.sets.append((entity_id, float(value)))
self.batt = float(value)
return True
return await super().set_number(entity_id, float(value))
class World:
def __init__(self, opts=CAR, setpoint=10, grid=800.0, phases=1):
self.sim = SimCharger(setpoint_a=setpoint)
self.sim.plug_in()
self.sim.phases_allowed = phases
self.site = Site(self.sim, grid=grid)
self.t = 1000.0
CLOCK[0] = self.t
self.c = Controller(dict(opts), self.site, _Store(), _Pub(),
stop=asyncio.Event())
self.c.auto = True
self.c.dev_min, self.c.dev_max = -5000.0, 5000.0
self.drv = self.c.charger
if hasattr(self.drv, "_sleep"):
self.drv._sleep = self.sleep
self.drv._clock = lambda: CLOCK[0]
async def sleep(self, s):
self.sim.tick(s)
self.t += s
CLOCK[0] = self.t
async def step(self, n=1, dt=1.0):
for _ in range(n):
self.sim.tick(dt)
self.t += dt
CLOCK[0] = self.t
await self.c.read_inputs(now_mono=self.t)
await self.c.cycle()
await self.c.car_settle()
async def act(self, what, value):
return await self.c.handle_action(what, value=value)
def writes(self, what=None):
return self.sim.writes(what)
@property
def wr(self):
return self.c.car_writer
W_BAD = []
def block_why(w, lang="en"):
"""car_block's Why, with N2 and N3 held across the call."""
c = w.c
before = (snap(c), len(w.sim.log), list(w.drv.sent),
len(w.site.charger_writes()))
homeview._LANG[0] = uitext.lang_of(lang)
try:
out = homeview.car_block(c, datetime.now(timezone.utc))
t = out["why"] if out else "<no block>"
except Exception as e: # noqa: BLE001
t = f"<EXC {type(e).__name__} {e}>"
finally:
homeview._LANG[0] = "en"
after = (snap(c), len(w.sim.log), list(w.drv.sent),
len(w.site.charger_writes()))
if before != after:
W_BAD.append(t)
return t
def set_text(w, lang="en"):
return exp(lang, "manual_set", a=f"{float(w.c.car_a):.0f}",
phases=pw_l(lang, w.c.car_n))
async def ready(phases, a, to, ramp=200.0, delay=1.0, shadow="off"):
w = World(dict(CAR, shadow_mode=shadow), setpoint=a, phases=phases)
await w.step(8)
await w.act("car_phases", phases)
await w.act("car_mode", "manual")
await w.act("car_current", a)
await w.step(8)
w.sim.ramp_w_s, w.sim.stop_delay_s = ramp, delay
await w.act("car_phases", to)
return w
async def t8():
w = World(dict(CAR, shadow_mode="on"), setpoint=10, phases=3)
await w.step(8)
await w.act("car_phases", 3)
await w.act("car_mode", "manual")
await w.act("car_current", 16)
await w.step(80)
w.c.car_over = True
w.c.peak_guard = G(floor_limited=True)
return w, {lg: block_why(w, lg) for lg in LANGS}
w8, t8w = run(t8())
would_a = nth(w8.wr.would) if w8.wr.would else None
check("T8: shadow world, Manual 16 A, car over: shadow-over text in en and "
f"nl, no 'You set': {t8w}",
w8.c.shadow and present(would_a) and w8.wr.would is not None
and all(PEAK[lg] in t8w[lg] and YOU[lg] not in t8w[lg] for lg in LANGS)
and t8w["en"] == exp("en", "manual_shadow_over",
a=f"{float(w8.wr.would[0]):.0f}",
phases=pw(w8.wr.would[1])))
check("T8/N3: shadow world: no simulator log, no driver send, no charger "
"write", w8.sim.log == [] and w8.drv.sent == []
and w8.site.charger_writes() == [])
async def gave_up(refuse_select):
# 3 phases wanted -> the sim is on 1; or the other way, as EV-28's T11.
w = await ready(3, 16, 1, ramp=(3000.0 if refuse_select else 200.0))
if refuse_select:
w.sim.request_phases = lambda n: False
texts = {}
await w.step(40)
texts["try1"] = (w.wr.phases_gave_up, w.wr.phase_fails, block_why(w))
await w.step(int(PHASE_GAP_S) + 60)
await w.step(int(PHASE_GAP_S) + 60)
texts["end"] = (w.wr.phases_gave_up, w.wr.phase_fails, block_why(w),
block_why(w, "nl"))
return w, texts
for label, refuse in (("T11 the car keeps drawing", False),
("T12 the select is refused", True)):
w_, tt = run(gave_up(refuse))
g1, f1, why1 = tt["try1"]
ge, fe, whye, whyn = tt["end"]
want = exp("en", "manual_phases", a="16", phases="1 phase",
real="3 phases")
check(f"{label}: after the 3rd failed try the Why is the E2 text "
f"{whye!r}", ge and fe == 3 and whye == want
and whyn == exp("nl", "manual_phases", a="16",
phases=pw_l("nl", 1), real=pw_l("nl", 3))
and w_.sim.phases_allowed == 3 and KEEPS["en"] not in whye)
check(f"{label}: before the give-up (gap wait) it is manual_blocked "
f"{why1!r}", not g1 and f1 >= 1
and why1 == exp("en", "manual_blocked"))
# T19: another writer raises the current during a phase change.
async def other_in_seq():
w = World(CAR, setpoint=10, phases=1)
w.sim.ramp_w_s, w.sim.stop_delay_s = 50.0, 40.0
await w.step(60)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(3)
await w.act("car_phases", 3)
await w.step(3)
mid = (w.wr.seq is not None, block_why(w))
w.sim.set_current(9)
got = None
for _ in range(60):
await w.step(1)
if w.wr.other:
got = (block_why(w), block_why(w, "nl"))
break
return w, mid, got
w19, mid19, got19 = run(other_in_seq())
check("T19: during the sequence the Why is today's manual_set "
f"{mid19[1]!r}", mid19[0] and mid19[1] == set_text(w19))
check("T19: the first car_block after w.other turns True is the hold text "
f"(en and nl): {got19!r}",
got19 is not None and got19[0] == exp("en", "manual_other")
and got19[1] == exp("nl", "manual_other")
and YOU["en"] not in got19[0] and KEEPS["en"] not in got19[0]
and STAYS["en"] not in got19[0])
async def t27():
w, _m, _g = await other_in_seq()
await w.act("car_current", 12)
await w.step(5)
return w, block_why(w)
w27, why27 = run(t27())
okset = {set_text(w27), exp("en", "manual_blocked"),
exp("en", "manual_phases", a="12", phases="3 phases",
real="1 phase")}
check(f"T27: the user changes the current: the hold is lifted and the hold "
f"text is gone ({why27!r})", not w27.wr.hold
and why27 != exp("en", "manual_other") and why27 in okset)
# T20 / T28: the other writer on equal phases.
async def other_equal():
w = World(CAR, setpoint=10, phases=1)
await w.step(8)
await w.act("car_phases", 1)
await w.act("car_mode", "manual")
await w.act("car_current", 10)
await w.step(10)
pre = block_why(w)
t0 = w.t
w.sim.set_current(8)
before, first, secs = [], None, None
for _ in range(60):
await w.step(1)
if w.wr.other:
first, secs = block_why(w), w.t - t0
break
before.append(block_why(w))
held_for = None
w.sim.set_current(10)
after = []
for _ in range(40):
await w.step(1)
after.append((w.wr.hold, block_why(w)))
if not w.wr.hold:
break
return w, pre, before, first, secs, after
w20, pre20, before20, first20, secs20, after20 = run(other_equal())
check("T20: before the hold the Why is today's manual_set, every step "
f"({len(before20)} steps)", pre20 == set_text(w20) and before20
and all(t == set_text(w20) for t in before20))
check(f"T20: the hold text from the first call after w.other turns True, "
f"{secs20} s after the write (<= WRITER_S + 5 = 35)",
first20 == exp("en", "manual_other") and secs20 is not None
and secs20 <= carmode.WRITER_S + 5.0)
check("T28: the other writer puts the current back: the hold clears and the "
"Why is manual_set in the same step",
len(after20) >= 1 and not after20[-1][0]
and after20[-1][1] == set_text(w20) and len(after20) <= 5)
# N2/N3 over every World call above.
check(f"N2/N3: every car_block call in the World rows changed nothing and "
f"sent nothing ({len(W_BAD)} did)", not W_BAD)
print()
if fails:
print(f"{len(fails)} FAILED")
sys.exit(1)
print("all ok")