diff --git a/goodwe_controller/app/homeview.py b/goodwe_controller/app/homeview.py index 4774469..84c0fdd 100644 --- a/goodwe_controller/app/homeview.py +++ b/goodwe_controller/app/homeview.py @@ -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")), diff --git a/goodwe_controller/app/ui_text/en.json b/goodwe_controller/app/ui_text/en.json index 0cf0be9..ea2a878 100644 --- a/goodwe_controller/app/ui_text/en.json +++ b/goodwe_controller/app/ui_text/en.json @@ -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." } }, diff --git a/goodwe_controller/app/ui_text/nl.json b/goodwe_controller/app/ui_text/nl.json index 975e3dd..62c123f 100644 --- a/goodwe_controller/app/ui_text/nl.json +++ b/goodwe_controller/app/ui_text/nl.json @@ -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." } }, diff --git a/goodwe_controller/test_ev14.py b/goodwe_controller/test_ev14.py new file mode 100644 index 0000000..56f117f --- /dev/null +++ b/goodwe_controller/test_ev14.py @@ -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"" + 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"" + 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 " 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 "" + except Exception as e: # noqa: BLE001 + t = f"" + 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")