Lukas Knoeller
75466761a1
Translates status values the integration previously surfaced as raw
Samsung strings: cycle progress ('Rinse' -> "Rinsing"), diagnosis state,
buzzer volume options, and the drum-clean counter's unit. Progress and
diagnosis become enum sensors so Home Assistant looks their state up in
the catalog; progress keys come from lowercasing the device's own value
rather than a hardcoded map, so adding a language is a catalog-only
change (PR #341 review).
Rebased onto main, which has since gained the issue #345 sticky hold, and
fixed up for two problems that combination exposes:
Home Assistant refuses an enum state that isn't in the sensor's options,
which takes the entity out rather than degrading it. The sticky hold froze
progress at the device's raw 'Finish' while rep_fn had been normalized to
'finish', so every completed cycle -- the exact path #345 exists to serve
-- would have produced a rejected state.
Separately, options built from the catalog can only ever list values we
have a translation for, while this registry's rule is that an unrecognized
device value renders raw. Every progress token the shipped fixtures
advertise is covered today, but Samsung ships more devices than we have
dumps for, so the sensor platform now admits the live value into its own
options: known values translate, unknown ones display untranslated instead
of breaking the entity.
The drum-clean unit moves from a native unit to the catalog because Home
Assistant rejects an entity declaring both. Note it resolves against the
default language, so the localized unit strings are inert -- kept only
because every catalog must mirror English key for key.
Also moves the diagnosis normalizer to common.py, so dryer.py doesn't
import a private symbol from dishwasher.py to get it.
116 lines
4.2 KiB
Python
116 lines
4.2 KiB
Python
"""An enum sensor's reported state must always be inside its options.
|
|
|
|
Home Assistant raises for an enum sensor whose state isn't in `options`
|
|
(sensor/__init__.py: "provides state value ... which is not in the list of
|
|
options provided"), so a value outside the list isn't a cosmetic problem --
|
|
it takes the entity out.
|
|
|
|
Two ways that bites, both from PR #341 giving `progress` a `device_class`
|
|
of enum:
|
|
|
|
- the sticky hold (issue #345) froze the entity at the device's raw
|
|
'Finish' while `rep_fn` had been normalized to 'finish', so every
|
|
completed cycle -- the exact path #345 exists to serve -- produced a
|
|
state outside the options;
|
|
- any progress value not in the translation catalog. Every token the
|
|
shipped fixtures advertise is covered today, but this registry's rule is
|
|
that an unrecognized device value renders raw rather than breaking, and
|
|
Samsung ships more devices than we have dumps for.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import cast
|
|
|
|
from custom_components.localthings.coordinator import LocalThingsCoordinator
|
|
from custom_components.localthings.registry.adapter import flatten
|
|
from custom_components.localthings.registry.capabilities.operational import OPERATIONAL_STATE
|
|
from custom_components.localthings.registry.discovery import BoundEntity
|
|
from custom_components.localthings.registry.entities import SensorDesc
|
|
from custom_components.localthings.sensor import LocalThingsSensor
|
|
|
|
_HREF = "/operational/state/vs/0"
|
|
_PROGRESS = next(
|
|
e for e in OPERATIONAL_STATE.entities if e.key == "progress" and isinstance(e, SensorDesc)
|
|
)
|
|
_ALL_BOUND = [
|
|
BoundEntity(href=_HREF, capability=OPERATIONAL_STATE, desc=desc)
|
|
for desc in OPERATIONAL_STATE.entities
|
|
]
|
|
|
|
|
|
class _FakeConfigEntry:
|
|
def __init__(self):
|
|
self.options: dict = {}
|
|
|
|
|
|
class _FakeCoordinator:
|
|
def __init__(self):
|
|
self.device_serial = "TEST-SERIAL"
|
|
self.config_entry = _FakeConfigEntry()
|
|
self.resources: dict[str, dict] = {}
|
|
|
|
def resource(self, href: str) -> dict:
|
|
return self.resources.get(href) or {}
|
|
|
|
@property
|
|
def data(self) -> dict:
|
|
return flatten(_ALL_BOUND, self.resources)
|
|
|
|
|
|
def _sensor(desc):
|
|
coordinator = _FakeCoordinator()
|
|
bound = BoundEntity(href=_HREF, capability=OPERATIONAL_STATE, desc=desc)
|
|
return LocalThingsSensor(cast(LocalThingsCoordinator, coordinator), bound), coordinator
|
|
|
|
|
|
def _set(coordinator, **fields):
|
|
coordinator.resources[_HREF] = {f"x.com.samsung.da.{k}": v for k, v in fields.items()}
|
|
|
|
|
|
def test_the_sticky_hold_freezes_at_a_value_inside_the_options():
|
|
"""Issue #345's grace window fires on every finished cycle, so a held
|
|
value outside the options would break the common path, not an edge."""
|
|
sensor, coordinator = _sensor(_PROGRESS)
|
|
|
|
_set(coordinator, state="Run", progress="Wash")
|
|
assert sensor.native_value == "wash"
|
|
|
|
# Cycle finishes, then the device drops out of active -- the hold engages.
|
|
_set(coordinator, state="Run", progress="Finish")
|
|
assert sensor.native_value in sensor.options
|
|
_set(coordinator, state="Ready", progress="Finish")
|
|
held = sensor.native_value
|
|
assert held == "finish"
|
|
assert held in sensor.options
|
|
|
|
|
|
def test_a_progress_value_we_cannot_translate_still_reports():
|
|
"""An unrecognized device value renders raw rather than taking the
|
|
entity out -- the same rule the course tables follow."""
|
|
sensor, coordinator = _sensor(_PROGRESS)
|
|
|
|
_set(coordinator, state="Run", progress="SomeFutureStage")
|
|
value = sensor.native_value
|
|
assert value == "somefuturestage"
|
|
assert value in sensor.options
|
|
# ...and admitting it doesn't drop the translated ones.
|
|
assert "rinse" in sensor.options
|
|
|
|
|
|
def test_known_values_do_not_grow_the_options_list():
|
|
assert _PROGRESS.options is not None
|
|
sensor, coordinator = _sensor(_PROGRESS)
|
|
|
|
_set(coordinator, state="Run", progress="Rinse")
|
|
assert sensor.options == list(_PROGRESS.options)
|
|
|
|
|
|
def test_a_non_enum_sensor_has_no_options():
|
|
percentage = next(e for e in OPERATIONAL_STATE.entities if e.key == "progress_percentage")
|
|
sensor, coordinator = _sensor(percentage)
|
|
|
|
_set(coordinator, state="Run", progressPercentage="40")
|
|
assert sensor.options is None
|
|
assert sensor.native_value == 40
|