Merge pull request 'EV-14: Car Why says what happens in shadow mode and after an abandoned phase change' (#270) from EV-14 into release/1.0
infra-pin / fresh (push) Successful in 1s
infra-pin / fresh (push) Successful in 1s
This commit was merged in pull request #270.
This commit is contained in:
@@ -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")),
|
||||
|
||||
@@ -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."
|
||||
}
|
||||
},
|
||||
|
||||
@@ -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."
|
||||
}
|
||||
},
|
||||
|
||||
@@ -0,0 +1,832 @@
|
||||
"""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)
|
||||
# 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 "<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")
|
||||
Reference in New Issue
Block a user