Files
cantabile-ha-addons/src/edge/tests/test_shades.py
T

527 lines
30 KiB
Python

# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
"""Shades (ha-cover, shades.py), temperature sensors (ha-climate-sensor) and
weather services (ha-weather): which devices the profiles offer (never a
garage door, never the box's own CPU temperature), their fragments and the
owner's settings, the shade's rules on the sun, the guard around them, the
dashboard and the plan in words."""
import json
import pathlib
from datetime import datetime, timezone
from zoneinfo import ZoneInfo
import pytest
import yaml
from cantabile_edge import dashboards, devprofiles as dp, propose, shades
from cantabile_edge.consent import Consent
from cantabile_edge.executor import actions_for
from cantabile_edge.guard import Action, Guard
from cantabile_edge.inputs import Collector, model_state
from cantabile_edge.mapping import Mapping
from cantabile_edge.policy import Policy
ROOT = pathlib.Path(__file__).resolve().parents[2]
PROFILES = {p["id"]: p for p in propose.load_profiles(str(ROOT / "profiles"))}
BERLIN = {"latitude": 52.52, "longitude": 13.40}
# -- which profile, which device ---------------------------------------------------------------
def registry(*devices):
"""devices: (id, manufacturer, model, platform, [(entity_id, device_class, category)], entry_type)."""
reg = {"areas": [{"area_id": "bedroom", "name": "Bedroom"}], "devices": [], "entities": []}
for dev_id, maker, model, platform, ents, *kind in devices:
reg["devices"].append({"id": dev_id, "name": dev_id, "manufacturer": maker, "model": model,
"domains": [platform], "area_id": "bedroom", "entry_type": kind[0] if kind else None})
for eid, dc, *cat in ents:
reg["entities"].append({"entity_id": eid, "device_id": dev_id, "unique_id": eid, "platform": platform,
"device_class": dc, "entity_category": cat[0] if cat else None})
return reg
def offered(reg):
return {o["id"]: o["profiles"] for o in dp.offers(reg, PROFILES.values())}
def test_covers_offered_never_a_garage_door():
reg = registry(
("rbs", "SONOFF", "MINI-RBS", "sonoff", [("cover.left_curtain", None)]), # SonoffLAN: no class
("blind", "Somfy", "RTS", "somfy", [("cover.kitchen_blind", "blind")]),
("garage", "Meross", "MSG100", "meross", [("cover.garage", "garage")]),
("gate", "Nice", "Gate", "nice", [("cover.gate", "gate")]),
("both", "Shelly", "2PM", "shelly", [("cover.awning", "awning"), ("cover.door", "door")]),
("damper", "Acme", "Vent", "acme", [("cover.vent", "damper")]),
("window", "Velux", "Window", "velux", [("cover.roof_window", "window")]))
got = offered(reg)
assert got["rbs"] == ["ha-cover"] and got["blind"] == ["ha-cover"]
for dev in ("garage", "gate", "both", "damper", "window"):
assert got[dev] == [], dev # not even generic: never offered
# a specific profile first: an SPM's sonoff device stays the SPM's
spm = {"manufacturer": "SONOFF", "model": "SPM-Main"}
fits = dp.fitting(PROFILES.values(), spm, ["sonoff"], ["cover", "sensor.power"])
assert all(not dp.fallback(p) for p in fits) or fits == []
def test_temperature_sensors_offered_not_system_or_device_internal():
reg = registry(
("esp", "Espressif", "esp32", "esphome", [("sensor.office_temp", "temperature"), ("sensor.office_hum", "humidity"),
("sensor.esp_internal", "temperature", "diagnostic"),
("sensor.esp_battery", "battery")]),
("zb", "Xiaomi", "LYWSD03MMC", "zha", [("sensor.bath_temp", "temperature")]),
("ble", "Govee", "H5075", "govee_ble", [("sensor.balcony_temp", "temperature")]),
("snzb", "SONOFF", "SNZB-02D", "zha", [("sensor.living_temp", "temperature")]),
("ac", "Espressif", "esp32", "esphome", [("climate.ac", None), ("sensor.ac_temp", "temperature")]),
("sysmon", "Home Assistant", "System Monitor", "systemmonitor", [("sensor.processor_temperature", "temperature")]),
("inverter", "Growatt", "MIN", "growatt", [("sensor.inv_temp", "temperature"), ("sensor.inv_power", "power")]),
("diag", "Acme", "Router", "acme", [("sensor.router_temp", "temperature", "diagnostic")]),
("met", "Met.no", "Forecast", "met", [("weather.home", None), ("sensor.met_temp", "temperature")], "service"),
("backup", "Home Assistant", "Backup", "backup", [("sensor.backup_state", None)], "service"))
got = offered(reg)
assert got["esp"] == got["zb"] == got["ble"] == ["ha-climate-sensor"]
assert got["snzb"] == ["sonoff-snzb-02"] # its own profile
assert got["ac"] == ["ha-thermostat"] # a thermostat stays one
assert got["sysmon"] == [] and got["inverter"] == [] and got["diag"] == []
assert got["met"] == ["ha-weather"] # a weather service is offered
assert "backup" not in got # other services are not
# -- fragments and the owner's settings -------------------------------------------------------
def cover_ent(eid="cover.left_curtain", **attrs):
return {"entity_id": eid, "device_id": "d", "unique_id": eid,
"attributes": dict({"current_position": 100, "supported_features": 15}, **attrs)}
def test_cover_fragment_protected_with_its_room():
p = PROFILES["ha-cover"]
s = dp.setup_for(p, ["sonoff"])
frag, missing = dp.mapping_for("ha-cover-1", p, s, [cover_ent()], "Bedroom", set())
(c,) = frag["controls"]
assert c["kind"] == "cover" and c["entities"] == {"cover": "cover.left_curtain"} and c["consent"] is False
assert c["params"]["area"] == "bedroom" and c["params"]["min_move_s"] == 1800
assert [a["asset"] for a in frag["assets"]] == ["room.bedroom.shade_position"] and missing == ["room.{area}.shade_tilt"]
prot = dp.profile_protection("ha-cover-1", p, s, [cover_ent()], frag, now=1)
assert prot[f"control:{c['id']}"]["level"] == "protected"
# the owner: room and window
thermo = {"profile": "ha-thermostat", "assets": [{"asset": "room.living_room.temp"}],
"controls": [{"id": "heating", "kind": "heating"}, {"id": "cooling", "kind": "cooling"}]}
sh = dp.set_shade(frag, {"area": "Living room", "facing": "SW"}, [thermo])
assert sh == {"area": "living_room", "facing": 225.0, "room": "heating"}
assert dp.set_shade(frag, {"area": "", "facing": "275"}) == {"area": "", "facing": 275.0, "room": ""}
with pytest.raises(dp.Fail):
dp.set_shade(frag, {"facing": "up"})
with pytest.raises(dp.Fail):
dp.set_shade({"controls": [{"kind": "heating"}]}, {"facing": "N"})
def test_sensor_indoor_outdoor_and_second_reading():
p = PROFILES["ha-climate-sensor"]
ents = [{"entity_id": "sensor.office_temp", "device_id": "d", "unique_id": "t", "device_class": "temperature"},
{"entity_id": "sensor.office_hum", "device_id": "d", "unique_id": "h", "device_class": "humidity"},
{"entity_id": "sensor.esp_internal", "device_id": "d", "unique_id": "i", "device_class": "temperature",
"entity_category": "diagnostic"}]
taken = {"room.office.temp"} # the room has a temperature already
frag, _ = dp.mapping_for("ha-climate-sensor-1", p, dp.setup_for(p, ["esphome"]), ents, "Office", set(taken))
assert {a["asset"]: a["entity"] for a in frag["assets"]} == {"room.office.temp_2": "sensor.office_temp",
"room.office.humidity": "sensor.office_hum"}
assert dp.place_of(frag) == {"place": "indoor", "area": "office"}
dp.set_place(frag, {"place": "outdoor"}, taken)
assert {a["asset"] for a in frag["assets"]} == {"outside.temp", "outside.humidity"}
assert frag["inputs"] == {"outside_temp": "sensor.office_temp"} and dp.place_of(frag)["place"] == "outdoor"
dp.set_place(frag, {"place": "indoor", "area": "Bedroom"}, taken)
assert {a["asset"] for a in frag["assets"]} == {"room.bedroom.temp", "room.bedroom.humidity"} and "inputs" not in frag
with pytest.raises(dp.Fail):
dp.set_place(frag, {"place": "attic"})
def test_one_weather_source_and_a_measured_outdoor_wins(tmp_path):
p = PROFILES["ha-weather"]
s = dp.setup_for(p, ["met"])
w = {"entity_id": "weather.home", "device_id": "m", "unique_id": "w",
"attributes": {"temperature": 8.0, "humidity": 70, "cloud_coverage": 40}}
met, _ = dp.mapping_for("ha-weather-1", p, s, [w], None, set())
assert met["inputs"] == {"weather": "weather.home"}
assert {a["asset"] for a in met["assets"] if a.get("fallback")} == {"outside.temp", "outside.humidity"}
owm, _ = dp.mapping_for("ha-weather-2", p, s, [dict(w, entity_id="weather.owm")], None,
{"outside.temp", "outside.humidity"})
dp.one_weather(owm, [met])
assert "inputs" not in owm and dp.weather_of(owm) == {"active": False, "entity": "weather.owm"}
frags = {"ha-weather-1": met, "ha-weather-2": owm}
dp.set_weather(frags, "ha-weather-2")
assert dp.weather_of(met)["active"] is False and owm["inputs"] == {"weather": "weather.owm"}
dp.set_weather(frags, "ha-weather-1")
assert dp.weather_of(met)["active"] is True and "inputs" not in owm
# the agent: an outdoor thermometer takes outside.temp and the outside temperature
sensor = {"version": 3, "device": "ha-climate-sensor-1", "profile": "ha-climate-sensor",
"assets": [{"entity": "sensor.balcony_temp", "asset": "outside.temp_2", "kind": "gauge", "unit": "°C"}],
"inputs": {"outside_temp": "sensor.balcony_temp"}}
(tmp_path / "mapping.d").mkdir()
(tmp_path / "mapping.yaml").write_text(yaml.safe_dump({"version": 3, "assets": [],
"inputs": {"outside_temp": "sensor.forecast_helper"}}))
for name, f in (("a-weather", met), ("b-sensor", sensor)):
(tmp_path / "mapping.d" / f"{name}.yaml").write_text(json.dumps(f))
m = Mapping.load(str(tmp_path / "mapping.yaml"))
assert m.by_asset["outside.temp"].entity == "sensor.balcony_temp"
assert m.by_asset["outside.temp_2"].entity == "weather.home" and m.by_asset["outside.temp_2"].fallback
assert m.inputs.outside_temp == "sensor.balcony_temp" and m.inputs.weather == "weather.home"
# -- the rules ----------------------------------------------------------------------------------
def ts(y, mo, d, h=0, tz="Europe/Berlin"):
return int(datetime(y, mo, d, h, tzinfo=ZoneInfo(tz)).timestamp())
def state(start, steps=96, t_out=30.0, occupied=1, prices=None, location=BERLIN):
return {"start": start, "step_s": 900, "steps": steps, "tz": "Europe/Berlin", "t_out": [t_out] * steps,
"occupied": [occupied] * steps if isinstance(occupied, int) else occupied,
"price_import": prices or [30.0] * steps, "sky": [1.0] * steps, "location": location}
def shade(facing=270, pos=100, **params):
return {"id": "curtain", "kind": "cover", "params": dict({"facing": facing}, **params),
"state": {"position_pct": pos}, "bounds": {"position_pct": [0, 100]}}
def moves(sch, start):
out = []
for k, v in enumerate(sch["set"]):
if v is not None:
local = datetime.fromtimestamp(start + k * 900, timezone.utc).astimezone(ZoneInfo("Europe/Berlin"))
out.append((local.strftime("%H:%M"), v, sch["why"][k]))
return out
def test_sun_position():
# Berlin, midsummer: the sun in the south at about 13:10 CEST, 61° high; in the west in the evening
el, az = shades.sun_position(ts(2026, 6, 21, 13) + 600, 52.52, 13.40)
assert 59 < el < 62 and 170 < az < 190
el, az = shades.sun_position(ts(2026, 6, 21, 19), 52.52, 13.40)
assert 10 < el < 25 and 270 < az < 300
assert shades.sun_position(ts(2026, 6, 21, 1), 52.52, 13.40)[0] < 0
assert shades.facing("sw") == 225 and shades.facing(-1) is None and shades.compass(260) == "W"
def test_summer_west_facade_closes_in_the_afternoon_sun():
start = ts(2026, 7, 15)
sch = shades.schedule(shade(270), state(start), {"temp_c": 26.0, "setpoint_c": 24.0})
m = moves(sch, start)
assert m[0][1] == 30 and m[0][2] == "sun on the west facade" and "13:00" <= m[0][0] <= "15:00", m
assert m[1][1] == 100 and m[1][2] == "the sun has left the west facade" and "19:00" <= m[1][0] <= "21:30", m
assert len(m) == 2
# nobody home: closed all the way
assert moves(shades.schedule(shade(270), state(start, occupied=0), {"temp_c": 26.0, "setpoint_c": 24.0}),
start)[0][1] == 0
# a cool room on a mild day: nothing at stake
assert moves(shades.schedule(shade(270), state(start, t_out=20.0), {"temp_c": 21.0, "setpoint_c": 24.0}), start) == []
# ... unless the evening is dear: shaded before it
dear = [30.0] * 64 + [60.0] * 32
m = moves(shades.schedule(shade(270), state(start, t_out=20.0, prices=dear), {"temp_c": 21.0, "setpoint_c": 24.0}),
start)
assert m and m[0][2] == "sun on the west facade: before the dear hours"
# the morning sun is on the east facade, not on the west one
m = moves(shades.schedule(shade(90), state(start), {"temp_c": 26.0, "setpoint_c": 24.0}), start)
assert "07:00" <= m[0][0] <= "09:00" and m[0][2] == "sun on the east facade", m
def test_winter_opens_in_the_sun_closes_at_night_never_in_quiet_hours():
start = ts(2026, 1, 15)
sch = shades.schedule(shade(180, pos=0), state(start, steps=192, t_out=2.0), {"season": "heating"})
m = moves(sch, start)
assert m[0][1] == 100 and m[0][2] == "winter sun on the south facade: its warmth in" and m[0][0] >= "08:00", m
assert m[1][1] == 0 and m[1][2] == "night: closed to keep the warmth in" and "16:00" <= m[1][0] <= "18:00", m
assert m[2][1] == 100 and m[2][0] >= "07:00", m # the next morning, after the quiet hours
assert not any("22:00" <= t or t < "07:00" for t, _, _ in m)
# quiet from 16:00: the night's closing waits for its end (and is never in the dark opened)
noon = ts(2026, 1, 15, 12)
m = moves(shades.schedule(shade(180, pos=100, quiet_from="16:00", quiet_to="23:00"),
state(noon, steps=48, t_out=2.0), {"season": "heating"}), noon)
assert m == [("23:00", 0, "night: closed to keep the warmth in")]
# the owner allows moves at night
m = moves(shades.schedule(shade(180, pos=100, quiet_from="16:00", quiet_to="23:00", night_moves=1),
state(noon, steps=48, t_out=2.0), {"season": "heating"}), noon)
assert m[0][1] == 0 and m[0][0] < "18:00"
# the facade not known: only the night's closing and the morning's opening
m = moves(shades.schedule(shade(-1, pos=100), state(start, steps=192, t_out=2.0), {"season": "heating"}), start)
assert [v for _, v, _ in m] == [0, 100, 0] and m[1][2] == "morning: open again" # the evening, the morning, the evening
# no location: nothing at all
assert moves(shades.schedule(shade(180), state(start, location={}), {}), start) == []
def test_unpriced_steps_are_no_dear_hours():
# the tariff's prices end before the horizon (None after: bundles.prices), or there is none at all
# (2026-11-05: every plan of a flat with a shade failed summing them)
start = ts(2026, 7, 15)
cool = {"temp_c": 21.0, "setpoint_c": 24.0}
dear = [30.0] * 64 + [60.0] * 16 + [None] * 16
m = moves(shades.schedule(shade(270), state(start, t_out=20.0, prices=dear), cool), start)
assert m and m[0][2] == "sun on the west facade: before the dear hours"
# no prices: no dear hours (no stand-in price); the warm room still shaded
assert moves(shades.schedule(shade(270), state(start, t_out=20.0, prices=[None] * 96), cool), start) == []
m = moves(shades.schedule(shade(270), state(start, prices=[None] * 96), {"temp_c": 26.0, "setpoint_c": 24.0}),
start)
assert m[0][2] == "sun on the west facade"
# the winter's rules use no price: the same moves with the tail unpriced
jan = ts(2026, 1, 15)
full = shades.schedule(shade(180, pos=0), state(jan, t_out=2.0), {"season": "heating"})
part = shades.schedule(shade(180, pos=0), state(jan, t_out=2.0, prices=[30.0] * 90 + [None] * 6),
{"season": "heating"})
assert part["set"] == full["set"]
def test_minimum_interval_between_moves():
start = ts(2026, 7, 15)
flip = [k % 2 for k in range(96)] # occupancy changing every quarter hour
sch = shades.schedule(shade(270, min_move_s=3600), state(start, occupied=flip), {"temp_c": 26.0, "setpoint_c": 24.0})
at = [k for k, v in enumerate(sch["set"]) if v is not None]
assert len(at) >= 2 and all(b - a >= 4 for a, b in zip(at, at[1:]))
def test_a_shade_the_agent_moved_moves_back_in_the_next_plans():
# 2026-11-05: Munich 1's shade closed for the night on 30 October and stayed
# closed: every plan after the move started from the closed shade and no
# longer knew why it was closed, so the morning's opening was never planned
evening = ts(2026, 1, 15, 17)
night = {"season": "heating"}
assert moves(shades.schedule(shade(-1, pos=0), state(evening, t_out=2.0), night), evening) == []
m = moves(shades.schedule(shade(-1, pos=0), state(evening, t_out=2.0), dict(night, ours="night")), evening)
assert m[0][1:] == (100, "morning: open again") and m[0][0] >= "07:00", m
# summer: shaded from the sun, opened again when the sun has left
noon = ts(2026, 7, 15, 16)
warm = {"temp_c": 26.0, "setpoint_c": 24.0}
sch = shades.schedule(shade(270, pos=30), state(noon, steps=32), dict(warm, ours="shade"))
assert moves(sch, noon)[0][1:] == (100, "the sun has left the west facade")
# the rule each move is for, into the plan's entry
start = ts(2026, 1, 15)
sch = shades.schedule(shade(-1, pos=100), state(start, steps=192, t_out=2.0), night)
assert [r for r, v in zip(sch["rule"], sch["set"]) if v is not None] == ["night", "", "night"]
def test_moves_kept_while_the_shade_is_where_the_agent_put_it(tmp_path):
mv = shades.Moves(str(tmp_path))
assert mv.ours("curtain", 0.0) is None
mv.record("curtain", "night", 0.0, 1_800_000_000)
assert mv.ours("curtain", 2.0) == "night"
assert mv.ours("curtain", 40.0) is None # moved by hand: the owner's position stays
assert mv.ours("curtain", None) is None
again = shades.Moves(str(tmp_path)) # across a restart
assert again.ours("curtain", 0.0) == "night"
again.record("curtain", "", 100.0, 1_800_050_000) # opened again: nothing of ours
assert again.ours("curtain", 100.0) is None
# -- the plan, the guard, the executor -----------------------------------------------------------
MAPPING = {"version": 3, "assets": [],
"controls": [{"id": "curtain", "kind": "cover", "consent": True, "entities": {"cover": "cover.curtain"},
"params": {"facing": 270, "area": "bedroom"}},
{"id": "rbs", "kind": "cover", "consent": True, "entities": {"cover": "cover.rbs"}}]}
class Clock:
def __init__(self, t):
self.t = t
def __call__(self):
return self.t
@pytest.fixture
def site(tmp_path):
(tmp_path / "mapping.yaml").write_text(yaml.safe_dump(MAPPING))
(tmp_path / "consent.json").write_text(json.dumps({"share": True, "control": True}))
return tmp_path
def move(control="curtain", entity="cover.curtain", value=30.0, service="set_cover_position"):
return Action(control, "cover", entity, "cover", service, {"position": int(value)}, value, "position_pct")
def test_guard_override_pause_min_interval_shadow_and_protection(site):
m = Mapping.load(str(site / "mapping.yaml"))
clk = Clock(1_800_000_000.0)
mode = ["auto"]
g = Guard(m.controls, Consent(str(site)), lambda: mode[0], clock=clk)
assert g.check(move()) == (True, "")
g.done(move())
clk.t += 600
ok, why = g.check(move(value=100.0))
assert not ok and "at most once in 1800" in why # the minimum interval
# the owner moves it by hand: off it for 4 hours (not the 2 of a thermostat)
g.observe("curtain", "cover.curtain", 31, clk.t) # where it was told: no override
assert not g.overridden("curtain")
g.observe("curtain", "cover.curtain", 80, clk.t)
assert g.overridden("curtain") and g.events[-1]["until"] == int(clk.t + 14400)
clk.t += 3 * 3600
assert "by hand" in g.check(move(value=0.0))[1]
clk.t += 3600 + 1
assert g.check(move(value=0.0)) == (True, "")
# never in shadow or advisory
for mo in ("shadow", "advisory"):
mode[0] = mo
assert g.check(move(value=0.0))[1].startswith(f"mode {mo}")
mode[0] = "auto"
# protected: never moved at all (open as much as closed)
(site / "protection.json").write_text(json.dumps({"v": 1, "entries": {"control:curtain": {"level": "protected", "at": 1}}}))
g.policy = Policy(str(site), "ab" * 16, clk)
for v, svc in ((100.0, "set_cover_position"), (0.0, "close_cover"), (100.0, "open_cover")):
ok, why = g.check(move(value=v, service=svc))
assert not ok and why.startswith("protected: Cantabile does not move it"), svc
def test_executor_open_close_only_and_waits_while_moving(site):
m = Mapping.load(str(site / "mapping.yaml"))
curtain, rbs = m.controls
col = Collector()
col.on_entities({"a": {"cover.curtain": {"s": "open", "a": {"current_position": 100, "supported_features": 15}},
"cover.rbs": {"s": "open", "a": {"supported_features": 11}}}})
assert [(a.service, a.value) for a in actions_for(curtain, {"set": 30}, col)] == [("set_cover_position", 30.0)]
assert [(a.service, a.value) for a in actions_for(rbs, {"set": 30}, col)] == [("close_cover", 0.0)]
assert actions_for(rbs, {"set": 80}, col) == [] # open already
assert actions_for(curtain, {"set": None}, col) == [] # a hold between moves
col.on_entities({"c": {"cover.curtain": {"+": {"s": "closing"}}}})
assert actions_for(curtain, {"set": 0}, col) == [] # moving: wait
def test_model_state_gives_each_shade_its_schedule(site):
m = Mapping.load(str(site / "mapping.yaml"))
class Bundles:
def prices(self, *a):
from types import SimpleNamespace
return SimpleNamespace(import_ct=[30.0] * 192, export_ct=[8.0] * 192, note="t")
def forecast(self, *a):
return None
def model_id(self):
return ""
col = Collector()
col.on_entities({"a": {"cover.curtain": {"s": "open", "a": {"current_position": 100}},
"sensor.out": {"s": "31"}}})
m.inputs.outside_temp = "sensor.out"
forecast = [{"datetime": datetime.fromtimestamp(ts(2026, 7, 15) + h * 3600, timezone.utc).isoformat(),
"temperature": 25.0, "cloud_coverage": 0} for h in range(49)]
s = model_state(ts(2026, 7, 15), m.controls, m.inputs, col, Bundles(), None, "Europe/Berlin", forecast,
location=BERLIN, shade_ctx={"curtain": {"temp_c": 26.0, "setpoint_c": 24.0}})
d = next(x for x in s["devices"] if x["id"] == "curtain")
assert any(v == 30 for v in d["schedule"]["set"]) and s["sky"][0] == 1.0
# a thermometer outside: the forecast moved to what it measures now
assert s["t_out"][0] == 31.0 and s["t_out"][30] == 25.0 and "outdoor sensor" in s["sources"]["t_out"]
def test_optimizer_takes_the_schedule():
pytest.importorskip("highspy")
from cantabile_edge import optimizer
start = ts(2026, 7, 15)
s = state(start, steps=96)
s.update(price_export=[8.0] * 96, price_note="t", load_w=[400.0] * 96, pv_w=[0.0] * 96, sun=[0.5] * 96)
room = {"id": "ac", "kind": "cooling", "channels": ["climate"],
"params": {"r_k_per_kw": 10, "c_kwh_per_k": 3, "max_power_w": 1500, "comfort_c": 25, "setup_c": 28, "cop": 3},
"state": {"temp_c": 26.0}, "bounds": {"temp_c": [18, 30, "owner", "owner"]}}
d = dict(shade(270), params={"facing": 270, "room": "ac", "gain_w": 800}, channels=["cover"])
d["schedule"] = shades.schedule(d, s, {"temp_c": 26.0, "setpoint_c": 24.0})
s["devices"] = [room, d]
p = optimizer.plan(s, 20)
sets = [e for e in p["devices"]["curtain"] if e["set"] is not None]
assert [e["set"] for e in sets] == [30, 100] and sets[0]["why"] == "sun on the west facade"
# -- in words: the plan, the dashboard, the page ---------------------------------------------------
def test_words():
assert shades.say(30) == "close to 30 %" and shades.say(100) == "open" and shades.say(0) == "close"
assert shades.say(30, "de") == "auf 30 % schließen"
assert shades.why_words("sun on the west facade", "de") == "Sonne auf der Westseite"
assert shades.why_words("night: closed to keep the warmth in", "de").startswith("Nacht")
def test_announce_coming_up_in_words(tmp_path):
from test_announce import make
from test_control_parts import MAPPING as BASE
import time
a, ann = make(tmp_path, dict(BASE, controls=BASE["controls"][:4] + [dict(BASE["controls"][4], name="Bedroom curtains")]))
now = time.time()
a.control.plan = {"made": now, "devices": {"blind": [{"t": now - 60, "set": None, "why": ""},
{"t": now + 600, "set": 30, "why": "sun on the west facade"},
{"t": now + 1500, "set": None, "why": ""}]}}
st = ann._plan_state()
assert st["next"].startswith("Bedroom curtains: close to 30 % at ") and st["next"].endswith("— sun on the west facade")
assert [n["set"] for n in st["attrs"]["next"]] == ["close to 30 %"] # holds are not listed
assert st["controls"]["blind"]["now"] == "-"
def test_dashboard_cover_features():
assert dashboards.cover_features({"supported_features": 15}) == [{"type": "cover-position"}]
assert dashboards.cover_features({"supported_features": 11}) == [{"type": "cover-open-close"}]
assert dashboards.cover_features({"supported_features": 15 | 128}) == [{"type": "cover-position"},
{"type": "cover-tilt-position"}]
def test_addon_devices_page_shade(tmp_path):
import contextvars
from cantabile_edge import i18n
from test_devpage import Site, ent, st
s = Site(tmp_path)
s.ha.reg["areas"].append({"area_id": "bedroom", "name": "Bedroom"})
s.ha.reg["devices"] += [
{"id": "rbs", "name": "Left curtain", "manufacturer": "SONOFF", "model": "MINI-RBS", "area_id": "bedroom",
"config_entries": ["e4"]},
{"id": "garage", "name": "Garage", "manufacturer": "Meross", "model": "MSG100", "config_entries": ["e5"]}]
s.ha.reg["entities"] += [ent("cover.left_curtain", "rbs", "c1", "sonoff"), ent("cover.garage", "garage", "g1", "meross")]
s.ha.states += [st("cover.left_curtain", "unavailable", supported_features=15), # its class: none (SonoffLAN)
st("cover.garage", "unavailable", device_class="garage")] # unavailable: still a garage
out = s.req()
assert 'name="ha_device" value="rbs"' in out and 'name="ha_device" value="garage"' not in out
s.post(do="use", ha_device="rbs", profile="ha-cover", name="Left curtain")
dev_id = next(i for i, d in s.devices().items() if d["profile"] == "ha-cover")
out = s.req(query=f"p=devices&d={dev_id}")
assert "Room and window" in out and '<option value="Bedroom" selected>Bedroom</option>' in out
assert "Controls: blinds and curtains" in out and "Allow Cantabile to move it" in out
s.post(do="use", ha_device="dev-ac", profile="ha-thermostat") # the living room's A/C
ac = next(i for i, d in s.devices().items() if d["profile"] == "ha-thermostat")
s.post(do="shade", id=dev_id, area="Living room", facing="SE")
p = next(c for c in s.frag(dev_id)["controls"] if c["kind"] == "cover")["params"]
assert (p["area"], p["facing"]) == ("living_room", 135.0)
assert p["room"] in {c["id"] for c in s.frag(ac)["controls"]} # its sun counts in the A/C's room
m = Mapping.load(str(s.mapping)) # another device's room: kept
assert next(c for c in m.controls if c.kind == "cover").p("room") == p["room"]
assert "the window faces" in s.post(do="shade", id=dev_id, facing="up")
def run():
i18n.use("de")
return s.req(query=f"p=devices&d={dev_id}")
de = contextvars.copy_context().run(run)
assert "Raum und Fenster" in de and "Südosten" in de and "Bewegen durch Cantabile erlauben" in de
def test_executor_keeps_what_a_planned_move_was_for(site):
import asyncio
from cantabile_edge.controller import Controller
from cantabile_edge.config import Config
m = Mapping.load(str(site / "mapping.yaml"))
clk = Clock(float(ts(2026, 1, 15, 17)))
cfg = Config(site_id="ab" * 16, mapping=str(site / "mapping.yaml"), state_dir=str(site))
ctl = Controller(cfg, m, Consent(str(site)), sink=None, clock=clk)
ctl.mode.set("auto", "test")
ctl.col.on_entities({"a": {"cover.curtain": {"s": "open", "a": {"current_position": 100, "supported_features": 15}},
"cover.rbs": {"s": "open", "a": {"supported_features": 11}}}})
called = []
class Client:
async def call_service(self, domain, service, entity, data, allowed):
called.append((service, entity, data))
t = int(clk.t)
ctl.executor.plan = {"made": t, "devices": {
"curtain": [{"t": t, "set": 0, "why": "night: closed to keep the warmth in", "rule": "night"}],
"rbs": [{"t": t, "set": None, "why": ""}]}}
asyncio.run(ctl.executor.tick(Client(), True))
assert called == [("set_cover_position", "cover.curtain", {"position": 0})]
ctl.col.on_entities({"c": {"cover.curtain": {"+": {"s": "closed", "a": {"current_position": 0}}}}})
assert ctl.shade_ctx()["curtain"]["ours"] == "night" and "ours" not in ctl.shade_ctx()["rbs"]
# kept across a restart: the next morning's plan opens it
again = Controller(cfg, m, Consent(str(site)), sink=None, clock=clk)
again.col.on_entities({"a": {"cover.curtain": {"s": "closed", "a": {"current_position": 0}}}})
assert again.shade_ctx()["curtain"]["ours"] == "night"
assert again.mode() == "auto" and again.mode.source().startswith("set by test at ")