"""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) # Review: the phases word is the writer's `would`, as manual_would's. c = U(shadow=True, over=True, a=16.0, n=1, would=(10.0, 3)) check(f"T1 phases ({lang}): the phases come from would, not car_n", why(c, lang) == exp(lang, "manual_shadow_over", a="10", phases=pw_l(lang, 3))) 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, would=(10.0, 3)) 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 = uitext.raw("en")["home_words"]["car"]["why"].get(key) nl_t = uitext.raw("nl")["home_words"]["car"]["why"].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")